Spring AOP 与事务机制

@Transactional
public void createOrder(OrderDTO dto) {
    orderMapper.insert(order);
    try {
        paymentService.charge(order.getAmount());  // 抛出 PaymentException
    } catch (PaymentException e) {
        log.error("支付失败", e);  // 异常被吞掉，事务不回滚
    }
    orderMapper.updateStatus(order.getId(), "PAID");
}

JDK 动态代理                      CGLIB 代理
┌─────────────────┐              ┌─────────────────┐
│   OrderService  │              │   OrderService  │
│   (接口)         │              │   (原始类)       │
└────────┬────────┘              └────────┬────────┘
         │                                │
         │ 实现                            │ 继承
         ▼                                ▼
┌─────────────────┐              ┌─────────────────┐
│ $Proxy0         │              │ OrderService$$  │
│ implements      │              │ EnhancerByCGLIB │
│ OrderService    │              │ extends         │
│                 │              │ OrderService    │
│ InvocationHandler│             │                 │
│   invoke()      │              │ MethodInterceptor│
│     ↓           │              │   intercept()   │
│   目标方法       │              │     ↓           │
└─────────────────┘              │   目标方法(super)│
                                 └─────────────────┘

目标方法正常执行                目标方法抛出异常
    │                               │
    ▼                               ▼
┌──────────┐                  ┌──────────┐
│ @Before  │                  │ @Before  │
└────┬─────┘                  └────┬─────┘
     │                             │
┌────▼─────┐                  ┌────▼─────┐
│ @Around  │                  │ @Around  │
│ 前半部分  │                  │ 前半部分  │
│   ↓      │                  │   ↓      │
│ 目标方法  │                  │ 目标方法  │
│   ↓      │                  │   ↓      │
│ 正常返回  │                  │ 抛出异常  │
│   ↓      │                  │   ↓      │
│ 后半部分  │                  │ 后半部分  │
└────┬─────┘                  └────┬─────┘
     │                             │
┌────▼─────┐                  ┌────▼─────┐
│@After    │                  │@After    │
└────┬─────┘                  └────┬─────┘
     │                             │
┌────▼─────┐                  ┌────▼─────┐
│@AfterReturning│              │@AfterThrowing│
└──────────┘                  └──────────┘

传播行为决策树

当前是否存在事务？
    ├── 是
    │   ├── REQUIRED → 加入当前事务
    │   ├── SUPPORTS → 加入当前事务
    │   ├── MANDATORY → 加入当前事务
    │   ├── REQUIRES_NEW → 挂起当前事务，创建新事务
    │   ├── NOT_SUPPORTED → 挂起当前事务，非事务执行
    │   ├── NEVER → 抛出异常
    │   └── NESTED → 在当前事务中创建 savepoint
    └── 否
        ├── REQUIRED → 创建新事务
        ├── SUPPORTS → 非事务执行
        ├── MANDATORY → 抛出异常
        ├── REQUIRES_NEW → 创建新事务
        ├── NOT_SUPPORTED → 非事务执行
        ├── NEVER → 非事务执行
        └── NESTED → 创建新事务（等价于 REQUIRED）

Bean 生命周期中的 AOP 介入点

① 实例化
    ↓
② 属性填充
    ↓
③ 初始化
    ├── Aware 回调
    ├── BeanPostProcessor.before()
    ├── @PostConstruct / afterPropertiesSet()
    ├── BeanPostProcessor.after()  ← AOP 代理在此创建！
    │                                   AbstractAutoProxyCreator
    │                                   postProcessAfterInitialization()
    │                                        ↓
    │                                   检查是否需要代理
    │                                   (匹配 Pointcut)
    │                                        ↓
    │                                   创建代理对象
    │                                   (JDK 或 CGLIB)
    │                                        ↓
    │                                   用代理对象替代原始 Bean
    │
④ 使用
    ↓
⑤ 销毁

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 获取缓存 key
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 检查是否已经代理过
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 判断是否需要代理（匹配 Advisor）
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 获取适用于当前 Bean 的 Advisor 列表
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(
        bean.getClass(), beanName, null);

    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 创建代理对象
        Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors,
            new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;  // 用代理对象替代原始 Bean
    }
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;  // 不需要代理，返回原始 Bean
}

// InvocationHandler 实现
public class JdkProxy implements InvocationHandler {
    private final Object target;

