Spring Boot 中 @Transactional 失效的 12 种场景与解法

引言

@Transactional 大概是 Spring Boot 项目里用得最多、也最容易”看着生效其实没生效”的注解。它的失效有个讨厌的特点:不报错、不告警、日志干干净净。方法照常执行,SQL 照常发出,只是该回滚的时候没回滚,于是线上多了一条脏数据,或者出现了一个”钱扣了但订单没生成”的经典事故。

本文按”机制 → 场景 → 解法 → 排查”的顺序展开,适合已经用过 @Transactional、但遇到过”明明加了注解却没回滚”的中高级开发者。读完你应该能做到两件事:看到一个失效现象,能在 30 秒内定位到属于哪一类根因;写新代码时,能避开这 12 个坑。

一、先讲机制:注解是怎么变成事务的

一句话版本:@Transactional 本身不开启事务,它只是一份元数据;真正开启事务的是 Spring 为你的 Bean 生成的代理对象里的 TransactionInterceptor。

sequenceDiagram
    participant C as 调用方(Controller)
    participant P as Spring 代理对象
    participant I as TransactionInterceptor
    participant T as 目标方法(真实 Bean)
    participant M as PlatformTransactionManager
    C->>P: 调用 orderService.save(order)
    P->>I: 命中切点,进入拦截器
    I->>M: getTransaction():开启事务,把连接绑定到当前线程
    I->>T: 反射调用真实方法
    T-->>I: 正常返回 或 抛出异常
    alt 抛出 RuntimeException 或 Error
        I->>M: rollback()
    else 正常返回,或抛出受检异常
        I->>M: commit()
    end
    Note over C,T: 只有开头这一跳经过代理,事务才会被开启

图 1:一次事务方法调用的完整链路。关键在第二步——代理是唯一入口。

这个机制可以类比成剧院检票:代理对象是大门,TransactionInterceptor 是门口的检票员,@Transactional 是写在票面上的座次信息。你从大门进,票一定被查;但你从后台通道直接走进观众席,戏照样演,票没人看。

对应关系是:大门对应代理入口,检票员对应事务拦截器,票面对应注解元数据,演出对应你的业务代码。这个比喻的边界要说清楚——门禁只管得住大门,Spring 还提供 AspectJ 编译期织入(@EnableTransactionManagement(mode = AdviceMode.ASPECTJ))这种方式,相当于给每个通道都装了闸机,它不受代理入口限制。但对绝大多数 Boot 项目,默认就是代理模式,所以”没走大门”是最高频的失效原因。

把上面这条链拆开,事务真正生效需要四个条件同时成立:

① 从代理入口进入跨 Bean 调用、可见性满足、不是 final / static / private② 异常能被拦截器看到默认只认 RuntimeException / Error,catch 吞掉等于没抛③ 事务管理器对得上数据源多数据源要显式指定,表引擎必须支持事务④ 同一个线程、同一条连接@Async、新线程、线程池里都没有事务上下文四个条件缺一个:注解还在,事务不在

图 2:事务生效的四个必要条件。下文 12 个场景,本质上都是这四条的某个条件被破坏。

二、失效场景:按根因分四类

第一类:代理没生效

场景 1:同类内部方法自调用(最高频)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Service
public class OrderService {

@Autowired
private OrderMapper orderMapper;

public void createOrder(Order order) {
saveOrder(order); // 直接 this 调用,不经过代理
}

@Transactional(rollbackFor = Exception.class)
public void saveOrder(Order order) {
orderMapper.insert(order);
throw new IllegalStateException("金额超限"); // 本来应该回滚
}
}

现象:saveOrder 里的异常抛出去了,但 insert 的数据已经在库里。

原因:createOrder 里的 saveOrder(order) 编译后是 this.saveOrder(order),this 是真实对象,不是代理对象。方法调用根本没有经过 TransactionInterceptor。

这是最容易被忽略的一条,因为两个方法都加了注解、都看着很规范。

场景 2:方法可见性不满足当前代理类型

  • private 方法:任何代理模式都不会生效(官方文档明确说明只有通过代理进入才生效,而代理无法拦截 private)。
  • 基于接口的代理(JDK 动态代理):事务方法必须是 public,且在被代理的接口中定义。
  • 基于类的代理(CGLIB):从 Spring Framework 6.0 起,protected 和包可见的方法默认也可以设为事务性;Spring 5.x(对应 Boot 2.x)仍然只支持 public。

