Skip to content

3.1-6 事务管理:传播、隔离、同步、失效场景 ​

所属:03 主流框架 / 3.1 Spring 分级:A 状态:◐ 初稿 关联:3.1-1、3.1-2、3.1-4、3.1-5、3.1-10、3.2-5、3.3-1、4.1-3、4.1-10、4.1-14、6.1-3

  • 题型:原理 / 场景 / 排障

  • 一句话结论:Spring 事务是 PlatformTransactionManager 之上的声明式包装:TransactionInterceptor 在方法前后执行 getTransaction → proceed → commit/rollback,DataSourceTransactionManager 把 Connection 通过 TransactionSynchronizationManager 的 ThreadLocal 绑定到当前线程,让同线程内的 DAO/MyBatis 共用一条连接。传播行为是 Spring 层决定“加入 / 新建 / 挂起 / 嵌套”,隔离级别只是透传给数据库。@Transactional 失效最终只归三类:调用没走代理、事务属性不匹配(异常类型 / 方法可见性 / 管理器 / 引擎)、事务边界设计错(自调用、跨线程、跨服务、大事务)。

  • 分层要点:

    1. 三个核心抽象:PlatformTransactionManager 管“怎么开/提交/回滚”,TransactionDefinition 管“属性”(传播、隔离、超时、只读、回滚规则),TransactionStatus 管“这一次事务的运行态”(是否新事务、是否 rollback-only、savepoint)。声明式由 TransactionInterceptor + BeanFactoryTransactionAttributeSourceAdvisor 驱动(3.1-5),编程式用 TransactionTemplate 或直接调 manager。
    2. 事务怎么“传播”到 DAO:doBegin 时 con.setAutoCommit(false),再把 ConnectionHolder 绑定到 TransactionSynchronizationManager 的 ThreadLocal;DataSourceUtils.getConnection / MyBatis 的 SpringManagedTransaction 都先从 ThreadLocal 取,取不到才向连接池借新连接并 autocommit。所以事务的前提是同一线程,@Async、线程池、CompletableFuture 都会丢事务。
    3. 传播行为的本质是“要不要新物理事务”:REQUIRED/SUPPORTS/MANDATORY 是“加入已有事务”(没有就按各自规则处理);REQUIRES_NEW/NOT_SUPPORTED/NEVER 要“挂起当前事务”;NESTED 用 savepoint 在原事务内做子事务。挂起 = 解绑 ThreadLocal 资源 + 记住原状态,恢复时再绑回去。
    4. 隔离级别是数据库的事:Spring 只做 Connection.setTransactionIsolation 透传;ISOLATION_DEFAULT 表示交给数据库(MySQL InnoDB 默认 RR,Oracle 默认 RC)。隔离级别解决脏读/不可重复读/幻读,不解决丢失更新——丢失更新要靠乐观锁(version)或悲观锁(select ... for update),见 4.1-10。
    5. 回滚规则是“异常类型 + 是否被吞”:默认只对 RuntimeException/Error 回滚,受检异常不回滚,要显式 rollbackFor;异常被 catch 后没 rethrow,拦截器看不到异常,照样提交;内层 REQUIRED 失败会把共享事务标记 rollback-only,外层 catch 后提交会抛 UnexpectedRollbackException。
    6. 事务同步是“事务生命周期钩子”:TransactionSynchronizationManager.registerSynchronization 注册 beforeCommit / beforeCompletion / afterCommit / afterCompletion;@TransactionalEventListener(phase = AFTER_COMMIT) 是它的注解封装。典型用途是提交后发 MQ、删缓存、写审计;注意 afterCommit 抛异常不会回滚(已经提交了),fallbackExecution=false 时没有事务事件会被丢弃。
    7. 失效场景按根因记,不要背现象:代理类(自调用 / private / final / 非 Spring Bean / new 出来的对象)、属性类(受检异常没配 rollbackFor / 用错 transactionManager / 表是 MyISAM / 传播写错)、线程类(@Async / 手动线程池 / 并行流)、边界类(跨服务 RPC、跨库、DDL 隐式提交、大事务超时)。
    8. 工程取舍:事务要短——长事务持有行锁/连接、撑大 undo、放大 binlog、加重主从延迟、回滚慢、死锁概率高。事务内不要做 RPC/HTTP/发消息/大文件;批量写分批提交;跨服务一致性用本地消息表/事务消息/TCC,而不是把 @Transactional 当分布式事务。
  • 图/流程:

