1. 为什么你的项目需要多数据源?
如果你正在开发一个稍微复杂点的企业应用,大概率会遇到一个头疼的问题:数据不在同一个地方。我见过太多项目,一开始图省事,所有表都塞进一个数据库里。结果呢?业务发展起来,用户量上来了,或者需要对接外部系统,数据就开始“分家”了。比如,核心的用户订单数据放在公司自建的MySQL主库,而用户行为日志为了分析方便,得实时同步到另一个专门的ClickHouse库;又或者,你需要从A系统的Oracle数据库里定时拉取客户信息,清洗转换后,写入到你自己系统的MySQL库中。
这种“跨库操作”的需求,就是多数据源配置的典型场景。它不是什么高深莫测的黑科技,而是一个解决实际数据孤岛问题的工程化方案。简单来说,就是让你的一个SpringBoot应用,能同时“认识”并“操作”多个不同的数据库连接。原始文章里提到了从A库读、往B库写的例子,这其实只是最基础的一种。在实际工作中,场景要丰富得多:
- 读写分离:为了应对高并发,主库负责写,多个从库负责读。应用需要根据操作类型动态选择数据源。
- 分库分表:数据量太大,单库扛不住,按业务或用户ID分到不同的物理数据库上。
- 多租户架构:一个SaaS平台,每个租户的数据独立存放在一个数据库实例中,应用需要根据当前登录的租户动态切换连接。
- 异构数据源同步:就像前面说的,数据来源五花八门,可能是MySQL、PostgreSQL,也可能是Oracle甚至MongoDB,你需要在一个服务里搞定它们。
只用SpringBoot默认的单数据源配置,遇到这些情况就抓瞎了。你会发现自己被困在一个数据库里,想访问另一个库的数据,要么走别扭的数据库链路(如FEDERATED引擎),要么就得额外写一个服务,引入不必要的网络开销和复杂度。直接在应用层配置多数据源,把数据交互的逻辑收拢在业务代码内部,往往是更清晰、更可控的选择。
所以,掌握SpringBoot+MyBatis多数据源配置,不是一个“炫技”的技能,而是一个后端开发者解决真实数据存取问题的基本功。它能让你设计的系统更灵活,更好地适应业务的变化。接下来,我们就抛开理论,直接上手,看看怎么从零开始搭建一个能“左右逢源”的多数据源项目。
2. 五分钟快速搭建双数据源环境
好了,道理讲完了,我们直接动手。我保证,只要你跟着步骤走,五分钟内就能让项目连接上两个数据库。这里我们沿用最经典的场景:一个本地MySQL数据库(local_db),一个远程测试环境MySQL数据库(dev_db)。我们的目标是配置好它们,并且能成功进行测试查询。
2.1 项目初始化与核心依赖
首先,用你喜欢的IDE(比如IntelliJ IDEA)或者通过Spring Initializr网站,创建一个标准的SpringBoot项目。在选择依赖时,勾选上 Spring Web、MyBatis Framework 和 MySQL Driver。不过,通过Initializr添加的MyBatis依赖可能不是最新版,为了更稳定,我习惯在pom.xml里明确指定版本。
下面是我在实际项目中常用的依赖配置,比原始文章里的更全面一些,加入了Druid连接池(性能好,监控功能强大)和Lombok(简化代码):
<dependencies>
<!-- SpringBoot Web基础 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- JDBC支持,必须 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- MyBatis官方与SpringBoot的整合启动器 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.3.0</version> <!-- 使用稳定版本 -->
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<!-- 阿里Druid连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.20</version>
</dependency>
<!-- 简化POJO开发 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- 测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
注意:这里没有排除SpringBoot的自动数据源配置,因为我们后面会手动配置多个数据源,所以需要在主启动类上做点手脚,这个稍后说。
2.2 多数据源配置的“心脏”:application.yml
配置文件是区别单数据源和多数据源的关键。单数据源时,spring.datasource下面直接跟url、username等属性。多数据源时,我们需要把它们“包”起来,给每个数据源起个名字。
原始文章里提到了用jdbcUrl替代url,这是因为当配置顶级属性是spring.datasource时,SpringBoot会自动绑定标准属性。但当我们将其作为子属性(如spring.datasource.dev)时,使用jdbc-url或jdbcUrl是Druid或HikariCP连接池能正确识别的属性名。为了清晰和兼容性,我推荐以下写法:
spring:
datasource:
# 第一个数据源,命名为 local
local:
driver-class-name: com.mysql.cj.jdbc.Driver
jdbc-url: jdbc:mysql://localhost:3306/local_db?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: root
password: your_local_password
type: com.alibaba.druid.pool.DruidDataSource
# Druid连接池可选配置(根据性能调整)
druid:
initial-size: 5
min-idle: 5
max-active: 20
test-on-borrow: true
validation-query: SELECT 1
# 第二个数据源,命名为 dev
dev:
driver-class-name: com.mysql.cj.jdbc.Driver
jdbc-url: jdbc:mysql://192.168.1.100:3306/dev_db?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: dev_user
password: your_dev_password
type: com.alibaba.druid.pool.DruidDataSource
druid:
initial-size: 5
min-idle: 5
max-active: 20
看,是不是很直观?local和dev就是两个数据源的标识符,后面在Java代码里我们会用到它们。请务必将jdbc-url、username和password替换成你自己数据库的真实信息。
2.3 告别自动配置:主启动类的关键一步
配置写好了,但如果你现在启动项目,SpringBoot还是会试图根据默认规则去创建单个DataSource Bean,这肯定会报错,因为它发现配置里有local和dev,不知道用哪个。
所以,我们需要在主启动类上,排除掉SpringBoot关于DataSource的自动配置类,告诉它:“这个我自己来管”。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MultiDataSourceApplication {
public static void main(String[] args) {
SpringApplication.run(MultiDataSourceApplication.class, args);
}
}
加上exclude = {DataSourceAutoConfiguration.class}这一句,就等于关掉了SpringBoot在数据源配置上的“自动驾驶”模式,切换到了我们手动操作的“手动挡”。这是实现多数据源配置非常关键且容易忽略的一步。
3. 核心配置解析:如何让MyBatis认识两个“家”
配置文件只是定义了数据源的信息,就像给了你两个仓库的地址和钥匙。接下来,我们需要在Java代码里,根据这些信息,分别打造两把专用的“钥匙”(DataSource Bean),并为MyBatis分别配置两个“管家”(SqlSessionFactory),让它们各司其职,管理各自仓库的货物(Mapper和SQL)。
3.1 数据源配置类:打造两把专属钥匙
我们不能让Spring自动创建DataSource了,那就自己来。通常,我会为每个数据源创建一个独立的配置类,这样逻辑清晰,便于维护。这里以local数据源为例,dev数据源完全类似。
LocalDataSourceConfig.java
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.apache.ibatis.session.SqlSessionFactory;
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 javax.sql.DataSource;
@Configuration
// 重点1:指定这个SqlSessionFactory管理的Mapper接口所在包
@MapperScan(basePackages = "com.yourpackage.mapper.local",
sqlSessionFactoryRef = "localSqlSessionFactory")
public class LocalDataSourceConfig {
// 重点2:创建名为“localDataSource”的Bean,并从配置文件中加载前缀为“spring.datasource.local”的属性
@Primary // 重点3:在多个同类型Bean中,标记这个为主要(默认)的。通常指定一个数据源为@Primary。
@Bean(name = "localDataSource")
@ConfigurationProperties(prefix = "spring.datasource.local")
public DataSource localDataSource() {
// 使用Druid的Builder来构建,它会自动绑定上面prefix指定的所有属性
return DruidDataSourceBuilder.create().build();
}
// 重点4:创建名为“localSqlSessionFactory”的Bean,它使用上面创建的localDataSource
@Bean(name = "localSqlSessionFactory")
public SqlSessionFactory localSqlSessionFactory(
@Qualifier("localDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
// 注入专属数据源
sessionFactoryBean.setDataSource(dataSource);
// 指定该数据源对应的MyBatis XML映射文件位置(可选,但推荐)
sessionFactoryBean.setMapperLocations(
new PathMatchingResourcePatternResolver()
.getResources("classpath:mapper/local/*.xml"));
// 如果你有全局的mybatis配置(如驼峰命名转换),也可以在这里设置
// sessionFactoryBean.setConfigLocation(...);
return sessionFactoryBean.getObject();
}
}
逐行解析关键点:
@MapperScan:这是MyBatis-Spring整合的核心注解。basePackages指定了这个数据源对应的Mapper接口所在的包路径。sqlSessionFactoryRef则明确告诉Spring,扫描到这个包下的Mapper接口时,应该绑定到哪个SqlSessionFactoryBean上(这里就是localSqlSessionFactory)。这是实现Mapper与数据源一一对应的关键!@Bean(name = "localDataSource"):在Spring容器中注册一个名为localDataSource的DataSource类型的Bean。名字很重要,后面注入时要用到。@ConfigurationProperties(prefix = "spring.datasource.local"):魔法发生的地方。这个注解会将application.yml中所有以spring.datasource.local开头的属性(jdbc-url,username,druid.*等),自动赋值给这个DataSourceBean的对应属性。@Primary:当一个接口有多个实现Bean时(比如这里有localDataSource和devDataSource,它们都是DataSource类型),@Primary标记的Bean会被优先作为默认注入项。在多数据源场景下,你必须且只能选择一个数据源加上@Primary注解,否则在一些需要自动注入DataSource而又未指定名称的地方,Spring会因无法选择而报错。通常选择你最常用的、或者作为默认写库的数据源。SqlSessionFactoryBean:这是创建MyBatis核心对象SqlSessionFactory的工厂Bean。我们为每个数据源都创建一个,并为其设置专属的DataSource和可选的MapperLocations(XML文件路径)。这样,不同包下的Mapper就自然关联到了不同的数据库连接。
对于dev数据源,创建另一个配置类DevDataSourceConfig.java,内容几乎一样,只需将所有的local替换为dev,并且不要在devDataSource上添加@Primary注解(除非你想让它成为默认数据源)。
3.2 目录结构规划:让代码井井有条
清晰的目录结构能极大避免混乱。我推荐这样组织你的项目:
src/main/java/com/yourpackage/
├── MultiDataSourceApplication.java
├── config/
│ ├── LocalDataSourceConfig.java
│ └── DevDataSourceConfig.java
├── mapper/
│ ├── local/ # 对应local数据源的Mapper接口
│ │ └── LocalTestMapper.java
│ └── dev/ # 对应dev数据源的Mapper接口
│ └── DevTestMapper.java
├── entity/ # 实体类,如果两边表结构一样可以共用
│ └── TestEntity.java
└── service/ # 业务服务层
└── DataSyncService.java
src/main/resources/
├── application.yml
└── mapper/ # MyBatis XML文件(如果使用)
├── local/
│ └── LocalTestMapper.xml
└── dev/
└── DevTestMapper.xml
把不同数据源的Mapper接口和XML文件(如果用的话)分开放到不同的子包下,这与配置类中的@MapperScan设置完全对应,一目了然。
4. 实战演练:实现跨库数据同步
环境搭好了,配置也清楚了,是时候干点“实事”了。我们来实现一个最常见的场景:从dev数据库的source_table表读取数据,经过一些简单的处理(比如字段映射、逻辑判断),然后写入到local数据库的target_table表中。
4.1 定义Mapper:各为其主
首先,定义两个Mapper接口,它们分别位于被@MapperScan扫描的对应包下。
DevTestMapper.java (在 mapper.dev 包下)
package com.yourpackage.mapper.dev;
import com.yourpackage.entity.TestEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper // 这个注解可加可不加,因为@MapperScan已经扫描了这个包
public interface DevTestMapper {
/**
* 从dev数据源查询数据
*/
@Select("SELECT id, name, create_time FROM source_table WHERE status = 1")
List<TestEntity> selectActiveData();
}
LocalTestMapper.java (在 mapper.local 包下)
package com.yourpackage.mapper.local;
import com.yourpackage.entity.TestEntity;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface LocalTestMapper {
/**
* 向local数据源插入数据
* 注意:这里假设target_table表有 id, name, sync_time 字段
* 我们演示一个简单的字段映射:source的create_time -> target的sync_time
*/
@Insert("INSERT INTO target_table(name, sync_time) VALUES (#{name}, #{createTime})")
int insertData(TestEntity entity);
}
TestEntity.java
package com.yourpackage.entity;
import lombok.Data;
import java.time.LocalDateTime;
@Data // Lombok注解,自动生成getter, setter等
public class TestEntity {
private Long id;
private String name;
private LocalDateTime createTime;
// 可以包含其他字段...
}
注意,两个Mapper接口因为被不同的SqlSessionFactory管理,所以它们会自然而然地使用各自配置的数据源。你不需要在代码里做任何切换数据源的操作,这是配置阶段就决定好的。
4.2 编写服务层:串联业务流程
现在,我们在服务层注入这两个Mapper,并编写同步逻辑。
DataSyncService.java
package com.yourpackage.service;
import com.yourpackage.entity.TestEntity;
import com.yourpackage.mapper.dev.DevTestMapper;
import com.yourpackage.mapper.local.LocalTestMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
@Slf4j // Lombok的日志注解
public class DataSyncService {
@Autowired
private DevTestMapper devTestMapper; // 操作dev库
@Autowired
private LocalTestMapper localTestMapper; // 操作local库
/**
* 简单的跨库数据同步方法
* 从dev库读,写入local库
*/
@Transactional // 注意事务管理器,见下文分析
public void syncDataFromDevToLocal() {
log.info("开始从DEV库同步数据到LOCAL库...");
// 1. 从dev数据源查询
List<TestEntity> dataList = devTestMapper.selectActiveData();
if (dataList.isEmpty()) {
log.info("未查询到待同步数据。");
return;
}
log.info("查询到 {} 条待同步数据。", dataList.size());
int successCount = 0;
// 2. 遍历并写入local数据源
for (TestEntity entity : dataList) {
try {
int rows = localTestMapper.insertData(entity);
if (rows > 0) {
successCount++;
// 这里可以添加更复杂的业务逻辑,比如数据转换、校验等
log.debug("成功同步数据: ID={}, Name={}", entity.getId(), entity.getName());
}
} catch (Exception e) {
// 处理单条插入失败,可以根据业务决定是记录日志继续,还是抛出异常回滚
log.error("同步数据失败: {}", entity, e);
// 如果希望单条失败不影响整体,可以 continue
// 如果希望任意失败则整体回滚,可以 throw e;
}
}
log.info("数据同步完成。总计处理 {} 条,成功 {} 条。", dataList.size(), successCount);
}
}
4.3 事务管理的坑与解决之道
上面代码中的@Transactional注解,在单数据源时工作得很好。但在多数据源环境下,它默认使用那个被标记为@Primary的数据源所对应的事务管理器。这意味着,如果localDataSource是@Primary,那么@Transactional只会管理localTestMapper.insertData操作的事务,而devTestMapper.selectActiveData的查询并不在一个事务里(不过查询通常也不需要事务)。
问题来了:如果我们希望dev的查询和local的写入作为一个分布式事务(要么都成功,要么都失败),默认的@Transactional是做不到的。这是一个典型的分布式事务问题。
对于跨库数据同步这种场景,我的实战经验是,根据业务对一致性的要求,采取不同策略:
- 最终一致性(推荐):大多数同步场景,如日志同步、数据备份、非核心数据迁移,并不需要强一致性。我们可以去掉方法上的
@Transactional,采用“记录错误+重试+补偿”的机制。就像上面代码里的try-catch,单条失败记录日志,继续同步下一条。然后通过定时任务重新处理失败的数据。这种方式性能好,实现简单。 - 强一致性(复杂):如果业务要求极高,比如金融转账涉及两个独立数据库,就必须引入分布式事务解决方案。例如:
- Seata (AT模式):阿里开源的分布式事务框架,对代码侵入小,但需要部署额外的TC(事务协调器)服务。
- XA协议:使用支持XA的数据库驱动和JTA(Java Transaction API)管理器。配置复杂,性能较差,通常不推荐。
- 最大努力通知型:基于可靠消息队列(如RocketMQ的事务消息),保证本地事务和消息发送的最终一致性。
在单纯的SpringBoot多数据源项目中,我强烈建议你先采用最终一致性方案。它足够应对90%的跨库同步场景。当你真的需要强一致性时,再去调研和引入Seata这类框架,那将是另一个层面的架构设计了。
4.4 运行与测试
最后,我们写个测试类或者一个简单的Controller来触发这个同步任务。
MultiDataSourceApplicationTests.java
import com.yourpackage.service.DataSyncService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class MultiDataSourceApplicationTests {
@Autowired
private DataSyncService dataSyncService;
@Test
void testCrossDatabaseSync() {
dataSyncService.syncDataFromDevToLocal();
// 你可以在这里添加断言,查询local库的数据来验证同步结果
}
}
运行这个测试方法。如果一切配置正确,你会在控制台看到日志输出,并且能在local数据库的target_table表中找到从dev库同步过来的数据。
5. 进阶:动态数据源与更多实战场景
基础的双数据源固定配置已经掌握了,但在更复杂的生产环境中,数据源的选择可能不是写死在代码里的。比如在多租户系统中,租户的数据库连接信息是动态从配置中心获取的;或者在读写分离场景下,需要在运行时根据SQL是读还是写来动态切换数据源。这就需要动态数据源技术。
5.1 动态数据源路由原理
动态数据源的核心是抽象路由。我们不再直接注入固定的DataSource,而是注入一个AbstractRoutingDataSource。这个类持有一个“目标数据源”的映射表(Map),并提供了一个determineCurrentLookupKey()方法。每次执行数据库操作前,Spring都会调用这个方法,获取一个“查找键”(比如local或dev),然后根据这个键去映射表里找到对应的真实DataSource来使用。
那么,如何设置这个“查找键”呢?通常的做法是使用ThreadLocal。ThreadLocal可以为每个线程单独保存一个变量副本。我们在执行DAO方法前,将当前线程要使用的数据源标识(如dev)存入ThreadLocal,然后在determineCurrentLookupKey()方法中取出这个标识返回即可。
5.2 实现一个简单的动态数据源
这里给出一个高度简化的实现思路,让你感受一下其脉络:
-
定义数据源上下文持有者:使用
ThreadLocal存储数据源键。public class DynamicDataSourceContextHolder { private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>(); public static void setDataSourceKey(String key) { CONTEXT_HOLDER.set(key); } public static String getDataSourceKey() { return CONTEXT_HOLDER.get(); } public static void clearDataSourceKey() { CONTEXT_HOLDER.remove(); } } -
继承AbstractRoutingDataSource:
@Configuration public class DynamicDataSourceConfig { @Bean @Primary // 动态数据源作为主数据源 public DataSource dynamicDataSource( @Qualifier("localDataSource") DataSource localDataSource, @Qualifier("devDataSource") DataSource devDataSource) { Map<Object, Object> targetDataSources = new HashMap<>(); targetDataSources.put("local", localDataSource); targetDataSources.put("dev", devDataSource); DynamicRoutingDataSource routingDataSource = new DynamicRoutingDataSource(); routingDataSource.setDefaultTargetDataSource(localDataSource); // 设置默认数据源 routingDataSource.setTargetDataSources(targetDataSources); return routingDataSource; } static class DynamicRoutingDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { // 关键:从这里获取当前线程指定的数据源键 return DynamicDataSourceContextHolder.getDataSourceKey(); } } } -
使用AOP或自定义注解切换数据源:你可以定义一个注解,如
@DataSource("dev"),然后通过Spring AOP,在方法执行前,根据注解值调用DynamicDataSourceContextHolder.setDataSourceKey(...),方法执行后清理ThreadLocal。
这样,你的Service方法就可以通过注解来灵活指定使用哪个数据源了。当然,一个成熟的动态数据源方案还需要考虑事务传播、连接池管理、失败回退等很多细节,通常会直接使用成熟的开源组件,比如MyBatis-Plus的多数据源模块。
5.3 使用MyBatis-Plus简化多数据源配置
如果你觉得上面的原生配置和动态数据源实现太繁琐,强烈推荐使用MyBatis-Plus (MP)。它对多数据源的支持非常优雅,几乎可以做到“开箱即用”。
-
添加依赖:
<dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter</artifactId> <version>3.6.1</version> <!-- 使用最新稳定版 --> </dependency> -
简化配置:
spring: datasource: dynamic: primary: local # 设置默认数据源 strict: false # 是否严格匹配数据源,默认false datasource: local: url: jdbc:mysql://localhost:3306/local_db?... username: root password: ... driver-class-name: com.mysql.cj.jdbc.Driver dev: url: jdbc:mysql://192.168.1.100:3306/dev_db?... username: dev_user password: ... driver-class-name: com.mysql.cj.jdbc.Driver -
使用注解切换:在Service方法或Mapper接口上使用
@DS("dev")注解,即可切换到dev数据源。MP会自动处理路由和ThreadLocal的清理,无需你手动编写任何配置类。@Service public class SomeService { @DS("dev") // 指定使用dev数据源 public List<User> getUsersFromDev() { return userMapper.selectList(null); } @DS("local") // 指定使用local数据源 public void saveToLocal(User user) { userMapper.insert(user); } }
MyBatis-Plus的动态数据源功能极大地降低了多数据源的使用门槛,是我在快速开发项目时的首选方案。
6. 避坑指南与性能优化
配置和使用多数据源的过程中,我踩过不少坑,这里分享几个最常见的,帮你提前绕过去。
坑1:启动报错 Consider marking one of the beans as @Primary 这是最经典的错误。根本原因是Spring容器里存在多个同类型(DataSource或SqlSessionFactory)的Bean,而某些地方(比如事务管理器、JdbcTemplate自动配置)需要自动注入一个,它不知道选哪个。解决方案:确保在你的多个数据源配置类中,有且仅有一个DataSource Bean被标记为@Primary。通常选择你最常用的那个。
坑2:Mapper扫描冲突或找不到 症状是启动时报“找不到Mapper”或者“Bean创建失败”。原因:@MapperScan注解配置错误,导致多个SqlSessionFactory都去扫描了同一个包,或者该包的Mapper没有被任何SqlSessionFactory扫描到。解决方案:严格按照我们之前的配置,确保每个@MapperScan的basePackages指向不同的、独立的包路径,并且sqlSessionFactoryRef指向正确的工厂Bean名字。
坑3:事务不生效或混乱 如前所述,多数据源下默认的@Transactional只对@Primary数据源生效。如果你在非主数据源的操作上加了@Transactional,事务可能不会按你预期回滚。解决方案:对于需要跨多个非主数据源的事务,考虑使用最终一致性方案或引入Seata。如果只是单个非主数据源需要事务,可以为该数据源单独配置一个DataSourceTransactionManager,然后在@Transactional注解中指定使用哪个事务管理器(transactionManager = "devTransactionManager")。
坑4:连接池配置不当导致性能问题 为每个数据源都配置了连接池,但参数不合理。比如max-active(最大连接数)设置过大,可能导致数据库连接耗尽;设置过小,则在高并发时排队等待。优化建议:
- 根据数据库服务器的性能和业务并发量,合理设置
max-active、min-idle、max-wait等参数。 - 为不同重要性的数据源设置不同的连接池参数。核心业务库可以给更多连接,分析型日志库可以少一些。
- 启用Druid的监控功能(
stat-view-servlet),定期观察连接池的使用情况,如活跃连接数、等待次数等,进行动态调整。
坑5:忽视连接泄露 在复杂的业务逻辑或异常处理中,如果数据库连接没有正确关闭,会导致连接泄露,最终连接池被占满,服务不可用。解决方案:
- 确保使用MyBatis时,
SqlSession被正确关闭(通常框架会自动处理)。 - 使用Druid连接池,并开启
remove-abandoned等泄露检测功能。 - 在代码中,对于手动获取的
Connection,务必在finally块中关闭。
多数据源配置是项目架构中一个非常实用的技能点,从简单的双库同步到复杂的动态路由,其核心思想都是对数据库连接进行精细化管理。理解其原理,掌握至少一种实现方式,并能规避常见陷阱,你的后端技术工具箱里就又多了一件趁手的兵器。记住,技术选型没有绝对的好坏,适合业务场景、团队能力和维护成本的,才是最好的。先从简单的静态多数据源开始,随着业务复杂度的提升,再逐步演进到动态数据源或引入分布式事务框架,这才是稳健的架构演进之路。
2303



被折叠的 条评论
为什么被折叠?



