Spring Boot多数据源配置实战指南：从选型到落地优化

在后端开发中，随着业务复杂度提升，单一数据源往往无法满足需求——比如电商系统需要区分订单库与用户库、数据归档场景需要同时操作业务库与历史库、高并发场景需要通过读写分离提升性能。多数据源配置已成为后端开发者的必备技能。本文从核心场景、选型方案、实战实现到避坑优化，完整拆解Spring Boot生态下的多数据源配置全流程。

一、为什么需要多数据源？核心场景与价值

多数据源并非“炫技”，而是为了解决单一数据源无法覆盖的业务痛点，核心应用场景分为4类：

业务拆分：大型系统按业务模块拆分数据库（如电商系统的订单库、用户库、商品库），降低单库压力，提升系统扩展性；
读写分离：主库负责写入操作，从库负责查询操作，通过负载均衡分散压力，解决高并发下的查询性能瓶颈；
数据归档/同步：如历史数据归档场景，需同时操作“业务库（源库）”和“历史库（目标库）”，实现数据迁移；
多类型数据源整合：系统需同时连接关系型数据库（MySQL）、非关系型数据库（Redis）、数据仓库（ClickHouse）等不同类型数据源，实现数据联动。

多数据源配置的核心价值：解耦业务与数据、提升系统性能、保障数据安全与可扩展性。

二、多数据源配置选型：3种主流方案对比

Spring Boot生态下，多数据源配置有多种实现方案，需根据业务复杂度、技术栈选型合适的方案。以下是3种主流方案的详细对比：

实现方案	核心原理	优势	局限性	适用场景
配置多个DataSource Bean	为每个数据源配置独立的DataSource、SqlSessionFactory、MapperScannerConfigurer，通过包路径区分数据源	1. 实现简单，无额外依赖；2. 数据源隔离性好；3. 支持不同ORM框架	1. 配置冗余，新增数据源需重复配置；2. 无法动态切换数据源；3. 跨数据源事务处理复杂	数据源数量固定、无需动态切换的场景（如固定的业务库拆分）
动态数据源切换（主流）	通过ThreadLocal存储当前数据源标识，结合AOP切面拦截注解，动态切换DataSource	1. 配置简洁，支持动态新增数据源；2. 切换灵活，可通过注解快速指定数据源；3. 适配大多数业务场景	1. 需自定义切面与上下文管理；2. 跨数据源事务需额外处理；3. 多线程环境下需注意线程安全	大多数多数据源场景（读写分离、数据归档、动态业务库）
分布式事务框架（Seata/Sharding-JDBC）	通过框架封装多数据源管理与分布式事务，支持数据源分片、动态路由	1. 支持分布式事务；2. 提供丰富的分片策略；3. 高可用、可扩展	1. 框架学习成本高；2. 轻量场景略显重量级；3. 配置与运维复杂	大型分布式系统、需分布式事务或数据分片的场景

选型建议： - 简单场景（固定2-3个数据源）：优先用“多个DataSource Bean”方案； - 通用场景（需动态切换、数据源较多）：首选“动态数据源切换”方案； - 分布式场景（需事务一致性、数据分片）：用Seata/Sharding-JDBC框架。

三、实战：动态数据源切换方案落地（Spring Boot+MyBatis-Plus）

以“业务库+历史库”的双数据源场景为例（呼应历史数据归档需求），采用“动态数据源切换”方案，实现通过注解快速指定数据源的功能。技术栈：Spring Boot 2.7.x + MyBatis-Plus 3.5.x + MySQL。

1. 环境准备

（1）引入核心依赖

在pom.xml中引入Spring Boot核心依赖、MyBatis-Plus、数据库驱动、连接池依赖：

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId>  </dependency>  <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.3.1</version> </dependency>  <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <scope>runtime</scope> </dependency>  <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.2.16</version> </dependency>  <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency>

（2）配置多数据源信息

