Spring手动开启事务提交事务

• Spring框架提供了多种方法来手动开启事务。在使用Spring进行事务管理时，常见的方法有两种：

  1. 基于注解的事务管理
     通过使用@Transactional注解，可以将方法标记为需要进行事务管理的方法。在这种方式下，Spring框架会根据方法的调用情况自动开启和提交事务。对于需要手动开启事务的情况，可以在类上标注@Transactional注解，并在方法内调用TransactionStatus对象的begin方法来手动开启事务，最后通过TransactionStatus对象的commit或rollback方法来提交或回滚事务。

  例如：

  @Service
  @Transactional
  public class UserService {
  
      @Autowired
      private UserDAO userDAO;
  
      public void createUser(User user) {
          // 手动开启事务
          TransactionStatus transactionStatus = TransactionAspectSupport.currentTransactionStatus();
          transactionStatus.setRollbackOnly();
  
          try {
              // 事务操作
              userDAO.createUser(user);
              // 事务提交
              transactionStatus.setRollbackOnly(false);
          } catch (Exception e) {
              // 事务回滚
              transactionStatus.setRollbackOnly(true);
          }
      }
  }
  

  1. 编程式事务管理
     通过使用TransactionTemplate对象来手动控制事务的开启、提交和回滚。TransactionTemplate是Spring框架提供的一个用于管理事务的工具类，可以在方法内部创建TransactionTemplate对象，并使用其execute方法执行需要进行事务管理的代码块。

  例如：

  @Service
  public class UserService {
  
      @Autowired
      private UserDAO userDAO;
  
      @Autowired
      private PlatformTransactionManager transactionManager;
  
      public void createUser(User user) {
          // 获取事务定义
          DefaultTransactionDefinition def = new DefaultTransactionDefinition();
          // 设置事务隔离级别
          def.setIsolationLevel(TransactionDefinition.ISOLATION_DEFAULT);
  
          // 设置事务传播行为
          def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
          
          // 获取事务对象
          TransactionStatus transactionStatus = transactionManager.getTransaction(def);
          
          try {
              // 事务操作
              userDAO.createUser(user);
              // 事务提交
              transactionManager.commit(transactionStatus);
          } catch (Exception e) {
              // 事务回滚
              transactionManager.rollback(transactionStatus);
          }
      }
  }
  

  以上两种方法都可以实现手动开启事务的功能，具体选择哪种方法取决于项目的需求和开发团队的偏好。