    public JdkProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置通知");
        Object result = method.invoke(target, args);  // 调用目标方法
        System.out.println("后置通知");
        return result;
    }
}

// 创建代理
OrderService target = new OrderServiceImpl();
OrderService proxy = (OrderService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(),  // 必须实现接口
    new JdkProxy(target)
);
proxy.createOrder();  // 走代理

// MethodInterceptor 实现
public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
                           MethodProxy proxy) throws Throwable {
        System.out.println("前置通知");
        Object result = proxy.invokeSuper(obj, args);  // 调用父类（目标类）方法
        System.out.println("后置通知");
        return result;
    }
}

// 创建代理
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(OrderService.class);  // 继承目标类
enhancer.setCallback(new CglibProxy());
OrderService proxy = (OrderService) enhancer.create();
proxy.createOrder();  // 走代理

// CGLIB 生成的 FastClass 伪代码
public int getIndex(String methodName, Class[] params) {
    // 为每个方法返回唯一的索引
    if (methodName.equals("createOrder") && params.length == 0) return 12;
    // ...
}

public Object invoke(int index, Object target, Object[] args) {
    // 通过索引直接调用，无需反射
    switch (index) {
        case 12: return ((OrderService)target).createOrder();
        // ...
    }
}

@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
    // proxyTargetClass: 是否强制使用 CGLIB
    // mode: PROXY（默认）或 ASPECTJ
    // order: 事务切面的优先级
}

调用代理方法
     │
     ▼
┌─────────────────────────┐
│ TransactionInterceptor  │
│   invoke()              │
└────┬────────────────────┘
     │
     ▼
┌─────────────────────────┐
│ TransactionAspectSupport│
│   invokeWithinTransaction│
└────┬────────────────────┘
     │
     ├── 1. 获取事务属性（@Transactional 注解信息）
     │
     ├── 2. 获取事务管理器（PlatformTransactionManager）
     │
     ├── 3. 判断当前是否存在事务
     │      └── 根据传播行为决定：加入、新建、挂起、异常...
     │
     ├── 4. 开启事务（获取 Connection，设置 autoCommit=false）
     │
     ├── 5. 执行目标方法（invocation.proceed()）
     │      └── 目标方法执行
     │
     ├── 6. 判断是否回滚
     │      └── 发生异常？异常类型匹配 rollbackFor？
     │           ├── 是 → 回滚事务（Connection.rollback()）
     │           └── 否 → 提交事务（Connection.commit()）
     │
     └── 7. 清理事务资源（释放 Connection）

// TransactionSynchronizationManager 维护线程绑定的事务资源
private static final ThreadLocal<Map<Object, Object>> resources =
    new NamedThreadLocal<>("Transactional resources");

// 当前线程绑定的数据库连接
ConnectionHolder holder = (ConnectionHolder) TransactionSynchronizationManager
    .getResource(dataSource);

@Transactional 失效场景分析

┌─────────────────────────────────────────────────────────────┐
│ 场景1：非 public 方法                                        │
│ 原因：@Transactional 只能作用于 public 方法（JDK 代理限制）    │
│ 解决：改为 public                                            │
├─────────────────────────────────────────────────────────────┤
│ 场景2：同类内部调用（this 调用）                              │
│ 原因：this 指向原始对象，绕过代理层                            │
│ 解决：注入自身代理 / 拆分到另一个类                             │
├─────────────────────────────────────────────────────────────┤
│ 场景3：异常被吞掉（try-catch 未抛出）                         │
│ 原因：事务切面只能拦截抛出的异常                               │
│ 解决：catch 后重新抛出 / 手动设置回滚                           │
├─────────────────────────────────────────────────────────────┤
│ 场景4：rollbackFor 配置错误                                   │
│ 原因：默认只回滚 RuntimeException， checked 异常不回滚           │
│ 解决：@Transactional(rollbackFor = Exception.class)           │
├─────────────────────────────────────────────────────────────┤
│ 场景5：数据库引擎不支持事务                                   │
│ 原因：MyISAM 不支持事务，必须用 InnoDB                         │
│ 解决：改用 InnoDB                                            │
├─────────────────────────────────────────────────────────────┤
│ 场景6：异步方法（@Async）                                     │
│ 原因：异步在新线程执行，ThreadLocal 的事务上下文丢失             │
│ 解决：异步方法单独加事务 / 主方法事务覆盖异步逻辑                 │
├─────────────────────────────────────────────────────────────┤
│ 场景7：private/final 方法（CGLIB 限制）                       │
│ 原因：CGLIB 无法代理 private/final 方法                        │
│ 解决：改为 public 非 final                                    │
├─────────────────────────────────────────────────────────────┤
│ 场景8：Spring 容器外调用                                      │
│ 原因：直接 new 的对象没有代理                                  │
│ 解决：从容器中获取 Bean                                        │
└─────────────────────────────────────────────────────────────┘

