JDK动态代理:
- 基于接口(java.lang.reflect.Proxy)
- 目标类必须实现接口
- 生成实现相同接口的代理类
- 核心:InvocationHandler.invoke()
代理对象
┌──────────────────────────────┐
│ implements IService │
│ │
│ methodA() { │
│ handler.invoke(this, ...) │ ← 拦截调用
│ } │
└──────────────────────────────┘
│ 调用
▼
InvocationHandler.invoke()
→ 前置通知
→ target.methodA() ← 反射调用目标方法
→ 后置通知
CGLIB动态代理:
- 基于继承(生成目标类的子类)
- 目标类不需要实现接口
- 不能代理final类和final方法
- 核心:MethodInterceptor.intercept()
- 性能略高于JDK代理(FastClass机制)
代理对象
┌──────────────────────────────┐
│ extends TargetClass │
│ │
│ methodA() { │
│ interceptor.intercept(...) │ ← 拦截调用
│ } │
└──────────────────────────────┘
| 对比 | JDK动态代理 | CGLIB |
|---|---|---|
| 实现 | 接口 | 继承(子类) |
| 要求 | 必须实现接口 | 不能是final类 |
| 性能 | JDK8+优化后接近CGLIB | 略高(FastClass) |
| Spring默认 | 有接口时用JDK | 无接口时用CGLIB |
| Spring Boot 2.x | 默认CGLIB | 默认CGLIB |
// Spring Boot 2.x 默认使用 CGLIB
// 可通过以下配置改回JDK动态代理:
spring.aop.proxy-target-class=false
// Spring 6 / Spring Boot 3.x:
// spring.aop.proxy-target-class 默认 true(CGLIB)
AbstractAutoProxyCreator(AOP核心):
Bean初始化阶段 → postProcessAfterInitialization()
┌──────────────────────────────────────────────────────┐
│ wrapIfNecessary(bean, beanName, cacheKey) │
│ │
│ 1. 查找匹配的Advisor(切面) │
│ → 扫描@Aspect定义的切点和方法 │
│ → 匹配当前Bean的类和方法 │
│ │
│ 2. 创建代理 │
│ createProxy(beanClass, advisors) │
│ ├── 有接口且proxyTargetClass=false → JDK代理 │
│ └── 无接口或proxyTargetClass=true → CGLIB代理 │
│ │
│ 3. 返回代理对象(替换原始Bean放入容器) │
└──────────────────────────────────────────────────────┘
Advice执行顺序(Spring 5.2.7+):
正常执行:
@Around.proceed()前
→ @Before
→ 目标方法
→ @AfterReturning
→ @After
→ @Around.proceed()后
异常执行:
@Around.proceed()前
→ @Before
→ 目标方法(抛异常)
→ @AfterThrowing
→ @After
→ @Around捕获异常或向上抛
拦截器链(MethodInterceptor链):
Proxy
→ Aspect1Around.intercept()
→ Aspect2Around.intercept()
→ AspectBefore
→ Target Method
→ AspectAfterReturning
→ Aspect1Around 后半段
→ Aspect1After
// Propagation 枚举
1. REQUIRED(默认)
→ 有事务就加入,没有就新建
→ 外层有事务 → 内层加入外层事务
→ 外层无事务 → 内层新建事务
→ 最常用!
2. SUPPORTS
→ 有事务就加入,没有就以非事务执行
3. MANDATORY
→ 必须在事务中执行,否则抛异常
4. REQUIRES_NEW
→ 总是新建事务
→ 外层事务挂起(suspend),内层独立事务
→ 内层回滚不影响外层(除非外层捕获异常后继续抛出)
5. NOT_SUPPORTED
→ 以非事务执行,如果当前有事务则挂起
6. NEVER
→ 以非事务执行,如果当前有事务则抛异常
7. NESTED
→ 在当前事务中创建保存点(savepoint)
→ 内层回滚到保存点,不影响外层
→ 外层回滚则内层也回滚
→ 需要底层数据库支持savepoint(如MySQL)
传播行为对比表:
| 传播行为 | 当前有事务 | 当前无事务 |
|---|---|---|
| REQUIRED | 加入 | 新建 |
| SUPPORTS | 加入 | 非事务 |
| MANDATORY | 加入 | 抛异常 |
| REQUIRES_NEW | 挂起当前,新建 | 新建 |
| NOT_SUPPORTED | 挂起当前 | 非事务 |
| NEVER | 抛异常 | 非事务 |
| NESTED | 嵌套(savepoint) | 新建 |
REQUIRED vs REQUIRES_NEW vs NESTED:
场景:methodA() 调用 methodB()
REQUIRED(默认):
methodA ──┬──→ 事务开始
│ methodB(加入同一事务)
│ methodB异常 → 整个事务回滚(A和B都回滚)
├──→ methodA继续
└──→ 事务提交
REQUIRES_NEW:
methodA ──┬──→ 事务A开始
│ methodB ──┬──→ 事务B开始(A挂起)
│ │ methodB异常 → 只回滚B
│ └──→ 事务B结束
│ methodA继续(不受B影响)
└──→ 事务A提交
注意:如果A捕获了B的异常但B的异常是 unchecked exception
且A的transaction manager标记了rollback-only,A也会回滚
NESTED:
methodA ──┬──→ 事务开始
│ methodB → SAVEPOINT(嵌套)
│ methodB异常 → 回滚到SAVEPOINT(A不受影响)
│ methodA继续
└──→ 事务提交
┌──────────────────────────────────────────────────────────────┐
│ 事务失效 9 种场景 │
├──────────────────────────────────────────────────────────────┤
│ │
│ 1. 自调用(Self-invocation) │
│ @Service │
│ public class OrderService { │
│ public void methodA() { │
│ this.methodB(); // ← 没走代理!事务不生效 │
│ } │
│ @Transactional │
│ public void methodB() { ... } │
│ } │
│ 原因:this调用不经过代理对象 │
│ 解决:注入自身 / AopContext.currentProxy() │
│ │
│ 2. 方法非public │
│ @Transactional │
│ private void method() { ... } // ← 非public,不生效! │
│ 原因:Spring AOP默认只代理public方法 │
│ 解决:改为public │
│ │
│ 3. 异常类型不匹配 │
│ @Transactional │
│ public void method() { │
│ throw new Exception("checked"); // ← 默认只回滚 │
│ } │
│ 原因:默认只回滚RuntimeException和Error │
│ 解决:@Transactional(rollbackFor = Exception.class) │
│ │
│ 4. 异常被catch吞掉 │
│ @Transactional │
│ public void method() { │
│ try { ... } │
│ catch (Exception e) { │
│ log.error(e); // ← 异常被吞,不会触发回滚 │
│ } │
│ } │
│ 解决:catch后 throw 或 手动回滚 │
│ TransactionAspectSupport.currentTransactionStatus() │
│ .setRollbackOnly(); │
│ │
│ 5. Bean未被Spring管理 │
│ public class OrderService { // ← 没有@Service! │
│ @Transactional │
│ public void method() { ... } │
│ } │
│ 原因:非Spring Bean,不会被AOP代理 │
│ 解决:加@Service/@Component │
│ │
│ 6. 数据库引擎不支持事务 │
│ MySQL的MyISAM引擎不支持事务! │
│ 解决:使用InnoDB引擎(ALTER TABLE ... ENGINE=InnoDB) │
│ │
│ 7. 传播行为配置错误 │
│ @Transactional(propagation = Propagation.NOT_SUPPORTED) │
│ // ← 以非事务执行,当然不回滚! │
│ 解决:使用正确的传播行为(默认REQUIRED) │
│ │
│ 8. @Transactional标注在final/static方法上 │
│ @Transactional │
│ public final void method() { ... } // ← 不生效! │
│ 原因:final/static方法无法被CGLIB重写,也无法被JDK代理 │
│ 解决:去掉final/static修饰符 │
│ │
│ 9. 多线程场景 │
│ @Transactional │
│ public void method() { │
│ new Thread(() -> { │
│ // ← 新线程中的操作不在事务中! │
│ // Spring事务基于ThreadLocal │
│ }).start(); │
│ } │
│ 原因:事务信息存储在ThreadLocal,新线程拿不到 │
│ 解决:使用编程式事务 / TransmittableThreadLocal │
│ │
└──────────────────────────────────────────────────────────────┘
@Transactional 底层实现:
1. 解析注解
Spring解析@Transactional注解 → 创建TransactionAttribute
→ 封装为BeanFactoryTransactionAttributeSourceAdvisor
2. 创建代理
AOP代理创建时,将事务Advisor加入拦截器链
3. 方法调用时执行拦截器
TransactionInterceptor.invoke()
→ TransactionAspectSupport.invokeWithinTransaction()
核心流程:
┌─────────────────────────────────────────────────────────┐
│ invokeWithinTransaction() │
│ │
│ 1. 获取事务属性(@Transactional的配置) │
│ 2. 获取TransactionManager │
│ 3. 获取事务状态(是否新事务/已有事务) │
│ tm.getTransaction(txAttr) │
│ → DataSource.getTransaction() │
│ → conn.setAutoCommit(false) ← 关闭自动提交! │
│ │
│ 4. 执行目标方法 │
│ retVal = invocation.proceed() │
│ │
│ 5. 正常 → 提交事务 │
│ tm.commit(status) │
│ → conn.commit() │
│ │
│ 5. 异常 → 回滚事务(根据rollbackFor判断) │
│ tm.rollback(status) │
│ → conn.rollback() │
│ │
└─────────────────────────────────────────────────────────┘
// 编程式事务(应对声明式事务失效的场景)
@Autowired
private PlatformTransactionManager transactionManager;
public void method() {
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = transactionManager.getTransaction(def);
try {
// 业务逻辑
transactionManager.commit(status);
} catch (Exception e) {
transactionManager.rollback(status);
throw e;
}
}
// 或使用 TransactionTemplate(更简洁)
@Autowired
private TransactionTemplate transactionTemplate;
public void method() {
transactionTemplate.execute(status -> {
// 业务逻辑
return result;
});
}
Q1: Spring AOP和AspectJ的区别?
Spring AOP是运行时代理(JDK/CGLIB),只支持方法级别的切面。AspectJ是编译时/加载时织入,支持字段、构造器等更细粒度的切面。Spring AOP更简单但不支持同一类内部调用的拦截。
Q2: 为什么自调用会导致事务失效?
因为@Transactional依赖AOP代理,代理只在外部调用时生效。this.method()是直接调用目标对象的方法,不经过代理,所以事务拦截器不会执行。解决方案:注入自身(@Lazy private OrderService self)或使用AopContext.currentProxy()。
Q3: REQUIRES_NEW和NESTED的区别?
REQUIRES_NEW创建完全独立的新事务(外层事务挂起),内层回滚不影响外层。NESTED在当前事务中创建savepoint,内层回滚到savepoint,但外层回滚时内层也回滚。NESTED更轻量(不需要创建新事务和连接)。
Q4: @Transactional(readOnly=true)有什么用?
(1) 提示数据库驱动做优化(如MySQL的InnoDB不检查修改);(2) Hibernate/JPA不做脏检查(提升性能);(3) 可以配置只读从库路由。注意:readOnly不保证绝对不会写入,只是优化提示。
Q5: 一个方法上有多个切面(如@Async + @Transactional),执行顺序是什么?
由@Order或实现Ordered接口决定。顺序小的先执行(外层包裹)。如果@Transactional在@Async外层,事务先生效;反之,异步执行时可能没有事务。建议@Transactional在外层。
1. 编写代码验证自调用事务失效:在一个@Service中,非事务方法调用@Transactional方法,观察是否回滚。
2. 写出7种事务传播行为在"当前有事务"和"当前无事务"两种情况下的行为。
3. REQUIRES_NEW场景:外层REQUIRED,内层REQUIRES_NEW抛异常被外层catch,最终外层事务是否回滚?为什么?
4. 解释为什么@Transactional标注在private方法上不生效(从AOP代理的原理分析)。
5. 设计一个场景:方法A调用方法B(异步@Async),B需要事务。如何让B的事务正常工作?