• 在Spring中，我们可以使用@Transactional注解来声明事务。通过在方法或类上添加该注解，Spring会为我们自动管理事务的开启、提交和回滚。但是，有时候我们需要手动开启事务，以便更细粒度地控制事务的边界。下面是在Spring中手动开启事务的几种方式：

  1. 使用TransactionTemplate
     TransactionTemplate是Spring提供的一个工具类，它简化了事务管理的过程。我们可以通过实例化TransactionTemplate对象，并调用execute方法来执行需要进行事务管理的逻辑代码块。在execute方法的回调函数中，可以使用TransactionStatus对象来手动开启和提交事务。

  下面是使用TransactionTemplate手动开启事务的示例代码：

  @Autowired
  private TransactionTemplate transactionTemplate;
  
  public void performTransaction() {
      transactionTemplate.execute(new TransactionCallbackWithoutResult() {
          @Override
          protected void doInTransactionWithoutResult(TransactionStatus status) {
              // 执行需要进行事务管理的逻辑代码
          }
      });
  }
  

  1. 使用PlatformTransactionManager
     PlatformTransactionManager是Spring用于管理事务的接口。我们可以通过依赖注入的方式获取PlatformTransactionManager对象，并调用其getTransaction方法来手动开启事务。

  下面是使用PlatformTransactionManager手动开启事务的示例代码：

  @Autowired
  private PlatformTransactionManager transactionManager;
  
  public void performTransaction() {
      TransactionDefinition definition = new DefaultTransactionDefinition();
      TransactionStatus status = transactionManager.getTransaction(definition);
      
      try {
          // 执行需要进行事务管理的逻辑代码
          
          transactionManager.commit(status);
      } catch(Exception e) {
          transactionManager.rollback(status);
      }
  }
  

  1. 使用TransactionInterceptor
     TransactionInterceptor是Spring AOP中的一个拦截器，它可以对方法进行拦截，并在方法执行前后进行事务管理。我们可以通过配置TransactionInterceptor来手动开启事务。

  下面是使用TransactionInterceptor手动开启事务的示例代码：

  @Autowired
  private TransactionInterceptor transactionInterceptor;
  
  public void performTransaction() {
      Method method = ReflectionUtils.findMethod(getClass(), "methodName", parameterTypes);
      TransactionAspectSupport.currentTransactionStatus().isTransactionActive();
      transactionInterceptor.invoke(new MethodInvocationProceedingJoinPoint(method, args) {
          // 实现proceed方法并在其中执行需要进行事务管理的逻辑代码
      });
  }
  

  1. 使用AOP切面
     在Spring中，我们也可以通过定义AOP切面来手动开启事务。通过在切面的方法中将事务的开启逻辑放在@Before通知中实现。

  下面是使用AOP切面手动开启事务的示例代码：

  @Aspect
  @Component
  public class TransactionAspect {
      @Autowired
      private PlatformTransactionManager transactionManager;
  
      @Before("execution(* com.example.service.*.*(..))")
      public void beginTransaction(JoinPoint joinPoint) {
          TransactionDefinition definition = new DefaultTransactionDefinition();
          TransactionStatus status = transactionManager.getTransaction(definition);
          
          // 保存TransactionStatus对象到ThreadLocal中，方便其他地方获取并进行事务管理
      }
  }
  

  1. 使用编程式事务管理
     在一些特殊的场景下，我们可能需要使用编程式事务管理。通过调用DataSource的getConnection方法获取数据库连接，并手动设置事务的隔离级别、提交或回滚事务来实现。

  下面是使用编程式事务管理手动开启事务的示例代码：

  @Autowired
  private DataSource dataSource;
  
  public void performTransaction() throws SQLException {
      Connection connection = dataSource.getConnection();
      connection.setAutoCommit(false);
      
      try {
          // 执行需要进行事务管理的逻辑代码
          
          connection.commit();
      } catch (SQLException e) {
          connection.rollback();
      } finally {
          connection.close();
      }
  }
  

  在Spring中，事务是通过TransactionTemplate或者注解的方式来管理的。你可以手动开启事务来确保一系列操作的原子性和一致性。

  下面是手动开启事务的方法和操作流程：

  1. 配置事务管理器
     首先，你需要配置一个事务管理器。在Spring中，常用的事务管理器是DataSourceTransactionManager或JtaTransactionManager。这个配置放在Spring的配置文件中，以XML配置为例：

  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSource" />
  </bean>
  

  1. 创建TransactionTemplate对象
     通过TransactionTemplate可以简化使用事务的代码，它提供了一系列操作事务的模板方法。你可以在需要的地方创建一个TransactionTemplate对象：

  @Autowired
  private TransactionTemplate transactionTemplate;
  

  1. 使用TransactionTemplate进行事务操作
     在需要进行事务操作的方法中，使用TransactionTemplate的execute方法来执行事务的逻辑代码。例如，你的业务逻辑代码如下：

  public void doTransactionLogic() {
      // 在事务中执行的业务逻辑代码
  }
  

  将其改写为使用TransactionTemplate来开启事务：

  public void doTransactionLogic() {
      transactionTemplate.execute(new TransactionCallbackWithoutResult() {
          @Override
          protected void doInTransactionWithoutResult(TransactionStatus status) {
              // 在事务中执行的业务逻辑代码
          }
      });
  }
  

  需要注意的是，TransactionCallbackWithoutResult是一个抽象类，其中的doInTransactionWithoutResult方法是一个抽象方法，你需要在其中实现你的业务逻辑代码。

  1. 配置事务注解
     除了使用TransactionTemplate，你还可以使用注解的方式来开启事务。首先，需要在Spring的配置文件中启用事务注解：

  <tx:annotation-driven transaction-manager="transactionManager" />
  

  然后，在需要进行事务操作的方法上添加@Transactional注解：

  @Transactional
  public void doTransactionLogic() {
      // 在事务中执行的业务逻辑代码
  }
  

  通过以上的方式，你就能手动开启事务并进行事务的操作了。无论是使用TransactionTemplate还是注解的方式，都可以实现事务的管理和控制。