在企业级微服务开发中，多数据源场景（主从分离、多业务库协同）十分常见，默认 Spring Boot 单数据源配置无法满足需求，且多数据源下的事务一致性、动态切换、读写分离路由等问题是生产级开发的核心痛点。本文基于 Spring Boot 2.7.x，结合dynamic-datasource-spring-boot-starter实现动态多数据源配置，落地主从分离读写分离、多数据源事务控制、跨库事务解决方案，兼顾实用性与专业性，适配生产环境复杂数据源场景。
一、核心认知：多数据源场景与核心痛点
1. 常见多数据源应用场景
- 主从分离（读写分离）：主库负责写入操作，从库负责查询操作，提升数据库并发处理能力；
- 多业务库隔离：不同业务模块数据存储在不同数据库（如订单库、用户库、商品库），实现数据隔离与权限管控；
- 跨库联合查询：单个业务需从多个数据库获取数据，需动态切换数据源完成查询；
- 分库分表辅助：配合分库分表框架，实现不同分片库的动态访问。
2. 生产级核心痛点
- 数据源切换繁琐：传统多数据源需手动配置多个 DataSource，切换逻辑侵入业务代码；
- 读写分离路由不灵活：无法按方法 / 注解自动路由主从库，易出现 “读主库” 性能浪费；
- 多数据源事务难控制：单数据源事务（@Transactional）无法覆盖多库操作，跨库事务一致性难以保障；
- 配置冗余：多数据源连接池、驱动配置重复，维护成本高；
- 动态扩容困难：新增数据源需重启服务，无法热加载。
3. 核心技术选型
选用dynamic-datasource-spring-boot-starter（简称动态数据源），核心优势：
- 零侵入：基于 Spring AOP 实现数据源切换，无需修改业务代码；
- 注解驱动：支持
@DS注解指定数据源，灵活适配多场景； - 自动适配：兼容 Spring 事务、MyBatis/MyBatis-Plus、JPA 等框架；
- 功能丰富：支持主从分离、负载均衡、动态新增数据源、事务嵌套。
二、实战 1：动态多数据源基础配置（主从分离 + 多业务库）
1. 环境准备：引入核心依赖
xml
<!-- Spring Boot 核心依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- 动态多数据源核心依赖 --> <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifactId> <version>3.6.1</version> </dependency> <!-- MyBatis-Plus 依赖（适配持久层） --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.3.1</version> </dependency> <!-- MySQL 驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <!-- 连接池（HikariCP 原生适配） --> <dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> </dependency>2. 多数据源配置（application.yml）
支持主从分离 + 多业务库配置，默认数据源为master，主从库通过slave_xxx命名自动识别。
yaml
spring: # 动态多数据源核心配置 datasource: dynamic: primary: master # 默认数据源（主库） strict: false # 非严格模式：未匹配到数据源时使用默认数据源 datasource: # 主库（写入操作） master: url: jdbc:mysql://127.0.0.1:3306/db_master?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver # HikariCP 连接池配置 hikari: maximum-pool-size: 15 minimum-idle: 5 connection-timeout: 30000 idle-timeout: 600000 # 从库1（查询操作） slave_1: url: jdbc:mysql://127.0.0.1:3307/db_slave1?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver hikari: maximum-pool-size: 20 minimum-idle: 8 # 从库2（查询操作，负载均衡） slave_2: url: jdbc:mysql://127.0.0.1:3308/db_slave2?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver hikari: maximum-pool-size: 20 minimum-idle: 8 # 业务库1（订单库） order_db: url: jdbc:mysql://127.0.0.1:3306/db_order?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver # 业务库2（用户库） user_db: url: jdbc:mysql://127.0.0.1:3306/db_user?useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver3. 数据源切换核心用法（@DS 注解）
通过@DS注解灵活指定数据源，支持类级别（全局生效）和方法级别（优先级更高）。
（1）默认数据源（主库）：无需注解
java
运行
// 无@DS注解，默认使用master主库（写入操作） @Service public class ProductServiceImpl implements ProductService { @Resource private ProductMapper productMapper; // 写入操作：主库执行 @Override @Transactional(rollbackFor = Exception.class) public boolean saveProduct(Product product) { return productMapper.insert(product) > 0; } }（2）指定从库 / 业务库：方法级注解
java
运行
@Service public class ProductServiceImpl implements ProductService { @Resource private ProductMapper productMapper; @Resource private OrderMapper orderMapper; @Resource private UserMapper userMapper; // 读取操作：指定slave_1从库 @Override @DS("slave_1") public Product getProductById(Long id) { return productMapper.selectById(id); } // 读取操作：主从负载均衡（注解指定slave，自动轮询slave_1/slave_2） @Override @DS("slave") public List<Product> listProduct() { return productMapper.selectList(null); } // 跨库查询：分别访问订单库和用户库 @DS("order_db") public Order getOrderById(Long orderId) { return orderMapper.selectById(orderId); } @DS("user_db") public User getUserById(Long userId) { return userMapper.selectById(userId); } }（3）类级注解：统一指定数据源
java
运行
// 类级@DS：该类所有方法默认使用order_db订单库 @Service @DS("order_db") public class OrderServiceImpl implements OrderService { @Resource private OrderMapper orderMapper; // 默认使用order_db，无需重复注解 public Order getOrder(Long id) { return orderMapper.selectById(id); } // 方法级注解覆盖类级：指定master主库执行写入 @Override @DS("master") @Transactional(rollbackFor = Exception.class) public boolean createOrder(Order order) { return orderMapper.insert(order) > 0; } }三、实战 2：主从分离读写分离自动路由（无注解方案）
通过 AOP + 自定义规则，实现 “写入自动走主库，读取自动走从库”，无需手动加@DS注解，降低开发成本。
1. 自定义读写分离路由规则
java
运行
package com.example.datasource.config; import com.baomidou.dynamic.datasource.annotation.DS; import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.stereotype.Component; import java.lang.reflect.Method; /** * 读写分离自动路由AOP：无需@DS注解，自动路由主从库 */ @Aspect @Component public class ReadWriteSplitAop { // 切点：所有Service层方法 @Pointcut("execution(* com.example.datasource.service.*.*(..))") public void servicePointcut() {} @Around("servicePointcut()") public Object around(ProceedingJoinPoint joinPoint) throws Throwable { // 1. 优先判断方法/类是否有@DS注解，有则直接使用，不执行自动路由 MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); DS methodDs = AnnotationUtils.findAnnotation(method, DS.class); DS classDs = AnnotationUtils.findAnnotation(joinPoint.getTarget().getClass(), DS.class); if (methodDs != null || classDs != null) { return joinPoint.proceed(); } // 2. 无@DS注解，按方法名判断读写操作 String methodName = method.getName().toLowerCase(); try { // 写入方法：走主库（master） if (methodName.startsWith("save") || methodName.startsWith("insert") || methodName.startsWith("update") || methodName.startsWith("delete") || methodName.startsWith("create")) { DynamicDataSourceContextHolder.push("master"); } else { // 读取方法：走从库（slave，自动负载均衡） DynamicDataSourceContextHolder.push("slave"); } return joinPoint.proceed(); } finally { // 3. 清除数据源上下文，避免污染 DynamicDataSourceContextHolder.poll(); } } }2. 启用 AOP 路由
确保 Spring Boot 开启 AOP 支持（引入 spring-boot-starter-aop 依赖，默认已包含），无需额外配置，启动后自动生效。
四、实战 3：多数据源事务控制（单库 / 跨库）
多数据源场景下，事务控制分单数据源事务和跨数据源事务，需针对性处理。
1. 单数据源事务：直接使用 @Transactional
单个数据源内的操作，直接使用 Spring 原生@Transactional注解，完全兼容。
java
运行
// 单数据源（order_db）事务：正常生效 @Service @DS("order_db") public class OrderServiceImpl implements OrderService { @Resource private OrderMapper orderMapper; @Resource private OrderItemMapper orderItemMapper; // 单库事务：订单+订单项插入，同属order_db，事务生效 @Override @Transactional(rollbackFor = Exception.class) public boolean createOrder(Order order, List<OrderItem> items) { // 插入订单 orderMapper.insert(order); // 插入订单项 items.forEach(item -> { item.setOrderId(order.getId()); orderItemMapper.insert(item); }); return true; } }2. 跨数据源事务：分布式事务解决方案
跨多个数据源的操作，单@Transactional无法保证一致性，需结合分布式事务框架（Seata）实现，核心步骤如下：
（1）引入 Seata 依赖
xml
<dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-seata</artifactId> <version>2021.0.4.0</version> </dependency>（2）配置 Seata 事务分组
yaml
seata: tx-service-group: order_tx_group # 事务分组 registry: type: nacos nacos: server-addr: 127.0.0.1:8848 namespace: dev group: SEATA_GROUP config: type: nacos nacos: server-addr: 127.0.0.1:8848 namespace: dev group: SEATA_GROUP（3）跨库事务实现（@GlobalTransactional）
java
运行
@Service public class CrossDbService { @Resource private OrderService orderService; // 操作order_db @Resource private UserService userService; // 操作user_db // 跨库事务：订单创建+用户积分更新，通过Seata保证一致性 @GlobalTransactional(rollbackFor = Exception.class, timeoutMills = 30000) public boolean createOrderWithUserPoint(Order order, Long userId, Integer point) { // 1. 订单库操作（order_db） boolean orderSuccess = orderService.createOrder(order); if (!orderSuccess) { throw new RuntimeException("订单创建失败"); } // 2. 用户库操作（user_db） boolean pointSuccess = userService.updateUserPoint(userId, point); if (!pointSuccess) { throw new RuntimeException("用户积分更新失败"); } return true; } }五、生产级优化与避坑指南
1. 性能优化要点
- 连接池优化：主库侧重写入，连接池大小适中（10-20）；从库侧重读取，连接池可稍大（20-30）；
- 从库负载均衡：动态数据源默认支持
slave关键字轮询负载均衡，高并发可配置权重； - 避免跨库查询：尽量减少跨库联合查询，可通过数据同步（如 Canal）将数据同步到统一查询库；
- 数据源懒加载：开启
dynamic-datasource.lazy: true，按需加载数据源，减少启动耗时。
2. 常见坑点与解决方案
- 注解优先级问题：方法级
@DS> 类级@DS> 默认数据源，避免注解冲突； - 事务与数据源冲突：
@Transactional需与@DS作用于同一数据源，跨库事务必须用@GlobalTransactional； - 从库延迟问题：主从同步存在延迟，核心业务读取可临时走主库，避免数据不一致；
- 动态数据源切换失效：确保 AOP 切面生效，避免方法内部调用（内部调用不触发 AOP）；
- 连接泄露：确保连接池配置合理，避免长时间占用连接，及时释放数据源上下文。
六、总结
Spring Boot 结合dynamic-datasource-spring-boot-starter实现多数据源管理，核心价值在于零侵入、灵活切换、兼容主流框架，配合 AOP 可实现读写分离自动路由，结合 Seata 可解决跨库事务一致性问题。生产落地时，需根据业务场景选择合适的数据源策略，兼顾性能与一致性，同时规避注解冲突、事务失效等坑点，保障多数据源场景下的服务稳定性。
)