在application.yml中配置两个数据源：业务库（business）和历史库（history），指定连接信息、连接池参数：

spring: datasource: # 业务库（源库）配置 business: url: jdbc:mysql://localhost:3306/ecommerce_business?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver druid: initial-size: 5 # 初始化连接数 min-idle: 5 # 最小空闲连接数 max-active: 20 # 最大活跃连接数 max-wait: 60000 # 最大等待时间（毫秒） # 历史库（目标库）配置 history: url: jdbc:mysql://localhost:3306/ecommerce_history?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true username: root password: 123456 driver-class-name: com.mysql.cj.jdbc.Driver druid: initial-size: 5 min-idle: 5 max-active: 20 max-wait: 60000 # MyBatis-Plus配置 mybatis-plus: mapper-locations: classpath:mapper/**/*.xml # Mapper.xml文件路径 type-aliases-package: com.example.multi.datasource.entity # 实体类包路径 configuration: map-underscore-to-camel-case: true # 下划线转驼峰 log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 开发环境打印SQL

2. 核心配置：动态数据源切换核心组件

动态数据源切换的核心是通过ThreadLocal存储当前线程的数据源标识，结合AOP切面拦截自定义注解，实现数据源的动态切换。需实现4个核心组件：数据源枚举、数据源上下文、数据源切换注解、AOP切面。

（1）数据源枚举（DataSourceType）

定义数据源标识，与application.yml中的数据源名称对应，便于统一管理：

