【Spring源码】Spring事务原理-Toy模板网

这篇具有很好参考价值的文章主要介绍了【Spring源码】Spring事务原理。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1、什么是事务

2、Spring事务基本概念

2.1、基础配置

2.1.1、Spring事务的基础配置

2.1.2、Spring事务的传播特性

2.1.3、Spring事务的隔离级别

2.2、基本原理

3、事务嵌套

3.1、PROPAGATION_REQUIRED

3.2、PROPAGATION_REQUIRES_NEW

3.3、PROPAGATION_SUPPORTS

3.4、PROPAGATION_NESTED

4、源码看事务

5、事务失效

6、小结

1、什么是事务

事务是访问并可能更新数据库中各种数据项的一个程序执行单元，这个操作单元要么全部执行成功，要么全部执行失败。同时也是恢复和并发控制的基本单位。

事务的特性（ACID）：

原子性（Automicity）：一个事务是一个不可分割的工作单元，该工作单元可以包含很多操作，要么都做，要么都不做。
一致性（Consistency）：事务必须使数据库从一个一致性状态编导另一个一致性状态。
隔离性（Isolation）：一个事务的执行不能被其他事务干扰，即一个事务的内部操作及使用的数据对并发其他事务来说是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（Durability）：也称永久性，指一个事务一旦提交，他对数据库中数据的改变就是永久性的，其他操作或故障不应该对其有任何影响。

2、Spring事务基本概念

2.1、基础配置

我们先来回顾一下Spring事务的基础配置信息，以下由ChatGPT给我们提供的相关资料：

2.1.1、Spring事务的基础配置

1、问：Spring事务的基础配置

ChatGPT答：在 Spring 中配置事务管理通常需要以下步骤：

配置数据源：在 Spring 中，我们需要配置一个数据源，它用于连接数据库并执行相关的操作。
配置事务管理器：事务管理器是 Spring 中用来管理事务的核心组件。Spring 支持多种事务管理器，例如 JpaTransactionManager、DataSourceTransactionManager 等。
开启事务支持：在 Spring 的配置文件中通过 tx:annotation-driven标签来开启事务支持。
声明式事务管理：使用 @Transactional 注解来声明需要被事务管理的方法，该注解可以配置事务的传播行为、隔离级别、超时时间等参数。

下面是一个示例 Spring 配置文件，演示了如何配置基于注解的声明式事务管理：

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
  <property name="username" value="root"/>
  <property name="password" value=""/>
</bean>

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

<tx:annotation-driven/>

<bean id="myService" class="com.example.MyServiceImpl"/>

在上述配置文件中，我们首先配置了一个 DriverManagerDataSource 类型的数据源，并命名为 dataSource。然后我们配置了一个 DataSourceTransactionManager 类型的事务管理器，并将其与数据源关联起来。

接着，通过 tx:annotation-driven/ 标签来开启事务支持。最后，我们配置了一个名为 myService 的服务类，该类中使用了 @Transactional 注解来声明事务管理。

2.1.2、Spring事务的传播特性

问：Spring事务的传播特性

ChatGPT答：在 Spring 中，事务的传播特性（Propagation）用于控制在嵌套事务中，事务的行为如何传播到嵌套的方法调用中。Spring 提供了以下传播特性选项：

PROPAGATION_REQUIRED：默认选项，表示如果当前存在事务，则加入该事务，如果不存在，则新建一个事务。
PROPAGATION_SUPPORTS：表示如果当前存在事务，则加入该事务，如果不存在，则以非事务的方式执行。
PROPAGATION_MANDATORY：表示必须在一个已存在的事务中执行，否则抛出异常。
PROPAGATION_REQUIRES_NEW：表示不管当前是否存在事务，都会新开一个事务执行，并挂起当前事务。
PROPAGATION_NOT_SUPPORTED：表示以非事务的方式执行操作，如果当前存在事务，则将其挂起。
PROPAGATION_NEVER：表示以非事务的方式执行操作，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED：表示如果当前存在事务，则在该事务中嵌套一个事务执行，嵌套事务具有独立的保存点，并可以单独回滚，如果不存在，则新建一个事务。