text
声明式事务调用链:
  caller → proxy(TransactionInterceptor)
    → createTransactionIfNecessary
      → PlatformTransactionManager.getTransaction(definition)
        → doGetTransaction / isExistingTransaction
        → handleExistingTransaction(传播决策)
        → doBegin:setAutoCommit(false) + bindResource(ConnectionHolder)
    → invocation.proceed()   // 业务方法 + DAO
    → commitTransactionAfterReturning
      → triggerBeforeCommit → doCommit → triggerAfterCommit → triggerAfterCompletion
    → 异常:completeTransactionAfterThrowing
      → rollbackOn(ex) ? rollback : commit
text
连接绑定:
  TransactionSynchronizationManager (ThreadLocal)
    resources: { DataSource → ConnectionHolder }
    synchronizations: [ TransactionSynchronization... ]
    actualTransactionActive / currentTransactionReadOnly / isolationLevel

  DAO 调用 DataSourceUtils.getConnection(ds)
    → ThreadLocal 命中 → 复用同一 Connection
    → 未命中 → 从连接池取新连接(autocommit=true)
text
传播决策(有外层事务时):
  REQUIRED      → 加入,共享 TransactionStatus
  SUPPORTS      → 加入
  MANDATORY     → 加入;没有事务则抛 IllegalTransactionStateException
  REQUIRES_NEW  → suspend 外层,新建物理事务
  NOT_SUPPORTED → suspend 外层,以非事务方式执行
  NEVER         → 有事务则抛 IllegalTransactionStateException
  NESTED        → 同连接 + savepoint;回滚到 savepoint,外层可继续
text
REQUIRED 内层失败:
  outer (tx T)
    → inner REQUIRED(同一个 T)
      → 抛异常 → processRollback → T 标记 rollback-only
    → outer catch 住异常,继续执行
    → outer 正常返回 → commit → 发现 rollback-only
      → UnexpectedRollbackException
text
事务同步时序:
  beforeCommit   → 可抛异常触发回滚(此时还没提交)
  beforeCompletion
  doCommit
  afterCommit    → 已提交,抛异常不会回滚
  afterCompletion(status) → 清理资源,STATUS_COMMITTED / ROLLED_BACK
  • 版本/源码锚点:

    • Spring Framework 5.3.x / 6.x:PlatformTransactionManager、AbstractPlatformTransactionManager(getTransaction/commit/rollback/handleExistingTransaction/suspend/resume)、DataSourceTransactionManager(doBegin/doCommit/doRollback/DataSourceTransactionObject)、TransactionTemplate。
    • 声明式:TransactionInterceptor#invokeWithinTransaction、AnnotationTransactionAttributeSource、BeanFactoryTransactionAttributeSourceAdvisor、ProxyTransactionManagementConfiguration。
    • 同步:TransactionSynchronizationManager(bindResource/getResource/registerSynchronization/isActualTransactionActive)、TransactionSynchronization(beforeCommit/beforeCompletion/afterCommit/afterCompletion)、TransactionSynchronizationUtils。
    • Spring 5.3:TransactionSynchronization 改为 default 方法,TransactionSynchronizationAdapter 废弃;@TransactionalEventListener 支持 phase/fallbackExecution。
    • Spring 6.0 / Boot 3:jakarta.transaction;类代理(CGLIB)下 protected/包可见方法可参与事务,接口(JDK)代理仍要求 public 且声明在接口上,private 方法永远不生效;稳妥做法是事务方法一律 public。
    • Spring Boot:TransactionAutoConfiguration、DataSourceTransactionManagerAutoConfiguration 自动配置;spring.aop.proxy-target-class 默认 true(3.1-5)。
    • 数据库:MySQL 8.0 InnoDB 默认 RR、支持 savepoint;innodb_lock_wait_timeout 默认 50s;DDL 隐式提交;MyISAM 不支持事务。主从延迟见 4.1-14。
  • 传播行为:

传播外层有事务外层无事务物理事务内层回滚影响典型场景
REQUIRED(默认)加入新建共用外层标记外层 rollback-only绝大多数业务方法
REQUIRES_NEW挂起外层,新建新建独立只回滚自己,外层可提交记失败日志、独立流水、发件箱
NESTEDsavepoint等同新建同连接子事务回滚到 savepoint,外层可继续部分失败不影响整体(需 InnoDB)
SUPPORTS加入非事务执行无(无外层时)无事务可回滚查询方法,兼容有无事务
NOT_SUPPORTED挂起外层非事务执行无自身不回滚大查询/报表,避免占事务
MANDATORY加入抛异常必须已有同 REQUIRED强制在事务内调用的内部方法
NEVER抛异常非事务执行无—明确禁止事务的场景

