Spring的事務處理中，通用的事務處理流程框架是由抽象事務管理器AbstractPlatformTransactionManager來提供的，而具體的底層事務處理實現，由PlatformTransactionManager的具體實現類來實現，如 DataSourceTransactionManager 、JtaTransactionManager和 HibernateTransactionManager等。

對於具體的事務管理器而言，它們只需要處理和具體資料來源相關的元件設定就可以了。如doGetTransaction()，doCommit(status)方法等。

本文主要介紹DataSourceTransactionManager中的具體實現。

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager  
        implements ResourceTransactionManager, InitializingBean {  
    //注入資料來源  
    private DataSource dataSource;  
//資料來源事務處理器預設構造方法，建立一個數據源事務處理器例項，並設定允許巢狀事務  
    public DataSourceTransactionManager() {  
        setNestedTransactionAllowed(true);  
    }  
    //根據給定資料來源，建立一個數據源事務處理器例項  
    public DataSourceTransactionManager(DataSource dataSource) {  
        this();  
        setDataSource(dataSource);  
        afterPropertiesSet();  
    }  
    //設定資料來源  
    public void setDataSource(DataSource dataSource) {  
        if (dataSource instanceof TransactionAwareDataSourceProxy) {  
            //如果資料來源是一個事務包裝資料來源代理，則獲取事務包裝代理的目標資料來源   
            this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource();  
        }  
        else {  
            this.dataSource = dataSource;  
        }  
    }  
    //獲取資料來源  
    public DataSource getDataSource() {  
        return this.dataSource;  
    }  
    //資料來源事務處理器物件構造方法的回撥函式  
    public void afterPropertiesSet() {  
        if (getDataSource() == null) {  
            throw new IllegalArgumentException("Property 'dataSource' is required");  
        }  
    }  
public Object getResourceFactory() {  
        return getDataSource();  
    }  
//建立事務，對資料庫而言，是由Connection來完成事務工作的。該方法把資料庫的//Connection物件放到一個ConnectionHolder物件中，然後封裝到一個  
//DataSourceTransactionObject物件中  
    protected Object doGetTransaction() {  
        //建立資料來源事務物件  
        DataSourceTransactionObject txObject = new DataSourceTransactionObject();  
        //設定資料來源事務物件對巢狀事務使用儲存點  
        txObject.setSavepointAllowed(isNestedTransactionAllowed());  
        //從事務管理容器中獲取存放資料庫Connection的物件  
        ConnectionHolder conHolder =  
            (ConnectionHolder) TransactionSynchronizationManager.getResource(this.dataSource);  
        txObject.setConnectionHolder(conHolder, false);  
        return txObject;  
    }  
    //判斷是否已經存在事務  
    protected boolean isExistingTransaction(Object transaction) {  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
    //根據存放資料庫連線的ConnectionHolder的isTransactionActive屬性來判斷  
        return (txObject.getConnectionHolder() != null && txObject.getConnectionHolder().isTransactionActive());  
    }  
    //處理事務開始的方法  
    protected void doBegin(Object transaction, TransactionDefinition definition) {  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
        Connection con = null;  
        try {  
            //如果資料來源事務物件的ConnectionHolder為null或者是事務同步的  
            if (txObject.getConnectionHolder() == null ||  
        txObject.getConnectionHolder().isSynchronizedWithTransaction()) {  
                //獲取當前資料來源的資料庫連線  
                Connection newCon = this.dataSource.getConnection();  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");  
                }  
                //為資料來源事務物件設定ConnectionHolder  
                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);  
            }  
    //設定資料來源事務物件的事務同步    txObject.getConnectionHolder().setSynchronizedWithTransaction(true);  
            //獲取資料來源事務物件的資料庫連線  
            con = txObject.getConnectionHolder().getConnection();  
            //根據資料連線和事務屬性，獲取資料庫連線的事務隔離級別  
            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);  
    //為資料來源事務物件設定事務隔離級別  
    txObject.setPreviousIsolationLevel(previousIsolationLevel);  
            //如果資料庫連線設定了自動事務提交屬性，則關閉自動提交  
            if (con.getAutoCommit()) {  
                //儲存資料庫連線設定的自動連線到資料來源事務物件中  
                txObject.setMustRestoreAutoCommit(true);  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Switching JDBC Connection [" + con + "] to manual commit");  
                }  
                //設定資料庫連線自動事務提交屬性為false，即禁止自動事務提交  
                con.setAutoCommit(false);  
            }  
            //啟用當前資料來源事務物件的事務配置  
            txObject.getConnectionHolder().setTransactionActive(true);  
            //獲取事務配置的超時時長  