@Service
public class OrderService {

    @Transactional
    public void createOrder(Order order) {
        orderMapper.insert(order);
        // 同类内部调用：this 指向原始对象，不是代理对象
        this.updateInventory(order);  // 事务注解不生效！
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateInventory(Order order) {
        inventoryService.deduct(order.getItems());
    }
}

@Service
public class OrderService {

    @Autowired
    private OrderService self;  // 注入自己的代理对象

    @Transactional
    public void createOrder(Order order) {
        orderMapper.insert(order);
        // 通过代理对象调用，事务生效
        self.updateInventory(order);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateInventory(Order order) {
        inventoryService.deduct(order.getItems());
    }
}

REQUIRES_NEW                          NESTED
┌─────────────────┐                  ┌─────────────────┐
│  外层事务 T1     │                  │  外层事务 T1     │
│    begin        │                  │    begin        │
│      ↓          │                  │      ↓          │
│    操作 A       │                  │    操作 A       │
│      ↓          │                  │      ↓          │
│  ┌───────────┐  │                  │  savepoint S1   │  ← 创建 savepoint
│  │ 挂起 T1    │  │                  │      ↓          │
│  │ 新建 T2    │  │                  │    操作 B       │
│  │   begin    │  │                  │      ↓          │
│  │   操作 B    │  │                  │  内层异常？      │
│  │   commit   │  │                  │    ├── 是 → rollback to S1│
│  │ 恢复 T1    │  │                  │    └── 否 → 继续 │
│  └───────────┘  │                  │      ↓          │
│      ↓          │                  │    操作 C       │
│    操作 C       │                  │      ↓          │
│    commit       │                  │    commit       │
└─────────────────┘                  └─────────────────┘

@Service
public class OrderService {

    @Transactional
    public void batchCreate(List<Order> orders) {
        for (Order order : orders) {
            // 每次循环都挂起外层事务、创建新事务
            // 如果连接池大小为 20，循环 21 次就会耗尽
            logService.saveLog(order);  // REQUIRES_NEW
        }
    }
}

@Aspect
@Component
public class LogAspect {

    @Pointcut("@annotation(com.example.annotation.LogOperation)")
    public void logPointcut() {}

    @Around("logPointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long start = System.currentTimeMillis();
        String methodName = point.getSignature().getName();
        String className = point.getTarget().getClass().getSimpleName();

        try {
            Object result = point.proceed();
            long cost = System.currentTimeMillis() - start;
            System.out.printf("[SUCCESS] %s.%s cost=%dms%n", className, methodName, cost);
            return result;
        } catch (Throwable e) {
            long cost = System.currentTimeMillis() - start;
            System.out.printf("[FAILED] %s.%s cost=%dms, error=%s%n",
                className, methodName, cost, e.getMessage());
            throw e;
        }
    }
}

// 使用
@LogOperation
public void createOrder(Order order) {
    // ...
}

@Service
public class OuterService {

    @Autowired
    private InnerService innerService;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 测试 REQUIRED（默认）
    @Transactional
    public void testRequired() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        innerService.required();  // 加入当前事务
        throw new RuntimeException("外层回滚，内层也回滚");
    }

    // 测试 REQUIRES_NEW
    @Transactional
    public void testRequiresNew() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        try {
            innerService.requiresNew();  // 独立事务，会提交
        } catch (Exception e) {
            // 内层异常不影响外层
        }
        throw new RuntimeException("外层回滚，但内层已独立提交");
    }

    // 测试 NESTED
    @Transactional
    public void testNested() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        try {
            innerService.nested();  // 创建 savepoint
        } catch (Exception e) {
            // 内层回滚到 savepoint，外层继续
        }
        jdbcTemplate.update("INSERT INTO test VALUES (3)");  // 这条会保留
    }
}

