SpringBoot多数据源动态路由与MyBatisPlus整合实践

1. 多数据源场景下的SpringBoot架构挑战

在企业级应用开发中，多数据源接入是刚需而非选配。我经历过一个电商后台系统改造项目，需要同时对接MySQL的商品数据库、SQL Server的订单系统以及PostgreSQL的日志分析库。这种异构数据库并存的情况，正是SpringBoot多数据源配置的典型应用场景。

传统单数据源配置就像单车道公路，所有车辆（SQL请求）只能排队通过。而多数据源则是立交桥系统，不同数据库的请求可以并行处理。但实现这种架构需要解决几个核心问题：

1. 连接池隔离：每个数据源需要独立的连接池管理，避免线程竞争
2. 事务边界：跨库事务需要特殊处理（通常采用最终一致性方案）
3. ORM映射：MyBatisPlus需要正确绑定到指定数据源的SQL会话
4. 路由机制：运行时动态确定SQL应该发往哪个数据库

以MySQL 8.0和SQL Server 2019为例，它们的驱动配置差异就很大：

properties复制# MySQL配置
spring.datasource.mysql.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.mysql.url=jdbc:mysql://localhost:3306/db1?useSSL=false

# SQL Server配置  
spring.datasource.sqlserver.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver
spring.datasource.sqlserver.url=jdbc:sqlserver://localhost:1433;databaseName=db2

关键提示：SQL Server的JDBC URL格式特殊，分号作为参数分隔符，这与MySQL的问号语法完全不同，这是初期配置最容易出错的地方。

2. 基于AbstractRoutingDataSource的动态路由实现

SpringBoot内置的AbstractRoutingDataSource是实现多数据源路由的核心类。它的工作原理类似于网络交换机，通过查找当前线程绑定的数据源Key来决定实际使用的连接。以下是具体实现步骤：

2.1 上下文持有器模式

首先需要创建线程安全的数据源上下文管理器：

java复制public class DataSourceContextHolder {
    private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>();
    
    public static void setDataSource(String name) {
        CONTEXT.set(name);
    }
    
    public static String getDataSource() {
        return CONTEXT.get();
    }
    
    public static void clear() {
        CONTEXT.remove();
    }
}

2.2 动态数据源实现类

继承AbstractRoutingDataSource并重写determineCurrentLookupKey方法：

java复制public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

2.3 数据源配置类

配置主从数据源bean时需要注意连接池参数隔离。以HikariCP为例：

java复制@Configuration
public class DataSourceConfig {
    
    @Bean
    @ConfigurationProperties("spring.datasource.mysql")
    public DataSource mysqlDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean  
    @ConfigurationProperties("spring.datasource.sqlserver")
    public DataSource sqlServerDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }

    @Bean
    @Primary
    public DataSource dynamicDataSource() {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("mysql", mysqlDataSource());
        targetDataSources.put("sqlserver", sqlServerDataSource());
        
        DynamicDataSource ds = new DynamicDataSource();
        ds.setTargetDataSources(targetDataSources);
        ds.setDefaultTargetDataSource(mysqlDataSource());
        return ds;
    }
}

实战经验：HikariCP的maxPoolSize要根据实际业务场景调整。对于写密集型操作建议设置较小值（如10-20），而读密集型可以适当增大（30-50）。不同数据源的连接池大小应该独立配置。

3. MyBatisPlus的多数据源适配策略

MyBatisPlus需要与动态数据源协同工作，这里有几个关键配置点：

3.1 SqlSessionFactory配置

必须为每个数据源创建独立的SqlSessionFactory：

java复制@Bean
public SqlSessionFactory mysqlSqlSessionFactory(
        @Qualifier("dynamicDataSource") DataSource dataSource) throws Exception {
    MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setMapperLocations(
        new PathMatchingResourcePatternResolver()
            .getResources("classpath:mapper/mysql/*.xml"));
    return factory.getObject();
}

