【Spring】事务的执行原理（三）

事务的回滚

1. 如果获取事务属性不为空，并且抛出的异常是RuntimeException或者Error类型，调用事务管理器中的rollback方法进行回滚

2. 如果事务属性为空或者抛出的异常不是RuntimeException，也不是Error，将继续提交事务

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {

    /**
     * 处理抛出异常下的事务
     */
    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);
            }
            // 如果事务属性不为空并且异常是是RuntimeException或者Error
            if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    // 获取事务管理器，调用rollback方法进行回滚
                    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;
                }
            }
            else {
                // 如果事务属性为空或者异常不是RuntimeException或者Error，继续提交事务
                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;
                }
            }
        }
    }
}

// DefaultTransactionAttribute中实现了rollbackOn方法
public class DefaultTransactionAttribute extends DefaultTransactionDefinition implements TransactionAttribute {
    /**
     * 判断是否是RuntimeException或者Error
     */
    @Override
    public boolean rollbackOn(Throwable ex) {
        return (ex instanceof RuntimeException || ex instanceof Error);
    }
}

rollback方法在AbstractPlatformTransactionManager中实现，主要分为以下三种情况：

1. 判断事务是否设置了保存点，如果设置了将事务回滚到保存点
2. 如果是一个独立的新事务，直接回滚即可
3. 如果既没有设置保存点，也不是一个新事务，说明可能处于嵌套事务中，此时只设置回滚状态rollbackOnly为true，当它的外围事务进行提交时，如果发现回滚状态为true，则不提交

以上步骤执行完毕，调用cleanupAfterCompletion方法进行资源的清理已经挂起事务的恢复。

public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
    /* 
	 * 回滚
	 */
    @Override
    public final void rollback(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException(
                    "Transaction is already completed - do not call commit or rollback more than once per transaction");
        }
        // 转为DefaultTransactionStatus
        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        // 处理回滚
        processRollback(defStatus, false);
    }

    /**
     * 处理回滚
     */
    private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
        try {
            boolean unexpectedRollback = unexpected;

            try {
                // 回滚之前的触发器
                triggerBeforeCompletion(status);
                // 是否有保存点
                if (status.hasSavepoint()) {
                    if (status.isDebug()) {
                        logger.debug("Rolling back transaction to savepoint");
                    }
                    // 回滚至保存点
                    status.rollbackToHeldSavepoint();
                }
                else if (status.isNewTransaction()) { // 如果是一个独立的新事务
                    if (status.isDebug()) {
                        logger.debug("Initiating transaction rollback");
                    }
                    // 直接回滚
                    doRollback(status);
                }
                else {
                    // 如果处于一个嵌套的事务汇总
                    if (status.hasTransaction()) {
                        // 如果本地的回滚状态置为true 或者 事务失败进行全局回滚
                        if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
                            if (status.isDebug()) {
                                logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
                            }
                            // 设置事务rollbackOnly状态为true
                            doSetRollbackOnly(stat);
                        }
                        else {
                            // 打印日志，意思是由事务的组织者决定是否回滚
                            if (status.isDebug()) {
                                logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
                            }
                        }
                    }
                    else {
                        // 打印DEBUG日志，应该回滚但是没有获取到事务
                        logger.debug("Should roll back transaction but cannot - no transaction available");
                    }
                    // Unexpected rollback only matters here if we're asked to fail early
                    if (!isFailEarlyOnGlobalRollbackOnly()) {
                        unexpectedRollback = false;
                    }
                }
            }
            catch (RuntimeException | Error ex) {
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
                throw ex;
            }
            // 回滚之后的触发器
            triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

            // Raise UnexpectedRollbackException if we had a global rollback-only marker
            if (unexpectedRollback) {
                throw new UnexpectedRollbackException(
                        "Transaction rolled back because it has been marked as rollback-only");
            }
        }
        finally {
            // 清除相关资源并恢复挂起的事务
            cleanupAfterCompletion(status);
        }
    }

    /**
     * 当一个事务失败以后，是否全局的标进行事务回滚
     */
    public final boolean isGlobalRollbackOnParticipationFailure() {
        return this.globalRollbackOnParticipationFailure;
    }
}

回滚处理

rollbackToHeldSavepoint回滚至保存点

rollbackToHeldSavepoint方法在AbstractTransactionStatus中实现，它调用了getSavepointManager方法获取保存点管理器，调用SavepointManager的rollbackToSavepoint方法进行回滚的：

public abstract class AbstractTransactionStatus implements TransactionStatus {

    public void rollbackToHeldSavepoint() throws TransactionException {
        Object savepoint = getSavepoint();
        if (savepoint == null) {
            throw new TransactionUsageException(
                    "Cannot roll back to savepoint - no savepoint associated with current transaction");
        }
        // getSavepointManager方法在DefaultTransactionStatus中实现
        getSavepointManager().rollbackToSavepoint(savepoint);
        getSavepointManager().releaseSavepoint(savepoint);
        setSavepoint(null);
    }
}

