忙活了一個星期，看了N多Spring、Hibernate原始碼，查了N多資料，走了N多彎路，總算實現了分散式事務。回頭看看，實現這個功能對自己的提升確實是巨大的。

    進入正題，官網之前的選庫方案是在DataSource層面進行選庫的，繼承org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource來進行的選庫，用SpringAOP做切面，在進入DAO方法之前進行選庫（比如某個引數或者註解等）。事務用的是org.springframework.orm.hibernate3.HibernateTransactionManager。在一次操作單個數據庫的情況下是沒有問題的，但是在一次操作多個數據庫時，比如有A、B兩個庫裡面有一個相同的表，在A插入一條資料a，在B插入一條資料b，事務便會出問題，在提交的時候會全部提交到A庫去，究其原因，應該是在事務開啟時就打開了session，而一般開啟事務時是在service層，沒有進入DAO層。也就是說在開啟事務時根本沒有進行選庫操作，而是進入的預設的資料庫，導致事務提交時提交錯了資料庫。

    為了解決這個問題，在網上瀏覽了一番後，找到一個CobarClient的阿里出的分散式資料庫訪問層，找到其中的事務管理類檢視原始碼 com.alibaba.cobar.client.transaction.MultipleDataSourcesTransactionManager ，研究了一番後，按照自己的思路實現，發現根本沒有進入事務控制，資料直接就到資料庫了。發現事情沒有這麼簡單，CobarClient是根據DataSource進行的事務開啟和關閉操作，和官網環境不同，是用的Spring-Hibernate，事務管理也是Spring的 tx:annotation-driven 標籤，而且CobarClient幾年前就不更新了，還不知道用的是那個Spring-Hibernate版本，所以只能另尋解決辦法。

    在經歷過上次失敗後，突然想到官網用的最原始的org.springframework.orm.hibernate3.HibernateTransactionManager這個事務管理器是有效果的，只是最後commit的時候資料放錯庫了而已。那我寫個類繼承這個，重寫相關方法不就行了，然後我就根據CobarClient的思想進行改造，在doBegin方法中把配置的全部的資料庫連線開啟了事務（事實上這樣做很蠢，如果有100個配置，不就有100個事務了。。。），doCommit和doRollback方法迴圈呼叫的父類方法按照FILO規則來，然後又出問題了。因為SessionFactory是同一個，Spring會報一個同步錯誤，大意就是說你的session開啟了一個以上事務，便會報錯。

    這是才意識到，選庫和分散式事務是要相互配合的。

    於是進行了一次比較大的修改，拋棄org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource選庫方案，在初始化時進行SessionFactory初始化（為此又研究了Spring動態註冊，以及org.springframework.beans.factory.FactoryBean.getObject()，一路艱辛啊。。），在選庫時由選擇DataSource改為選擇SessionFactory，DAO層在呼叫時根據執行緒引數（java.lang.ThreadLocal）中的選庫結果呼叫SessionFactory。事務方面研究了org.springframework.transaction.support.AbstractPlatformTransactionManager的原始碼，重點在於getTransaction方法發現doGetTransaction返回的結果並不重要（返回型別是Object），在框架中並沒有其他使用它的地方，只有在必須實現的方法doBegin、doCommit、doRollback，以及掛起doSuspend，恢復掛起doResume方法isExistingTransaction是否已開啟事務方法，以及doCleanupAfterCompletion事務結束後的銷燬方法中用到。而這些方法都需要我們來實現，那麼就有了一個想法。

    在doGetTransaction方法中標識事務是否開啟：

    private ThreadLocal<Object> isTransaction = new ThreadLocal<Object>();   
  
    @Override
    protected Object doGetTransaction() throws TransactionException {
        Object o = new Object();
        isTransaction.set(o);
        return o;
    }

    事實上這裡返回的object沒有任何用處。而isTransaction只是標識事務開啟而已，如果get出來為空則是沒有開啟事務。

    在doBegin中將TransactionDefinition存起來（根據原始碼呼叫，這個東西從頭到尾都是一個）

 private ThreadLocal<TransactionDefinition> localTransactionDefinition = new ThreadLocal<TransactionDefinition>();
  @Override
  protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
      //將TransactionDefinition儲存起來
      try {
          localTransactionDefinition.set(ObjectUtil.<TransactionDefinition>deepClone(definition));
      } catch (IOException e) {
          e.printStackTrace();
      } catch (ClassNotFoundException e) {
          e.printStackTrace();
      }
  }

    /**
     * DataSourceAspect中選庫時開啟事務操作，如之前（執行緒中）就以開啟事務，則不做操作
     * @param sessionFactory 選中的庫
     * @return 是否成功開啟事務
     * @throws Exception
     */
    public boolean chooseDataSource(SessionFactory sessionFactory) throws Exception {
        Assert.notNull(sessionFactory, "Empty SessionFactory!");
        //check sessionFactory is correct
        if (!checkSessionFactory(sessionFactory)) return false;
        //check transaction is start
        if (isTransaction.get() == null) return false;
        //check sessionFactory is started transaction
        if (isInTransaction(sessionFactory)) return false;
        List<HibernateTransactionObject> localObj = getLocalObj();
        HibernateTransactionObject txObject = getHibernateTransactionObject(sessionFactory);
        doBegin(txObject);
        localObj.add(txObject);
        setLocalObj(localObj);
        return true;
    }
  
    private HibernateTransactionObject getHibernateTransactionObject(SessionFactory sessionFactory) {
        Assert.notNull(sessionFactory, "Empty SessionFactory!");
        HibernateTransactionObject txObject = new HibernateTransactionObject();
        txObject.setSavepointAllowed(isNestedTransactionAllowed());
        txObject.setSessionFactory(sessionFactory);
        SessionHolder sessionHolder =
                (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
        if (sessionHolder != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Found thread-bound Session [" +
                        SessionFactoryUtils.toString(sessionHolder.getSession()) + "] for Hibernate transaction");
            }
            txObject.setSessionHolder(sessionHolder);
        }
        DataSource dataSource = SessionFactoryUtils.getDataSource(sessionFactory);
        if (dataSource != null) {
            txObject.setDataSource(dataSource);
            ConnectionHolder conHolder = (ConnectionHolder)
                    TransactionSynchronizationManager.getResource(dataSource);
            txObject.setConnectionHolder(conHolder);
        }
        return txObject;
    }
 
    /**
     * 開啟一個事務
     * @param txObject
     * @throws Exception
     */
    private void doBegin(HibernateTransactionObject txObject) throws Exception {
        TransactionDefinition definition = localTransactionDefinition.get();
        if (definition == null) throw new Exception("Transaction is not begin!");
        if (txObject.hasConnectionHolder() && !txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
            throw new IllegalTransactionStateException(
                    "Pre-bound JDBC Connection found! HibernateTransactionManager does not support " +
                            "running within DataSourceTransactionManager if told to manage the DataSource itself. " +
                            "It is recommended to use a single HibernateTransactionManager for all transactions " +
                            "on a single DataSource, no matter whether Hibernate or JDBC access.");
        }
        Session session = null;
        try {
            if (txObject.getSessionHolder() == null || txObject.getSessionHolder().isSynchronizedWithTransaction()) {
                Session newSession = txObject.getSessionFactory().openSession();
                if (logger.isDebugEnabled()) {
                    logger.debug("Opened new Session [" + SessionFactoryUtils.toString(newSession) +
                            "] for Hibernate transaction");
                }
                txObject.setSession(newSession);
            }
            session = txObject.getSessionHolder().getSession();
            if (isSameConnectionForEntireSession(session)) {
                // We're allowed to change the transaction settings of the JDBC Connection.
                if (logger.isDebugEnabled()) {
                    logger.debug(
                            "Preparing JDBC Connection of Hibernate Session [" + SessionFactoryUtils.toString(session) + "]");
                }
                Connection con = session.connection();
                Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
                txObject.setPreviousIsolationLevel(previousIsolationLevel);
            }
            else {
                // Not allowed to change the transaction settings of the JDBC Connection.
                if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
                    // We should set a specific isolation level but are not allowed to...
                    throw new InvalidIsolationLevelException(
                            "HibernateTransactionManager is not allowed to support custom isolation levels: " +
                                    "make sure that its 'prepareConnection' flag is on (the default) and that the " +
                                    "Hibernate connection release mode is set to 'on_close' (SpringTransactionFactory's default). " +
                                    "Make sure that your LocalSessionFactoryBean actually uses SpringTransactionFactory: Your " +
                                    "Hibernate properties should *not* include a 'hibernate.transaction.factory_class' property!");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug(
                            "Not preparing JDBC Connection of Hibernate Session [" + SessionFactoryUtils.toString(session) + "]");
                }
            }
            if (definition.isReadOnly() && txObject.isNewSession()) {
                // Just set to MANUAL in case of a new Session for this transaction.
                session.setFlushMode(FlushMode.MANUAL);
            }
            if (!definition.isReadOnly() && !txObject.isNewSession()) {
                // We need AUTO or COMMIT for a non-read-only transaction.
                FlushMode flushMode = session.getFlushMode();
                if (flushMode.lessThan(FlushMode.COMMIT)) {
                    session.setFlushMode(FlushMode.AUTO);
                    txObject.getSessionHolder().setPreviousFlushMode(flushMode);
                }
            }
            Transaction hibTx;
            // Register transaction timeout.
            int timeout = determineTimeout(definition);
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                // Use Hibernate's own transaction timeout mechanism on Hibernate 3.1+
                // Applies to all statements, also to inserts, updates and deletes!
                hibTx = session.getTransaction();
                hibTx.setTimeout(timeout);
                hibTx.begin();
            }
            else {
                // Open a plain Hibernate transaction without specified timeout.
                hibTx = session.beginTransaction();
            }
            // Add the Hibernate transaction to the session holder.
            txObject.getSessionHolder().setTransaction(hibTx);
            // Register the Hibernate Session's JDBC Connection for the DataSource, if set.
            if (txObject.getDataSource() != null) {
                Connection con = session.connection();
                ConnectionHolder conHolder = new ConnectionHolder(con);
                if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                    conHolder.setTimeoutInSeconds(timeout);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Exposing Hibernate transaction as JDBC transaction [" + con + "]");
                }
                TransactionSynchronizationManager.bindResource(txObject.getDataSource(), conHolder);
                txObject.setConnectionHolder(conHolder);
            }
            // Bind the session holder to the thread.
            if (txObject.isNewSessionHolder()) {
                TransactionSynchronizationManager.bindResource(txObject.getSessionFactory(), txObject.getSessionHolder());
            }
            txObject.getSessionHolder().setSynchronizedWithTransaction(true);
        }
        catch (Exception ex) {
            if (txObject.isNewSession()) {
                try {
                    if (session.getTransaction().isActive()) {
                        session.getTransaction().rollback();
                    }
                }
                catch (Throwable ex2) {
                    logger.debug("Could not rollback Session after failed transaction begin", ex);
                }
                finally {
                    SessionFactoryUtils.closeSession(session);
                }
            }
            throw new CannotCreateTransactionException("Could not open Hibernate Session for transaction", ex);
        }
    }
 
    /**
     * Hibernate transaction object, representing a SessionHolder.
     * Used as transaction object by HibernateTransactionManager.
     */
    public class HibernateTransactionObject extends JdbcTransactionObjectSupport {
        private SessionHolder sessionHolder;
        private boolean newSessionHolder;
        private boolean newSession;
        private DataSource dataSource;
        private SessionFactory sessionFactory;
        public void setSession(Session session) {
            this.sessionHolder = new SessionHolder(session);
            this.newSessionHolder = true;
            this.newSession = true;
        }
        public void setExistingSession(Session session) {
            this.sessionHolder = new SessionHolder(session);
            this.newSessionHolder = true;
            this.newSession = false;
        }
        public void setSessionHolder(SessionHolder sessionHolder) {
            this.sessionHolder = sessionHolder;
            this.newSessionHolder = false;
            this.newSession = false;
        }
        public SessionHolder getSessionHolder() {
            return this.sessionHolder;
        }
        public boolean isNewSessionHolder() {
            return this.newSessionHolder;
        }
        public boolean isNewSession() {
            return this.newSession;
        }
        public DataSource getDataSource() {
            return dataSource;
        }
        public void setDataSource(DataSource dataSource) {
            this.dataSource = dataSource;
        }
        public SessionFactory getSessionFactory() {
            return sessionFactory;
        }
        public void setSessionFactory(SessionFactory sessionFactory) {
            this.sessionFactory = sessionFactory;
        }
        public boolean hasSpringManagedTransaction() {
            return (this.sessionHolder != null && this.sessionHolder.getTransaction() != null);
        }
        public boolean hasHibernateManagedTransaction() {
            return (this.sessionHolder != null && this.sessionHolder.getSession().getTransaction().isActive());
        }
        public void setRollbackOnly() {
            this.sessionHolder.setRollbackOnly();
            if (hasConnectionHolder()) {
                getConnectionHolder().setRollbackOnly();
            }
        }
        public boolean isRollbackOnly() {
            return this.sessionHolder.isRollbackOnly() ||
                    (hasConnectionHolder() && getConnectionHolder().isRollbackOnly());
        }
        @Override
        public void flush() {
            try {
                this.sessionHolder.getSession().flush();
            }
            catch (HibernateException ex) {
                throw SessionFactoryUtils.convertHibernateAccessException(ex);
            }
        }
    }

    好吧，除了chooseDataSource方法之外  基本copy的org.springframework.orm.hibernate3.HibernateTransactionManager。HibernateTransactionObject 中添加了SessionFactory和DataSource兩個屬性。

至於doCommit和doRollback基本就是按照FILO迴圈操作了

    完成程式碼後試驗，發現成功了。成功提交回滾，不會提交到一個庫裡面了。事務掛起沒有實驗成功，因為並沒有進掛起方法。原因暫時不明，需要繼續查資料。