一个多数据源路由问题引发的疑案

清风镰月

已于 2024-07-21 18:02:38 修改

阅读量527

点赞数 13

分类专栏： java 文章标签： java spring

于 2024-07-21 17:47:55 首次发布

本文链接：https://blog.csdn.net/cj19852005/article/details/140591171

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

缘起

某日需要将线下环境的数据同步到线上环境。这时就涉及到在一个项目中使用多个数据源，一个线下数据源，一个线上数据源的情况。但是使用多数据源的时候，发现多数据源不能正常切换，切换后路由到的数据源还是切换之前的数据源。

案件重现

这个项目的多数据源路由是借助org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource来做的。

下面是相关代码和配置

public class MultiDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceIdHolder.getDataSourceId();
    }
}

public class DataSourceIdHolder {

    private static final String OFFLINE_DATA_SOURCE = "dataSourceOffline";
    private static final String ONLINE_DATA_SOURCE = "dataSourceOnline";
    private static final String ADMIN_DATA_SOURCE = "adminDataSource";

    private static final ThreadLocal<String> dataSourceTL = ThreadLocal.withInitial(() -> ONLINE_DATA_SOURCE);

    public static void setDataSource(boolean isOnline) {
        dataSourceTL.set(isOnline ? ONLINE_DATA_SOURCE : OFFLINE_DATA_SOURCE);
    }

    public static void useAdminDataSource() {
        dataSourceTL.set(ADMIN_DATA_SOURCE);
    }

    public static boolean isChoosedOnline() {
        return dataSourceTL.get().equals(ONLINE_DATA_SOURCE);
    }

    public static String getDataSourceId() {
        return dataSourceTL.get();
    }

    public static void remove() {
        dataSourceTL.remove();
    }

 <bean id="multipleDataSource" class="com.ytgw.common.dal.domain.datasource.MultiDataSource">
        <property name="targetDataSources">
            <map>
                <entry value-ref="dataSourceOffline" key="dataSourceOffline"/>
                <entry value-ref="dataSourceOnline" key="dataSourceOnline"/>
                <entry value-ref="adminDataSource" key="adminDataSource"/>
            </map>
        </property>
        <property name="defaultTargetDataSource" ref="dataSourceOnline"/>
    </bean>

 <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="multipleDataSource"/>
    </bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

下面在一个方法中访问多个数据源，从一个数据源中获取数据，处理后，插入到另外一个数据源，实际情况是在插入数据的时候使用的还是第一个数据源。

    @Transactional
    @Override
    public Long initFlowRules() {
        Long lastId = 0L;
        Long count = 0L;
        while (true) {
            //============这里使用数据源A==================
            doChangeDataSourceToCurrentEnv();
            List<CommunicationLimiterDO> communicationLimiterDOList = communicationLimiterDao
                    .selectByLastId(lastId, 100);
            if (CollectionUtils.isEmpty(communicationLimiterDOList)) {
                break;
            }
            lastId = communicationLimiterDOList.get(communicationLimiterDOList.size() - 1).getId();
            communicationLimiterDOList = communicationLimiterDOList.stream()
                    .filter(communicationLimiterDO -> !communicationLimiterDO.getActionUri().contains("transNotify.do")
                                                      && !communicationLimiterDO.getActionUri().contains("emailSend"))
                    .collect(Collectors.toList());
            if (CollectionUtils.isEmpty(communicationLimiterDOList)) {
                continue;
            }
            count += communicationLimiterDOList.size();
            List<FlowResourceDO> flowResourceDOList = wrapFlowResource(communicationLimiterDOList);
           //==============这里切换到数据源B，实际没有生效，下面的flowRuleDao.batchInsert使用的数据源还是数据源A==================
            useAdminDataSource();
            flowResourceDOList.stream().forEach(flowResourceDO -> flowResourceDao.batchInsert(flowResourceDO));
            List<FlowRuleDO> flowRuleDOList = wrapFlowRule(communicationLimiterDOList);
            for (int i = 0, len = flowRuleDOList.size(); i < len; ++i) {
                flowRuleDOList.get(i).setResourceId(flowResourceDOList.get(i).getId());
            }
            flowRuleDOList.stream().forEach(flowRuleDO -> flowRuleDao.batchInsert(flowRuleDO));
        }
        return count;
    }

第一次执行doChangeDataSourceToCurrentEnv后，mybatis底层执行到BaseExecutor的getConnection方法，这个方法是直接调用trasaction.getConnection()来获取connection的（从截图看到这时的transaction对象是12392），从debug截图看获取到的是test-ytgwConfig数据源，符合预期。

 public Connection getConnection() throws SQLException {
    if (this.connection == null) {
      openConnection();
    }
    return this.connection;
  }

  /**
   * Gets a connection from Spring transaction manager and discovers if this
   * {@code Transaction} should manage connection or let it to Spring.
   * <p>
   * It also reads autocommit setting because when using Spring Transaction MyBatis
   * thinks that autocommit is always false and will always call commit/rollback
   * so we need to no-op that calls.
   */
  private void openConnection() throws SQLException {
    this.connection = DataSourceUtils.getConnection(this.dataSource);
    this.autoCommit = this.connection.getAutoCommit();
    this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);

    if (logger.isDebugEnabled()) {
      logger.debug(
          "JDBC Connection ["
              + this.connection
              + "] will"
              + (this.isConnectionTransactional ? " " : " not ")
              + "be managed by Spring");
    }
  }

接着走到第二次数据源操作flowRuleDao.batchInsert，从debug切图来看是还是同个trasaction对象，这个时候就直接返回了老trasaction对象的connetion字段，所以导致第二次数据源数据源切换没有生效。

到这里找到了引起问题的原因，至于为什么两次数据源操作获取的都是同一个transaction对象，这个是spring的事务管理机制。

如果要解决这个问题，最简单粗暴的方法就是不使用spring事务，把initFlowRules方法的@Transactional去掉即可。
从下面的debug截图来看，去掉@Transactional后第一次数据源操作使用的transaction对象是12813，访问到的数据源是test-ytgwConfig。