@Transactional导致无法动态数据源切换

公司目前数据源为主从模式：主库可读写，从库只负责读。使用spring-jdbc提供的AbstractRoutingDataSource结合ThreadLocal存储key，实现数据源动态切换。

最近项目加入数据源切换后，偶尔会报出read-only异常，百思不得其解......

<!--数据源-->
<bean id="dsCrm" class="cn.mwee.framework.commons.utils.datasource.RoutingDataSource">
        <property name="targetDataSources">
            <map key-type="java.lang.String">
                <entry key="master" value-ref="dsCrm_master"/>
                <entry key="slave1" value-ref="dsCrm_slave1"/>
                <entry key="slave2" value-ref="dsCrm_slave2"/>
            </map>
        </property>
        <!--默认走主库-->
        <property name="defaultTargetDataSource" ref="dsCrm_master"/>
</bean>

RoutingDataSource类是对AbstractRoutingDataSource轻量封装实现determineCurrentLookupKey ：

public class RoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DBContext.getDBKey();
    }
}

对应的业务代码如下，数据源切换在其他项目使用正常，代码迁移过来之后偶发报出read-only异常，数据库处于只读模式。写方法需要事物默认走主库，在该方法前也没有数据源的切换。 

@Transactional(rollbackFor = Exception.class)
public DataResult settingMarketMsg(SettingMarketMsgRequest request) {
        .....
}
@Slave
public DataResult detailMarketMsg(DetailMarketMsgRequest request) {
        ......
}  

因为aop切面只会切入打上@Slave注解的方法并切为从库，方法返回会清除key。所以臆想着肯定不会有问题？思考N久。。。

最后在aop的配置中看到破绽：

 @Component("dynamicDataSourceAspect")
 public class DynamicDataSourceAspect {
 public void setCrmDataSource(JoinPoint joinPoint) {
         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
         Method method = methodSignature.getMethod();
         // 默认 master 优先
         DBContext.setDBKey(DbKeyConstant.DS_MASTER);
         if (method.isAnnotationPresent(Slave.class)) {
             DBContext.setDBKey(DbKeyConstant.DS_SLAVE_1);
         }
         logger.info("Revert DataSource : {} > {}", DBContext.getDBKey(), joinPoint.getSignature());
     }
     public void clearCrmDataSource(JoinPoint joinPoint) {
         logger.info("Clear DataSource : {} > {}", DBContext.getDBKey(), joinPoint.getSignature());
         DBContext.clearDBKey();
     }
 }

aop的xml配置 :

 <aop:aspectj-autoproxy proxy-target-class="true"/>
 <aop:config>
    <aop:aspect id="dynamicDataSourceAspect" ref="dynamicDataSourceAspect" order="3">
             <aop:pointcut id="dsAspect"
                           expression="@annotation(cn.mwee.framework.commons.utils.datasource.Slave)"/>
             <aop:before pointcut-ref="dsAspect" method="setCrmDataSource"/>
             <aop:after-returning pointcut-ref="dsAspect" method="clearCrmDataSource"/>
    </aop:aspect>
 </aop:config>   

问题出在after-returning 即 方法正常返回之后执行，一旦执行异常就不会执行。此时线程如果没有被回收将一直持有该key。那线程持有该key，怎么跟上述【read-only异常】联系起来呢？

先看事物管理器配置：

<!--事务管理器-->
<bean id="crmTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dsCrm"/>
</bean>
<tx:annotation-driven transaction-manager="crmTxManager"/>

DataSourceTransactionManager的源码事物开始doBegin部分:

 /**
      * This implementation sets the isolation level but ignores the timeout.
      */
     @Override
     protected void doBegin(Object transaction, TransactionDefinition definition) {
         DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
         Connection con = null;

         try {

             // 第一次获取数据源，往后直接复用
             if (txObject.getConnectionHolder() == null ||
                     txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                 Connection newCon = this.dataSource.getConnection();
                 if (logger.isDebugEnabled()) {
                     logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
                 }
                 txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
             }

             txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
             con = txObject.getConnectionHolder().getConnection();

             Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
             txObject.setPreviousIsolationLevel(previousIsolationLevel);

             // 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);
             }

             prepareTransactionalConnection(con, definition);
             txObject.getConnectionHolder().setTransactionActive(true);

             int timeout = determineTimeout(definition);
             if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                 txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
             }

             // Bind the connection holder to the thread.
             if (txObject.isNewConnectionHolder()) {
                 TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
             }
         }

         catch (Throwable ex) {
             if (txObject.isNewConnectionHolder()) {
                 DataSourceUtils.releaseConnection(con, this.dataSource);
                 txObject.setConnectionHolder(null, false);
             }
             throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
         }
     }

AbstractRoutingDataSource获取数据源源码：

 /**
      * Retrieve the current target DataSource. Determines the
      * {@link #determineCurrentLookupKey() current lookup key}, performs
      * a lookup in the {@link #setTargetDataSources targetDataSources} map,
      * falls back to the specified
      * {@link #setDefaultTargetDataSource default target DataSource} if necessary.
      * @see #determineCurrentLookupKey()
      */
     protected DataSource determineTargetDataSource() {
         // 根据线程绑定的key获取数据源， 如果不存在则获取默认数据源
         Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
         Object lookupKey = determineCurrentLookupKey();
         DataSource dataSource = this.resolvedDataSources.get(lookupKey);
         if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
             dataSource = this.resolvedDefaultDataSource;
         }
         if (dataSource == null) {
             throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
         }
         return dataSource;
     }

这样可以解释偶发报出read-only异常了。项目使用tomcat，其中tomcat工作线程池是复用。当tomcat工作线程响应请求，访问带有@Slave方法，数据源切换至从库。由于某种原因异常导致未进入after-returning线程绑定的key未清除。此时访问写方法并tomcat使用同一个工作线程响应请求，通过AbstractRoutingDataSource将获得只读库的数据源，因而会产生报出read-only异常。

问题偶发原因在于必须满足两点：

　　1、只读请求异常未切数据源

　　2、复用相同tomcat工作线程池。

找到问题症结之后，自然容易解决：将after-returning 修改为 after（不管是否异常，都执行)，每次必清空数据源即可。

<aop:config>
        <aop:aspect id="dynamicDataSourceAspect" ref="dynamicDataSourceAspect" order="3">
            <aop:pointcut id="dsAspect"
                          expression="@annotation(cn.mwee.framework.commons.utils.datasource.Slave)"/>
            <aop:before pointcut-ref="dsAspect" method="setCrmDataSource"/>
            <aop:after pointcut-ref="dsAspect" method="clearCrmDataSource"/>
        </aop:aspect>
</aop:config> 

参考链接 ：

@Transactional导致AbstractRoutingDataSource动态数据源无法切换的解决办法

Tomcat线程池策略

详解 Tomcat 的连接数与线程池