在之前的文章Spring事务源码解析（二）获取增强中，我们分析了Spring事务的实现是基于AOP实现的，还分析了增强BeanFactoryTransactionAttributeSourceAdvisor中的相关内容。而这个增强中包含一个拦截器TransactionInterceptor，代理的实现就是基于这个拦截器
现在来看一下这个拦截器的代码

TransactionInterceptor

invoke() 方法中调用了 TransactionInterceptor 父类的方法 invokeWithinTransaction() ，处理方法的调用

  1.     public Object invoke(final MethodInvocation invocation) throws Throwable {
  2.         Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
  3.         // 往下看
  4.         return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
  5.     }
  6. protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
  7.             final InvocationCallback invocation) throws Throwable {
  10.         TransactionAttributeSource tas = getTransactionAttributeSource();
  11.           // 获取事务属性
  12.         final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
  13.             //【这里获取到了用户注入的DataSourceTransactionManager】
  14.         final PlatformTransactionManager tm = determineTransactionManager(txAttr);
  15.           //方法标识，例如usersService.testTransaction
  16.         final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
  17.         //声明式事务
  18.         if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
  19.             // 1.创建TransactionInfo
  20.             TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
  21.             Object retVal = null;
  22.             try {
  23.                 // 2. 调用执行链
  24.                 retVal = invocation.proceedWithInvocation();
  25.             }
  26.             catch (Throwable ex) {
  27.                 // 3. 异常回滚
  28.                 completeTransactionAfterThrowing(txInfo, ex);
  29.                 throw ex;
  30.             }
  31.             finally {
  32.                   //4. 清除事务信息
  33.                 cleanupTransactionInfo(txInfo);
  34.             }
  35.               //5 提交事务
  36.             commitTransactionAfterReturning(txInfo);
  37.             return retVal;
  38.         }
  40.         else {
  41.           //编程式事务处理
  42.             final ThrowableHolder throwableHolder = new ThrowableHolder();
  44.             try {
  45.                 Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
  46.                     TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
  47.                     try {
  48.                         return invocation.proceedWithInvocation();
  49.                     }
  50.                     catch (Throwable ex) {
  51.                         if (txAttr.rollbackOn(ex)) {
  52.                             if (ex instanceof RuntimeException) {
  53.                                 throw (RuntimeException) ex;
  54.                             }
  55.                             else {
  56.                                 throw new ThrowableHolderException(ex);
  57.                             }
  58.                         }
  59.                         else {
  60.                             throwableHolder.throwable = ex;
  61.                             return null;
  62.                         }
  63.                     }
  64.                     finally {
  65.                         cleanupTransactionInfo(txInfo);
  66.                     }
  67.                 });
  69.                 if (throwableHolder.throwable != null) {
  70.                     throw throwableHolder.throwable;
  71.                 }
  72.                 return result;
  73.             }
  74.             catch (ThrowableHolderException ex) {
  75.                 throw ex.getCause();
  76.             }
  77.             catch (TransactionSystemException ex2) {
  78.                 if (throwableHolder.throwable != null) {
  79.                     logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
  80.                     ex2.initApplicationException(throwableHolder.throwable);
  81.                 }
  82.                 throw ex2;
  83.             }
  84.             catch (Throwable ex2) {
  85.                 if (throwableHolder.throwable != null) {
  86.                     logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
  87.                 }
  88.                 throw ex2;
  89.             }
  90.         }
  91.     }

DataSourceTransactionManager

txManager的注入在查找对应的TransactionManager中，最终会寻找PlatformTransactionManager类型的类，用户之前在JDBCConfig配置时配置了一个DataSourceTransactionManager，它是PlatformTransactionManager的实现类
image.png

由于咱们经常使用的就是声明式事务，所以接下来的解析也是基于声明式事务来的

创建事务

  1. protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
  2.             @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
  4.         //如果事务没有指定名称则使用方法标识
  5.         if (txAttr != null && txAttr.getName() == null) {
  6.             txAttr = new DelegatingTransactionAttribute(txAttr) {
  7.                 @Override
  8.                 public String getName() {
  9.                     return joinpointIdentification;
  10.                 }
  11.             };
  12.         }
  14.         TransactionStatus status = null;
  15.         if (txAttr != null) {
  16.             if (tm != null) {
  17.                //1. 创建事务
  18.                 status = tm.getTransaction(txAttr);
  19.             }
  20.             else {
  21.                 if (logger.isDebugEnabled()) {
  22.                     logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
  23.                             "] because no transaction manager has been configured");
  24.                 }
  25.             }
  26.         }
  27.           //2.构建事务信息
  28.         return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
  29.     }

