事務屬性定義介面

TransactionDefinition是事務屬性定義介面，儲存事務定義的各種屬性，如超時時間、隔離級別、傳播屬性等。

public interface TransactionDefinition {
    //獲取事務傳播型別
    int getPropagationBehavior();

    //獲取事務隔離級別
    int getIsolationLevel();

    //獲取事務超時時間
    int getTimeout();

    //事務的只讀性
    boolean isReadOnly();

    //獲取事務名稱
    String getName();

}
 

事務例項介面

TransactionStatus是事務例項介面，表示了當前事務在記憶體中的一個例項，從名字來看儲存了事務的執行狀態資訊。
AbstractTransactionStatus是抽象實現，DefaultTransactionStatus是事務例項的預設實現。

事務管理器

PlatformTransactionManager是Spring事務的核心介面，一般不會直接使用該介面，應用程式可以直接用TransactionTemplate或者AOP進行事務操作。AbstractPlatformTransactionManager是PlatformTransactionManager的抽象類實現。

public interface PlatformTransactionManager {

    //根據事務指定的策略獲取啟用的事務或者重新建立一個事務。
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    //提交事務
    void commit(TransactionStatus status) throws TransactionException;

    //回滾事務
    void rollback(TransactionStatus status) throws
 
 TransactionException;

}

AbstractPlatformTransactionManager定義事務實現的骨架。

獲取事務

getTransaction(TransactionDefinition definition)主要邏輯是首先獲取當前執行緒的事務:

        Object transaction = doGetTransaction();

注意doGetTransaction是個鉤子方法，負責子類方法的回撥，凡是以do開頭的方法都類似，後續不在贅述。

如果當前執行緒已經存在事務，則handleExistingTransaction(definition, transaction, debugEnabled)，這個方法根據配置的事務策略處理存在的事務:

        if (isExistingTransaction(transaction)) {
            // Existing transaction found -> check propagation behavior to find out how to behave.
            return handleExistingTransaction(definition, transaction, debugEnabled);
        }

如果當前執行緒不存在事務，則開啟新事務:

else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
                definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
                definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
            SuspendedResourcesHolder suspendedResources = suspend(null);
            if (debugEnabled) {
                logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
            }
            try {
                boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
                DefaultTransactionStatus status = newTransactionStatus(
                        definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
                doBegin(transaction, definition);
                prepareSynchronization(status, definition);
                return status;
            }
            catch (RuntimeException ex) {
                resume(null, suspendedResources);
                throw ex;
            }
            catch (Error err) {
                resume(null, suspendedResources);
                throw err;
            }

我們選擇DataSourceTransactionManager的doBegin看看，裡面設定事務為手動提交模式，然後啟用當前事務:

// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
            // so we don't want to do it unnecessarily (for example if we've explicitly
            // configured the connection pool to set it already).
            if (con.getAutoCommit()) {
                txObject.setMustRestoreAutoCommit(true);
                if (logger.isDebugEnabled()) {
                    logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
                }
                con.setAutoCommit(false); //設定為手動提交
            }
            txObject.getConnectionHolder().setTransactionActive(true);

事務提交

主要實現方法是processCommit，在事務提交之前還做了其他額外準備操作，然後執行doCommit方法，出錯時不會進行資源清理操作，不做回滾操作，回滾操作由呼叫者發起。

private void processCommit(DefaultTransactionStatus status) throws TransactionException {
        try {
            boolean beforeCompletionInvoked = false;
            try {
                prepareForCommit(status);
                triggerBeforeCommit(status);
                triggerBeforeCompletion(status);
                beforeCompletionInvoked = true;
                boolean globalRollbackOnly = false;
                if (status.isNewTransaction() || isFailEarlyOnGlobalRollbackOnly()) {
                    globalRollbackOnly = status.isGlobalRollbackOnly();
                }
                if (status.hasSavepoint()) {
                    if (status.isDebug()) {
                        logger.debug("Releasing transaction savepoint");
                    }
                    status.releaseHeldSavepoint();
                }
                else if (status.isNewTransaction()) {
                    if (status.isDebug()) {
                        logger.debug("Initiating transaction commit");
                    }
                    doCommit(status);
                }
                // Throw UnexpectedRollbackException if we have a global rollback-only
                // marker but still didn't get a corresponding exception from commit.
                if (globalRollbackOnly) {
                    throw new UnexpectedRollbackException(
                            "Transaction silently rolled back because it has been marked as rollback-only");
                }
            }
            catch (UnexpectedRollbackException ex) {
                // can only be caused by doCommit
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
                throw ex;
            }

            ...

事務回滾

    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 defStatus = (DefaultTransactionStatus) status;
        processRollback(defStatus);
    }

事務同步管理器

TransactionSynchronizationManager關鍵實現是依賴ThreadLocal。各種資料庫資源儲存在各自執行緒的副本中，保證執行緒安全，典型的用空間換時間的做法。

    private static final ThreadLocal<Map<Object, Object>> resources =
            new NamedThreadLocal<Map<Object, Object>>("Transactional resources");

    private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
            new NamedThreadLocal<Set<TransactionSynchronization>>("Transaction synchronizations");

    private static final ThreadLocal<String> currentTransactionName =
            new NamedThreadLocal<String>("Current transaction name");

    private static final ThreadLocal<Boolean> currentTransactionReadOnly =
            new NamedThreadLocal<Boolean>("Current transaction read-only status");

    private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
            new NamedThreadLocal<Integer>("Current transaction isolation level");

    private static final ThreadLocal<Boolean> actualTransactionActive =
            new NamedThreadLocal<Boolean>("Actual transaction active");