Java 后端 / 技术文章
Spring 事务传播为什么会改变结果
Spring 事务里最容易让人困惑的场景,是“代码只是换了一个传播策略,数据库结果却变了”。这篇文章面向已经使用 @Transactional 的 Java 后端工程师,集中解决嵌套调用下事务到底是复用、挂起、创建还是依赖保存点的问题。读完后,你可以从调用关系和传播策略直接判断哪些写入会一起提交、哪些可以独立提交,以及为什么异常有时会让外层事务最终回滚。
先看核心:传播行为改变的是事务归属
事务传播行为并不是“异常处理开关”,它首先决定一个事务方法被调用时,当前已有事务应该怎么处理。
可以把一次嵌套调用抽象成:
OuterService -> InnerService -> Database
假设外层方法先写订单,再调用内层方法写日志。两层方法都标记了 @Transactional,最终数据库结果并不只由“有没有异常”决定,还取决于内层方法采用什么传播策略。
最关键的区别是:
| 传播策略 | 外层已有事务时 | 典型结果 |
|---|---|---|
REQUIRED |
加入当前事务 | 外层与内层共享一个物理事务 |
REQUIRES_NEW |
暂停当前事务并新建事务 | 内层可以独立提交或回滚 |
NESTED |
在当前事务中建立保存点 | 局部回滚后可由外层继续 |
NOT_SUPPORTED |
挂起当前事务,以非事务方式执行 | 内层操作不属于外层事务 |
因此,判断“最终数据库会怎样”,第一步不是看异常,而是先确认内层调用最终属于哪一个事务。
REQUIRED:异常影响范围通常会扩大到整个调用链
REQUIRED 是最常见的默认选择。外层没有事务时,它会创建事务;外层已经存在事务时,它会加入外层事务。
例如:
@Service
public class OrderService {
@Transactional
public void createOrder() {
orderRepository.insertOrder();
auditService.writeAudit();
}
}
@Service
public class AuditService {
@Transactional
public void writeAudit() {
auditRepository.insertAudit();
}
}这里虽然两个方法都写了 @Transactional,但在一次正常的 Spring 代理调用中,writeAudit() 并不会因为注解存在就自动创建第二个事务。外层已经存在事务时,REQUIRED 会加入当前事务。
因此可以理解为:
OrderService -> T1
AuditService -> 加入 T1
如果审计写入抛出运行时异常,并且异常最终让事务拦截器看到失败状态,那么外层订单写入和审计写入都可能回滚。反过来,即使内层捕获了异常,若共享事务已经被标记为 rollback-only,外层最后提交时仍可能得到 UnexpectedRollbackException。
用一个最小示例验证共享事务关系:
@Transactional
public void outer() {
jdbcTemplate.update("insert into orders(id) values (1)");
inner();
}
@Transactional(propagation = Propagation.REQUIRED)
public void inner() {
jdbcTemplate.update("insert into audit_log(id) values (1)");
throw new RuntimeException("audit failed");
}预期结果
事务 T1 开始
orders 写入
inner 加入 T1
audit_log 写入
RuntimeException
T1 rollback
orders = 0 条新增
audit_log = 0 条新增这里最容易产生的误判是“内层有自己的 @Transactional,所以内层应该自己回滚”。实际情况是,传播策略决定了它是否复用外层事务;REQUIRED 在已有事务时不会创建新的物理事务。
REQUIRES_NEW:内层提交结果可以脱离外层保留
REQUIRES_NEW 的关键不是“回滚更强”,而是“当前事务先挂起,再创建一个全新的事务”。
调用关系从共享事务变成:
T1 -> 挂起 -> T2 -> commit/rollback -> 恢复 T1
例如:
@Transactional
public void createOrder() {
jdbcTemplate.update("insert into orders(id) values (1)");
auditService.writeAudit();
throw new RuntimeException("order failed");
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void writeAudit() {
jdbcTemplate.update("insert into audit_log(id) values (1)");
}这时内层审计事务 T2 成功提交后,外层 T1 再回滚,也不会把已经提交的 T2 一起撤销。
预期结果
T1 begin
orders 写入
T1 suspend
T2 begin
audit_log 写入
T2 commit
T1 resume
RuntimeException
T1 rollback
最终:orders = 0 条,audit_log = 1 条这就是为什么 REQUIRES_NEW 常用于某些“外层失败也要保留”的记录,例如独立审计、失败记录或特定操作日志。
但它也带来一个明显代价:系统现在拥有两个独立提交点。外层业务失败并不意味着内层数据会一起消失,所以使用前必须确认这种结果正是业务想要的。
NESTED:回滚可以退到保存点,而不是直接结束整个外层事务
NESTED 和 REQUIRES_NEW 最容易被混淆,因为两者都能表现出“内层失败后外层还能继续”。真正的区别在于:NESTED 通常仍然使用外层物理事务,只是在进入嵌套部分时建立数据库保存点。
可以把过程理解成:
T1 begin -> 前置更新 -> SAVEPOINT S1 -> 嵌套更新 -> rollback to S1 -> 外层继续 -> T1 commit
概念示例:
@Transactional
public void process() {
jdbcTemplate.update("update orders set status = 'PROCESSING' where id = 1");
auditService.tryOptionalStep();
jdbcTemplate.update("update orders set status = 'READY' where id = 1");
}
@Transactional(propagation = Propagation.NESTED)
public void tryOptionalStep() {
jdbcTemplate.update("insert into optional_record(id) values (1)");
throw new RuntimeException("optional step failed");
}理想化地看,内层失败时可以回滚到保存点,而不是创建独立事务。
预期结果
T1 begin
orders = PROCESSING
SAVEPOINT S1
optional_record 写入
异常
ROLLBACK TO S1
orders 继续执行
orders = READY
T1 commit
optional_record 不保留这里必须注意一个工程前提:NESTED 的实际效果依赖事务管理器以及底层数据库是否支持相应的保存点语义。不能只看到 propagation = NESTED 就假定所有环境都能表现出完全相同的行为。
为什么“改传播策略”会改变最终数据库结果
把三种策略放在一起,差异就很清楚:
| 场景 | REQUIRED |
REQUIRES_NEW |
NESTED |
|---|---|---|---|
| 外层已有事务 | 加入 T1 | 挂起 T1,创建 T2 | 在 T1 中创建保存点 |
| 内层成功 | 一起由 T1 提交 | T2 先独立提交 | 继续使用 T1 |
| 内层失败 | 通常影响共享事务 | T2 独立回滚,T1 可继续 | 可回滚到保存点 |
| 外层最终回滚 | 内层一起回滚 | 已提交的 T2 不受影响 | 保存点后的改动随 T1 回滚 |
| 是否产生独立提交点 | 否 | 是 | 否 |
因此,“传播行为为什么会改变结果”的本质可以概括为:
传播策略 -> 事务归属 -> 提交/回滚边界 -> 数据库最终状态
它改变的不是业务代码里的 if/else,而是 Spring 如何组织事务上下文,以及一次异常究竟能影响哪个事务。
排查嵌套事务时,先回答这四个问题
遇到“明明抛异常却没回滚”或者“外层回滚了,日志却还在”的问题,不要先改 rollbackFor。按下面的顺序判断更稳定。
第一,调用是不是经过 Spring 事务代理。方法上的 @Transactional 只有在事务拦截器真正生效时才会产生声明式事务效果。尤其要警惕同一个 Bean 内部使用 this.method() 的自调用路径。
第二,调用发生时外层有没有已经存在的事务。没有事务时,REQUIRED 和 REQUIRES_NEW 的结果可能非常接近;真正拉开差异的是“已有事务”的嵌套调用。
第三,内层最终采用什么传播策略。看到两个方法都写了 @Transactional,不能据此判断存在两个事务。需要继续看 propagation,再结合调用时事务上下文判断。
第四,异常最终是如何传播的。异常被重新抛出、被捕获后继续执行、事务被标记为 rollback-only,都会导致不同结果。尤其是共享事务下,内层失败后即使捕获异常,外层也未必能正常提交。
可以用以下思路快速建立判断链:
调用发生
-> 是否经过事务代理
-> 当前是否已有事务
-> propagation 如何处理当前事务
-> 当前调用属于 T1、T2 还是 T1 的保存点
-> 异常发生后谁被标记回滚
-> 最终哪个事务 commit / rollback
-> 数据库留下什么什么时候应该主动使用不同传播策略
REQUIRED 适合默认的业务一致性边界:订单主表、明细、库存等应该作为一个原子操作完成时,让它们共享一个事务通常更直观。
REQUIRES_NEW 适合业务上明确要求“独立提交”的场景,但要接受它带来的多个提交点,以及连接、锁和并发资源方面的额外成本。
NESTED 适合希望在同一个事务中提供局部回滚能力的场景,但应该先确认事务管理器和数据库环境对保存点的支持方式。
真正重要的判断不是“哪个传播策略更高级”,而是先定义结果:
“外层失败时,这次内层写入应该消失吗?”
“内层失败时,外层剩余操作应该继续吗?”
“内层需要独立提交,还是只需要局部回滚?”
把这三个问题回答清楚,再选择传播策略,通常比看到异常后临时修改注解更可靠。