记忆:REQUIRED 是最常见的坑(内层失败拖垮外层);REQUIRES_NEW 要新连接(池小 + 嵌套会耗尽);NESTED 靠 savepoint(JTA 不支持,NestedTransactionNotSupportedException)。

  • 隔离级别:
级别脏读不可重复读幻读MySQL InnoDB 实现要点
READ_UNCOMMITTED可能可能可能直接读最新版本,几乎不用
READ_COMMITTED否可能可能每条语句新快照;RC 下间隙锁基本关闭
REPEATABLE_READ(MySQL 默认)否否快照读避免,当前读靠 next-key lock事务内第一次读建快照;MVCC 见 4.1-3
SERIALIZABLE否否否读加共享锁,并发骤降
DEFAULT———交给数据库;Spring 不猜

关键区分:隔离级别防的是“读”的异常,防不住“写覆盖”。库存扣减、余额更新要靠 version 乐观锁或 for update 悲观锁,把隔离级别开到 SERIALIZABLE 是代价最大的错误答案。

  • 事务同步回调:
回调时机能否影响事务典型用途
beforeCommit提交前,事务仍可回滚能(抛异常→回滚)校验、最后一致性检查
beforeCompletion提交/回滚前统一回调不能(异常仅记录)资源清理
afterCommit已提交不能(抛异常不回滚)发 MQ、删缓存、发领域事件
afterCompletion完成后不能(可看 status)埋点、释放自定义资源
@TransactionalEventListener(AFTER_COMMIT)提交后不能替代手写同步器;无事务时默认不执行
  • 声明式 vs 编程式:
维度@TransactionalTransactionTemplate直接 PlatformTransactionManager
侵入性低,注解中,代码内高
边界控制整个方法代码块完全手动
自调用失效不受影响不受影响
传播/回滚注解属性execute 内 status.setRollbackOnly()手动
适用常规 Service局部事务、循环内独立提交框架/中间件代码
  • 失效场景与定位:
现象/根因说明处理
自调用this.methodB() 绕过代理拆 Bean、自注入 @Lazy、AopContext、TransactionTemplate
private / final / static 方法代理无法拦截改 public、去 final、改结构
非 Spring Beannew 出来的对象没有代理交给容器管理
受检异常不回滚默认只回滚 RuntimeException/ErrorrollbackFor = Exception.class
异常被吞catch 后没 rethrow,拦截器认为成功rethrow 或 setRollbackOnly()
UnexpectedRollbackException内层 REQUIRED 已标记 rollback-only,外层还提交不要让外层吞内层异常;或内层改 REQUIRES_NEW
用错事务管理器多数据源只配了一个 transactionManager@Transactional(transactionManager = "orderTxManager")
表引擎不支持MyISAM / 部分中间件换 InnoDB;确认 DDL 隐式提交
@Async / 线程池事务绑定 ThreadLocal,子线程没有在异步方法内新开事务;或事务提交后再异步
@Transactional + @Async 同方法代理顺序不确定,事务可能在外层线程开启拆成两个 Bean,异步方法内自己开事务
跨服务 RPC本地事务管不到远端本地消息表 / 事务消息 / TCC / Saga(6.1)
大事务超时/锁等待长事务持锁,innodb_lock_wait_timeout拆小事务、分批、把 RPC 移出事务
DDL 在事务里MySQL DDL 隐式提交迁移脚本单独执行
  • 大事务的代价:
