MyBatis-Plus多数据源配置：动态切换数据源的企业级解决方案
项目地址: https://gitcode.com/gh_mirrors/my/mybatis-plus 引言：多数据源场景下的痛点与挑战
在企业级应用开发中，多数据源（Multiple DataSource）需求日益普遍。无论是微服务架构下的数据库分片、读写分离，还是多租户（Multi-Tenancy）场景下的数据隔离，亦或是业务模块化的数据库拆分，都需要高效、灵活的数据源管理方案。
传统MyBatis框架在多数据源配置上存在诸多痛点：
- 配置复杂，需要手动管理多个SqlSessionFactory
- 动态切换逻辑繁琐，容易产生线程安全问题
- 缺乏统一的事务管理机制
- 代码侵入性强，维护成本高
MyBatis-Plus作为MyBatis的强大增强工具包，提供了完善的多数据源解决方案，本文将深入探讨其企业级实现方案。
核心架构设计
动态数据源路由原理
MyBatis-Plus的多数据源实现基于Spring的AbstractRoutingDataSource抽象类，通过线程上下文（ThreadLocal）实现数据源的动态切换。
关键技术组件
| 组件 | 作用 | 核心类 |
|---|---|---|
| 动态数据源 | 负责数据源路由 | DynamicDataSource |
| 数据源上下文 | 线程级数据源管理 | DataSourceContextHolder |
| 切面配置 | 方法级数据源切换 | DataSourceAspect |
| 事务管理 | 多数据源事务协调 | ChainedTransactionManager |
实战配置指南
1. 基础依赖配置
<dependencies>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>3.6.1</version>
</dependency>
</dependencies>
2. 多数据源配置示例
spring:
datasource:
dynamic:
primary: master
strict: false
datasource:
master:
url: jdbc:mysql://localhost:3306/master_db
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
slave1:
url: jdbc:mysql://localhost:3306/slave1_db
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
slave2:
url: jdbc:mysql://localhost:3306/slave2_db
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
# 多租户数据源配置
tenant:
tenant1:
url: jdbc:mysql://localhost:3306/tenant1_db
username: tenant1
password: tenant1_pass
tenant2:
url: jdbc:mysql://localhost:3306/tenant2_db
username: tenant2
password: tenant2_pass
3. 动态数据源切换实现
/**
* 数据源上下文管理器
*/
public class DataSourceContextHolder {
private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
public static void setDataSource(String dataSource) {
CONTEXT_HOLDER.set(dataSource);
}
public static String getDataSource() {
return CONTEXT_HOLDER.get();
}
public static void clearDataSource() {
CONTEXT_HOLDER.remove();
}
}
/**
* 动态数据源路由器
*/
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return DataSourceContextHolder.getDataSource();
}
}
/**
* 数据源切换切面
*/
@Aspect
@Component
@Order(-100) // 确保在事务切面之前执行
public class DataSourceAspect {
@Pointcut("@annotation(com.example.annotation.Master) || " +
"execution(* com.example.service..*.insert*(..)) || " +
"execution(* com.example.service..*.update*(..)) || " +
"execution(* com.example.service..*.delete*(..))")
public void masterPointcut() {}
@Pointcut("@annotation(com.example.annotation.Slave) || " +
"execution(* com.example.service..*.select*(..)) || " +
"execution(* com.example.service..*.get*(..)) || " +
"execution(* com.example.service..*.find*(..)) || " +
"execution(* com.example.service..*.query*(..))")
public void slavePointcut() {}
@Before("masterPointcut()")
public void beforeMaster() {
DataSourceContextHolder.setDataSource("master");
}
@Before("slavePointcut()")
public void beforeSlave() {
// 负载均衡选择从库
String slave = loadBalanceSelectSlave();
DataSourceContextHolder.setDataSource(slave);
}
@After("masterPointcut() || slavePointcut()")
public void after() {
DataSourceContextHolder.clearDataSource();
}
private String loadBalanceSelectSlave() {
// 简单的轮询负载均衡算法
// 实际项目中可使用更复杂的策略
return "slave" + (System.currentTimeMillis() % 2 + 1);
}
}
4. 多租户数据源隔离方案
/**
* 租户上下文管理器
*/
public class TenantContext {
private static final ThreadLocal<String> TENANT_HOLDER = new ThreadLocal<>();
public static void setTenant(String tenantId) {
TENANT_HOLDER.set(tenantId);
}
public static String getTenant() {
return TENANT_HOLDER.get();
}
public static void clearTenant() {
TENANT_HOLDER.remove();
}
}
/**
* 租户数据源路由器
*/
public class TenantDataSourceRouter {
@Autowired
private DynamicDataSource dynamicDataSource;
public void routeByTenant() {
String tenantId = TenantContext.getTenant();
if (StringUtils.isNotBlank(tenantId)) {
DataSourceContextHolder.setDataSource("tenant_" + tenantId);
}
}
}
/**
* 租户拦截器
*/
@Component
public class TenantInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
// 从请求头或Token中获取租户信息
String tenantId = request.getHeader("X-Tenant-Id");
if (StringUtils.isNotBlank(tenantId)) {
TenantContext.setTenant(tenantId);
}
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
TenantContext.clearTenant();
}
}
高级特性与最佳实践
1. 读写分离策略
2. 事务管理策略
/**
* 多数据源事务管理器
*/
@Configuration
public class TransactionConfig {
@Bean
public PlatformTransactionManager transactionManager(
@Qualifier("masterDataSource") DataSource masterDataSource,
@Qualifier("slave1DataSource") DataSource slave1DataSource,
@Qualifier("slave2DataSource") DataSource slave2DataSource) {
Map<Object, PlatformTransactionManager> transactionManagers = new HashMap<>();
transactionManagers.put("master", new DataSourceTransactionManager(masterDataSource));
transactionManagers.put("slave1", new DataSourceTransactionManager(slave1DataSource));
transactionManagers.put("slave2", new DataSourceTransactionManager(slave2DataSource));
return new ChainedTransactionManager(
transactionManagers.get("master"),
transactionManagers.get("slave1"),
transactionManagers.get("slave2")
);
}
}
/**
* 分布式事务示例
*/
@Service
public class OrderService {
@Transactional
public void createOrder(Order order) {
// 主库写操作
orderMapper.insert(order);
// 从库读操作（在同一个事务中）
Order latestOrder = orderMapper.selectLatestOrder();
// 如果需要在事务中强制使用主库
DataSourceContextHolder.setDataSource("master");
try {
orderDetailMapper.insert(order.getDetails());
} finally {
DataSourceContextHolder.clearDataSource();
}
}
}
3. 性能优化与监控
/**
* 数据源监控组件
*/
@Component
public class DataSourceMonitor {
@Autowired
private DynamicDataSource dynamicDataSource;
@Scheduled(fixedDelay = 60000) // 每分钟监控一次
public void monitorDataSourceHealth() {
Map<Object, DataSource> resolvedDataSources = dynamicDataSource.getResolvedDataSources();
resolvedDataSources.forEach((key, dataSource) -> {
try (Connection connection = dataSource.getConnection()) {
boolean isValid = connection.isValid(5); // 5秒超时
log.info("数据源 {} 健康状态: {}", key, isValid ? "正常" : "异常");
if (!isValid) {
// 触发告警或自动切换逻辑
handleDataSourceFailure(key.toString());
}
} catch (SQLException e) {
log.error("数据源 {} 监控异常: {}", key, e.getMessage());
}
});
}
private void handleDataSourceFailure(String dataSourceKey) {
// 实现故障转移逻辑
log.warn("数据源 {} 发生故障，正在执行故障转移", dataSourceKey);
}
}
/**
* SQL执行时间监控
*/
@Aspect
@Component
public class SqlPerformanceAspect {
private static final ThreadLocal<Long> START_TIME = new ThreadLocal<>();
@Pointcut("execution(* com.baomidou.mybatisplus.core.mapper.BaseMapper.*(..))")
public void mapperMethods() {}
@Around("mapperMethods()")
public Object monitorSqlPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
START_TIME.set(System.currentTimeMillis());
try {
return joinPoint.proceed();
} finally {
long costTime = System.currentTimeMillis() - START_TIME.get();
String dataSource = DataSourceContextHolder.getDataSource();
String methodName = joinPoint.getSignature().getName();
if (costTime > 1000) { // 超过1秒的慢SQL
log.warn("慢SQL告警 - 数据源: {}, 方法: {}, 耗时: {}ms",
dataSource, methodName, costTime);
}
START_TIME.remove();
}
}
}
企业级场景解决方案
1. 微服务架构下的数据源治理
2. 多租户数据隔离策略对比
| 策略类型 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 独立数据库 | 数据完全隔离，安全性高 | 成本高，维护复杂 | 金融、政府等高安全要求场景 |
| 共享数据库独立Schema | 成本适中，隔离性较好 | 需要数据库权限管理 | 中型企业SaaS应用 |
| 共享数据库共享Schema | 成本最低，部署简单 | 数据隔离性差，需要应用层控制 | 小型应用或内部系统 |
3. 数据源配置管理最佳实践
# 生产环境多数据源配置模板
spring:
datasource:
dynamic:
# 基础配置
primary: master
strict: true
seata: false
p6spy: false
# 数据源配置
datasource:
master:
url: jdbc:mysql://${MASTER_DB_HOST:localhost}:3306/${MASTER_DB_NAME}
username: ${MASTER_DB_USER}
password: ${MASTER_DB_PASSWORD}
driver-class-name: com.mysql.cj.jdbc.Driver
# 连接池配置
hikari:
connection-timeout: 30000
maximum-pool-size: 20
minimum-idle: 5
idle-timeout: 600000
max-lifetime: 1800000
slave:
url: jdbc:mysql://${SLAVE_DB_HOST:localhost}:3306/${SLAVE_DB_NAME}
username: ${SLAVE_DB_USER}
password: ${SLAVE_DB_PASSWORD}
driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
connection-timeout: 30000
maximum-pool-size: 15
minimum-idle: 3
# 多租户配置
tenant:
enabled: true
header: X-Tenant-Id
tenants:
- key: tenant1
url: jdbc:mysql://${TENANT1_DB_HOST}:3306/tenant1
username: tenant1_user
password: ${TENANT1_DB_PASSWORD}
- key: tenant2
url: jdbc:mysql://${TENANT2_DB_HOST}:3306/tenant2
username: tenant2_user
password: ${TENANT2_DB_PASSWORD}
故障排查与性能调优
常见问题解决方案
-
数据源切换失败
- 检查切面执行顺序，确保在事务之前
- 验证ThreadLocal的清理逻辑
-
事务管理异常
- 使用ChainedTransactionManager管理多数据源事务
- 避免在事务中频繁切换数据源
-
连接池泄漏
- 配置合适的连接池参数
- 启用连接泄漏检测
-
性能瓶颈
- 监控SQL执行时间
- 优化数据源路由算法
性能监控指标
| 监控指标 | 正常范围 | 告警阈值 | 处理建议 |
|---|---|---|---|
| 连接池活跃连接数 | < 最大连接数的80% | > 最大连接数的90% | 扩容或优化SQL |
| SQL平均执行时间 | < 100ms | > 1000ms | 优化索引或SQL |
| 数据源切换频率 | < 100次/秒 | > 500次/秒 | 检查业务逻辑 |
| 连接获取等待时间 | < 50ms | > 200ms | 调整连接池参数 |
总结与展望
MyBatis-Plus的多数据源解决方案为企业级应用提供了强大而灵活的数据访问能力。通过合理的架构设计和最佳实践，可以构建出高性能、高可用的多数据源系统。
核心价值总结：
- 🚀 高性能：基于动态路由和连接池优化
- 🔒 安全可靠：完善的事务管理和故障恢复机制
- 📊 可观测：全面的监控和告警体系
- 🎯 灵活扩展：支持多种业务场景和架构模式
未来发展方向：
- 云原生数据源管理
- AI驱动的智能路由优化
- 无服务器架构适配
- 更强大的监控和自愈能力
掌握MyBatis-Plus多数据源配置，将为你的企业级应用开发带来质的飞跃，助力构建更加健壮和高效的业务系统。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