获取事务

  1. public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
  2.         //1. 获取事务【这里调用的使用的对应的DataSourcetTransactionManager，上方tm赋值的】
  3.           Object transaction = doGetTransaction();
  4.         boolean debugEnabled = logger.isDebugEnabled();
  6.         if (definition == null) {
  7.             definition = new DefaultTransactionDefinition();
  8.         }
  9.         //2. 判断当前线程是否存在事务
  10.         if (isExistingTransaction(transaction)) {
  11.               //【存在事务则使用嵌套事务处理】    
  12.             return handleExistingTransaction(definition, transaction, debugEnabled);
  13.         }
  15.         // 事务超时
  16.         if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
  17.             throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
  18.         }
  20.         // 如果当前没有事务，但是事务的传播行为被定义为PROPAGATION_MANDATORY，则抛出异常
  21.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
  22.             throw new IllegalTransactionStateException(
  23.                     "No existing transaction found for transaction marked with propagation 'mandatory'");
  24.         }//当事务的传播行为需要新建事务时的处理
  25.         else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
  26.                 definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
  27.                 definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
  28.             SuspendedResourcesHolder suspendedResources = suspend(null);
  29.             if (debugEnabled) {
  30.                 logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
  31.             }
  32.             try {
  33.                 boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
  34.                 DefaultTransactionStatus status = newTransactionStatus(
  35.                         definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
  36.                   //3. 【准备事务】
  37.                   doBegin(transaction, definition);
  38.                   //4. 记录事务状态
  39.                 prepareSynchronization(status, definition);
  40.                 return status;
  41.             }
  42.             catch (RuntimeException | Error ex) {
  43.                 resume(null, suspendedResources);
  44.                 throw ex;
  45.             }
  46.         }
  47.         else {
  48.             // 创建空事务
  49.             if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
  50.                 logger.warn("Custom isolation level specified but no actual transaction initiated; " +
  51.                         "isolation level will effectively be ignored: " + definition);
  52.             }
  53.             boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
  54.             return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
  55.         }
  56.     }

整个获取事务的过程还是包含多个步骤的，其中doBegin比较值得聊一聊

  1. protected void doBegin(Object transaction, TransactionDefinition definition) {
  2.         DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
  3.         Connection con = null;
  5.         try {
  6.             if (!txObject.hasConnectionHolder() ||
  7.                     txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
  8.                 Connection newCon = obtainDataSource().getConnection();
  9.                 if (logger.isDebugEnabled()) {
  10.                     logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
  11.                 }
  12.                 txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
  13.             }
  15.             txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
  16.            //获取当前数据库连接
  17.             con = txObject.getConnectionHolder().getConnection();
  18.             //获取隔离级别
  19.             Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
  20.             txObject.setPreviousIsolationLevel(previousIsolationLevel);
  22.             // 设置自动提交
  23.             if (con.getAutoCommit()) {
  24.                 txObject.setMustRestoreAutoCommit(true);
  25.                 if (logger.isDebugEnabled()) {
  26.                     logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
  27.                 }
  28.                 con.setAutoCommit(false);
  29.             }
  31.             prepareTransactionalConnection(con, definition);
  32.               //设置当前线程存在事务的标示
  33.             txObject.getConnectionHolder().setTransactionActive(true);
  34.             //设置超时时间
  35.             int timeout = determineTimeout(definition);
  36.             if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
  37.                 txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
  38.             }
  40.             // 将连接绑定到当前线程(里面有ThreadLocal)
  41.             if (txObject.isNewConnectionHolder()) {
  42.                 TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
  43.             }
  44.         }
  46.         catch (Throwable ex) {
  47.             if (txObject.isNewConnectionHolder()) {
  48.                 DataSourceUtils.releaseConnection(con, obtainDataSource());
  49.                 txObject.setConnectionHolder(null, false);
  50.             }
  51.             throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
  52.         }
  53.     }

嵌套事务处理