维度影响缓解
锁行锁/间隙锁持有时间长,阻塞并发缩小事务范围,锁操作放最后
连接占用连接池,吞吐下降事务内不做 RPC/IO,NOT_SUPPORTED 跑大查询
undo / MVCCundo 膨胀,历史版本链变长分批提交,控制单事务行数
binlog / 主从大事务一次写大量 binlog,从库延迟分批(如每 500~1000 行),见 4.1-14
回滚回滚成本高,可能长时间锁预校验、幂等、失败快速退出
死锁交叉更新顺序不一致统一加锁顺序、短事务、重试
  • 深挖点(面试官常追的 6 个):

    1. 传播行为在源码里怎么实现:AbstractPlatformTransactionManager#getTransaction 先 doGetTransaction 拿事务对象,isExistingTransaction 判断是否已有事务;有则进 handleExistingTransaction——REQUIRED 直接返回带当前事务的 TransactionStatus;REQUIRES_NEW 调 suspend 解绑 ThreadLocal 资源并 doBegin 新事务;NESTED 调 createAndHoldSavepoint(Connection.setSavepoint);NOT_SUPPORTED/NEVER/MANDATORY 分别挂起或校验。提交/回滚时 commit 判断 isNewTransaction,嵌套事务走 releaseHeldSavepoint/rollbackToHeldSavepoint 而不是真提交。
    2. 一个事务里连接为什么是同一个:DataSourceTransactionManager#doBegin 关闭 autocommit 后,把 ConnectionHolder 以 DataSource 为 key 绑到 TransactionSynchronizationManager 的 ThreadLocal;DataSourceUtils.getConnection 先查这个 ThreadLocal,命中就返回同一连接,未命中才向连接池借。MyBatis 的 SpringManagedTransaction 也走 DataSourceUtils,所以 SqlSession 能在事务内共享。跨线程 ThreadLocal 丢失,这就是 @Async 丢事务的根因。
    3. REQUIRED 内层失败为什么外层也回滚:内层和外层共享同一个 TransactionStatus;内层抛异常时 processRollback 会把整个事务标记 rollback-only(globalRollbackOnParticipationFailure 默认 true)。外层如果 catch 掉异常继续跑,最后 commit 发现 rollback-only,processCommit 直接回滚并抛 UnexpectedRollbackException。这不是“外层没配回滚”,而是“内层已经判了死刑”。要隔离失败就用 REQUIRES_NEW。
    4. REQUIRES_NEW 和 NESTED 怎么选:REQUIRES_NEW 挂起外层、新借一条连接、独立提交/回滚,代价是同时占两条连接——连接池小的时候,外层持连接、内层再要连接,高并发下会互相等待甚至耗尽;同一条记录上还可能自己锁自己。NESTED 复用同一连接、用 savepoint 回滚到子事务起点,开销小,但外层回滚会连内层一起回滚,且 JTA 不支持、MySQL 需要 InnoDB。日志/流水这种“必须留下”的用 REQUIRES_NEW,可丢弃的分支用 NESTED。
    5. 事务同步/提交后动作:TransactionSynchronizationManager.registerSynchronization 注册的回调在 AbstractPlatformTransactionManager#processCommit 里按 beforeCommit → beforeCompletion → doCommit → afterCommit → afterCompletion 触发。afterCommit 时事务已提交,发 MQ 失败只能重试/补偿,不能回滚——所以“事务提交后发消息”要么用本地消息表(同一事务写 outbox,异步投递),要么用 RocketMQ 事务消息。删缓存也应放 afterCommit,否则并发读会把旧值写回缓存(4.2-10)。
    6. 失效排查的顺序:第一步确认代理——AopUtils.isAopProxy(bean)、断点 TransactionInterceptor、看启动日志的代理类名;第二步确认事务真的开了——TransactionSynchronizationManager.isActualTransactionActive()、isSynchronizationActive();第三步看属性——方法是否 public、异常类型是否命中 rollbackOn、transactionManager 是否对应数据源;第四步看线程——是否被 @Async/线程池切走;第五步看数据库——表引擎、DDL、锁等待。按这个顺序能覆盖 90% 的“事务不生效”。
  • 追问链:

    1. Spring 事务的核心抽象? → PlatformTransactionManager / TransactionDefinition / TransactionStatus。
    2. 声明式事务怎么实现的? → TransactionInterceptor + Advisor + 代理。
    3. @Transactional 在哪一层生效? → 代理层,方法调用前后。
    4. 编程式事务怎么做? → TransactionTemplate 或直接调 manager。
    5. 传播行为有几种? → 7 种:REQUIRED/REQUIRES_NEW/NESTED/SUPPORTS/NOT_SUPPORTED/MANDATORY/NEVER。
    6. 默认传播? → REQUIRED。
    7. REQUIRED 语义? → 有则加入,无则新建。
    8. REQUIRES_NEW 语义? → 挂起外层,新建独立事务。
    9. NESTED 语义? → 同连接 savepoint 子事务。
    10. NESTED 和 REQUIRES_NEW 区别? → 同/异连接、savepoint/新事务、外层回滚是否连带。
    11. NESTED 依赖什么? → JDBC savepoint;JTA 不支持;InnoDB 支持。
    12. SUPPORTS 语义? → 有事务加入,无事务非事务执行。
    13. NOT_SUPPORTED 语义? → 挂起事务,非事务执行。
    14. MANDATORY 语义? → 必须在事务中,否则抛异常。
    15. NEVER 语义? → 不能在事务中,否则抛异常。
    16. 挂起事务做了什么? → 解绑 ThreadLocal 资源、记录状态,恢复时绑回。
    17. 隔离级别几种? → 4 种 + DEFAULT。
    18. Spring 默认隔离级别? → DEFAULT,由数据库决定。
    19. MySQL 默认隔离级别? → RR。
    20. Oracle 默认? → READ COMMITTED。
    21. RR 能防幻读吗? → 快照读靠 MVCC,当前读靠 next-key lock。
    22. 隔离级别能防丢失更新吗? → 不能,要乐观锁/悲观锁。
    23. 回滚规则? → 默认 RuntimeException/Error,受检异常需 rollbackFor。
    24. 受检异常怎么回滚? → rollbackFor = Exception.class。
    25. 异常被 catch 会回滚吗? → 不会,除非 rethrow 或 setRollbackOnly()。
    26. UnexpectedRollbackException 原因? → 内层已标记 rollback-only,外层提交。
    27. 怎么只回滚内层? → 内层 REQUIRES_NEW 或 NESTED。
    28. 事务同步器是什么? → TransactionSynchronization,事务生命周期回调。
    29. 有哪些回调? → beforeCommit/beforeCompletion/afterCommit/afterCompletion。
    30. afterCommit 抛异常会回滚吗? → 不会,已提交。
    31. 提交后发消息怎么做? → @TransactionalEventListener(AFTER_COMMIT) / 本地消息表 / 事务消息。
    32. @TransactionalEventListener 默认行为? → AFTER_COMMIT,无事务时不执行(fallbackExecution=false)。
    33. 事务里连接怎么共享? → TransactionSynchronizationManager ThreadLocal 绑定 ConnectionHolder。
    34. 没有事务时 DAO 怎么拿连接? → 每次从池里取,autocommit。
    35. 为什么 @Async 里事务失效? → ThreadLocal 不跨线程。
    36. @Transactional + @Async 同方法? → 代理顺序不可靠,拆 Bean。
    37. 自调用为什么失效? → this 绕过代理(3.1-5)。
    38. private 方法能加事务吗? → 代理方式下不行;Spring 6 类代理支持 protected/包可见,private 永远不行。
    39. final 方法呢? → CGLIB 不能覆盖,失效。
    40. 多数据源怎么指定事务? → @Transactional(transactionManager = "...") 或 @Transactional("tm")。
    41. 只读事务有什么用? → 优化提示、读写分离路由、部分库禁止写。
    42. readOnly 一定不写吗? → 是提示,取决于驱动/库;路由场景用 LazyConnectionDataSourceProxy。
    43. 事务超时怎么生效? → ConnectionHolder 记剩余时间,JDBC 层转成 statement 的 query timeout。
    44. 大事务有什么危害? → 锁、连接、undo、binlog、主从延迟、回滚慢、死锁。
    45. 怎么优化大事务? → 拆小、分批提交、RPC 移出、异步化。
    46. REQUIRES_NEW 会耗尽连接池吗? → 会,外层持连接内层再借,池小/并发高时互相等待。
    47. 事务里调用 RPC 有什么问题? → 持锁/持连接等网络,超时不可控;放到事务外或用 outbox。
    48. Spring 事务能跨服务吗? → 不能,只是本地事务;分布式事务见 6.1。
    49. 事务和缓存顺序? → 提交后删缓存/发事件,避免脏读。
    50. 面试怎么总结? → 抽象三层 → 代理 + ThreadLocal 连接 → 7 种传播 → 隔离透传 → 回滚规则 → 事务同步 → 失效三类根因 → 大事务与分布式边界。
  • 生产案例/取舍(示例,替换成你的项目):

    • 订单创建里调库存 RPC,库存超时导致订单事务长时间持锁;把 RPC 移到事务外,用本地消息表补偿。
    • 主方法 @Transactional 内调用同类 recordLog(),日志事务不生效;拆到独立 Bean 或 REQUIRES_NEW。
    • 内层 REQUIRED 扣减失败抛异常,外层 catch 后仍提交,抛 UnexpectedRollbackException;内层改 REQUIRES_NEW 或不要吞异常。
    • 批量导入 10 万行一个事务,主从延迟 30s、undo 膨胀;改每 1000 行一批提交。
    • @Async 方法上加 @Transactional,异步线程无事务,写库失败没回滚;在异步方法内部用 TransactionTemplate。
    • 多数据源只配了一个 transactionManager,第二个库的操作不在事务里;显式指定事务管理器。
    • 支付回调里先更新订单再发 MQ,MQ 发送失败导致状态与消息不一致;改 outbox 表 + 定时投递。
    • 事务提交后立刻删缓存,仍被并发读回填旧值;用 afterCommit + 延迟双删或 CDC(4.2-10)。
    • 报表查询套在事务里,长查询占连接;查询方法 NOT_SUPPORTED 或走只读库。
    • REQUIRES_NEW 记失败日志,连接池 10、并发 20 时大量线程等待;改异步日志或独立数据源。
    • MySQL 表是 MyISAM,回滚无效;迁移 InnoDB。
    • 迁移脚本里 DDL 和 DML 混在一个事务,DDL 隐式提交导致部分成功;拆脚本。
    • 事务内 select ... for update 顺序不一致,两个服务互相死锁;统一加锁顺序 + 重试。
    • 取舍:@Transactional 换低侵入,代价是自调用/代理边界;TransactionTemplate 换精确边界,代价是代码侵入;REQUIRES_NEW 换失败隔离,代价是连接与自锁风险;NESTED 换轻量子事务,代价是 savepoint 限制;拆小事务换吞吐,代价是一致性要靠补偿。
  • 易错点:

    • 认为 @Transactional 加在方法上就一定生效。
    • 认为自调用会走代理。
    • 认为 private 方法加 @Transactional 生效。
    • 认为 final 方法能被 CGLIB 拦截。
    • 认为受检异常默认回滚。
    • 认为 catch 住异常事务仍会回滚。
    • 认为内层 REQUIRED 失败只回滚内层。
    • 认为外层 catch 内层异常就能正常提交。
    • 认为 UnexpectedRollbackException 是数据库报的。
    • 认为 REQUIRES_NEW 和 NESTED 一样。
    • 认为 NESTED 在任何数据库/事务管理器都支持。
    • 认为 REQUIRES_NEW 没有额外连接开销。
    • 认为传播行为能跨线程传递。
    • 认为 @Async 方法上的 @Transactional 一定生效。
    • 认为 @Transactional 能跨服务/跨库。
    • 认为隔离级别能解决丢失更新。
    • 认为 DEFAULT 隔离级别等于 RR。
    • 认为 Spring 会统一设置隔离级别(它只透传)。
    • 认为 readOnly=true 一定阻止写。
    • 认为事务超时会强杀事务(JDBC 下多为语句级 query timeout)。
    • 认为 afterCommit 里抛异常会回滚。
    • 认为 @TransactionalEventListener 无事务时也会执行。
    • 认为事务里发 MQ 一定可靠。
    • 认为大事务只是“慢一点”。
    • 认为 DDL 可以和安全回滚。
    • 认为 MyISAM 也支持事务。
    • 认为多数据源会自动选对事务管理器。
    • 认为 TransactionSynchronizationAdapter 还是推荐写法(5.3 起已废弃)。
  • 30 秒口述稿:

