一、一次让人抓狂的线上问题
如果你写过几个 Spring Boot 项目,大概都体会过“加了个 @Transactional,但数据还是乱了”的滋味。别着急,这不是你一个人踩过的坑,尤其是当你把一个系统拆成了多个数据库,或者搞了读写分离、分库分表之后,问题就变得更加隐蔽。
我举个例子。有个小商城,用户下单后要同时做两件事:往订单库里插入一条订单记录,再往库存库里扣掉对应的库存数量。这两个库是独立部署的,业务上必须保证“同生共死”——万一扣库存失败,订单也不能留下。你信誓旦旦地在 Service 方法上写了一个 @Transactional,模拟测试也正常,结果上线第二天,对账就发现有的订单存在,但库存没扣;或者更诡异的是库存扣了,订单却没了。你翻遍日志,一点异常都没有,因为事务压根就没管住第二个库。
这是多数据源配置下事务失效的典型隐蔽场景。很多人遇到后第一反应是“是不是 MyBatis 的 bug”,或者“是不是 MySQL 事务隔离级别有问题”,其实根源往往出在 Spring 的事务管理机制和你的数据源配置上。今天咱们就从底层原理说起,再给你一个能落地的完整方案。
二、先看看多数据源是怎么搭出来的
2.1 最简单的多数据源配置
假设我们现在有两个数据库:db_order 负责订单,db_stock 负责库存。在 Spring Boot + MyBatis 项目里,大家很喜欢用“两个独立数据源 + 两个 SqlSessionFactory”的方式来搞。先看一份常见的配置类,注意看,这里暗藏玄机。
/**
* 技术栈:Spring Boot 2.7.5 + MyBatis 3.5.12 + HikariCP
* 这是一个“普通”的多数据源配置,后面会演示它为什么会让事务失效
*/
@Configuration
public class MultiDataSourceConfig {
/**
* 订单数据源
*/
@Bean(name = "orderDataSource")
@ConfigurationProperties(prefix = "spring.datasource.order")
public DataSource orderDataSource() {
// HikariCP 由 Spring Boot 自动配置
return DataSourceBuilder.create().build();
}
/**
* 库存数据源
*/
@Bean(name = "stockDataSource")
@ConfigurationProperties(prefix = "spring.datasource.stock")
public DataSource stockDataSource() {
return DataSourceBuilder.create().build();
}
/**
* 为订单数据源构建 SqlSessionFactory
* 注意:这里指定了 Mapper XML 放在 classpath:mapper/order/ 下
*/
@Bean(name = "orderSqlSessionFactory")
public SqlSessionFactory orderSqlSessionFactory(
@Qualifier("orderDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
bean.setMapperLocations(new PathMatchingResourcePatternResolver()
.getResources("classpath:mapper/order/*.xml"));
return bean.getObject();
}
/**
* 为库存数据源构建 SqlSessionFactory
* Mapper XML 放在 classpath:mapper/stock/ 下
*/
@Bean(name = "stockSqlSessionFactory")
public SqlSessionFactory stockSqlSessionFactory(
@Qualifier("stockDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
bean.setMapperLocations(new PathMatchingResourcePatternResolver()
.getResources("classpath:mapper/stock/*.xml"));
return bean.getObject();
}
/**
* 只配置了一个事务管理器,绑定的是订单数据源。
* 这就是后面事务失效的导火索之一。
*/
@Bean(name = "transactionManager")
public DataSourceTransactionManager transactionManager(
@Qualifier("orderDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}
对应的 application.yml 大概长这样:
spring:
datasource:
order:
jdbc-url: jdbc:mysql://localhost:3306/db_order?useSSL=false&serverTimezone=Asia/Shanghai
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
stock:
jdbc-url: jdbc:mysql://localhost:3306/db_stock?useSSL=false&serverTimezone=Asia/Shanghai
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
接着我们再配两个 Mapper 扫描器,让不同的 Mapper 接口绑定到不同的 SqlSessionFactory。这一步很关键,但很多人往往漏掉。
@Configuration
@MapperScan(
basePackages = "com.example.mapper.order",
sqlSessionFactoryRef = "orderSqlSessionFactory")
public class OrderMapperConfig {
}
@Configuration
@MapperScan(
basePackages = "com.example.mapper.stock",
sqlSessionFactoryRef = "stockSqlSessionFactory")
public class StockMapperConfig {
}
2.2 业务代码长什么样
业务代码很直观:一个方法里同时调用订单 Mapper 和库存 Mapper。你可能会像下面这样写:
/**
* 订单服务,这里故意演示事务失效的场景
*/
@Service
public class OrderService {
/** 操作 db_order 库 */
@Autowired
private OrderMapper orderMapper;
/** 操作 db_stock 库 */
@Autowired
private StockMapper stockMapper;
/**
* 创建订单并扣减库存
* 注意:这里使用了默认的事务管理器(绑定订单库)
* 业务要求:如果金额大于1000,就抛出异常,让订单和库存都回滚
*/
@Transactional
public void createOrderWithStock(Order order, Stock stock) {
// 第一步:往订单库插入订单
orderMapper.insert(order);
// 第二步:往库存库扣减库存
stockMapper.deduct(stock);
// 第三步:模拟业务校验失败
if (order.getAmount() > 1000) {
throw new RuntimeException("订单金额太大,需要全部回滚");
}
}
}
你看,加了 @Transactional,够标准吧?但是跑一下你会发现:异常抛出来之后,订单确实回滚了,但库存扣减却“成功提交”了。为什么?因为 Spring 默认使用的 transactionManager 只管理了 orderDataSource,对 stockDataSource 的操作根本不在同一事务里,甚至根本没有任何事务包裹。第二个库的每一次 SQL 都是自动提交,已经提交的库存扣减当然就收不回来了。
三、为什么事务说失效就失效了?
3.1 Spring事务到底是怎么工作的
要搞明白这个问题,得先说说 Spring 事务的基本原理。你在方法上标注 @Transactional 的时候,Spring 会通过 AOP 生成一个代理对象。在调用方法之前,代理对象会向容器要一个 PlatformTransactionManager,然后基于它开启一个数据库事务。这个事务的本质,就是把“一个数据库连接”绑定到当前线程上,后续所有 SQL 都走这个连接,直到事务提交或回滚。
关键点就藏在这里:一个事务管理器通常只对应一个数据源。DataSourceTransactionManager 内部持有某个数据源,它开启的事务只会把连接绑定到那个数据源上。如果你在同一个事务方法里操作了另一个数据源,不好意思,那个数据源根本不会加入当前事务,它会自己开一个独立连接,自动提交。
那多数据源时是不是只要配置多个事务管理器就行了?也可以,但问题又来了。Spring 容器里有多个 PlatformTransactionManager 的时候,@Transactional 不知道你要用哪一个。你可以用 @Transactional(transactionManager = "stockTransactionManager") 明确指定,但这样也只能顾得上其中一个数据源。两个库之间的原子性依然无法保证。
3.2 多数据源下的事务传播机制有多闹心
Spring 的事务传播机制你可能背得很熟:REQUIRED、REQUIRES_NEW、NESTED 等等。但一旦涉及多数据源,这些机制就会被“叠加魔改”。咱们用一个更隐蔽的场景来说明。
看下面这段代码:
/**
* 演示内部调用导致的事务传播注解失效
*/
@Service
public class StockService {
@Autowired
private StockMapper stockMapper;
/**
* 这个方法声明了 REQUIRES_NEW,表示无论如何都会开启一个新事务
*/
@Transactional(propagation = Propagation.REQUIRES_NEW,
transactionManager = "stockTxManager")
public void deductStock(Stock stock) {
stockMapper.deduct(stock);
}
}
然后在另一个 Service 里调用它:
@Service
public class OrderService {
@Autowired
private OrderMapper orderMapper;
@Autowired
private StockService stockService;
/**
* 这里在订单事务里调用库存事务
* 因为 StockService 是代理对象,所以 REQUIRES_NEW 是有效的
*/
@Transactional(transactionManager = "orderTxManager")
public void createOrder(Order order, Stock stock) {
orderMapper.insert(order);
stockService.deductStock(stock); // 新事务,独立提交/回滚
}
}
这个场景下,两个事务确实是独立的,REQUIRES_NEW 也起作用了。但如果 StockService.deductStock 被 OrderService 内部调用——注意是“内部调用”,比如你把 deductStock 方法写进了 OrderService 里,并且直接 this.deductStock(...) 调用,那么 Spring 代理就绕过去了,REQUIRES_NEW 形同虚设。再加上多数据源,你很可能以为自己开了一个新事务来操作库存库,结果它只是在了订单事务里“裸奔”了一小段。这种隐蔽程度,不踩一次坑很难发现。
所以多数据源事务失效的根因可以总结为三句话:
- 单数据源事务管理器管不了其他数据源的连接。
- 多个事务管理器同时存在时,@Transactional 选型容易选错或者没有明确指定。
- 同一个类内部的方法调用会让 Spring AOP 代理失效,传播机制自然就不起作用。
四、完整解决方案:让Atomikos接管全局事务
现在该上正菜了。要解决跨数据源的事务一致性问题,最成熟的做法是引入 JTA(Java Transaction API),用 Atomikos 这样的分布式事务框架来统一管理多个数据源的事务。JTA 的底层是 XA 两阶段提交协议,简单说就是:先预提交,所有库都说“准备好了”,再统一提交;任何一个库失败,就全部回滚。
4.1 引入JTA依赖
我们把项目改成基于 Atomikos 的方案。技术栈还是 Spring Boot + MyBatis,额外加上 Atomikos 的 JTA 支持。在 pom.xml 里加上:
<!-- 技术栈:Spring Boot 2.7.5 + MyBatis 3.5.12 + Atomikos 4.6.3 -->
<!-- JTA 事务管理支持,官方带 Atomikos -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jta-atomikos</artifactId>
<version>2.7.5</version>
</dependency>
<!-- MyBatis 的 Spring Boot 启动器,这个你应该已经有了 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.3.1</version>
</dependency>
4.2 配置Atomikos数据源
这里我们不再使用 HikariCP 那样的普通数据源了,而是用 Atomikos 提供的 AtomikosDataSourceBean 来包装两个 XA 数据源。XA 数据源是参与分布式事务的基础,MySQL 的驱动自带 MysqlXADataSource,可以直接用。
/**
* 技术栈:Spring Boot 2.7.5 + MyBatis 3.5.12 + Atomikos 4.6.3
* Atomikos 多数据源与 JTA 事务管理器配置
*/
@Configuration
public class AtomikosDataSourceConfig {
/**
* 订单库 XA 数据源
* uniqueResourceName 在 JTA 中必须唯一,不能重复
*/
@Bean(name = "orderDataSource")
public DataSource orderDataSource() {
AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
ds.setUniqueResourceName("orderDS");
ds.setXaDataSourceClassName("com.mysql.cj.jdbc.MysqlXADataSource");
// XA 数据源的连接信息需要放到 Properties 里
Properties props = new Properties();
props.setProperty("URL", "jdbc:mysql://localhost:3306/db_order?useSSL=false&serverTimezone=Asia/Shanghai");
props.setProperty("user", "root");
props.setProperty("password", "123456");
ds.setXaProperties(props);
// 连接池大小
ds.setMaxPoolSize(10);
return ds;
}
/**
* 库存库 XA 数据源
*/
@Bean(name = "stockDataSource")
public DataSource stockDataSource() {
AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
ds.setUniqueResourceName("stockDS");
ds.setXaDataSourceClassName("com.mysql.cj.jdbc.MysqlXADataSource");
Properties props = new Properties();
props.setProperty("URL", "jdbc:mysql://localhost:3306/db_stock?useSSL=false&serverTimezone=Asia/Shanghai");
props.setProperty("user", "root");
props.setProperty("password", "123456");
ds.setXaProperties(props);
ds.setMaxPoolSize(10);
return ds;
}
/**
* Atomikos 的事务管理器(UserTransactionManager)
*/
@Bean(name = "atomikosTransactionManager")
public UserTransactionManager atomikosTransactionManager() throws SystemException {
UserTransactionManager userTransactionManager = new UserTransactionManager();
userTransactionManager.setForceShutdown(false);
return userTransactionManager;
}
/**
* Atomikos 的用户事务(UserTransactionImp)
*/
@Bean(name = "userTransaction")
public UserTransactionImp userTransaction() throws SystemException, IllegalStateException {
UserTransactionImp userTransactionImp = new UserTransactionImp();
userTransactionImp.setTransactionTimeout(60); // 超时时间 60 秒
return userTransactionImp;
}
/**
* Spring 的 JtaTransactionManager,把上面两个整合起来
* 之后在 @Transactional 里指定这个事务管理器即可
*/
@Bean(name = "jtaTransactionManager")
public JtaTransactionManager jtaTransactionManager(
@Qualifier("userTransaction") UserTransactionImp userTransactionImp,
@Qualifier("atomikosTransactionManager") UserTransactionManager userTransactionManager) {
JtaTransactionManager manager = new JtaTransactionManager(userTransactionManager, userTransactionImp);
return manager;
}
/**
* 订单库 SqlSessionFactory
*/
@Bean(name = "orderSqlSessionFactory")
public SqlSessionFactory orderSqlSessionFactory(
@Qualifier("orderDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
bean.setMapperLocations(new PathMatchingResourcePatternResolver()
.getResources("classpath:mapper/order/*.xml"));
return bean.getObject();
}
/**
* 库存库 SqlSessionFactory
*/
@Bean(name = "stockSqlSessionFactory")
public SqlSessionFactory stockSqlSessionFactory(
@Qualifier("stockDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
bean.setMapperLocations(new PathMatchingResourcePatternResolver()
.getResources("classpath:mapper/stock/*.xml"));
return bean.getObject();
}
}
4.3 把数据源交给MyBatis使用
跟上一步类似,我们还是用 @MapperScan 来绑定不同的 Mapper 包。注意这里没有另外配置事务管理器,事务管理器已经由上面的 jtaTransactionManager 统一提供了。
@Configuration
@MapperScan(
basePackages = "com.example.mapper.order",
sqlSessionFactoryRef = "orderSqlSessionFactory")
public class OrderMapperConfig {
}
@Configuration
@MapperScan(
basePackages = "com.example.mapper.stock",
sqlSessionFactoryRef = "stockSqlSessionFactory")
public class StockMapperConfig {
}
4.4 在Service上正确使用事务
现在万事俱备,只欠“事务”了。在 Service 方法上,你需要明确指定 jtaTransactionManager,这样 Spring 才会用 JTA 事务来管理你后面的所有数据源连接。
/**
* 订单服务,使用 JTA 事务实现跨库一致性
*/
@Service
public class OrderService {
@Autowired
private OrderMapper orderMapper;
@Autowired
private StockMapper stockMapper;
/**
* 创建订单并扣减库存
* 注意 transactionManager 指定为 jtaTransactionManager
* 事务传播机制默认是 REQUIRED:两个 Mapper 操作都在同一个全局事务里
* 任何一个抛异常,两个库都会回滚
*/
@Transactional(transactionManager = "jtaTransactionManager")
public void createOrderWithStock(Order order, Stock stock) {
// 先在订单库插入订单
orderMapper.insert(order);
// 再在库存库扣减库存
stockMapper.deduct(stock);
// 模拟异常
if (order.getAmount() > 1000) {
throw new RuntimeException("订单金额太大,需要全部回滚");
}
}
}
就这样,再跑一次测试:异常一抛,订单回滚了,库存也跟着回滚。两边像坐了同一艘船,沉一起沉,浮一起浮。你之前担心的“事务失效”问题,算是彻底解决了。
五、这套方案的适用场景与优缺点
5.1 适合哪些场景
- 强一致性要求高的跨库写操作,比如订单库、账户库、余额库之间需要同步更新。
- 微服务还未拆分,但数据库已经分库的过渡期,想先用分布式事务稳住。
- 数据量不大、并发可控的内部系统,比如后台运营系统、财务对账系统。
- 项目已经用了 MyBatis,不想引入重量级微服务框架(比如 Seata)时,Atomikos 是一个不错的选择。
5.2 技术有哪些优缺点
咱们说实话,分布式事务没有银弹,Atomikos 也不例外。
优点:
- 模型统一,JTA 是 Java 标准,学习成本适中。
- 能真正保证两阶段提交,数据一致性很强。
- 与 Spring 整合比较顺畅,
@Transactional风格没变。
缺点:
- 性能有损耗。两阶段提交需要多次网络往返,在高并发场景下很容易成为瓶颈。
- 不可用风险高。如果其中一个数据库网络抖动,整个事务都会被拖住,用户体验会很差。
- XA 协议对数据库锁时间较长,容易产生死锁或锁等待。
- Atomikos 本身比较“重”,维护成本比普通数据源高。
- 没有什么是万能的,如果业务量再大,可能还是得考虑“最终一致性”方案,比如本地消息表、MQ 事务消息、事件溯源等等。
所以,我的建议是:能用单一数据源解决就别搞多数据源;如果必须多数据源,先想想能不能把两个写操作拆开,用异步消息去“尝试通知”+“补偿”来保证最终一致。只有真正需要强一致的短期场景,才值得上 JTA。
六、避坑指南(注意事项)
即便你照着上面的配置做了,也还有几个容易踩的坑,我帮你提前列出来。
第一,uniqueResourceName 必须全局唯一,而且不能随便改。Atomikos 会按照这个名字做事务恢复,如果你改了名字,那些“悬挂”的旧事务可能再也找不回来了。
第二,事务超时时间要合理设置。我上面设的是 60 秒。如果你某个业务执行很慢,超过 60 秒,事务会自动回滚。反过来,如果设太大,长期占用数据库连接,连接池会被打满。
第三,MysqlXADataSource 的 URL 参数名是大写的。如果你之前写 jdbc-url 习惯了,在这里很容易写错成 jdbcUrl,导致连不上数据库。
第四,MyBatis 的 Mapper XML 里不能有跨库的 join 查询,因为每个 Mapper 都绑定到了固定的数据源。即使 JTA 事务能让两个库都参与事务,也无法解决单条 SQL 跨库读取的问题。
第五,同一个 Service 类内部的 this 调用仍然会让事务传播机制失效。就算你用 jtaTransactionManager,也不能在 this.method() 里指望 REQUIRES_NEW 生效。方法是代理对象调用的才有效,外部注入的 Service 才是代理对象。
第六,连接池参数要调优。AtomikosDataSourceBean 的 maxPoolSize 不应太小,否则高并发时连接不够用;也别太大,否则数据库压力大。建议根据压测结果来定。
第七,日志要开起来。Atomikos 默认有比较详细的日志,强烈建议你在生产环境打开,方便排查“悬挂事务”和“无法回滚”的问题。
七、文章总结
咱们今天从一次线上事故出发,看到了 MyBatis 多数据源下事务失效的典型表现:看似加了 @Transactional,实则只有某一个数据源在事务里。接着我们分析了背后的原理,一个是单个 PlatformTransactionManager 只能管一个数据源,另一个是 Spring AOP 代理在某些情况下的局限。然后给出了基于 Atomikos + JTA 的完整解决方案,其中还穿插了 Spring 事务传播机制的解释。
这个方案确实能解决问题,但也不是万能的。你需要在“强一致性”和“性能”之间做取舍。所有分布式事务方案都有代价,关键是明白你在什么场景下愿意付出这个代价。如果只是临时跨库,Atomikos 可以让你的系统立刻安全;如果未来要支撑大规模高并发,还是尽早规划成微服务 + 事件驱动 + 最终一致性的架构,那样才能真正走得远。
希望这篇博客能帮你把“多数据源事务失效”这块硬骨头啃下来。下次再遇到类似问题,别再慌着背锅,先想一想:你的 @Transactional 到底交给谁去管了?
评论
围绕“MyBatis多数据源配置下事务失效的隐蔽场景,结合Spring事务传播机制给出完整解决方案”参与讨论