至于记录事务状态这里先不说，先看一下已存在的事务是如何处理的

  1. private TransactionStatus handleExistingTransaction(
  2.             TransactionDefinition definition, Object transaction, boolean debugEnabled)
  3.             throws TransactionException {
  4.         //判断传播行为是否需要存在事务
  5.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
  6.             throw new IllegalTransactionStateException(
  7.                     "Existing transaction found for transaction marked with propagation 'never'");
  8.         }
  9.         //不开启事务
  10.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
  11.             if (debugEnabled) {
  12.                 logger.debug("Suspending current transaction");
  13.             }
  14.             Object suspendedResources = suspend(transaction);
  15.             boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
  16.             return prepareTransactionStatus(
  17.                     definition, null, false, newSynchronization, debugEnabled, suspendedResources);
  18.         }
  19.         //总是新建事务
  20.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
  21.             if (debugEnabled) {
  22.                 logger.debug("Suspending current transaction, creating new transaction with name [" +
  23.                         definition.getName() + "]");
  24.             }
  25.             SuspendedResourcesHolder suspendedResources = suspend(transaction);
  26.             try {
  27.                 boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
  28.                 DefaultTransactionStatus status = newTransactionStatus(
  29.                         definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
  30.                 doBegin(transaction, definition);
  31.                 prepareSynchronization(status, definition);
  32.                 return status;
  33.             }
  34.             catch (RuntimeException | Error beginEx) {
  35.                 resumeAfterBeginException(transaction, suspendedResources, beginEx);
  36.                 throw beginEx;
  37.             }
  38.         }
  39.         //嵌套事务
  40.         if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
  41.             if (!isNestedTransactionAllowed()) {
  42.                 throw new NestedTransactionNotSupportedException(
  43.                         "Transaction manager does not allow nested transactions by default - " +
  44.                         "specify 'nestedTransactionAllowed' property with value 'true'");
  45.             }
  46.             if (debugEnabled) {
  47.                 logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
  48.             }
  49.             if (useSavepointForNestedTransaction()) {
  50.                 // Create savepoint within existing Spring-managed transaction,
  51.                 // through the SavepointManager API implemented by TransactionStatus.
  52.                 // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
  53.                 DefaultTransactionStatus status =
  54.                         prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
  55.                 status.createAndHoldSavepoint();
  56.                 return status;
  57.             }
  58.             else {
  59.                 // Nested transaction through nested begin and commit/rollback calls.
  60.                 // Usually only for JTA: Spring synchronization might get activated here
  61.                 // in case of a pre-existing JTA transaction.
  62.                 boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
  63.                 DefaultTransactionStatus status = newTransactionStatus(
  64.                         definition, transaction, true, newSynchronization, debugEnabled, null);
  65.                 doBegin(transaction, definition);
  66.                 prepareSynchronization(status, definition);
  67.                 return status;
  68.             }
  69.         }
  71.         // Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
  72.         if (debugEnabled) {
  73.             logger.debug("Participating in existing transaction");
  74.         }
  75.         if (isValidateExistingTransaction()) {
  76.             if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
  77.                 Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
  78.                 if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
  79.                     Constants isoConstants = DefaultTransactionDefinition.constants;
  80.                     throw new IllegalTransactionStateException("Participating transaction with definition [" +
  81.                             definition + "] specifies isolation level which is incompatible with existing transaction: " +
  82.                             (currentIsolationLevel != null ?
  83.                                     isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
  84.                                     "(unknown)"));
  85.                 }
  86.             }
  87.             if (!definition.isReadOnly()) {
  88.                 if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
  89.                     throw new IllegalTransactionStateException("Participating transaction with definition [" +
  90.                             definition + "] is not marked as read-only but existing transaction is");
  91.                 }
  92.             }
  93.         }
  94.         boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
  95.         return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
  96.     }

可以看到记录事务状态是最后一步了，嵌套和不嵌套都会走这里

  1. protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
  2.         if (status.isNewSynchronization()) {
  3.             TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
  4.             TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
  5.                     definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
  6.                             definition.getIsolationLevel() : null);
  7.             TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
  8.             TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
  9.             TransactionSynchronizationManager.initSynchronization();
  10.         }
  11.     }

构建事务信息

  1. protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
  2.             @Nullable TransactionAttribute txAttr, String joinpointIdentification,
  3.             @Nullable TransactionStatus status) {
  5.         TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
  6.         if (txAttr != null) 
  7.             if (logger.isTraceEnabled()) {
  8.                 logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
  9.             }
  10.             // 记录事务状态
  11.             txInfo.newTransactionStatus(status);
  12.         }
  13.         else {
  14.             if (logger.isTraceEnabled())
  15.                 logger.trace("Don't need to create transaction for [" + joinpointIdentification +
  16.                         "]: This method isn't transactional.");
  17.         }
  19.         txInfo.bindToThread();
  20.         return txInfo;
  21.     }