建议:不管哪个版本,把 @Transactional 一律写在 public 方法上,是最省心的做法。这条规则的出处见文末参考链接中的官方文档”代理模式下的方法可见性与 @Transactional”一节。

场景 3:final 类、final 方法、static 方法

CGLIB 通过继承生成子类,final 类无法被继承,final 方法无法被覆盖,static 方法属于类而不属于实例——三者都不会被代理拦截。

1
2
3
4
5
@Service
public final class ReportService { // final 类:整个类的事务都不生效
@Transactional
public void generate() { /* ... */ }
}

解决:去掉 final;static 方法改为实例方法,或把事务逻辑挪到外层 Bean。

场景 4:注解写在接口上,代理却是 CGLIB

Spring Boot 2.x 起 spring.aop.proxy-target-class 默认是 true,也就是默认走 CGLIB。此时如果 @Transactional 只写在接口方法上,实现类的方法不会被识别为事务方法(注解不会被继承到实现方法上)。

解决:注解写在实现类上。官方文档也是这个建议。

场景 5:对象不是 Spring 管理的 Bean

1
2
OrderService service = new OrderService();   // 自己 new,没有代理
service.saveOrder(order); // 注解形同虚设

或者把 Service 注入到工具类的静态字段里、在 @PostConstruct 里提前把 this 缓存起来——都绕过了容器,自然没有代理。

场景 6:没开事务管理

Spring Boot 的 TransactionAutoConfiguration 在检测到 PlatformTransactionManager Bean 时会自动开启事务管理,所以正常项目不用手写 @EnableTransactionManagement。但以下情况会让它失效:自己排除了自动配置、用纯 @Configuration 手工装配数据源却没注册事务管理器、或者引入了多个 PlatformTransactionManager 却一个都没标 @Primary。

第二类:异常没触发回滚

场景 7:抛的是受检异常

@Transactional 的默认回滚规则是:RuntimeException 及其子类、Error 回滚;受检异常(checked exception)提交。

1
2
3
4
5
@Transactional                       // 少了 rollbackFor
public void importData(File file) throws IOException {
orderMapper.insert(...);
throw new IOException("文件读取失败"); // 受检异常 → 事务提交,数据留下
}

解决:@Transactional(rollbackFor = Exception.class)。这是我在业务代码里最推荐的写法,默认值太反直觉。

场景 8:异常被自己 catch 掉了

1
2
3
4
5
6
7
8
9
@Transactional(rollbackFor = Exception.class)
public void submit(Order order) {
try {
orderMapper.insert(order);
remoteService.notifyPartner(order); // 这里抛异常
} catch (Exception e) {
log.error("通知合作方失败", e); // 吞掉了,拦截器看不到异常
}
}

现象:异常日志有,数据却没回滚。

解决有三种,按场景选:

1
2
3
4
5
6
7
8
9
10
11
12
13
// 方案 A:记录后重新抛出(推荐,让事务边界自己处理)
catch (Exception e) {
log.error("通知合作方失败", e);
throw e;
}