package com.example.multi.datasource.config; /** * 数据源枚举：对应配置文件中的数据源名称 */ public enum DataSourceType { BUSINESS, // 业务库（默认数据源） HISTORY // 历史库 }}

（2）数据源上下文（DataSourceContextHolder）

通过ThreadLocal存储当前线程的数据源标识，确保线程安全（避免多线程环境下数据源混乱）：

package com.example.multi.datasource.config; /** * 数据源上下文：存储当前线程的数据源标识 */ public class DataSourceContextHolder { // ThreadLocal：线程本地变量，确保每个线程的数据源标识独立 private static final ThreadLocal<DataSourceType> CONTEXT_HOLDER = new ThreadLocal<>(); /** * 设置当前数据源 */ public static void setDataSourceType(DataSourceType type) { CONTEXT_HOLDER.set(type); } /** * 获取当前数据源（默认返回业务库） */ public static DataSourceType getDataSourceType() { return CONTEXT_HOLDER.get() == null ? DataSourceType.BUSINESS : CONTEXT_HOLDER.get(); } /** * 清除数据源标识：避免线程复用导致数据源污染 */ public static void clearDataSourceType() { CONTEXT_HOLDER.remove(); } }

（3）数据源切换注解（DataSource）

自定义注解，用于标记需要切换数据源的方法或类，指定要使用的数据源：

package com.example.multi.datasource.config; import java.lang.annotation.*; /** * 数据源切换注解：用于指定方法/类使用的数据源 */ @Target({ElementType.METHOD, ElementType.TYPE}) // 可用于方法或类上 @Retention(RetentionPolicy.RUNTIME) // 运行时生效 @Documented public @interface DataSource { // 默认数据源为业务库 DataSourceType value() default DataSourceType.BUSINESS; }

（4）AOP切面（DataSourceAspect）

通过AOP切面拦截@DataSource注解，在方法执行前设置当前数据源，执行后清除数据源标识，实现动态切换：

package com.example.multi.datasource.config; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.core.Ordered; import org.springframework.stereotype.Component; import org.aspectj.lang.annotation.Aspect; import java.lang.reflect.Method; /** * 数据源切换切面：拦截@DataSource注解，实现数据源动态切换 */ @Aspect @Component @Slf4j @Order(Ordered.HIGHEST_PRECEDENCE) // 设置切面优先级：确保在事务切面之前执行 public class DataSourceAspect { /** * 切入点：拦截所有带有@DataSource注解的方法或类 */ @Pointcut("@annotation(com.example.multi.datasource.config.DataSource) || @within(com.example.multi.datasource.config.DataSource)") public void dataSourcePointCut() {} /** * 方法执行前：设置当前数据源 */ @Before("dataSourcePointCut()") public void beforeSwitchDataSource(JoinPoint joinPoint) { // 获取当前方法上的@DataSource注解 MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); DataSource dataSourceAnnotation = method.getAnnotation(DataSource.class); // 如果方法上没有注解，检查类上是否有注解 if (dataSourceAnnotation == null) { dataSourceAnnotation = joinPoint.getTarget().getClass().getAnnotation(DataSource.class); } // 设置数据源标识 if (dataSourceAnnotation != null) { DataSourceType dataSourceType = dataSourceAnnotation.value(); DataSourceContextHolder.setDataSourceType(dataSourceType); log.info("切换数据源：{}", dataSourceType); } } /** * 方法执行后：清除数据源标识 */ @After("dataSourcePointCut()") public void afterSwitchDataSource(JoinPoint joinPoint) { DataSourceContextHolder.clearDataSourceType(); log.info("清除数据源标识"); } }

（5）动态数据源配置类（DynamicDataSourceConfig）

配置多个数据源Bean，创建动态数据源（DynamicRoutingDataSource），并将其作为默认数据源注入Spring容器：

package com.example.multi.datasource.config; import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder; import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.annotation.MapperScan; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import javax.sql.DataSource; import java.util.HashMap; import java.util.Map; /** * 动态数据源配置类：创建数据源Bean，配置动态数据源 */ @Configuration @MapperScan(basePackages = "com.example.multi.datasource.mapper") // 扫描Mapper接口包 public class DynamicDataSourceConfig { /** * 配置业务库数据源（对应application.yml中的spring.datasource.business） */ @Bean(name = "businessDataSource") @ConfigurationProperties(prefix = "spring.datasource.business") public DataSource businessDataSource() { // 使用德鲁伊连接池构建数据源 return DruidDataSourceBuilder.create().build(); } /** * 配置历史库数据源（对应application.yml中的spring.datasource.history） */ @Bean(name = "historyDataSource") @ConfigurationProperties(prefix = "spring.datasource.history") public DataSource historyDataSource() { return DruidDataSourceBuilder.create().build(); } /** * 配置动态数据源：整合所有数据源，实现动态切换 * @Primary：标识为默认数据源，避免Spring容器中数据源Bean冲突 */ @Bean(name = "dynamicDataSource") @Primary public DataSource dynamicDataSource( @Qualifier("businessDataSource") DataSource businessDataSource, @Qualifier("historyDataSource") DataSource historyDataSource) { DynamicRoutingDataSource dynamicDataSource = new DynamicRoutingDataSource(); // 存储所有数据源的映射关系 Map<Object, Object> dataSourceMap = new HashMap<>(); dataSourceMap.put(DataSourceType.BUSINESS, businessDataSource); dataSourceMap.put(DataSourceType.HISTORY, historyDataSource); dynamicDataSource.setTargetDataSources(dataSourceMap); // 设置默认数据源（业务库） dynamicDataSource.setDefaultTargetDataSource(businessDataSource); return dynamicDataSource; } /** * 配置SqlSessionFactory：指定动态数据源和Mapper.xml路径 */ @Bean public SqlSessionFactoryBean sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource) throws Exception { SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean(); sessionFactory.setDataSource(dynamicDataSource); // 配置Mapper.xml文件路径 sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver() .getResources("classpath:mapper/**/*.xml")); return sessionFactory; } /** * 配置事务管理器：绑定动态数据源，确保事务生效 */ @Bean public DataSourceTransactionManager transactionManager(@Qualifier("dynamicDataSource") DataSource dynamicDataSource) { return new DataSourceTransactionManager(dynamicDataSource); } }

（6）动态数据源路由类（DynamicRoutingDataSource）

继承AbstractRoutingDataSource，重写determineCurrentLookupKey方法，从数据源上下文中获取当前数据源标识，实现数据源路由：

package com.example.multi.datasource.config; import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; /** * 动态数据源路由类：根据数据源标识路由到对应的数据源 */ public class DynamicRoutingDataSource extends AbstractRoutingDataSource { /** * 重写方法：获取当前数据源标识（从上下文获取） */ @Override protected Object determineCurrentLookupKey() { DataSourceType dataSourceType = DataSourceContextHolder.getDataSourceType(); log.info("当前使用的数据源：{}", dataSourceType); return dataSourceType; } }

3. 业务实现：多数据源数据操作示例

以“订单数据查询（业务库）”和“订单历史数据插入（历史库）”为例，演示如何通过@DataSource注解切换数据源。

（1）实体类定义

定义订单实体（对应业务库t_order表）和订单历史实体（对应历史库t_order_history表）：

// 订单实体（业务库） package com.example.multi.datasource.entity; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; import java.math.BigDecimal; import java.time.LocalDateTime; @Data @TableName("t_order") public class Order { private Long id; private String orderNo; // 订单编号 private Long userId; // 用户ID private BigDecimal amount; // 订单金额 private Integer status; // 订单状态：0-待支付，1-已完成，2-已取消 private LocalDateTime createTime; // 创建时间 private LocalDateTime updateTime; // 更新时间 } // 订单历史实体（历史库） package com.example.multi.datasource.entity; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; import java.math.BigDecimal; import java.time.LocalDateTime; @Data @TableName("t_order_history") public class OrderHistory { private Long id; private String orderNo; private Long userId; private BigDecimal amount; private Integer status; private LocalDateTime createTime; private LocalDateTime updateTime; private LocalDateTime archiveTime; // 归档时间（历史库新增字段） }

（2）Mapper接口定义

定义OrderMapper（操作业务库t_order表）和OrderHistoryMapper（操作历史库t_order_history表），通过@DataSource注解指定数据源：

// OrderMapper（业务库） package com.example.multi.datasource.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.example.multi.datasource.config.DataSource; import com.example.multi.datasource.config.DataSourceType; import com.example.multi.datasource.entity.Order; import org.apache.ibatis.annotations.Param; import java.util.List; // 类上指定数据源：业务库（可省略，默认就是业务库） @DataSource(DataSourceType.BUSINESS) public interface OrderMapper extends BaseMapper<Order> { // 查询3个月前的订单（用于归档） List<Order> selectOldOrders(@Param("endTime") LocalDateTime endTime); } // OrderHistoryMapper（历史库） package com.example.multi.datasource.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.example.multi.datasource.config.DataSource; import com.example.multi.datasource.config.DataSourceType; import com.example.multi.datasource.entity.OrderHistory; import org.apache.ibatis.annotations.Param; import java.util.List; // 类上指定数据源：历史库 @DataSource(DataSourceType.HISTORY) public interface OrderHistoryMapper extends BaseMapper<OrderHistory> { // 批量插入历史订单 int batchInsert(@Param("list") List<OrderHistory> orderHistoryList); }

（3）Mapper XML实现

在resources/mapper目录下创建OrderMapper.xml和OrderHistoryMapper.xml，编写SQL语句：

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.example.multi.datasource.mapper.OrderMapper"> <select id="selectOldOrders" resultType="com.example.multi.datasource.entity.Order"> SELECT id, order_no, user_id, amount, status, create_time, update_time FROM t_order WHERE create_time < #{endTime} AND status IN (1, 2) -- 只查询已完成、已取消的订单 </select> </mapper>  <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.example.multi.datasource.mapper.OrderHistoryMapper"> <insert id="batchInsert"> INSERT INTO t_order_history ( id, order_no, user_id, amount, status, create_time, update_time, archive_time ) VALUES <foreach collection="list" item="item" separator=","> ( #{item.id}, #{item.orderNo}, #{item.userId}, #{item.amount}, #{item.status}, #{item.createTime}, #{item.updateTime}, #{item.archiveTime} ) </foreach> </insert> </mapper>

（4）Service层实现

实现订单归档服务，调用两个数据源的Mapper接口，完成“查询业务库旧订单→插入历史库→删除业务库旧订单”的流程：

package com.example.multi.datasource.service; import com.example.multi.datasource.config.DataSource; import com.example.multi.datasource.config.DataSourceType; import com.example.multi.datasource.entity.Order; import com.example.multi.datasource.entity.OrderHistory; import com.example.multi.datasource.mapper.OrderHistoryMapper; import com.example.multi.datasource.mapper.OrderMapper; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; import java.time.LocalDateTime; import java.util.List; import java.util.stream.Collectors; @Service @Slf4j public class OrderArchiveService { @Resource private OrderMapper orderMapper; @Resource private OrderHistoryMapper orderHistoryMapper; /** * 订单归档：从业务库迁移到历史库 */ @Transactional(rollbackFor = Exception.class) // 事务控制：确保迁移+删除原子性 public void archiveOrders() { log.info("开始执行订单归档任务"); try { // 1. 计算归档时间阈值：3个月前 LocalDateTime archiveEndTime = LocalDateTime.now().minusMonths(3); // 2. 从业务库查询旧订单（自动使用业务库数据源） List<Order> oldOrderList = orderMapper.selectOldOrders(archiveEndTime); if (oldOrderList.isEmpty()) { log.info("无需要归档的订单"); return; } log.info("本次需归档订单数量：{}", oldOrderList.size()); // 3. 转换为历史订单实体 List<OrderHistory> orderHistoryList = oldOrderList.stream().map(order -> { OrderHistory history = new OrderHistory(); BeanUtils.copyProperties(order, history); history.setArchiveTime(LocalDateTime.now()); // 设置归档时间 return history; }).collect(Collectors.toList()); // 4. 批量插入历史库（自动使用历史库数据源） orderHistoryMapper.batchInsert(orderHistoryList); log.info("订单批量插入历史库完成"); // 5. 批量删除业务库旧订单 List<Long> orderIds = oldOrderList.stream().map(Order::getId).collect(Collectors.toList()); orderMapper.deleteBatchIds(orderIds); log.info("业务库旧订单删除完成"); } catch (Exception e) { log.error("订单归档任务失败", e); throw new RuntimeException("归档失败", e); // 抛出异常触发事务回滚 } } }

（5）测试验证

编写测试类，调用archiveOrders方法，验证数据源切换是否生效：

package com.example.multi.datasource; import com.example.multi.datasource.service.OrderArchiveService; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import javax.annotation.Resource; @SpringBootTest public class MultiDataSourceTest { @Resource private OrderArchiveService orderArchiveService; @Test public void testArchiveOrders() { orderArchiveService.archiveOrders(); } }

运行测试后，查看日志： - 切换数据源：BUSINESS（查询业务库）； - 切换数据源：HISTORY（插入历史库）； - 再次切换到BUSINESS（删除业务库数据）；若数据成功从业务库迁移到历史库，说明多数据源配置生效。

四、多数据源配置避坑指南：8个高频问题与解决方案

多数据源配置在生产环境中容易出现数据源切换失效、事务异常、性能问题等，以下是8个高频坑点及规避方案：

1. 坑点1：数据源切换失效

现象：添加@DataSource注解后，数据源未切换，仍使用默认数据源。规避方案： - 检查切面优先级：确保数据源切换切面（@Order(Ordered.HIGHEST_PRECEDENCE)）在事务切面之前执行； - 检查注解位置：@DataSource注解需添加在方法上（类上注解优先级低于方法）； - 检查数据源枚举：确保注解指定的数据源枚举与配置文件中的数据源名称一致； - 检查ThreadLocal清理：确保方法执行后清除数据源标识，避免线程复用污染。

2. 坑点2：事务与多数据源冲突

现象：跨数据源操作时，事务无法回滚；或单数据源事务生效，但切换数据源后事务失效。规避方案： - 配置事务管理器：确保事务管理器绑定的是动态数据源（DynamicDataSource）； - 避免跨数据源事务：尽量将同一事务内的操作限制在单个数据源内； - 复杂场景用分布式事务：跨数据源事务需使用Seata等分布式事务框架。

3. 坑点3：多线程环境下数据源混乱

现象：使用线程池时，不同线程的数据源标识相互干扰，导致查询数据错误。规避方案： - 强制清除数据源标识：在每个线程任务执行完毕后，调用DataSourceContextHolder.clearDataSourceType()； - 线程池配置：避免使用无界线程池，控制线程复用频率； - 局部变量隔离：在多线程任务中，显式设置和清除数据源标识，不依赖全局状态。

4. 坑点4：连接池参数配置不合理

现象：多数据源并发访问时，出现连接超时、连接池耗尽等问题。规避方案： - 为每个数据源配置独立的连接池参数（初始化连接数、最大活跃数等）； - 根据业务并发量调整连接池大小：高并发数据源设置更大的max-active； - 启用连接池监控：通过德鲁伊监控页面（/druid/index.html）查看连接池状态，动态调整参数。

5. 坑点5：Mapper扫描范围错误

现象：Mapper接口无法注入，或注入后无法关联到正确的数据源。规避方案： - 统一扫描所有Mapper：在DynamicDataSourceConfig中通过@MapperScan扫描所有数据源的Mapper接口； - 避免重复扫描：不要在多个配置类中重复扫描同一Mapper包； - 明确数据源关联：通过@DataSource注解在Mapper类上指定数据源，避免混淆。

6. 坑点6：读写分离场景下主从同步延迟

现象：主库写入数据后，从库查询不到（主从同步延迟），导致业务异常。规避方案： - 关键业务强制走主库：如用户下单后查询订单状态，通过@DataSource(DataSourceType.MASTER)指定主库； - 配置主从同步优化：减少同步延迟（如优化binlog模式、增加从库配置）； - 重试机制：从库查询失败时，重试几次或切换到主库查询。

7. 坑点7：动态新增数据源时配置不生效

现象：运行时动态添加新数据源（如多租户场景），但无法切换到新数据源。规避方案： - 扩展动态数据源：在DynamicRoutingDataSource中添加动态更新数据源的方法； - 刷新数据源缓存：新增数据源后，调用dynamicDataSource.setTargetDataSources()更新数据源映射； - 线程安全控制：新增数据源时加锁，避免并发修改导致的线程安全问题。

8. 坑点8：忽略数据源监控

现象：多数据源运行状态不透明，出现问题后无法快速定位。规避方案： - 启用连接池监控：如德鲁伊监控，实时查看各数据源的连接数、SQL执行情况； - 日志追踪：在数据源切换切面中打印日志，记录每个方法使用的数据源； - 告警配置：针对连接池耗尽、SQL执行超时等问题配置告警（钉钉/邮件）。

五、进阶优化：多数据源配置的高级能力

对于复杂业务场景，还需掌握多数据源的进阶优化能力，提升系统性能与可扩展性：

1. 动态数据源健康检查

需求：实时监控各数据源的连接状态，发现异常数据源及时告警。实现方案： - 自定义健康检查器：实现Spring Boot的HealthIndicator接口，定期检查各数据源的连接状态； - 集成Spring Boot Actuator：通过/actuator/health端点暴露数据源健康状态，便于监控系统集成。

2. 多数据源读写分离优化

需求：自动将查询操作路由到从库，写入操作路由到主库，无需手动添加注解。实现方案： - 扩展切面逻辑：通过AOP拦截所有查询方法（select开头），自动切换到从库；写入方法（insert/update/delete开头）切换到主库； - 使用Sharding-JDBC：框架自带读写分离功能，支持多种负载均衡策略（轮询、随机等）。