SavepointManager是一个接口，它的继承关系如下：

DefaultTransactionStatus中获取SavepointManager的方法：

1. 获取transaction对象，前面的知识可知这里是一个DataSourceTransactionObject
2. 由继承关系可知DataSourceTransactionObject也是SavepointManager子类，所以将DataSourceTransactionObject转为SavepointManager返回

   public class DefaultTransactionStatus extends AbstractTransactionStatus {
       @Override
       protected SavepointManager getSavepointManager() {
           // 前面的知识可知这里是一个DataSourceTransactionObject
           Object transaction = this.transaction;
           if (!(transaction instanceof SavepointManager)) {
               throw new NestedTransactionNotSupportedException(
                       "Transaction object [" + this.transaction + "] does not support savepoints");
           }
           // 将DataSourceTransactionObject转为SavepointManager
           return (SavepointManager) transaction;
       }
   }

DataSourceTransactionObject是DataSourceTransactionManager的内部类，它继承了JdbcTransactionObjectSupport,rollbackToSavepoint方法在JdbcTransactionObjectSupport中实现：

1. 获取ConnectionHolder，ConnectionHolder持有数据库连接
2. 调用底层的rollback方法将事务回滚至保存点

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
        implements ResourceTransactionManager, InitializingBean {
    // 内部类DataSourceTransactionObject
    private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {

    }
}

// JdbcTransactionObjectSupport
public abstract class JdbcTransactionObjectSupport implements SavepointManager, SmartTransactionObject {
    /**
     * 回滚至保存点
     */
    @Override
    public void rollbackToSavepoint(Object savepoint) throws TransactionException {
        // 获取ConnectionHolder
        ConnectionHolder conHolder = getConnectionHolderForSavepoint();
        try {
            // 调用底层的rollback方法将事务回滚至保存点
            conHolder.getConnection().rollback((Savepoint) savepoint);
            conHolder.resetRollbackOnly();
        }
        catch (Throwable ex) {
            throw new TransactionSystemException("Could not roll back to JDBC savepoint", ex);
        }
    }

    /**
     * 释放保存点
     */
    @Override
    public void releaseSavepoint(Object savepoint) throws TransactionException {
        ConnectionHolder conHolder = getConnectionHolderForSavepoint();
        try {
            // 调用底层的方法释放保存点
            conHolder.getConnection().releaseSavepoint((Savepoint) savepoint);
        }
        catch (Throwable ex) {
            logger.debug("Could not explicitly release JDBC savepoint", ex);
        }
    }
}

doRollback事务回滚

回滚事务时先获取数据库连接，然后调用底层的rollback进行回滚：

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
        implements ResourceTransactionManager, InitializingBean {

    @Override
    protected void doRollback(DefaultTransactionStatus status) {
        // 获取数据源事务对象
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        // 获取数据库连接
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
        }
        try {
            // 调用底层的回滚方法
            con.rollback();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
        }
    }
}

doSetRollbackOnly设置回滚状态

doSetRollbackOnly方法在DataSourceTransactionManager中实现：

1. 将事务转为DataSourceTransactionObject对象，前面讲过DataSourceTransactionObject持有了数据库连接对象ConnectionHolder

2. 将ConnectionHolder的rollbackOnly属性置为true，先标记事务的回滚状态，交由外围事务进行判断统一进行回滚

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
        implements ResourceTransactionManager, InitializingBean {

    @Override
    protected void doSetRollbackOnly(DefaultTransactionStatus status) {
        // 获取数据源事务对象
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        if (status.isDebug()) {
            logger.debug("Setting JDBC transaction [" + txObject.getConnectionHolder().getConnection() +
                    "] rollback-only");
        }
        // 设置回滚状态
        txObject.setRollbackOnly();
    }

    /**
     * 内部类DataSourceTransactionObject
     */
    private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {

        // 省略其他方法

        // 设置回滚状态
        public void setRollbackOnly() {
            // 将ConnectionHolder的rollbackOnly属性置为true，在ConnectionHolder的父类ResourceHolderSupport中实现
            getConnectionHolder().setRollbackOnly();
        }
    }
}

// ConnectionHolder的父类ResourceHolderSupport
public abstract class ResourceHolderSupport implements ResourceHolder {

    private boolean rollbackOnly = false;

    /**
     * 标记事务回滚状态为true
     */
    public void setRollbackOnly() {
        this.rollbackOnly = true;
    }
}

资源清理

在事务回滚之后，需要清理相关的资源以及恢复被挂起的事务：

1. 如果事务的newSynchronization状态为true，清除当前线程绑定的事务相关信息
   • 在TransactionSynchronizationManager的clear方法中实现，清理了当前线程绑定的事务名称、事务隔离级别等信息
