java如何不走事务

Java中如何不走事务：通过设置事务属性、使用编程式事务管理、使用非事务性资源。其中，通过设置事务属性可以在Spring框架中使用@Transactional注解，设置事务传播属性为Propagation.NEVER，确保方法不在事务中运行。

一、通过设置事务属性

在Java的Spring框架中，可以通过设置@Transactional注解的属性来控制事务行为。具体来说，可以将传播属性设置为Propagation.NEVER，这将确保该方法在调用时不会启动一个新的事务，也不会加入到现有的事务中。

1. Propagation.NEVER的使用

Propagation.NEVER是Spring事务管理中的一种传播行为，它表示该方法不应该在事务中运行。如果当前存在一个事务，它将会抛出一个异常。

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
public class MyService {
    @Transactional(propagation = Propagation.NEVER)
    public void nonTransactionalMethod() {
        // 业务逻辑
    }
}

在上面的示例中，nonTransactionalMethod方法被标记为Propagation.NEVER，这意味着该方法在调用时不会启动一个新的事务，并且如果存在一个事务，它将会抛出异常。

2. 使用@Transactional的其他属性

除了Propagation.NEVER，Spring的@Transactional注解还提供了其他一些属性来控制事务行为，如隔离级别、超时时间、只读等。

@Transactional(propagation = Propagation.NEVER, isolation = Isolation.READ_COMMITTED, timeout = 5, readOnly = true)
public void anotherNonTransactionalMethod() {
    // 业务逻辑
}

在上面的示例中，anotherNonTransactionalMethod方法不仅设置了传播行为为Propagation.NEVER，还设置了隔离级别、超时时间和只读属性。

二、使用编程式事务管理

除了使用声明式事务管理（如@Transactional注解），还可以使用编程式事务管理来控制事务行为。在Spring中，可以通过PlatformTransactionManager接口来实现编程式事务管理。

1. PlatformTransactionManager的使用

PlatformTransactionManager接口提供了编程式事务管理的基本功能，可以在代码中手动启动、提交或回滚事务。

import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
public class MyService {
    private PlatformTransactionManager transactionManager;
    public MyService(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }
    public void nonTransactionalMethod() {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            // 业务逻辑
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

在上面的示例中，通过PlatformTransactionManager接口创建了一个事务定义，并将传播行为设置为Propagation.NEVER。然后手动启动事务，在业务逻辑执行完毕后提交事务，如果发生异常则回滚事务。

2. 编程式事务管理的优势

编程式事务管理相比声明式事务管理更加灵活，可以在运行时动态地控制事务行为。适用于一些复杂的事务需求，如在同一个方法中对不同的操作使用不同的事务传播行为。

三、使用非事务性资源

在某些场景下，可以选择使用非事务性资源来避免事务管理。例如，在数据库操作中，可以选择不使用事务的数据库连接，或者在消息队列操作中选择不使用事务性队列。

1. 非事务性数据库连接

可以通过配置数据源来获取非事务性的数据库连接。例如，在Spring中，可以通过配置DataSource来获取非事务性的数据库连接。

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class MyService {
    private DataSource dataSource;
    public MyService(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    public void nonTransactionalMethod() {
        try (Connection connection = dataSource.getConnection()) {
            // 业务逻辑
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

在上面的示例中，通过DataSource获取了一个非事务性的数据库连接，然后在业务逻辑中使用该连接。

2. 非事务性消息队列

在使用消息队列时，可以选择不使用事务性队列。例如，在RabbitMQ中，可以选择不启用事务支持。

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class MyService {
    private ConnectionFactory connectionFactory;
    public MyService(ConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }
    public void nonTransactionalMethod() {
        try (Connection connection = connectionFactory.newConnection();
             Channel channel = connection.createChannel()) {
            // 业务逻辑
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

在上面的示例中，通过ConnectionFactory获取了一个非事务性的RabbitMQ连接，然后在业务逻辑中使用该连接。

四、使用AOP自定义拦截器

可以使用AOP（面向切面编程）来自定义拦截器，在方法调用前后控制事务行为。例如，可以在方法调用前检查当前是否存在事务，并根据需要启动或终止事务。

1. 自定义拦截器

可以通过实现MethodInterceptor接口来自定义拦截器，然后在Spring配置中将其应用到需要的Bean上。

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
public class NonTransactionalInterceptor implements MethodInterceptor {
    private PlatformTransactionManager transactionManager;
    public NonTransactionalInterceptor(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_NEVER);
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            Object result = invocation.proceed();
            transactionManager.commit(status);
            return result;
        } catch (Throwable e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

在上面的示例中，自定义了一个拦截器，在方法调用前启动一个非事务性的事务管理，然后在方法调用后提交或回滚事务。

2. 应用拦截器

可以在Spring配置中将自定义的拦截器应用到需要的Bean上。

<bean id="nonTransactionalInterceptor" class="com.example.NonTransactionalInterceptor">
    <constructor-arg ref="transactionManager"/>
</bean>
<aop:config>
    <aop:advisor advice-ref="nonTransactionalInterceptor" pointcut="execution(* com.example.MyService.*(..))"/>
</aop:config>

在上面的配置中，将自定义的拦截器应用到了com.example.MyService类的所有方法上。

五、总结

以上介绍了在Java中不走事务的几种方法，包括通过设置事务属性、使用编程式事务管理、使用非事务性资源和使用AOP自定义拦截器。每种方法都有其适用的场景和优势，可以根据具体需求选择合适的方法。通过这些方法，可以灵活地控制事务行为，确保在需要时避免事务管理。