int timeout = determineTimeout(definition);  
//如果事務配置的超時時長不等於事務的預設超時時長  
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {  
        //資料來源事務物件設定超時時長  
        txObject.getConnectionHolder().setTimeoutInSeconds(timeout);  
            }  
            //把當前資料庫Connection和執行緒繫結  
            if (txObject.isNewConnectionHolder()) {  
        TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());  
            }  
        }  
        catch (Exception ex) {  
            DataSourceUtils.releaseConnection(con, this.dataSource);  
            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);  
        }  
    }  
    //事務掛起  
    protected Object doSuspend(Object transaction) {  
        //獲取事務物件  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
        //將事務物件中的ConnectionHolders設定為null  
        txObject.setConnectionHolder(null);  
        ConnectionHolder conHolder = (ConnectionHolder)  
        //解除事務物件和當前執行緒的繫結    TransactionSynchronizationManager.unbindResource(this.dataSource);  
        return conHolder;  
    }  
    //事務恢復  
    protected void doResume(Object transaction, Object suspendedResources) {  
        //獲取已暫停事務的ConnectionHolder  
        ConnectionHolder conHolder = (ConnectionHolder) suspendedResources;  
        //重新將事務物件和當前執行緒繫結  
        TransactionSynchronizationManager.bindResource(this.dataSource, conHolder);  
    }  
    //事務提交  
    protected void doCommit(DefaultTransactionStatus status) {  
        //獲取事務物件  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();  
        //通過事務物件獲取資料庫連線  
        Connection con = txObject.getConnectionHolder().getConnection();  
        if (status.isDebug()) {  
            logger.debug("Committing JDBC transaction on Connection [" + con + "]");  
        }  
        try {  
            //使用資料庫連線手動進行事務提交  
            con.commit();  
        }  
        catch (SQLException ex) {  
            throw new TransactionSystemException("Could not commit JDBC transaction", ex);  
        }  
    }  
    //事務回滾  
    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);  
        }  
    }  
    //設定回滾  
    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();  
    }  
    //操作完成之後清除操作  
    protected void doCleanupAfterCompletion(Object transaction) {  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
        //移除當前執行緒繫結的ConnectionHolder  
        if (txObject.isNewConnectionHolder()) {  
    TransactionSynchronizationManager.unbindResource(this.dataSource);  
        }  
        Connection con = txObject.getConnectionHolder().getConnection();  
        try {  
        //如果事務物件儲存了自動事務提交屬性，則設定資料庫連線的自動事務提交屬性  
            if (txObject.isMustRestoreAutoCommit()) {  
                con.setAutoCommit(true);  
            }  
            //事務結束後重置資料庫連線  
            DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());  
        }  
        catch (Throwable ex) {  
            logger.debug("Could not reset JDBC Connection after transaction", ex);  
        }  
        //如果事務物件中有新的ConnectionHolder   
        if (txObject.isNewConnectionHolder()) {  
            if (logger.isDebugEnabled()) {  
                logger.debug("Releasing JDBC Connection [" + con + "] after transaction");  
            }  
            //釋放資料庫連線  
            DataSourceUtils.releaseConnection(con, this.dataSource);  
        }  
        //清除事務物件的ConnectionHolder  
        txObject.getConnectionHolder().clear();  
    }  
//資料來源事務物件，內部類  
    private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {  
        //是否有新的ConnectionHolder  
        private boolean newConnectionHolder;  
        //是否儲存自動提交  
        private boolean mustRestoreAutoCommit;  
        //設定ConnectionHolder  
        public void setConnectionHolder(ConnectionHolder connectionHolder, boolean newConnectionHolder) {  
            //為父類JdbcTransactionObjectSupport設定ConnectionHolder  
            super.setConnectionHolder(connectionHolder);  
            this.newConnectionHolder = newConnectionHolder;  
        }  
        public boolean isNewConnectionHolder() {  
            return this.newConnectionHolder;  
        }  
        //呼叫父類JdbcTransactionObjectSupport的相關方法，查詢收費存在事務  
        public boolean hasTransaction() {  
            return (getConnectionHolder() != null && getConnectionHolder().isTransactionActive());  
        }  
        //設定是否儲存自動提交  
        public void setMustRestoreAutoCommit(boolean mustRestoreAutoCommit) {  
            this.mustRestoreAutoCommit = mustRestoreAutoCommit;  
        }  
        public boolean isMustRestoreAutoCommit() {  
            return this.mustRestoreAutoCommit;  
        }  
        //設定資料庫連線在操作失敗是，是否只回滾處理  
        public void setRollbackOnly() {  
            getConnectionHolder().setRollbackOnly();  
        }  
        public boolean isRollbackOnly() {  
            return getConnectionHolder().isRollbackOnly();  
        }  
    }  
}