下面是一个示例，演示如何在 XML 配置文件中配置事务的传播特性：

<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
    <tx:method name="add*" propagation="REQUIRED"/>
    <tx:method name="update*" propagation="REQUIRED"/>
    <tx:method name="delete*" propagation="REQUIRED"/>
    <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
    <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
  </tx:attributes>
</tx:advice>

<aop:config>
  <aop:pointcut id="serviceMethod" expression="execution(* com.example.service.*.*(..))"/>
  <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/>
</aop:config>

在上述配置文件中，我们首先定义了一个名为 txAdvice 的事务切面，其中通过 tx:attributes 标签来为不同的方法配置传播特性。

例如，我们为 add、update 和 delete 方法配置了 REQUIRED 传播特性，表示如果当前存在事务，则加入该事务，如果不存在，则新建一个事务。而对于 get 和 find 方法，我们配置了 SUPPORTS 传播特性，并设置了 read-only 属性为 true，表示这些方法是只读操作，不需要开启事务。

最后，我们通过 aop:config 标签来定义一个切入点和一个切面，并将切面和切入点关联起来，从而实现对服务类中的方法进行事务管理。

2.1.3、Spring事务的隔离级别

问：数据库事务的隔离级别

ChatGPT答：常见的隔离级别包括：

READ UNCOMMITTED（读未提交）：最低的隔离级别，允许一个事务读取另一个未提交的事务所做的修改，可能导致脏读、不可重复读和幻读问题。
READ COMMITTED（读已提交）：一个事务只能读取已经提交的数据，可以避免脏读问题，但是可能会出现不可重复读和幻读问题。
REPEATABLE READ（可重复读）：保证在事务处理期间多次读取同一数据时，数据保持一致。可以避免脏读和不可重复读问题，但仍可能出现幻读问题。
SERIALIZABLE（串行化）：最高的隔离级别，完全禁止不同事务之间的并发操作，可以避免所有可能的并发问题，但可能导致性能问题。

在实际应用中，可以通过设置数据库连接的隔离级别来指定事务的隔离级别。例如，在MySQL中可以使用如下SQL语句来设置隔离级别：

SET SESSION TRANSACTION ISOLATION LEVEL <隔离级别>

问：Spring事务的隔离级别

ChatGPT答：Spring支持以下五个隔离级别：

DEFAULT（默认）：使用底层数据源的默认隔离级别，这通常是数据库的隔离级别。
READ_UNCOMMITTED（读未提交）：最低的隔离级别，允许读取尚未提交的数据更改，可能导致脏读，不可重复读和幻读问题。
READ_COMMITTED（读已提交）：允许读取已提交的数据更改，可以避免脏读问题，但仍可能出现不可重复读和幻读问题。
REPEATABLE_READ（可重复读）：保证在事务处理期间多次读取同一数据时，数据保持一致。可以避免脏读和不可重复读问题，但仍可能出现幻读问题。
SERIALIZABLE（串行化）：最高的隔离级别，完全禁止不同事务之间的并发操作，可以避免所有可能的并发问题，但可能导致性能问题。

在选择隔离级别时，需要权衡数据的一致性和性能之间的关系，选择适合应用程序需求的隔离级别。隔离级别越高，可能会导致性能下降和死锁等问题，因此在选择隔离级别时需要谨慎考虑。

问：解析一下什么是脏读，不可重复读取，幻读

ChatGPT答：脏读、不可重复读和幻读是数据库中并发操作时可能出现的问题，这些问题与事务隔离级别有关。

脏读（Dirty Read）：一个事务读取了另一个事务尚未提交的数据，如果另一个事务回滚了操作，那么第一个事务读取的数据就是无效的。
不可重复读（Non-Repeatable Read）：一个事务在读取某一行数据时，另一个事务修改了该行数据并提交了事务，导致第一个事务多次读取同一数据时得到的结果不一致。
幻读（Phantom Read）：一个事务在读取一组数据时，另一个事务插入了符合该条件的新数据并提交了事务，导致第一个事务再次读取同一数据时得到的结果不一致。

