Spring 事务源码(五)：事务的传播特性

1、事务传播特性

　　Springs事务传播特性：

 

名称	解释
REQUIRED	支持当前事务，如果当前没有事务，就新建一个事务。 Spring 默认的事务传播特性	支持外层事务
SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行
MANDATORY	支持当前事务，如果当前没有事务，则抛出异常
REQUIRES_NEW	新建事务，如果当前存在事务，则事务挂起，新增一个事务，新建的事务和当前的事务没有任何关系，是两个独立的事务，外层的事务失败回归后，不能回滚内层事务的运行结果，内层事务失败抛出异常，外层事务有捕获，也能不回滚事务操作	不支持外层事务
NOT_SUPPORTED	不执行当前事务；而是总是执行非事务
NEVER	以非事务方式执行，如果当前存在事务，则抛出异常
NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与REQUIRED类似的操作	嵌套事务

 

2、外层传播特性REQUIRED为例分析Spring事务传播特性

　　外层的传播特性为REQUIRED，首先外层会新建一个事务TransactionInfo，如果已存在事务，那么内存的事务该如何执行？我们接着往下分析。

2.1、已存在事务执行流程入口

　　AbstractPlatformTransactionManager#getTransaction 获取事务状态核心伪代码：

// 获取事务信息
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {

　　// 若不指定事务定义，则使用默认的事务定义StaticTransactionDefinition
　　TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());

　　// 获取数据源对象 DataSourceTransactionObject
　　Object transaction = doGetTransaction();
　　boolean debugEnabled = logger.isDebugEnabled();

　　// 若已存在事务，按已存在事务流程执行
　　if (isExistingTransaction(transaction)) {
　　　　return handleExistingTransaction(def, transaction, debugEnabled);
　　}
}

1、创建数据源对象

　　AbstractPlatformTransactionManager#doGetTransaction 获取数据源属性对象核心代码：

// 创建数据源属性对象，并填充属性
protected Object doGetTransaction() {
   // 创建一个数据源事务对象
   DataSourceTransactionObject txObject = new DataSourceTransactionObject();
   // 是否允许当前事务设置保存点
   txObject.setSavepointAllowed(isNestedTransactionAllowed());
   // 对于内层被增强方法而言，数据源对应的jdbc连接在创建新事务时, 在事务同步管理器中已经完成初始化，此处事务管理器的jdbc连接不为空
   ConnectionHolder conHolder =
         (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
   txObject.setConnectionHolder(conHolder, false);
   // 返回事务对象
   return txObject;
}

　　创建数据源属性对象，并设置是否允许当前事务设置保存点，并获取数据源对应的jdbc连接，设置进数据源属性对象中。

2、是否为已存在的事务

　　DataSourceTransactionManager#isExistingTransaction 是否已存在事务核心代码

protected boolean isExistingTransaction(Object transaction) {
   DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
   // 判断数据源事务对象中是否有连接持有器，并且事务处理激活状态
   return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
}

3、执行已存在事务流程概览

3.1、核心流程图

3.2、核心伪代码

　　AbstractPlatformTransactionManager#handleExistingTransaction 执行已存在事务核心伪代码：

private TransactionStatus handleExistingTransaction(
      TransactionDefinition definition, Object transaction, boolean debugEnabled)
      throws TransactionException {

    // 当前事务行为为PROPAGATION_NEVER, 不支持事务,但是当前又存在一个事务,所以抛出异常
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
      throw new IllegalTransactionStateException(
            "Existing transaction found for transaction marked with propagation 'never'");
   }

   // 当前事务行为为PROPAGATION_NOT_SUPPORTED, 挂起已经存在的事务, 以非事务状态运行
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
      // 挂起当前事务并返回挂起的资源持有器
      Object suspendedResources = suspend(transaction);
      boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
      // 创建一个新的非事务状态(保存了上一个存在事务状态的属性)
      return prepareTransactionStatus(
            definition, null, false, newSynchronization, debugEnabled, suspendedResources);
   }

    // 当前事务行为为PROPAGATION_REQUIRES_NEW，挂起已经存在的事务，开启一个新事务
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
      if (debugEnabled) {
         logger.debug("Suspending current transaction, creating new transaction with name [" +
               definition.getName() + "]");
      }
      // 挂起当前事务并返回挂起的资源持有器
      SuspendedResourcesHolder suspendedResources = suspend(transaction);
      try {
         // 创建事务(保存了上一个存在事务状态的属性)
         return startTransaction(definition, transaction, debugEnabled, suspendedResources);
      }
      catch (RuntimeException | Error beginEx) {
         resumeAfterBeginException(transaction, suspendedResources, beginEx);
         throw beginEx;
      }
   }
  
   // 当前事务行为PROPAGATION_NESTED，判断是否允许嵌套事务，不允许，抛异常；
   // 否则，判断是否使用保存点执行Nest事务，若使用保存点，创建事务状态对象，并为当前事务创建一个保存点，返回事务状态对象；
   // 若不使用保存点执行Nest事务，创建事务执行
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
      // 支持嵌套事务，不允许就报异常
      if (!isNestedTransactionAllowed()) {
         throw new NestedTransactionNotSupportedException(
               "Transaction manager does not allow nested transactions by default - " +
               "specify 'nestedTransactionAllowed' property with value 'true'");
      }

      // 是否使用保存点执行nest事务，默认为true
      if (useSavepointForNestedTransaction()) {
         // 如果没有可以使用保存点的方式控制事务回滚，那么在嵌入式事务的建立初始保存点
         DefaultTransactionStatus status =
               prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
         // 为事务设置一个回退点
         status.createAndHoldSavepoint();
         return status;
      }
      else {
         // 不使用保存点的操作
         return startTransaction(definition, transaction, debugEnabled, null);
      }
   }
    
   // 若为REQUIRED
   // 事务是否需要同步标识
   boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
   // 创建事务状态对象，newTransaction标识设置为false，标识不是一个新事务
   return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

1、内层传播特性为NEVER

　　当前事务行为为PROPAGATION_NEVER, 不支持事务,但是当前又存在一个事务,所以抛出异常

2、内层传播特性为NOT_SUPPORTED

　　当前事务行为为PROPAGATION_NOT_SUPPORTED, 挂起已经存在的事务, 以非事务状态运行

3、内层传播特性为REQUIRES_NEW

　　当前事务行为为PROPAGATION_REQUIRES_NEW，挂起已经存在的事务，开启一个新事务

4、内层传播特性为NESTED

　　当前事务行为PROPAGATION_NESTED，判断是否允许嵌套事务，不允许，抛异常；

　　否则，判断是否使用保存点执行Nest事务，若使用保存点，创建事务状态对象，并为当前事务创建一个保存点，返回事务状态对象；

　　若不使用保存点执行Nest事务，开启一个新事务执行

5、内层传播特性为REQUIRED

　　当前事务行为PROPAGATION_REQUIRED，创建事务状态对象，newTransaction标识设置为false，标识不是一个新事务，并返回事务状态对象。不是一个新事务代表，jdbc连接用的是同一个，在异常未捕获时，若发生回滚则一起回滚。