Appearance
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失效最终只归三类:调用没走代理、事务属性不匹配(异常类型 / 方法可见性 / 管理器 / 引擎)、事务边界设计错(自调用、跨线程、跨服务、大事务)。分层要点:
- 三个核心抽象:
PlatformTransactionManager管“怎么开/提交/回滚”,TransactionDefinition管“属性”(传播、隔离、超时、只读、回滚规则),TransactionStatus管“这一次事务的运行态”(是否新事务、是否 rollback-only、savepoint)。声明式由TransactionInterceptor+BeanFactoryTransactionAttributeSourceAdvisor驱动(3.1-5),编程式用TransactionTemplate或直接调 manager。 - 事务怎么“传播”到 DAO:
doBegin时con.setAutoCommit(false),再把ConnectionHolder绑定到TransactionSynchronizationManager的 ThreadLocal;DataSourceUtils.getConnection/ MyBatis 的SpringManagedTransaction都先从 ThreadLocal 取,取不到才向连接池借新连接并 autocommit。所以事务的前提是同一线程,@Async、线程池、CompletableFuture都会丢事务。 - 传播行为的本质是“要不要新物理事务”:REQUIRED/SUPPORTS/MANDATORY 是“加入已有事务”(没有就按各自规则处理);REQUIRES_NEW/NOT_SUPPORTED/NEVER 要“挂起当前事务”;NESTED 用 savepoint 在原事务内做子事务。挂起 = 解绑 ThreadLocal 资源 + 记住原状态,恢复时再绑回去。
- 隔离级别是数据库的事:Spring 只做
Connection.setTransactionIsolation透传;ISOLATION_DEFAULT表示交给数据库(MySQL InnoDB 默认 RR,Oracle 默认 RC)。隔离级别解决脏读/不可重复读/幻读,不解决丢失更新——丢失更新要靠乐观锁(version)或悲观锁(select ... for update),见 4.1-10。 - 回滚规则是“异常类型 + 是否被吞”:默认只对
RuntimeException/Error回滚,受检异常不回滚,要显式rollbackFor;异常被 catch 后没 rethrow,拦截器看不到异常,照样提交;内层REQUIRED失败会把共享事务标记 rollback-only,外层 catch 后提交会抛UnexpectedRollbackException。 - 事务同步是“事务生命周期钩子”:
TransactionSynchronizationManager.registerSynchronization注册beforeCommit / beforeCompletion / afterCommit / afterCompletion;@TransactionalEventListener(phase = AFTER_COMMIT)是它的注解封装。典型用途是提交后发 MQ、删缓存、写审计;注意afterCommit抛异常不会回滚(已经提交了),fallbackExecution=false时没有事务事件会被丢弃。 - 失效场景按根因记,不要背现象:代理类(自调用 / private / final / 非 Spring Bean /
new出来的对象)、属性类(受检异常没配rollbackFor/ 用错transactionManager/ 表是 MyISAM / 传播写错)、线程类(@Async/ 手动线程池 / 并行流)、边界类(跨服务 RPC、跨库、DDL 隐式提交、大事务超时)。 - 工程取舍:事务要短——长事务持有行锁/连接、撑大 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 : committext
连接绑定:
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
→ UnexpectedRollbackExceptiontext
事务同步时序:
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。
- Spring Framework 5.3.x / 6.x:
传播行为:
| 传播 | 外层有事务 | 外层无事务 | 物理事务 | 内层回滚影响 | 典型场景 |
|---|---|---|---|---|---|
REQUIRED(默认) | 加入 | 新建 | 共用外层 | 标记外层 rollback-only | 绝大多数业务方法 |
REQUIRES_NEW | 挂起外层,新建 | 新建 | 独立 | 只回滚自己,外层可提交 | 记失败日志、独立流水、发件箱 |
NESTED | savepoint | 等同新建 | 同连接子事务 | 回滚到 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 编程式:
| 维度 | @Transactional | TransactionTemplate | 直接 PlatformTransactionManager |
|---|---|---|---|
| 侵入性 | 低,注解 | 中,代码内 | 高 |
| 边界控制 | 整个方法 | 代码块 | 完全手动 |
| 自调用 | 失效 | 不受影响 | 不受影响 |
| 传播/回滚 | 注解属性 | execute 内 status.setRollbackOnly() | 手动 |
| 适用 | 常规 Service | 局部事务、循环内独立提交 | 框架/中间件代码 |
- 失效场景与定位:
| 现象/根因 | 说明 | 处理 |
|---|---|---|
| 自调用 | this.methodB() 绕过代理 | 拆 Bean、自注入 @Lazy、AopContext、TransactionTemplate |
| private / final / static 方法 | 代理无法拦截 | 改 public、去 final、改结构 |
| 非 Spring Bean | new 出来的对象没有代理 | 交给容器管理 |
| 受检异常不回滚 | 默认只回滚 RuntimeException/Error | rollbackFor = 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 / MVCC | undo 膨胀,历史版本链变长 | 分批提交,控制单事务行数 |
| binlog / 主从 | 大事务一次写大量 binlog,从库延迟 | 分批(如每 500~1000 行),见 4.1-14 |
| 回滚 | 回滚成本高,可能长时间锁 | 预校验、幂等、失败快速退出 |
| 死锁 | 交叉更新顺序不一致 | 统一加锁顺序、短事务、重试 |
深挖点(面试官常追的 6 个):
- 传播行为在源码里怎么实现:
AbstractPlatformTransactionManager#getTransaction先doGetTransaction拿事务对象,isExistingTransaction判断是否已有事务;有则进handleExistingTransaction——REQUIRED直接返回带当前事务的TransactionStatus;REQUIRES_NEW调suspend解绑 ThreadLocal 资源并doBegin新事务;NESTED调createAndHoldSavepoint(Connection.setSavepoint);NOT_SUPPORTED/NEVER/MANDATORY分别挂起或校验。提交/回滚时commit判断isNewTransaction,嵌套事务走releaseHeldSavepoint/rollbackToHeldSavepoint而不是真提交。 - 一个事务里连接为什么是同一个:
DataSourceTransactionManager#doBegin关闭 autocommit 后,把ConnectionHolder以 DataSource 为 key 绑到TransactionSynchronizationManager的 ThreadLocal;DataSourceUtils.getConnection先查这个 ThreadLocal,命中就返回同一连接,未命中才向连接池借。MyBatis 的SpringManagedTransaction也走DataSourceUtils,所以SqlSession能在事务内共享。跨线程 ThreadLocal 丢失,这就是@Async丢事务的根因。 - REQUIRED 内层失败为什么外层也回滚:内层和外层共享同一个
TransactionStatus;内层抛异常时processRollback会把整个事务标记 rollback-only(globalRollbackOnParticipationFailure默认 true)。外层如果 catch 掉异常继续跑,最后commit发现 rollback-only,processCommit直接回滚并抛UnexpectedRollbackException。这不是“外层没配回滚”,而是“内层已经判了死刑”。要隔离失败就用REQUIRES_NEW。 - REQUIRES_NEW 和 NESTED 怎么选:
REQUIRES_NEW挂起外层、新借一条连接、独立提交/回滚,代价是同时占两条连接——连接池小的时候,外层持连接、内层再要连接,高并发下会互相等待甚至耗尽;同一条记录上还可能自己锁自己。NESTED复用同一连接、用 savepoint 回滚到子事务起点,开销小,但外层回滚会连内层一起回滚,且 JTA 不支持、MySQL 需要 InnoDB。日志/流水这种“必须留下”的用REQUIRES_NEW,可丢弃的分支用NESTED。 - 事务同步/提交后动作:
TransactionSynchronizationManager.registerSynchronization注册的回调在AbstractPlatformTransactionManager#processCommit里按beforeCommit → beforeCompletion → doCommit → afterCommit → afterCompletion触发。afterCommit时事务已提交,发 MQ 失败只能重试/补偿,不能回滚——所以“事务提交后发消息”要么用本地消息表(同一事务写 outbox,异步投递),要么用 RocketMQ 事务消息。删缓存也应放afterCommit,否则并发读会把旧值写回缓存(4.2-10)。 - 失效排查的顺序:第一步确认代理——
AopUtils.isAopProxy(bean)、断点TransactionInterceptor、看启动日志的代理类名;第二步确认事务真的开了——TransactionSynchronizationManager.isActualTransactionActive()、isSynchronizationActive();第三步看属性——方法是否 public、异常类型是否命中rollbackOn、transactionManager是否对应数据源;第四步看线程——是否被@Async/线程池切走;第五步看数据库——表引擎、DDL、锁等待。按这个顺序能覆盖 90% 的“事务不生效”。
- 传播行为在源码里怎么实现:
追问链:
- Spring 事务的核心抽象? →
PlatformTransactionManager/TransactionDefinition/TransactionStatus。 - 声明式事务怎么实现的? →
TransactionInterceptor+ Advisor + 代理。 @Transactional在哪一层生效? → 代理层,方法调用前后。- 编程式事务怎么做? →
TransactionTemplate或直接调 manager。 - 传播行为有几种? → 7 种:REQUIRED/REQUIRES_NEW/NESTED/SUPPORTS/NOT_SUPPORTED/MANDATORY/NEVER。
- 默认传播? →
REQUIRED。 - REQUIRED 语义? → 有则加入,无则新建。
- REQUIRES_NEW 语义? → 挂起外层,新建独立事务。
- NESTED 语义? → 同连接 savepoint 子事务。
- NESTED 和 REQUIRES_NEW 区别? → 同/异连接、savepoint/新事务、外层回滚是否连带。
- NESTED 依赖什么? → JDBC savepoint;JTA 不支持;InnoDB 支持。
- SUPPORTS 语义? → 有事务加入,无事务非事务执行。
- NOT_SUPPORTED 语义? → 挂起事务,非事务执行。
- MANDATORY 语义? → 必须在事务中,否则抛异常。
- NEVER 语义? → 不能在事务中,否则抛异常。
- 挂起事务做了什么? → 解绑 ThreadLocal 资源、记录状态,恢复时绑回。
- 隔离级别几种? → 4 种 + DEFAULT。
- Spring 默认隔离级别? →
DEFAULT,由数据库决定。 - MySQL 默认隔离级别? → RR。
- Oracle 默认? → READ COMMITTED。
- RR 能防幻读吗? → 快照读靠 MVCC,当前读靠 next-key lock。
- 隔离级别能防丢失更新吗? → 不能,要乐观锁/悲观锁。
- 回滚规则? → 默认 RuntimeException/Error,受检异常需
rollbackFor。 - 受检异常怎么回滚? →
rollbackFor = Exception.class。 - 异常被 catch 会回滚吗? → 不会,除非 rethrow 或
setRollbackOnly()。 UnexpectedRollbackException原因? → 内层已标记 rollback-only,外层提交。- 怎么只回滚内层? → 内层
REQUIRES_NEW或NESTED。 - 事务同步器是什么? →
TransactionSynchronization,事务生命周期回调。 - 有哪些回调? → beforeCommit/beforeCompletion/afterCommit/afterCompletion。
afterCommit抛异常会回滚吗? → 不会,已提交。- 提交后发消息怎么做? →
@TransactionalEventListener(AFTER_COMMIT)/ 本地消息表 / 事务消息。 @TransactionalEventListener默认行为? → AFTER_COMMIT,无事务时不执行(fallbackExecution=false)。- 事务里连接怎么共享? →
TransactionSynchronizationManagerThreadLocal 绑定ConnectionHolder。 - 没有事务时 DAO 怎么拿连接? → 每次从池里取,autocommit。
- 为什么
@Async里事务失效? → ThreadLocal 不跨线程。 @Transactional+@Async同方法? → 代理顺序不可靠,拆 Bean。- 自调用为什么失效? →
this绕过代理(3.1-5)。 - private 方法能加事务吗? → 代理方式下不行;Spring 6 类代理支持 protected/包可见,private 永远不行。
- final 方法呢? → CGLIB 不能覆盖,失效。
- 多数据源怎么指定事务? →
@Transactional(transactionManager = "...")或@Transactional("tm")。 - 只读事务有什么用? → 优化提示、读写分离路由、部分库禁止写。
readOnly一定不写吗? → 是提示,取决于驱动/库;路由场景用LazyConnectionDataSourceProxy。- 事务超时怎么生效? →
ConnectionHolder记剩余时间,JDBC 层转成 statement 的 query timeout。 - 大事务有什么危害? → 锁、连接、undo、binlog、主从延迟、回滚慢、死锁。
- 怎么优化大事务? → 拆小、分批提交、RPC 移出、异步化。
- REQUIRES_NEW 会耗尽连接池吗? → 会,外层持连接内层再借,池小/并发高时互相等待。
- 事务里调用 RPC 有什么问题? → 持锁/持连接等网络,超时不可控;放到事务外或用 outbox。
- Spring 事务能跨服务吗? → 不能,只是本地事务;分布式事务见 6.1。
- 事务和缓存顺序? → 提交后删缓存/发事件,避免脏读。
- 面试怎么总结? → 抽象三层 → 代理 + ThreadLocal 连接 → 7 种传播 → 隔离透传 → 回滚规则 → 事务同步 → 失效三类根因 → 大事务与分布式边界。
- Spring 事务的核心抽象? →
生产案例/取舍(示例,替换成你的项目):
- 订单创建里调库存 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→ 事务同步与提交后动作 → 失效场景分类排查 → 大事务代价与分布式事务边界。