← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L11 - Spring-AOP与事务失效

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、JDK动态代理 vs CGLIB


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)

二、AOP创建代理流程


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

三、事务传播机制(7种)


// 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种场景(重点!)


┌──────────────────────────────────────────────────────────────┐
│                  事务失效 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实现原理


@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在外层。

面试速记卡(考前30秒速看)

练习题(自测)

1. 编写代码验证自调用事务失效:在一个@Service中,非事务方法调用@Transactional方法,观察是否回滚。

2. 写出7种事务传播行为在"当前有事务"和"当前无事务"两种情况下的行为。

3. REQUIRES_NEW场景:外层REQUIRED,内层REQUIRES_NEW抛异常被外层catch,最终外层事务是否回滚?为什么?

4. 解释为什么@Transactional标注在private方法上不生效(从AOP代理的原理分析)。

5. 设计一个场景:方法A调用方法B(异步@Async),B需要事务。如何让B的事务正常工作?

学习资料