@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 的连接数与线程池