// 方案 B:保留异常不外抛,但手动标记回滚
catch (Exception e) {
log.error("通知合作方失败", e);
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

// 方案 C:这段逻辑本就不该在同一事务里,拆出去做成补偿/重试

场景 9:异常被包装成受检异常

throw new BizException(...) 如果 BizException extends Exception,同样不会回滚。要么让它继承 RuntimeException,要么显式 rollbackFor。这一条和场景 7 是同一个机制,但踩坑率更高,因为很多团队的”业务异常”基类偏偏写成了受检异常。

第三类:事务边界不对

场景 10:传播行为与嵌套调用

传播行为行为典型误区
REQUIRED(默认)有事务就加入,没有就新建以为内层方法会独立提交
REQUIRES_NEW挂起外层,新建独立事务同类自调用时完全不生效(同场景 1)
NESTED保存点,可局部回滚要求底层支持保存点,且仍在外层事务内
NOT_SUPPORTED挂起事务、非事务执行以为能”临时关掉事务”
NEVER有事务就抛异常常用于校验”此处不该在事务中”

典型事故:外层方法调用内层 REQUIRES_NEW 方法写审计日志,希望”主流程失败、日志保留”。如果内层是同类 this 调用,REQUIRES_NEW 根本不会创建新事务,日志会跟着主流程一起回滚。

场景 11:异步与多线程

1
2
3
4
@Transactional(rollbackFor = Exception.class)
public void batchImport(List<Order> orders) {
orders.forEach(o -> auditExecutor.submit(() -> orderMapper.insert(o))); // 子线程无事务
}

Spring 的事务上下文(连接、同步器)绑定在 ThreadLocal 上,不跨线程传递。@Async、CompletableFuture、自建线程池里的 DB 操作,全都在事务之外,既不参与回滚,也可能各自自动提交。

解决:子线程内的写操作自己开事务(注入 TransactionTemplate 在每个任务里执行),或改成串行/分批在主事务内完成。如果确实需要并行,得接受”部分成功”的事实,用补偿机制兜底。

场景 12:多数据源、只读事务、超时与隔离级别

  • 多数据源:@Transactional 默认找名为 transactionManager 的 Bean(或标了 @Primary 的)。第二个数据源必须写 @Transactional(transactionManager = "orderTxManager"),否则要么报”找不到事务管理器”,要么被主库管理器接管,导致另一个库的操作根本没进事务。
  • 只读事务:@Transactional(readOnly = true) 是给驱动和 ORM 的提示。JPA 下会切到 FlushMode.MANUAL,脏检查不刷库,写操作可能”执行了但没落库”;部分驱动在只读连接上直接拒绝写。所以别拿 readOnly 当”防止误写”的保险。
  • 超时:timeout 单位是秒,实现依赖底层(有的设置语句超时,有的只在事务开始时做检查),不要指望它精确中断长事务。
  • 隔离级别:isolation 只在新建事务时生效;加入已有事务时会被忽略。

边界之外:事务没问题,但结果依然不对

还有一类”看起来像失效”的情况,事务其实是生效的,只是时序错了:

  • 事务尚未提交就发 MQ 或调外部接口,对方先拿到消息、后看到数据,出现”消息到了、单查不到”;
  • 提交前用另一个线程去查同一份数据,读不到未提交的写入;
  • 中间夹了 DDL(ALTER TABLE、TRUNCATE),MySQL 会隐式提交,前面的事务边界被提前切断,后续异常也无法回滚已提交的部分。

解决:消息发送挂到 TransactionSynchronization#afterCommit,DDL 移出业务事务,跨线程读取改为事务内传递结果对象。

三、五种正解:需要”自己调自己”时怎么办

自调用是最高频的坑,下面五种解法按侵入性从低到高排列。

解法 1:拆到另一个 Bean(首选)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class OrderTxService {
@Transactional(rollbackFor = Exception.class)
public void saveOrder(Order order) { /* ... */ }
}

@Service
public class OrderService {
private final OrderTxService orderTxService;

public void createOrder(Order order) {
orderTxService.saveOrder(order); // 跨 Bean,走代理
}
}

优点:语义清晰、可测试、无额外配置。缺点:类数量变多。这是我默认推荐的方案。

解法 2:注入自身代理(改动最小)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class OrderService {

@Autowired
@Lazy // 必须加 @Lazy,否则构造期循环依赖
private OrderService self;

public void createOrder(Order order) {
self.saveOrder(order); // self 是代理对象,不是 this
}

@Transactional(rollbackFor = Exception.class)
public void saveOrder(Order order) { /* ... */ }
}

注意:字段类型写本类、变量名别叫 this;@Lazy 是为了打破自引用导致的三级缓存提前初始化问题。

解法 3:AopContext 取当前代理

1
2
3
4
5
6
@SpringBootApplication
@EnableAspectJAutoProxy(exposeProxy = true) // 必须显式开启
public class Application { }

// 调用处
((OrderService) AopContext.currentProxy()).saveOrder(order);

优点:不改依赖注入结构。缺点:全局开启代理暴露、强耦合 Spring API、单元测试里没有代理会直接抛异常。团队规范里不推荐作为常规手段。

解法 4:编程式事务 TransactionTemplate(最可控)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Service
public class OrderService {

private final TransactionTemplate txTemplate;
private final OrderMapper orderMapper;

public OrderService(PlatformTransactionManager tm, OrderMapper orderMapper) {
this.txTemplate = new TransactionTemplate(tm);
this.txTemplate.setPropagationBehavior(Propagation.REQUIRES_NEW.value());
this.orderMapper = orderMapper;
}

public void createOrder(Order order) {
txTemplate.executeWithoutResult(status -> {
orderMapper.insert(order);
if (order.getAmount() > 100) {
status.setRollbackOnly(); // 显式回滚,不依赖异常
}
});
}
}

优点:事务边界就是代码块边界,不受代理限制,自调用也没问题;异常处理、回滚条件都能写得很明白。适合”事务只包一小段”的场景。

解法 5:别在事务里干重活(架构级)

事务该短。把远程调用、文件 IO、消息发送挪到事务外;需要”业务成功后才发消息”,用事务同步回调:

1
2
3
4
5
6
7
TransactionSynchronizationManager.registerSynchronization(
new TransactionSynchronization() {
@Override
public void afterCommit() {
messageProducer.send(event);
}
});

四、排查路径:30 秒定位

flowchart TD
    A["怀疑事务没生效"] --> B{"是否从另一个 Bean 经代理调用?"}
    B -->|"否:this 调用 / 同类调用 / new 出来的对象"| B1["改走代理:拆 Bean、自注入 @Lazy 或 TransactionTemplate"]
    B -->|"是"| C{"可见性与代理类型匹配吗?"}
    C -->|"private / final / static / 接口代理下非 public"| C1["改 public、去 final,或把注解移到实现类"]
    C -->|"匹配"| D{"抛出的异常会触发回滚吗?"}
    D -->|"受检异常 / 被 catch 吞掉 / 被包装"| D1["加 rollbackFor 或重新抛出或 setRollbackOnly"]
    D -->|"运行时异常且未被吞"| E{"事务管理器与数据源匹配吗?"}
    E -->|"多数据源未指定 / 无管理器"| E1["指定 transactionManager 或补齐配置"]
    E -->|"匹配"| F["查引擎、DDL 隐式提交、异步线程、只读事务"]

图 3:排查决策树。按这个顺序走,比对着代码找注释快得多。

三个可用的验证手段:

1
2
3
4
5
6
7
8
9
10
// 1. 运行时判断当前线程有没有活动事务
boolean active = TransactionSynchronizationManager.isActualTransactionActive();

// 2. 打开事务日志(application.yml),能看到 begin/commit/rollback 三行才算真跑通
logging:
level:
org.springframework.transaction: DEBUG
org.springframework.jdbc.support.JdbcTransactionManager: DEBUG

// 3. 断点打在 TransactionInterceptor.invoke 上,看这次调用到底有没有进来

第 1 条要特别注意:它返回 true 只说明线程上有事务,不代表你预期的那个方法开启了事务——排查自调用时,把这一行日志打在目标方法第一行最有效。

五、最佳实践清单

  1. 注解一律写在实现类的 public 方法上,并显式写 rollbackFor = Exception.class。
  2. 事务方法只由外部 Bean 调用;同类自调用要么拆 Bean,要么 TransactionTemplate。
  3. 事务里只做数据库操作,远程调用、IO、消息统一放到事务外或 afterCommit。
  4. 一个事务一个数据源;多数据源显式写 transactionManager。
  5. 不拿 readOnly 当写入保护,不拿 timeout 当”防长事务”的主力手段。
  6. 提交前不做跨线程读、不发消息、不执行 DDL。
  7. 关键链路加一条”事务是否真的回滚”的集成测试——这类问题单元测试测不出来,只有连真库、真抛异常才看得见。

结语

@Transactional 失效的本质,几乎都能归结为四句话:没走代理、异常没抛对、管理器没对上、线程没带上。把这四条记牢,比背 12 个场景更管用——因为新坑总会以旧机制的变体重现。

如果只让我留一条经验:把 @Transactional(rollbackFor = Exception.class) 写成团队的代码模板默认值,并把”同类自调用”列为 Code Review 的固定检查项。这两件事能消掉这类事故的大半。

参考