Spring 事务是 PlatformTransactionManager 上的声明式包装:TransactionInterceptor 在方法前后开/提交/回滚,DataSourceTransactionManager 把 Connection 通过 TransactionSynchronizationManager 的 ThreadLocal 绑到当前线程,DAO 和 MyBatis 都复用它,所以事务不跨线程。传播行为七种,本质是加入、挂起新建、还是 savepoint 嵌套:REQUIRED 共享事务,内层失败会标记 rollback-only,外层提交抛 UnexpectedRollbackException;REQUIRES_NEW 独立但多占连接;NESTED 同连接靠 savepoint。隔离级别只是透传给数据库,默认由库决定,而且防不住丢失更新。回滚默认只认 RuntimeException/Error,受检异常要 rollbackFor。失效就三类根因:没走代理、属性不匹配、边界设计错。

  • 3 分钟展开顺序:结论(三层抽象 + 代理 + ThreadLocal 连接)→ 声明式调用链与编程式对比 → 连接绑定原理(为什么跨线程失效)→ 7 种传播行为与 REQUIRED/REQUIRES_NEW/NESTED 对比 → 隔离级别透传与丢失更新 → 回滚规则与 UnexpectedRollbackException → 事务同步与提交后动作 → 失效场景分类排查 → 大事务代价与分布式事务边界。