这三种问题可以通过设置不同的事务隔离级别来避免或减少发生。例如，READ COMMITTED隔离级别可以避免脏读问题，REPEATABLE READ隔离级别可以避免脏读和不可重复读问题，而SERIALIZABLE隔离级别可以避免所有并发问题。

2.2、基本原理

由上诉ChatGPT的答复，以及自己以往Spring事务的使用可知。Spring事务管理就是基于AOP实现，主要作用就是统一封装非功能性需求。Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，Spring也无法提供事务功能。

如果我们纯操作JDBC，那么我们可以按照如下步骤进行事务控制：

Connection conn = DriverManager.getConnection();获取数据库连接
开启事务是否自动提交，conn.setAutoCommit(true/false)
JDBC操作
提交事务conn.commit()或事务回滚conn.rollback()
关闭连接conn.close()

如果使用了Spring事务，我们就不需要手动开启或关闭事务操作（上述第2步和第4步）。而是交由Spring自己完成。那么Spring使用事务的方式有哪些呢？在 Spring 中，我们可以通过声明式事务管理和编程式事务管理两种方式来管理事务。

声明式事务管理是指将事务的定义和管理与业务逻辑分离，通过配置文件或注解等方式来实现事务管理。在 Spring 中，可以使用 @Transactional 注解来声明事务。
编程式事务管理是指在代码中通过编程的方式来控制事务，即在代码中手动开启、提交和回滚事务。Spring 提供了 TransactionTemplate 类来实现编程式事务管理。

示例代码如下：

// 声明式事务
@Service
public class TestServiceImpl {
     @Transactional(rollbackFor = Exception.class)
     public void reduce(){
         ......     
     }
}

// 编程式事务
@Service
public class TestServiceImpl {
     @Autowired
     TransactionTemplate transactionTemplate;
     
     public void reduce(){
         transactionTemplate.execute(status -> {
           ......
        });
     }
}

真正的数据库层的事务提交和回滚是通过binglog或redo log实现的。

网上借来一张Spring事务API架构图：

【Spring源码】Spring事务原理

3、事务嵌套

前面2章节都是从理论知识的角度阐述了事务的一些基本特性。显然这些背诵的八股文一下子就忘记了。接下来我们以实际业务的角度来分析一下几种传播机制。且以我们平时最常见到的调用方式来说明：那就是事务嵌套。

看一段代码：

@Service
class OrderService {
    @Resource
    ReduceService reduceService;
    
    @Transactional(rollbackFor = Exception.class)
    public void createOrder(){
        // 下单
        this.createOrder0();
        // 扣除库存
        reduceService.reduce();
    }
}

@Service
class ReduceService {
    
    @Transactional(rollbackFor = Exception.class)
    public void reduce(){
        ......
    }
}

这时候，OrderService的createOrder()调用ReduceService的reduce()方法，两个方法都声明了事务，这时候就形成了事务嵌套。

3.1、PROPAGATION_REQUIRED

当执行orderService.createOrder()时，spring已经发起事务，这时候调用reduceService.reduce()时，reduceService.reduce()发现自己已经运行在事务内部，就会直接使用外部事务。如果发现外部没有事务，那么就会给reduce()方法新建事务。

当orderService.createOrder()或reduceService.reduce()发生异常时，事务都会被回滚。【Spring源码】Spring事务原理

3.2、PROPAGATION_REQUIRES_NEW

当reduceService.reduce()设置了PROPAGATION_REQUIRES_NEW，orderService.createOrder()属性为PROPAGATION_REQUIRED。那么当执行到reduce()方法时，会判断外部是否有事务，如果有，则会挂起外部事务，然后自身创建一个新的内部事务，等到内部事务执行结束后，才会继续执行被挂起的外部事务。

这样的话，由于reduce()是新发起一个事务，且与外部事务是独立的。当createOrder()发生异常时，如果reduce()事务被提交了，那么是reduce()不会回滚的。相应的，如果reduce()抛出异常，被createOrder()捕获，那么createOrder()的事务仍然可能提交，取决于外部事务的回滚操作。

【Spring源码】Spring事务原理

3.3、PROPAGATION_SUPPORTS

与PROPAGATION_REQUIRED类似，只是当执行到reduceService.reduce()方法时，会判断createOrder()是否开启了事务，如果是的话，那么直接支持该事务。如果没有的话，那么自己也不支持事务。这个事务属性是完全取决于外部的事务。