@Service
public class InnerService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional(propagation = Propagation.REQUIRED)
    public void required() {
        jdbcTemplate.update("INSERT INTO test VALUES (2)");
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void requiresNew() {
        jdbcTemplate.update("INSERT INTO test VALUES (2)");
    }

    @Transactional(propagation = Propagation.NESTED)
    public void nested() {
        jdbcTemplate.update("INSERT INTO test VALUES (2)");
        throw new RuntimeException("内层异常，回滚到 savepoint");
    }
}

@Service
public class TransactionDemoService {

    // ========== 场景2：同类内部调用 ==========

    @Transactional
    public void outerMethod() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        // 问题：this 指向原始对象，updateStatus 的事务注解不生效
        this.updateStatus();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateStatus() {
        jdbcTemplate.update("INSERT INTO test VALUES (2)");
        throw new RuntimeException("内层异常");
    }

    // ========== 修复方案1：注入自身代理 ==========

    @Autowired
    private TransactionDemoService self;

    @Transactional
    public void outerMethodFixed() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        // 通过代理对象调用，事务生效
        self.updateStatus();
    }

    // ========== 修复方案2：拆分到另一个类 ==========

    @Autowired
    private StatusService statusService;

    @Transactional
    public void outerMethodBestPractice() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        statusService.updateStatus();  // 通过依赖注入调用，走代理
    }

    // ========== 场景3：异常被吞掉 ==========

    @Transactional
    public void swallowException() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        try {
            riskyOperation();
        } catch (Exception e) {
            log.error("出错", e);  // 异常被吞，事务不回滚！
        }
    }

    // 修复：重新抛出 或 手动回滚
    @Transactional
    public void fixSwallowedException() {
        jdbcTemplate.update("INSERT INTO test VALUES (1)");
        try {
            riskyOperation();
        } catch (Exception e) {
            log.error("出错", e);
            throw new RuntimeException(e);  // 重新抛出
            // 或者：TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }
}

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Class<?> targetClass = (invocation.getThis() != null ?
            AopUtils.getTargetClass(invocation.getThis()) : null);

        // 委托给父类的核心方法
        return invokeWithinTransaction(invocation.getMethod(), targetClass,
            invocation::proceed);
    }
}

// TransactionAspectSupport 的核心逻辑
protected Object invokeWithinTransaction(Method method, Class<?> targetClass,
                                         final InvocationCallback invocation) {
    // 1. 获取事务属性
    TransactionAttribute txAttr = getTransactionAttributeSource()
        .getTransactionAttribute(method, targetClass);

    // 2. 获取事务管理器
    PlatformTransactionManager tm = determineTransactionManager(txAttr);

    // 3. 创建事务信息（包含传播行为判断）
    TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, methodName);

    Object retVal;
    try {
        // 4. 执行目标方法
        retVal = invocation.proceedWithInvocation();
    } catch (Throwable ex) {
        // 5. 异常时回滚
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
    } finally {
        cleanupTransactionInfo(txInfo);
    }

    // 6. 正常时提交
    commitTransactionAfterReturning(txInfo);
    return retVal;
}

@Transactional
public void createOrder(Order order) {
    orderMapper.insert(order);           // 在事务中
    rpcService.notifyWarehouse(order);   // 不在事务中！
    mqService.sendOrderMessage(order);   // 不在事务中！
    redisTemplate.opsForValue().set(...);// 不在事务中！
}

@Transactional(rollbackFor = Exception.class)  // 所有异常都回滚
public void createOrder(Order order) {
    // ...
}

@Transactional(
    rollbackFor = Exception.class,
    noRollbackFor = BusinessException.class  // 业务异常不触发回滚
)

-- MySQL：查看运行中的事务
SELECT * FROM information_schema.innodb_trx
WHERE TIME_TO_SEC(timediff(now(), trx_started)) > 10;  -- 超过 10 秒

-- 应用层：设置事务超时
@Transactional(timeout = 5)  // 5 秒超时，自动回滚

public interface OrderService {
    void createOrder(Order order);
}

@Service
public class OrderServiceImpl implements OrderService {
    @Override
    @Transactional
    public void createOrder(Order order) {
        // ...
    }
}

@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = false)  // 强制 JDK 代理
public class Application {
    // ...
}