事务回滚

可以知道事务回滚是进入这个方法， invokeWithinTransaction() 的 completeTransactionAfterThrowing() 

  1. protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
  2.           //是否存在事务
  3.         if (txInfo != null && txInfo.getTransactionStatus() != null) {
  4.             if (logger.isTraceEnabled()) {
  5.                 logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
  6.                         "] after exception: " + ex);
  7.             }
  8.               //是否满足回滚条件，比如是否运行时异常等
  9.             if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
  10.                 try {
  11.                       //【回滚处理】
  12.                     txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
  13.                 }
  14.                 catch (TransactionSystemException ex2) {
  15.                     logger.error("Application exception overridden by rollback exception", ex);
  16.                     ex2.initApplicationException(ex);
  17.                     throw ex2;
  18.                 }
  19.                 catch (RuntimeException | Error ex2) {
  20.                     logger.error("Application exception overridden by rollback exception", ex);
  21.                     throw ex2;
  22.                 }
  23.             }
  24.             else {
  25.                 //不满足回滚条件时同样提交
  26.                 try {
  27.                     txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
  28.                 }
  29.                 catch (TransactionSystemException ex2) {
  30.                     logger.error("Application exception overridden by commit exception", ex);
  31.                     ex2.initApplicationException(ex);
  32.                     throw ex2;
  33.                 }
  34.                 catch (RuntimeException | Error ex2) {
  35.                     logger.error("Application exception overridden by commit exception", ex);
  36.                     throw ex2;
  37.                 }
  38.             }
  39.         }
  40.     }

回滚的逻辑

  1. public final void rollback(TransactionStatus status) throws TransactionException {
  2.    //如果事务完成了就不能回滚
  3.     if (status.isCompleted()) {
  4.         throw new IllegalTransactionStateException(
  5.                 "Transaction is already completed - do not call commit or rollback more than once per transaction");
  6.     }
  8.     DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
  9.     processRollback(defStatus, false);
  10. }
  11.    private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
  12.     try {
  13.         boolean unexpectedRollback = unexpected;
  15.         try {
  16.            //扩展点
  17.             triggerBeforeCompletion(status);
  18.                //如果有保存点
  19.             if (status.hasSavepoint()) {
  20.                 if (status.isDebug()) {
  21.                     logger.debug("Rolling back transaction to savepoint");
  22.                 }
  23.                    //推到保存点
  24.                 status.rollbackToHeldSavepoint();
  25.             }
  26.             else if (status.isNewTransaction()) {
  27.                 if (status.isDebug()) {
  28.                     logger.debug("Initiating transaction rollback");
  29.                 }//如果当前事务为独立事务则直接回退
  30.                 doRollback(status);
  31.             }
  32.             else {
  33.                 // Participating in larger transaction
  34.                 if (status.hasTransaction()) {
  35.                     if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
  36.                         if (status.isDebug()) {
  37.                             logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
  38.                         }
  39.                            //不是独立事务标记状态
  40.                         doSetRollbackOnly(status);
  41.                     }
  42.                     else {
  43.                         if (status.isDebug()) {
  44.                             logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
  45.                         }
  46.                     }
  47.                 }
  48.                 else {
  49.                     logger.debug("Should roll back transaction but cannot - no transaction available");
  50.                 }
  51.                 // Unexpected rollback only matters here if we're asked to fail early
  52.                 if (!isFailEarlyOnGlobalRollbackOnly()) {
  53.                     unexpectedRollback = false;
  54.                 }
  55.             }
  56.         }
  57.         catch (RuntimeException | Error ex) {
  58.             triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
  59.             throw ex;
  60.         }
  61.            //扩展点
  62.         triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
  64.         // Raise UnexpectedRollbackException if we had a global rollback-only marker
  65.         if (unexpectedRollback) {
  66.             throw new UnexpectedRollbackException(
  67.                     "Transaction rolled back because it has been marked as rollback-only");
  68.         }
  69.     }
  70.     finally {
  71.        //清理资源
  72.         cleanupAfterCompletion(status);
  73.     }
  74. }