【Spring源码】Spring事务原理

3.4、PROPAGATION_NESTED

当执行到ReduceService.reduce()方法时，如果reduce()出现内部异常，则reduce()会回滚到他执行之前的SavePoint，因此是不会产生脏数据的，相当于该方法从未执行过。

此时createOrder()方法可以直接try-catch异常，然后进行分支逻辑事务处理。如：

@Service
class OrderService {
    @Resource
    ReduceService reduceService;
    
    @Transactional(rollbackFor = Exception.class)
    public void createOrder(){
        // 下单
        this.createOrder0();
        // 扣除库存
        try {
            reduceService.reduce();
        } catch (Exception e) {
            // 如果扣除异常，则取消订单
            this.cancelOrder()
            return ;
        }
        
        // 进行下一步操作
        doSomething();
    }
}

@Service
class ReduceService {
    
    @Transactional(propagation = PROPAGATION.NESTED, rollbackFor = Exception.class)
    public void reduce(){
        ......
    }
}

也可以根据外部事务的具体配置决定要提交还是回滚。不过该方式只对DataSourceTransactionManager事务管理器有效。

【Spring源码】Spring事务原理

4、源码看事务

Spring中通过注解@EnableTransactionManagement开启事务，那么我们从这个注解开始入手：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
   boolean proxyTargetClass() default false;
   AdviceMode mode() default AdviceMode.PROXY;
   int order() default Ordered.LOWEST_PRECEDENCE;
}

可以看到@Import了TransactionManagementConfigurationSelector，而这个类实现了ImportSelector接口，提供了实现方式PROXY和ASPECTJ。默认PROXY

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {

   /**
    * Returns {@link ProxyTransactionManagementConfiguration} or
    * {@code AspectJ(Jta)TransactionManagementConfiguration} for {@code PROXY}
    * and {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()},
    * respectively.
    */
   @Override
   protected String[] selectImports(AdviceMode adviceMode) {
      switch (adviceMode) {
         case PROXY:
             // AutoProxyRegistrar ： 主要是注册了 InfrastructureAdvisorAutoProxyCreator 自动代理创建器。
             // 而 InfrastructureAdvisorAutoProxyCreator 的逻辑基本上和 Aop 的逻辑相同
             // ProxyTransactionManagementConfiguration ： 注册了事务实现的核心 Bean，
             // 包括 BeanFactoryTransactionAttributeSourceAdvisor 、 TransactionAttributeSource 、 TransactionInterceptor 等
            return new String[] {AutoProxyRegistrar.class.getName(),
                  ProxyTransactionManagementConfiguration.class.getName()};
         case ASPECTJ:
            return new String[] {determineTransactionAspectClass()};
         default:
            return null;
      }
   }

   private String determineTransactionAspectClass() {
      return (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader()) ?
            TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME :
            TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME);
   }

}

AutoProxyRegistrar：就是完成事务代理类创建的部分，也就是我们熟悉的AOP代理创建注册的流程，可以跟进查看源码org.springframework.context.annotation.AutoProxyRegistrar#registerBeanDefinitions
ProxyTransactionManagementConfiguration：注册事务的实现核心

查看源码org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration

@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

   // 设置了切面拦截方法，以及切点
   @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
         TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {

      BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
      advisor.setTransactionAttributeSource(transactionAttributeSource);
      advisor.setAdvice(transactionInterceptor);
      if (this.enableTx != null) {
         advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
      }
      return advisor;
   }

   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionAttributeSource transactionAttributeSource() {
      return new AnnotationTransactionAttributeSource();
   }


    // 设置事务拦截器，增强式事务的逻辑就是在这里
   @Bean
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
      TransactionInterceptor interceptor = new TransactionInterceptor();
      interceptor.setTransactionAttributeSource(transactionAttributeSource);
      if (this.txManager != null) {
         interceptor.setTransactionManager(this.txManager);
      }
      return interceptor;
   }

}

