Skip to content

事务管理:传播行为、隔离级别与失效场景 ​

本篇要点:能在十分钟内判断一个 @Transactional 到底有没有生效,并说清七种传播行为里哪几种在业务代码里是错的。前置要求:读过《Spring 基础:IoC 容器、Bean 生命周期与 AOP》的 AOP 代理与《数据访问:JdbcTemplate、Spring Data JPA 与 jOOQ》的聚合与 save 语义,知道一次 save 只保证一个聚合的原子性。

为什么需要它 ​

对账同学扔来一张工单:昨天有一批订单,钱收了,库存没扣。

线上代码大致长这样,四个编号是事后补的,当时没有注释:

java
@Service
public class OrderService {

    private final OrderMapper orderMapper;
    private final StockClient stockClient;

    @Transactional
    public void createOrder(OrderCmd cmd) {
        orderMapper.insert(cmd.toOrder());            // ① 订单写进去了
        this.writeAudit(cmd);                         // ② 自调用
        try {
            this.deductStock(cmd);                    // ③ 自调用 + 异常被吞
        } catch (Exception e) {
            log.warn("扣减库存失败,稍后补偿", e);      // ④ 这行 log 就是事故现场
        }
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deductStock(OrderCmd cmd) {
        stockClient.deduct(cmd.skuId(), cmd.qty());
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void writeAudit(OrderCmd cmd) { /* ... */ }
}

运行结果:接口返回 200,t_order 多了一行,库存表没有任何变化。log.warn 里躺着下游库存服务的 503 堆栈——失败被看见了,只是没人处理,外层 createOrder 拿着正常返回提交了事务。

第一反应是查那个 REQUIRES_NEW 是不是被写成了 REQUIRED。翻了一遍,没写错。真正的原因比这个蠢得多。

先把结论放前面:@Transactional 失效里绝大多数情况不是注解写错,而是调用没经过代理,或者异常没离开方法。 剩下的小部分才是传播级别、事务管理器和事件时机。这套语义由代理和连接绑定的实现方式决定,和补丁版本无关,截至 2026 年 11 月在 Spring Framework 7.x 上没有变化。

核心概念 ​

概念一:事务边界画在代理入口,不画在方法体里 ​

Spring 的事务是靠代理(proxy)加的。容器给你的 Bean 不是 OrderService 本身,而是一个子类或接口实现的代理;代理在方法调用前后开事务、提交、回滚,然后把调用转发给真实对象。

this.deductStock(cmd) 里的 this 指向真实对象,不指向代理。这行调用绕过了整个事务通知,REQUIRES_NEW 那行注解等于没写,如图 5-1 所示。

图 5-1 事务入口在代理上,方法体内部的跳转不会再进一次

这张图只说明一个位置关系:事务边界画在代理入口,方法内部再怎么跳,都不会第二次进入那个通知。

代理方式还有个容易记混的配置事实。Spring Boot 默认 spring.aop.proxy-target-class=true,用 CGLIB 生成子类代理;而 @EnableTransactionManagement 自己的默认 proxyTargetClass 是 false,是 Boot 把它改过来的。这决定了哪些方法能被代理:private 永远不行,final 方法和 final 类不行,子类覆盖不了。从 Framework 6.0 起,protected 和包可见方法在类代理下也能生效——但在团队规范里只标 public,因为没人记得住这条边界,静态扫描脚本也记不住。

另一个反直觉的细节:在目标对象内部用 AopUtils.isAopProxy(this) 判断,永远是 false,哪怕这个 Bean 确实是代理出来的。this 指向被代理的真实对象,不是外面那层壳。想判断代理有没有生效,看注入点拿到的那份引用,或者直接看事务日志。

异步则把这套绑定搬到了另一条线程上。@Async 把方法交给新线程,事务绑定存在 ThreadLocal 里,不跟过去:调用方有事务,异步方法里 isActualTransactionActive() 依然是 false。要它有事务,只能在异步方法自己头上再标一个 @Transactional,而那是另一个事务,和调用方没有原子性可言。

概念二:七种传播行为,决定的是连接借给谁 ​

传播行为(propagation)回答一个问题:进入这个方法时,已经有事务了怎么办。七种取值,最常被用到、也最容易出事的是前三种。

传播行为行为典型误用
REQUIRED(默认)有则加入,无则新建内层失败会拖垮外层,外层 catch 掉就报 UnexpectedRollbackException
REQUIRES_NEW挂起外层,另开事务与外层争同一行锁导致死锁;连接数翻倍
NESTED在外层内嵌 savepointJPA 下通常不支持;连接一换 savepoint 就失效
SUPPORTS有则加入,无则非事务执行被当成“一定有事务”来用
NOT_SUPPORTED挂起事务挂起期间的写操作回滚不了
MANDATORY必须有事务标在入口方法上,调用方直接报错
NEVER必须无事务少见,适合强制校验“这里不该有事务”

REQUIRED 的内层和外层共用一条连接、一个事务。内层抛异常时,事务已经被标记成 rollback-only,外层即使 catch 掉并正常返回,提交那一刻还是会抛:

text
org.springframework.transaction.UnexpectedRollbackException:
Transaction silently rolled back because it has been marked as rollback-only

这个异常最坑的地方是堆栈里没有你的业务代码,看起来像框架抽风。第一次见的人往往会去查数据库连接。

REQUIRES_NEW 要第二条连接。连接池 20 个的话,20 个并发请求就能把池占满,然后所有线程互相等;外层如果还锁着同一行数据,直接死锁,日志里只有一句 Lock wait timeout。

概念三:回滚规则是“异常有没有离开方法” ​

Spring 的默认规则是只对 RuntimeException 和 Error 回滚,受检异常(checked exception)会提交。它通常不是事故主因,主因是 catch (Exception e)。

只要异常还在方法里被消化掉,事务通知看到的就是正常返回,它会老老实实 commit。容错分支只有两条正路:让异常穿出去,或者把失败记录放进独立事务(REQUIRES_NEW)、投到补偿队列。

rollbackFor = Exception.class 只解决“受检异常不回滚”,解决不了“异常被吃掉”。另外 readOnly = true 不是写保护,它只是给驱动和 ORM 的提示,挡不住你手写的一条 update。

概念四:隔离级别是数据库的承诺,不是注解的承诺 ​

隔离级别(isolation level)描述并发事务之间能看见彼此多少中间状态,四档从松到紧:READ UNCOMMITTED(能读未提交)、READ COMMITTED(只能读已提交)、REPEATABLE READ(同一事务内重复读结果一致)、SERIALIZABLE(串行化)。

默认值由数据库决定,不由 Spring 决定:MySQL InnoDB 默认 REPEATABLE READ,PostgreSQL 默认 READ COMMITTED。@Transactional(isolation = ...) 做的事是在事务开始前把这个级别设到连接上,事务结束后 Spring 再把连接的隔离级别重置回原值,所以连接池复用不会把上一个事务的设置带出来。

它改不了数据库的实现方式。MySQL 的 REPEATABLE READ 靠 MVCC 快照读实现,调到 SERIALIZABLE 会把普通 SELECT 变成加锁读,锁范围和锁等待一起放大,吞吐掉一个量级。指望靠提高隔离级别解决超卖,通常是换来了更多死锁;正确做法是唯一索引,或者 SELECT ... FOR UPDATE 精确定位到那一行。

概念五:提交之后才该做的事 ​

@TransactionalEventListener 默认绑 AFTER_COMMIT,设计本意是“主流程成功后再做副作用”。它有两点文档里写得很轻。

一是没有活动事务时,监听器根本不会被调用,除非加 fallbackExecution = true。本地跑单测时事件一个都不触发,很容易怀疑自己注解写错了。

二是 AFTER_COMMIT 里如果写库,那个写入需要新事务;而监听器方法抛异常时,异常不会传回调用方——TransactionSynchronizationUtils 在回调时把 Throwable 捕获掉,只往日志里写一行,接口照样返回 200。业务日志一切正常,只有那一行躺在 org.springframework.transaction.support 包名下。

动手实践 ​

步骤 1:先证明代理有没有进来 ​

不要急着改代码。在怀疑的方法第一行加两行打印,让事实说话。

java
log.info("txActive={}, txName={}",
        TransactionSynchronizationManager.isActualTransactionActive(),
        TransactionSynchronizationManager.getCurrentTransactionName());

预期输出:deductStock 里打印 txActive=false, txName=null,createOrder 里打印 txActive=true, txName=com.example.OrderService.createOrder。同一个类,一个有一个没有,答案就清楚了:this. 调用没经过代理。

步骤 2:拆 Bean,让 REQUIRES_NEW 真的开新事务 ​

把 deductStock 挪到另一个 Bean(比如 StockService)里,由 OrderService 注入调用。改完再跑一次步骤 1 的打印,deductStock 会变成 txActive=true,而且事务名是它自己的方法名。

这一步只修好了一半。异常还是被那个 catch 吃掉了,库存服务的 503 依然只是一条 warn 日志。

步骤 3:容错分支改成显式补偿 ​

在事务方法里 catch 掉异常再打日志,等于主动放弃回滚。要补偿就写补偿:把失败请求写进补偿表(独立事务),由定时任务重试;或者投消息队列。让 createOrder 的异常正常抛出,接口返回 5xx,让调用方知道这次没成。

步骤 4:多数据源必须显式指定事务管理器 ​

另一个项目里遇到的是另一类。@Transactional 上什么都没写,服务里有两个 DataSource,结果报表库的写入怎么都不回滚。

java
@Configuration
public class TxConfig {

    @Bean
    public PlatformTransactionManager orderTxManager(DataSource orderDataSource) {
        return new DataSourceTransactionManager(orderDataSource);
    }

    @Bean
    public PlatformTransactionManager reportTxManager(DataSource reportDataSource) {
        return new DataSourceTransactionManager(reportDataSource);
    }
}

预期输出:应用能正常启动,第一次调用事务方法时抛 NoUniqueBeanDefinitionException: No qualifying bean of type 'PlatformTransactionManager',提示找到 2 个候选。

选择规则是这样的:先按类型找,多个候选时退回名字叫 transactionManager 的 Bean,再找不到才抛异常。所以不是“随机挑一个”,但结果一样难看。修法是显式写 @Transactional(transactionManager = "orderTxManager", rollbackFor = Exception.class)。跨库没有 XA 就不是原子的,这个注解只能保证你指定的那个库原子。

步骤 5:把事务的创建、提交、回滚留成痕迹 ​

yaml
logging:
  level:
    org.springframework.transaction: DEBUG
    org.springframework.jdbc.datasource.DataSourceTransactionManager: DEBUG

预期输出:每次调用依次出现 Creating new transaction with name [com.example.OrderService.createOrder]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT、Initiating transaction commit;回滚时是 Initiating transaction rollback 加 Rolling back JDBC transaction on Connection。事务到底有没有开,看这三行比看注解可靠。

排查时按现象往下找,比通读代码快:

现象先怀疑怎么验证
抛了异常但数据已提交受检异常,或异常被 catch断点看异常有没有离开方法;检查 rollbackFor
内层方法的事务注解像没写自调用、private、final打印 getCurrentTransactionName();看调用点是不是 this.
切库后写入不回滚没指定 transactionManager看启动日志里的事务管理器 Bean 名;断点看连接 URL
偶发 UnexpectedRollbackException内层 REQUIRED 失败被外层吞掉打开 org.springframework.transaction 的 DEBUG 日志
异步任务里的数据对不上线程切换,连接绑定没跟过去在异步方法里断言 isActualTransactionActive()
注解正常、commit 也执行了,就是不回滚表引擎不支持事务(如 MyISAM),或连接被手工 setAutoCommit(true)SHOW TABLE STATUS 看 Engine;检查有没有自己 getConnection()

常见误解 ​

误解一:写了 @Transactional 就有事务。注解只在代理入口生效,自调用、private、final 三种情况一律无效,第四种是异常在方法里被吃掉。前三种改结构,第四种改代码逻辑,都跟注解本身没关系。

误解二:rollbackFor = Exception.class 能兜住一切。它只扩大回滚触发的异常类型,管不到“异常没抛出去”。真正的兜底是让失败可见:要么外抛,要么独立事务记录,要么进补偿队列。

误解三:REQUIRES_NEW 适合当审计日志开关。每调一次要第二条连接,池子会被它切成两半;外层若锁着同一行,就是死锁。审计日志更合适的做法是同库同事务写入或异步落库,而不是在业务事务里嵌套一个必须成功的事务。

误解四:用 AopContext.currentProxy() 解决自调用。它要求 exposeProxy = true,把业务代码绑死在 AOP 实现上。拆 Bean 或者用 TransactionTemplate 都更干净。JPA 项目里也别用 NESTED 做部分回滚:savepoint 只在同一连接内有效,和 JPA 的 flush 时机配合起来几乎是玄学,很多场景直接抛 NestedTransactionNotSupportedException。

小结 ​

  • 事务边界在代理入口。自调用、private、final 三类失效是结构问题,改注解解决不了。
  • REQUIRED 内外共用一条连接,内层失败后外层 catch 掉,提交时会抛 UnexpectedRollbackException,堆栈里没有业务代码。
  • 回滚看的是异常有没有离开方法。rollbackFor 只改异常类型,不改异常的传播路径;readOnly 不是写保护。
  • 隔离级别的默认值由数据库决定(MySQL 是 REPEATABLE READ,PostgreSQL 是 READ COMMITTED),注解只负责把它设到连接上,改不了数据库的实现方式。
  • 多数据源要显式指定 transactionManager,否则按类型找、按名字兜底,你以为在 A 库,实际在 B 库。@TransactionalEventListener 在没有事务时不触发,AFTER_COMMIT 里的异常也不会传回调用方;排查时先打开 org.springframework.transaction 的 DEBUG。

相关主题 ​

事务保证的是一次请求内部的一致性,下一个问题是谁有资格发起这次请求。《认证与授权:Spring Security 7 与 OAuth2.1》讲认证与授权:Spring Security 7 的过滤器链、表单登录与 JWT 两种模式、OAuth2.1 的授权码与资源服务器,以及方法级鉴权(认证与授权)。本篇那个“异常被 catch 掉”的教训会再出现一次——在过滤器链里,异常同样可能被上游吃掉,返回 200。