@Bean  
public SqlSessionFactory sqlServerSqlSessionFactory(
        @Qualifier("dynamicDataSource") DataSource dataSource) throws Exception {
    MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setMapperLocations(
        new PathMatchingResourcePatternResolver()
            .getResources("classpath:mapper/sqlserver/*.xml"));
    // SQL Server需要特殊配置
    factory.setDatabaseIdProvider(new VendorDatabaseIdProvider(){
        {
            Properties properties = new Properties();
            properties.setProperty("SQL Server", "sqlserver");
            this.setProperties(properties);
        }
    });
    return factory.getObject();
}

3.2 事务管理器配置

多数据源需要明确的事务边界管理：

java复制@Bean
public PlatformTransactionManager transactionManager(
        @Qualifier("dynamicDataSource") DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
}

3.3 动态切换的AOP实现

通过切面编程实现服务层的数据源自动切换：

java复制@Aspect
@Component
@Order(-1) // 确保在事务切面之前执行
public class DataSourceAspect {
    
    @Before("@annotation(ds)")
    public void beforeSwitchDS(DataSourceSwitch ds) {
        if (!StringUtils.isEmpty(ds.value())) {
            DataSourceContextHolder.setDataSource(ds.value());
        }
    }
    
    @After("@annotation(ds)")  
    public void afterSwitchDS(DataSourceSwitch ds) {
        DataSourceContextHolder.clear();
    }
}

// 自定义注解
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceSwitch {
    String value() default "";
}

使用示例：

java复制@Service
public class OrderService {
    
    @DataSourceSwitch("mysql")
    public List<Order> queryFromMySQL() {
        return orderMapper.selectList(null);
    }
    
    @DataSourceSwitch("sqlserver") 
    public List<Order> queryFromSQLServer() {
        return orderMapper.selectList(null);
    }
}

4. 异构数据库的兼容性处理

当同时使用MySQL和SQL Server时，会遇到SQL语法差异问题。以下是常见痛点及解决方案：

4.1 分页查询差异

MySQL使用LIMIT：

sql复制SELECT * FROM orders LIMIT 10 OFFSET 20

SQL Server使用TOP和ROW_NUMBER()：

sql复制SELECT * FROM (
    SELECT *, ROW_NUMBER() OVER (ORDER BY id) AS row_num
    FROM orders
) AS temp WHERE row_num BETWEEN 21 AND 30

MyBatisPlus的解决方案：

java复制// 在配置类中添加分页插件
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    
    // 动态根据数据库类型选择分页策略
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL){
        @Override
        public void beforeQuery(Executor executor, MappedStatement ms, 
                Object parameter, RowBounds rowBounds, 
                ResultHandler resultHandler, BoundSql boundSql) {
            
            String ds = DataSourceContextHolder.getDataSource();
            if("sqlserver".equals(ds)){
                this.setDbType(DbType.SQL_SERVER);
            } else {
                this.setDbType(DbType.MYSQL);
            }
            super.beforeQuery(executor, ms, parameter, 
                    rowBounds, resultHandler, boundSql);
        }
    });
    
    return interceptor;
}

4.2 自增主键处理

MySQL配置：