而TransactionInterceptor这个类，就是我们切面的实现类，用于事务方法的拦截，然后通过Spring事务管理器PlatformTransactionManager进行管理。

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {

   public TransactionInterceptor() {}

   /**
    * 创建一个新的事务拦截器TransactionInterceptor.
    * @param ptm 默认的事务管理器，通过该事务管理器进行实际的事务管理
    * @param tas properties形式的事务属性
    * @since 5.2.5
    * @see #setTransactionManager
    * @see #setTransactionAttributeSource
    */
   public TransactionInterceptor(TransactionManager ptm, TransactionAttributeSource tas) {
      setTransactionManager(ptm);
      setTransactionAttributeSource(tas);
   }

   @Override
   @Nullable
   public Object invoke(MethodInvocation invocation) throws Throwable {
      // Work out the target class: may be {@code null}.
      // The TransactionAttributeSource should be passed the target class
      // as well as the method, which may be from an interface.
      Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

      // 配到父类TransactionAspectSupport的invokeWithinTransaction方法
      // 第三个参数是InvocationCallback接口，可以保证在父类TransactionAspectSupport#invokeWithinTransaction方法中回调到当前方法的拦截器链条
      return invokeWithinTransaction(invocation.getMethod(), targetClass, new CoroutinesInvocationCallback() {
         @Override
         @Nullable
         public Object proceedWithInvocation() throws Throwable {
            return invocation.proceed();
         }
         @Override
         public Object getTarget() {
            return invocation.getThis();
         }
         @Override
         public Object[] getArguments() {
            return invocation.getArguments();
         }
      });
   }
   ......
}

查看org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction

@Nullable
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
      final InvocationCallback invocation) throws Throwable {

   // 获取事务属性源TransactionAttributeSource
   TransactionAttributeSource tas = getTransactionAttributeSource();
   // 获取当前调用的方法的事务属性，如果TransactionAttribute为null，则该方法就是非事务方法
   final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
   // 获取事务管理器TransactionManager
   final TransactionManager tm = determineTransactionManager(txAttr);

   // 判断不同的事务管理器
   if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
       // ReactiveTransactionManager事务管理器不常用，这里省略
      ......
   }

   // 获取到常用的PlatformTransactionManager事务管理器
   PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
   //连接点识别符，也就是事务所作用的方法，如OrderService.createOrder()
   final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

   if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
      // Standard transaction demarcation with getTransaction and commit/rollback calls.
      // 创建一个标准事务
      TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

      Object retVal;
      try {
         // This is an around advice: Invoke the next interceptor in the chain.
         // This will normally result in a target object being invoked.
         // 调用拦截器链的下一个拦截器，最终目标方法会被调用
         retVal = invocation.proceedWithInvocation();
      }
      catch (Throwable ex) {
         // target invocation exception
         completeTransactionAfterThrowing(txInfo, ex);
         throw ex;
      }
      finally {
          // 清除事务信息
         cleanupTransactionInfo(txInfo);
      }

      if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
         // Set rollback-only in case of Vavr failure matching our rollback rules...
         TransactionStatus status = txInfo.getTransactionStatus();
         if (status != null && txAttr != null) {
            retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
         }
      }
      // 提交事务
      commitTransactionAfterReturning(txInfo);
      return retVal;
   }

   else {
      ......
   }
}

接着我们从createTransactionIfNecessary()跟进去会发现org.springframework.transaction.interceptor.TransactionAspectSupport#prepareTransactionInfo：

protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
      @Nullable TransactionAttribute txAttr, String joinpointIdentification,
      @Nullable TransactionStatus status) {

   TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
   if (txAttr != null) {
      // We need a transaction for this method...
      if (logger.isTraceEnabled()) {
         logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
      }
      // The transaction manager will flag an error if an incompatible tx already exists.
      txInfo.newTransactionStatus(status);
   }
   // 如果没有事务属性，则不需要创建事务
   else {
      // The TransactionInfo.hasTransaction() method will return false. We created it only
      // to preserve the integrity of the ThreadLocal stack maintained in this class.
      if (logger.isTraceEnabled()) {
         logger.trace("No need to create transaction for [" + joinpointIdentification +
               "]: This method is not transactional.");
      }
   }

   // We always bind the TransactionInfo to the thread, even if we didn't create
   // a new transaction here. This guarantees that the TransactionInfo stack
   // will be managed correctly even if no transaction was created by this aspect.
   // 将TransactionInfo绑定到当前线程，即使我们在这里没有创建一个新的事务
   // 这保证了TransactionInfo堆栈将被正确管理，即使这个aspect没有创建任何事务。
   // 而这里，便是我们经常提到了Spring事务是绑定到了TreadLocal进行管理的地方
   txInfo.bindToThread();
   return txInfo;
}