而真的的回滚逻辑则是利用JDBC的回滚逻辑实现的

  1. protected void doRollback(DefaultTransactionStatus status) {
  2.         DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)status.getTransaction();
  3.         Connection con = txObject.getConnectionHolder().getConnection();
  4.         if (status.isDebug()) {
  5.             this.logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
  6.         }
  8.         try {
  9.             con.rollback();
  10.         } catch (SQLException var5) {
  11.             throw new TransactionSystemException("Could not roll back JDBC transaction", var5);
  12.         }
  13.     }

事务提交

invokeWithinTransaction() 的 commitTransactionAfterReturning()

  1. protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
  2.         if (txInfo != null && txInfo.getTransactionStatus() != null) {
  3.             if (logger.isTraceEnabled()) {
  4.                 logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
  5.             }
  6.             txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
  7.         }
  8.     }
  9. public final void commit(TransactionStatus status) throws TransactionException {
  10.         //如果事务已经完成
  11.         if (status.isCompleted()) {
  12.             throw new IllegalTransactionStateException(
  13.                     "Transaction is already completed - do not call commit or rollback more than once per transaction");
  14.         }
  16.         DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
  17.         //如果事务设置了回滚标记则直接回滚
  18.         if (defStatus.isLocalRollbackOnly()) {
  19.             if (defStatus.isDebug()) {
  20.                 logger.debug("Transactional code has requested rollback");
  21.             }
  22.             processRollback(defStatus, false);
  23.             return;
  24.         }
  26.         if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
  27.             if (defStatus.isDebug()) {
  28.                 logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
  29.             }
  30.             processRollback(defStatus, true);
  31.             return;
  32.         }
  33.        //提交事务
  34.         processCommit(defStatus);
  35.     }
  36. private void processCommit(DefaultTransactionStatus status) throws TransactionException {
  37.         try {
  38.             boolean beforeCompletionInvoked = false;
  40.             try {
  41.                 boolean unexpectedRollback = false;
  42.                 //扩展点的相关调用
  43.                 prepareForCommit(status);
  44.                 triggerBeforeCommit(status);
  45.                 triggerBeforeCompletion(status);
  46.                 beforeCompletionInvoked = true;
  48.                 if (status.hasSavepoint()) {
  49.                     if (status.isDebug()) {
  50.                         logger.debug("Releasing transaction savepoint");
  51.                     }
  52.                     unexpectedRollback = status.isGlobalRollbackOnly();
  53.                     //清除保存点信息
  54.                     status.releaseHeldSavepoint();
  55.                 }
  56.                 else if (status.isNewTransaction()) {
  57.                     if (status.isDebug()) {
  58.                         logger.debug("Initiating transaction commit");
  59.                     }
  60.                     unexpectedRollback = status.isGlobalRollbackOnly();
  61.                     //提交事务，同样这里也是调用的JDBC的方法实现的
  62.                     doCommit(status);
  63.                 }
  64.                 else if (isFailEarlyOnGlobalRollbackOnly()) {
  65.                     unexpectedRollback = status.isGlobalRollbackOnly();
  66.                 }
  68.                 // Throw UnexpectedRollbackException if we have a global rollback-only
  69.                 // marker but still didn't get a corresponding exception from commit.
  70.                 if (unexpectedRollback) {
  71.                     throw new UnexpectedRollbackException(
  72.                             "Transaction silently rolled back because it has been marked as rollback-only");
  73.                 }
  74.             }
  75.             catch (UnexpectedRollbackException ex) {
  76.                 // can only be caused by doCommit
  77.                 triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
  78.                 throw ex;
  79.             }
  80.             catch (TransactionException ex) {
  81.                 // can only be caused by doCommit
  82.                 if (isRollbackOnCommitFailure()) {
  83.                     doRollbackOnCommitException(status, ex);
  84.                 }
  85.                 else {
  86.                     triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
  87.                 }
  88.                 throw ex;
  89.             }
  90.             catch (RuntimeException | Error ex) {
  91.                 if (!beforeCompletionInvoked) {
  92.                     triggerBeforeCompletion(status);
  93.                 }
  94.                 doRollbackOnCommitException(status, ex);
  95.                 throw ex;
  96.             }
  98.             // Trigger afterCommit callbacks, with an exception thrown there
  99.             // propagated to callers but the transaction still considered as committed.
  100.             try {
  101.                 triggerAfterCommit(status);
  102.             }
  103.             finally {
  104.                 triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
  105.             }
  107.         }
  108.         finally {
  109.             cleanupAfterCompletion(status);
  110.         }
  111.     }