2. 如果是一个新事务，清除当前线程与数据库连接的绑定关系，在DataSourceTransactionManager的doCleanupAfterCompletion方法中实现
3. 如果挂起的事务不为空，恢复挂起的事务
   • 获取数据源，恢复数据源与挂起事务的绑定关系
   • 恢复挂起事务与当前线程的同步信息

     public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
     
         /**
          * 回滚之后的清除操作
          * @see #doCleanupAfterCompletion
          */
         private void cleanupAfterCompletion(DefaultTransactionStatus status) {
             status.setCompleted();
             if (status.isNewSynchronization()) {
                 // 清除当前线程绑定的信息
                 TransactionSynchronizationManager.clear();
             }
             // 如果是一个新事务
             if (status.isNewTransaction()) {
                 // 清除当前线程与数据库连接的绑定关系
                 doCleanupAfterCompletion(status.getTransaction());
             }
             // 如果挂起的事务不为空
             if (status.getSuspendedResources() != null) {
                 if (status.isDebug()) {
                     logger.debug("Resuming suspended transaction after completion of inner transaction");
                 }
                 Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
                 // 恢复挂起的事务
                 resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
             }
         }
     
         /**
          * 恢复挂起的事务
          * @see #doResume
          * @see #suspend
          */
         protected final void resume(@Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder)
                 throws TransactionException {
     
             if (resourcesHolder != null) {
                 // 获取挂起的事务
                 Object suspendedResources = resourcesHolder.suspendedResources;
                 if (suspendedResources != null) {
                     // 获取数据源，并与挂起的事务进行绑定
                     doResume(transaction, suspendedResources);
                 }
                 // 挂起事务的同步信息
                 List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.suspendedSynchronizations;
                 if (suspendedSynchronizations != null) {
                     // 恢复事务与线程的同步信息
                     TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);
                     TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);
                     TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);
                     TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name);
                     doResumeSynchronization(suspendedSynchronizations);
                 }
             }
         }
     }
     
     // DataSourceTransactionManager
     public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
             implements ResourceTransactionManager, InitializingBean {
         // 主要是清除当前线程与数据库连接的绑定关系
         protected void doCleanupAfterCompletion(Object transaction) {
             DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
     
             // Remove the connection holder from the thread, if exposed.
             if (txObject.isNewConnectionHolder()) {
                 TransactionSynchronizationManager.unbindResource(obtainDataSource());
             }
     
             // 获取数据库连接
             Connection con = txObject.getConnectionHolder().getConnection();
             try {
                 if (txObject.isMustRestoreAutoCommit()) {
                     // 自动提交置为true
                     con.setAutoCommit(true);
                 }
                 // 重置数据库连接的相关设置
                 DataSourceUtils.resetConnectionAfterTransaction(
                         con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly());
             }
             catch (Throwable ex) {
                 logger.debug("Could not reset JDBC Connection after transaction", ex);
             }
     
             if (txObject.isNewConnectionHolder()) {
                 if (logger.isDebugEnabled()) {
                     logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
                 }
                 // 释放连接
                 DataSourceUtils.releaseConnection(con, this.dataSource);
             }
             // 清除当前线程与数据库连接的绑定关系
             txObject.getConnectionHolder().clear();
         }
     
         @Override
         protected void doResume(@Nullable Object transaction, Object suspendedResources) {
             // 获取数据源，并与挂起的事务进行绑定
             TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
         }
     }
     
     // TransactionSynchronizationManager
     public abstract class TransactionSynchronizationManager {
     
         // 保存了线程绑定的数据库资源信息，Map中Key为数据源构建的KEY，value为对应的ConnectionHolder
         private static final ThreadLocal<Map<Object, Object>> resources =
                 new NamedThreadLocal<>("Transactional resources");
         // 保存了线程绑定的事务同步信息TransactionSynchronization
         private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
                 new NamedThreadLocal<>("Transaction synchronizations");
     
         // 保存了线程绑定的事务名称
         private static final ThreadLocal<String> currentTransactionName =
                 new NamedThreadLocal<>("Current transaction name");
         // 保存了线程绑定的事务只读状态
         private static final ThreadLocal<Boolean> currentTransactionReadOnly =
                 new NamedThreadLocal<>("Current transaction read-only status");
     
         // 保存了线程绑定的事务隔离级别
         private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
                 new NamedThreadLocal<>("Current transaction isolation level");
         // 保存了线程绑定的事务活跃状态
         private static final ThreadLocal<Boolean> actualTransactionActive =
                 new NamedThreadLocal<>("Actual transaction active");
     
         /**
          * 清理事务与当前线程的各种同步状态
          */
         public static void clear() {
             // 清除当前线程绑定的事务同步信息TransactionSynchronization
             synchronizations.remove();
             // 清除当前线程绑定的事务名称
             currentTransactionName.remove();
             // 清除线程绑定的事务只读状态
             currentTransactionReadOnly.remove();
             // 清除线程绑定的事务隔离级别
             currentTransactionIsolationLevel.remove();
             // 清除线程绑定的事务活跃状态
             actualTransactionActive.remove();
         }
     }

总结

参考

【猫吻鱼】Spring源码分析：全集整理

Spring版本：5.2.5.RELEASE