SSM使用AbstractRoutingDataSource后究竟如何解决跨库事务

　　@Override
    protected Object determineCurrentLookupKey() {
        log.info("调用一次{}", MultiDataSourceHolder.getDataSourceKey());
        String dataSourceKey = MultiDataSourceHolder.getDataSourceKey();
        //初始化AbstractRoutingDataSource实现类时,dsRoutingSetProperties保存了多数据源名称
        return dataSourceKey == null ? dsRoutingSetProperties.getDataSourceKeysMapping().get(0) : dataSourceKey;
    }

　　　　//类实现了DataSource接口 getConnection() 调用此方法
protected DataSource determineTargetDataSource() {    
        Object lookupKey = this.determineCurrentLookupKey();
　　　　 //这里的作用的resolvedDataSources也是一个map,而我们实例化多数据源时设置的是名叫targetDataSource的map
        DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
　　　　 dataSource = this.resolvedDefaultDataSource; } }
      //我们来看另一个方法afterPropertiesSet,这个方法是实现了接口InitializingBean,在ioc实例化bean的时候,还未生成代理对象前会调用的方法,也就是还为注入到单例缓存池时

public void afterPropertiesSet() {
    　　...
        this.resolvedDataSources = new HashMap(this.targetDataSources.size());
　　　　 //java8添加的迭代方式
        this.targetDataSources.forEach((key, value) -> {
            Object lookupKey = this.resolveSpecifiedLookupKey(key);
　　　　　　　//实际上只有这里做了处理,如果map的值是String类型,用jndi的方式获取DataSource(我的技能树没点到这里,看不懂)
            DataSource dataSource = this.resolveSpecifiedDataSource(value);
            this.resolvedDataSources.put(lookupKey, dataSource);
        });
        if (this.defaultTargetDataSource != null) {
            //这里的处理同上
            this.resolvedDefaultDataSource = this.resolveSpecifiedDataSource(this.defaultTargetDataSource);
        }

先看下事务的三个关键性接口
PlatformTransactionManager    getTransaction/commit/rollback
TransactionStatus   事务运行状态   isNewTransaction()/hasSavepoint()     是否为新事务/是否有保存点
TransactionDefinition   事务属性 定义了大量关于隔离级别/传播行为的常量 

//ImportSelector接口需要实现的方法,作用是只要返回类的全限定名即可将Bean注入到容器内
protected String[] selectImports(AdviceMode adviceMode) {
        switch(adviceMode) {
　　　　　//打个断点进去 发现走的是Proxy,默认走的就是Proxy,这里注册了两个bean,进去ProxyTransactionManagementConfiguration里看看,发现就是一个配置类,
   //注册了三个bean,我们看一下TransactionInterceptor(拦截器,aop作用的实质)这个类

　   //方法很长,直接打一个端点在第一行,随便一个方法加上@Transactional,顺利进入
    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, TransactionAspectSupport.InvocationCallback invocation) throws Throwable {
　　　　 Object result;
        if (...) {
          ...
        } else {
　　　　　　　 //方法直接进到这里了
            TransactionAspectSupport.TransactionInfo txInfo = this.createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            try {
　　　　　　　　　　//执行下一层拦截器链 直到执行目标方法  
                result = invocation.proceedWithInvocation();

protected TransactionAspectSupport.TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm, @Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
      ....
                status = tm.getTransaction((TransactionDefinition)txAttr);
      ...
　　　　 //把TransactionStatus封装进TransactionInfo对象中,同时绑定到线程变量
        return this.prepareTransactionInfo(tm, (TransactionAttribute)txAttr, joinpointIdentification, status);

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
 　　　　 Object transaction = this.doGetTransaction();
　　　　 //如果ConnnectionHolder不为null transactionActive为true 进入这里 ,因为已经确定存在事务了,进去就事务传播行为做判断,是否建立保存点等
        if (this.isExistingTransaction(transaction)) {
            return this.handleExistingTransaction((TransactionDefinition)definition, transaction, debugEnabled);
        } 
　　　　　　.....
　　　　　　else {
　　　　　　　//第一次 进入这里   不需要处理其他
            AbstractPlatformTransactionManager.SuspendedResourcesHolder suspendedResources = this.suspend((Object)null);

protected Object doGetTransaction() {
        DataSourceTransactionManager.DataSourceTransactionObject txObject = new DataSourceTransactionManager.DataSourceTransactionObject();
        txObject.setSavepointAllowed(this.isNestedTransactionAllowed());
　　　　 //这里第一次(如果事务多次访问数据库)返回的为null,下文会看到具体过程  
        ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.obtainDataSource());
        txObject.setConnectionHolder(conHolder, false);
　　//看到这里可以发现 transaction 对象就是DataSourceTransactionObject,继承自JdbcTransactionObjectSupport,有一个属性ConnectionHolder,用来干嘛的??
        return txObject;
    }

public static Object getResource(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
　　　　 //这里的key就是 我们在声明TransactionManager注入的数据源 ,我这里就是MultiDataSource
        Object value = doGetResource(actualKey);

private static Object doGetResource(Object actualKey) {
　　　　　//记住这个 resources  它是一个ThreadLocal<Map<Object, Object>>对象 ,第一进来肯定直接return null了
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            return null;
        } else {
　　　　　　　//这里试想 如果map不为null 通过绑定的数据源 我们能拿到什么 ?
            Object value = map.get(actualKey);
            if (value instanceof ResourceHolder && ((ResourceHolder)value).isVoid()) {
                map.remove(actualKey);
                if (map.isEmpty()) {
                    resources.remove();
                }
                value = null;
            }
            return value;
        }
    }

protected void doBegin(Object transaction, TransactionDefinition definition) {
        DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)transaction;
        Connection con = null;
        try {
　　　　　　　　//前文发现,自身的ConnnectionHolder对象为null,这里就直接进入了
            if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                Connection newCon = this.obtainDataSource().getConnection();
                if (this.logger.isDebugEnabled()) {
                    this.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 (this.logger.isDebugEnabled()) {
                    this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
                }
　　　　　　　　　　//取消自动提交事务
                con.setAutoCommit(false);
            }
         　　// 这里影响后面 第二次进入 是否还会进入本方法
            txObject.getConnectionHolder().setTransactionActive(true);
            if (txObject.isNewConnectionHolder()) {
　　　　　　　　　　//方法进入这里  bindResource方法是不是有点熟悉 ?前文有个方法叫doGetResource()
                TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());
            }

public static void bindResource(Object key, Object value) throws IllegalStateException {
        Map<Object, Object> map = (Map)resources.get();
　　　　//之前的map为空,这下不为空了 
        if (map == null) {
            map = new HashMap();
            resources.set(map);
        }
　　　　 //之前介绍的key 就是数据源实例对象,value就是刚传进来的ConnnectionHolder
        Object oldValue = ((Map)map).put(actualKey, value);

@Configuration
@MapperScan(value = "com.zuan.cinema.mapper",sqlSessionFactoryRef = "sqlSessionFactory00")
@MapperScan(value = "com.zuan.cinema.mapper.m",sqlSessionFactoryRef = "sqlSessionFactory01")
public class DataSourceConfiguration {
　　 @Bean
    @Primary
    public SqlSessionFactory sqlSessionFactory00(@Qualifier("dataSource00") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/*.xml"));
        Interceptor interceptor = new PageInterceptor();
        sqlSessionFactoryBean.setPlugins(new Interceptor[]{interceptor});
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory01(@Qualifier("multiDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/m/*.xml"));
        Interceptor interceptor = new PageInterceptor();
        sqlSessionFactoryBean.setPlugins(new Interceptor[]{interceptor});
        return sqlSessionFactoryBean.getObject();
    }
}