Spring各种传播特性源码实现的概览

这几天都在分析Spring的源码实现,看到事务管理的部分

　　我们知道事务的传播特性有下面几种,我标黄的就是最常用的3中传播特性, Sping在发生事务嵌套的时候,会依据内层事务的传播特性,来决定内层是事务的行为

　　对于传播特性的处理,一定是在外层已经存在事务的情况下进行的, 使用了AOP事务管理 那么在执行外层方法前,进入代理的时候就会调用getTransaction(txAttr)方法来开启事务,此时因为还没有ConnectionHolder创建出来,所以一定会去创建Connection 和 ConnectionHolder 以及开启事务的,这个时候 spring不会关系外层方法对于的事务的传播特性,此时的传播特性也没有什么意义. 

　　到了第二层,这个传播特性才开始起作用了,在外层已经有事务开启的情况下,本层的方法是开启新事务,还是加入上层的事务,还是报错,等等举动,就都取决于这个传播特性了.

• PROPAGATION_MANDATORY  方法必须在事务中运行,如果没有事务就要抛出错误 MANDATORY 是强制的意思
• PROPAGATION_NESTED   嵌套,外层有事务的情况下 如果内层要打开事务就打开事务嵌套运行,如果内层没有事务就加入到上层事务中去,嵌套事务是可以独立提交和回滚的 (对于jdbc Spring其实在内层没有开启新事务,只是在内层方法前设置了savepoint)
• PROPAGATION_NEVER  表示这个方法不能运行在事务中,如果上下文有事务 就要抛出异常
• PROPAGATION_NOT_SUPPORTED 表示当前方法运行的时候 如果有上下文事务,那么上下文事务会被挂起 等该方法执行结束,上下文事务恢复
• PROPAGATION_REQUIRED  表示当前方法必须运行在事务中,如果上下文有事务就加入上下文事务;上下文没有事务,就启动一个新事务
• PROPAGATION_REQUIRES_NEW  当前方法一定会启动自己的事务,如果有上下文事务,上下文事务会被挂起的 (对于jdbc  Spring在内层开启新事务(创建了新的Connection  内层事务是独立的开启 提交 回滚的)
• PROPAGATION_SUPPORTS 表示当前方法不需要上下文事务,但是如果有上下文事务的话 还是可以在上下文事务里运行的

     

    对于不同的传播特性 做出不同的处理,这个逻辑所在的核心方法就是AbstractPlatformTransactionManager类中的handleExistingTransaction方法

看源码摘录:

     /**
      * Create a TransactionStatus for an existing transaction.
      */
     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) {
             if (debugEnabled) {
                 logger.debug("Suspending current transaction");
             }
             //开始挂起外层事务  这会把外层事务的ConnectionHolder ,names isolation 等等属性存到suspendedResources  然后suspendedResources 存到
 //本层事务对于的TransactionStatus对象里面
             //然后会清除TransactionSynchronizationManager里面的ThreadLocal属性 包括线程绑定的ConnectionHolder ,于是本层dao方法中如果要访问数据库就不能取ThreadLocal里的Connection了
 //得自己新建Connection,自然就实现了脱离外层事务的目的
             //等到本层dao方法结束,进行commit的时候 会跳过doCommit方法 执行resume方法 恢复外层事务
             Object suspendedResources = suspend(transaction); 

             //newSynchronization 肯定是false
             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 {
                 //开启本层新事务
                 boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);//也是true
                 //创建txStatus对象 isNewTransaction是true
                 DefaultTransactionStatus status = newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
                 //执行conn.setAutoCommit(false) 以及ConnectionHolder状态设置,以及ConnectionHolder线程绑定
                 doBegin(transaction, definition);
                 //TransactionSynchronizationManager属性填充
                 prepareSynchronization(status, definition);

                 return status;
             }
             catch (RuntimeException beginEx) {
                 //如果出异常 就恢复上层事务
                 resumeAfterBeginException(transaction, suspendedResources, beginEx);
                 throw beginEx;
             }
             catch (Error beginErr) {
                 resumeAfterBeginException(transaction, suspendedResources, beginErr);
                 throw beginErr;
             }
         }

         //PROPAGATION_NESTED 是嵌套,但是spring实现jdbc的嵌套并没有开启事务,而是通过设置savepoint来实现的
         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'");
             }
             if (debugEnabled) {
                 logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
             }
             //如果允许使用savepoint来实现Nest
             if (useSavepointForNestedTransaction()) {
                 // Create savepoint within existing Spring-managed transaction,
                 // through the SavepointManager API implemented by TransactionStatus.
                 // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
                 //不开启新事务 直接创建txStatus
                 DefaultTransactionStatus status = prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
                 //创建savepoint
                 status.createAndHoldSavepoint();
                 return status;
             }
             else {
                 //如果不允许使用savepoint 那就和PROPAGATION_REQUIRES_NEW 是一样的 本层开启全新事务  区别在于 这里是没有对上层事务做挂起
                 //这种事情主要用在JTA事务
                 // Nested transaction through nested begin and commit/rollback calls.
                 // Usually only for JTA: Spring synchronization might get activated here
                 // in case of a pre-existing JTA transaction.
                 boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
                 DefaultTransactionStatus status = newTransactionStatus(
                         definition, transaction, true, newSynchronization, debugEnabled, null);
                 doBegin(transaction, definition);
                 prepareSynchronization(status, definition);
                 return status;
             }
         }

         // Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
         if (debugEnabled) {
             logger.debug("Participating in existing transaction");
         }
         if (isValidateExistingTransaction()) {
             if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
                 Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
                 if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
                     Constants isoConstants = DefaultTransactionDefinition.constants;
                     throw new IllegalTransactionStateException("Participating transaction with definition [" +
                             definition + "] specifies isolation level which is incompatible with existing transaction: " +
                             (currentIsolationLevel != null ?
                                     isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
                                     "(unknown)"));
                 }
             }
             if (!definition.isReadOnly()) {
                 if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
                     throw new IllegalTransactionStateException("Participating transaction with definition [" +
                             definition + "] is not marked as read-only but existing transaction is");
                 }
             }
         }

         //PROPAGATION_SUPPORTS  和 PROPAGATION_REQUIRED的情况  处理方式是一样的 也就是不做任何处理 直接生产TransactionStatus对象就返回了 本层直接加入上层事务
         boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
         return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
     }