org.springframework.transaction.interceptor.TransactionAspectSupport#commitTransactionAfterReturning这里便是事务提交相关的处理：

protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
   if (txInfo != null && txInfo.getTransactionStatus() != null) {
      if (logger.isTraceEnabled()) {
         logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
      }
      txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
   }
}

如果出现异常，则走这里的逻辑org.springframework.transaction.interceptor.TransactionAspectSupport#completeTransactionAfterThrowing

protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
   if (txInfo != null && txInfo.getTransactionStatus() != null) {
      if (logger.isTraceEnabled()) {
         logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
               "] after exception: " + ex);
      }
      if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
         try {
             // 调用事务管理器进行事务的回滚
            txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
         }
         catch (TransactionSystemException ex2) {
            logger.error("Application exception overridden by rollback exception", ex);
            ex2.initApplicationException(ex);
            throw ex2;
         }
         catch (RuntimeException | Error ex2) {
            logger.error("Application exception overridden by rollback exception", ex);
            throw ex2;
         }
      }
      // 如果异常不满足，则进行提交commit,但是如果TransactionStatus.isRollbackOnly()方法被设置为true，那么仍然会回滚
      else {
         // We don't roll back on this exception.
         // Will still roll back if TransactionStatus.isRollbackOnly() is true.
         try {
            txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
         }
         catch (TransactionSystemException ex2) {
            logger.error("Application exception overridden by commit exception", ex);
            ex2.initApplicationException(ex);
            throw ex2;
         }
         catch (RuntimeException | Error ex2) {
            logger.error("Application exception overridden by commit exception", ex);
            throw ex2;
         }
      }
   }
}

至此，基本上源码的大致事务处理流程就已经走完。而这里只是声明式事务的基本处理流程，里面涉及到的AOP处理逻辑，在前面的《Bean生命周期》中有所提及，可以参考。还有其他细节还有待深入学习。

5、事务失效

前面讲到了一些Spring相关的基础理论知识，以及源码是如何实现的。其中我们知道了事务是通过AOP的方式来实现，那么面试中我们经常被问到的事务失效场景，是不是可以联想AOP的失效场景呢？答案是肯定可以的。

问：Spring事务失效场景有哪些？

ChatGPT答：Spring事务的失效情况主要有以下几种：

没有使用代理：Spring事务是通过代理实现的，如果没有使用代理，那么事务就不会生效。
非公共方法：只有公共方法才会被代理，如果事务注解被用于非公共方法，那么事务也不会生效。
异常被捕获：如果在事务方法内部抛出异常，但是异常被捕获并处理了，那么事务就不会生效。要使事务生效，异常必须被抛出到事务方法的外部。
事务方法调用内部方法：如果事务方法调用了另一个方法，而这个方法没有事务注解，那么事务就会失效。
外部方法调用事务方法：如果一个没有使用代理的类调用了一个事务方法，那么事务就会失效。这是因为Spring只能代理标记为@Transactional的公共方法。
静态方法：由于静态方法不属于对象，所以无法使用代理。因此，如果事务注解被用于静态方法，那么事务就不会生效。
异步调用：如果事务方法被异步调用，那么事务就会失效。因为在异步调用时，Spring无法在调用线程上下文中创建和管理事务。

6、小结

Spring事务作为Spring面试中的高频面试题，多少都会被问及。如果不清除事务的一些基础内容以及实现逻辑，很容易就卡顿甚至直接PASS。而日常业务逻辑处理中也免不了事务的基本处理，所以还是需要多巩固这方面的知识。文章来源地址https://www.toymoban.com/news/detail-402590.html

到了这里，关于【Spring源码】Spring事务原理的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！