xml复制<insert id="insert" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO user(name) VALUES(#{name})
</insert>

SQL Server配置：

xml复制<insert id="insert">
    <selectKey resultType="long" keyProperty="id" order="AFTER">
        SELECT SCOPE_IDENTITY()
    </selectKey>
    INSERT INTO user(name) VALUES(#{name})
</insert>

4.3 日期函数差异

统一处理方案：

java复制public class DateUtils {
    public static String now() {
        String ds = DataSourceContextHolder.getDataSource();
        if("sqlserver".equals(ds)){
            return "GETDATE()";
        } else {
            return "NOW()";
        }
    }
}

// 在Mapper XML中使用
<select id="selectRecent">
    SELECT * FROM logs WHERE create_time > ${@com.utils.DateUtils@now()}
</select>

5. 性能优化与监控

多数据源环境下，性能监控尤为重要。推荐以下实践：

5.1 连接池监控

集成Micrometer监控各数据源连接池：

java复制@Bean
public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags(
        @Qualifier("dynamicDataSource") DataSource dataSource) {
    return registry -> {
        if(dataSource instanceof DynamicDataSource) {
            DynamicDataSource ds = (DynamicDataSource)dataSource;
            ds.getResolvedDataSources().forEach((key, value) -> {
                if(value instanceof HikariDataSource) {
                    ((HikariDataSource) value).setMetricRegistry(registry);
                }
            });
        }
    };
}

5.2 慢SQL日志

为不同数据源配置独立的慢SQL阈值：

properties复制# MySQL慢查询阈值(毫秒)
spring.datasource.mysql.hikari.data-source-properties.logSlowQueries=1000
# SQL Server慢查询阈值 
spring.datasource.sqlserver.hikari.data-source-properties.logSlowQueries=2000

5.3 跨库查询优化

对于需要跨库关联查询的场景，建议：

1. 使用内存JOIN（先查单表再程序关联）
2. 建立数据仓库定期同步
3. 使用Elasticsearch等中间层

示例实现：

java复制public List<UserOrderDTO> getUserWithOrders(Long userId) {
    // 从MySQL查用户
    DataSourceContextHolder.setDataSource("mysql");
    User user = userMapper.selectById(userId);
    
    // 从SQL Server查订单
    DataSourceContextHolder.setDataSource("sqlserver");
    List<Order> orders = orderMapper.selectByUserId(userId);
    
    // 内存组装
    return orders.stream()
            .map(o -> new UserOrderDTO(user, o))
            .collect(Collectors.toList());
}

6. 常见问题排查指南

6.1 连接失败问题

症状：SQL Server连接报"01000错误"

排查步骤：

1. 检查SQL Server是否启用TCP/IP协议
2. 验证SQL Server身份验证模式（建议混合模式）
3. 检查防火墙1433端口
4. 确认JDBC URL格式正确

解决方案：

properties复制# 正确的SQL Server连接串示例
spring.datasource.sqlserver.url=jdbc:sqlserver://localhost:1433;
  databaseName=test;
  encrypt=true;
  trustServerCertificate=true

6.2 事务不生效问题

原因：跨数据源方法使用了@Transactional

解决方案：

java复制// 错误用法
@Transactional
public void crossDatabaseOperation() {
    // 操作MySQL
    DataSourceContextHolder.setDataSource("mysql");
    mysqlMapper.update();
    
    // 操作SQL Server
    DataSourceContextHolder.setDataSource("sqlserver");
    sqlserverMapper.update();
}

// 正确做法：拆分方法+分布式事务
@DataSourceSwitch("mysql")
public void updateMySQL() {
    mysqlMapper.update();
}

@DataSourceSwitch("sqlserver")  
public void updateSQLServer() {
    sqlserverMapper.update();
}

// 使用Seata等分布式事务框架
@GlobalTransactional
public void distributedUpdate() {
    updateMySQL();
    updateSQLServer();
}

6.3 MyBatis缓存冲突

症状：切换数据源后查询结果不一致

解决方案：

java复制@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    // 禁用二级缓存
    interceptor.addInnerInterceptor(new IllegalSQLInnerInterceptor());
    return interceptor;
}

// 或者在Mapper上直接配置
@CacheNamespace(flushInterval = 0, size = 0) // 禁用缓存
public interface UserMapper extends BaseMapper<User> {
}

经过多个生产项目验证，这套方案在日均百万级请求量的系统中表现稳定。关键在于合理设置连接池参数、做好监控、以及避免跨库事务。对于更复杂的场景，可以考虑引入ShardingSphere等专业中间件。