AOP

// 没有 AOP：每个方法都要重复写日志、事务、权限检查
public User findById(Long id) {
    log.info("开始查询 user={}", id);          // 日志
    checkPermission("user:read");              // 权限
    Transaction tx = db.beginTransaction();    // 事务
    try {
        User user = db.query(id);              // 真正的业务逻辑
        tx.commit();
        return user;
    } catch (Exception e) {
        tx.rollback();
        throw e;
    } finally {
        log.info("查询结束");                   // 日志
    }
}

// 有 AOP：业务方法只写业务，其余由切面处理
@Transactional
@PreAuthorize("hasRole('USER')")
public User findById(Long id) {
    return db.query(id);   // 只剩业务逻辑
}

<!-- 开启 AspectJ 注解代理 -->
<aop:aspectj-autoproxy/>

<!-- 切面类也要注册成 Bean -->
<bean class="com.example.aspect.LogAspect"/>

@Configuration
@EnableAspectJAutoProxy    // 必须加，否则 @Aspect 不生效
public class AppConfig {

    @Bean
    public LogAspect logAspect() {
        return new LogAspect();
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@Aspect
@Component
public class TimingAspect {

    // Pointcut：拦截 com.example.controller 包下所有类的所有方法
    @Around("execution(* com.example.controller..*(..))") 
    public Object logTiming(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            return pjp.proceed();   // 执行原方法
        } finally {
            long elapsed = System.currentTimeMillis() - start;
            System.out.printf("%s 耗时 %dms%n", pjp.getSignature(), elapsed);
        }
    }
}

execution(修饰符? 返回类型 类路径? 方法名(参数) 异常?)

// 拦截指定包下所有方法（含子包）
execution(* com.example.service..*(..))

// 拦截特定注解标注的方法
@annotation(org.springframework.transaction.annotation.Transactional)

// 拦截特定类的特定方法
execution(* com.example.UserService.findById(Long))

// 只匹配 com.example.service 包（不含子包）
execution(* com.example.service.*.*(..))

// 匹配 com.example.service 包及所有子包
execution(* com.example.service..*(..))

@Aspect          // AspectJ 注解
@Component
public class MyAspect {
    @Around("execution(* com.example.service..*(..))") // AspectJ Pointcut 语法
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // Spring 代理执行，不是 AspectJ 字节码织入
        return pjp.proceed();
    }
}

java -javaagent:aspectjweaver.jar -jar app.jar

@Configuration
@EnableLoadTimeWeaving
public class AppConfig { }

@Service
public class OrderService {

    public void placeOrder() {
        validate();  // ❌ 内部调用，AOP 不生效，validate() 上的切面被绕过
    }

    @Transactional
    public void validate() { ... }
}

HTTP 请求
  → Controller.findUser()
       ↕ Spring Security AOP（权限校验）
       ↕ 日志切面（记录入参）
  → Service.findUser()
       ↕ @Transactional AOP（开启事务）
       ↕ @Cacheable AOP（查缓存，命中则返回）
  → Repository.findById()   ← 真正的数据库查询
       ↕ @Transactional AOP（提交事务）
       ↕ 日志切面（记录耗时）
  → 返回响应

@Transactional
public void transferMoney(Long fromId, Long toId, BigDecimal amount) {
    accountDao.deduct(fromId, amount);   // 扣款
    accountDao.add(toId, amount);        // 入账
    // 任一步失败，两步都回滚，不会出现"扣了款但没入账"
}

@Transactional
public void batchInsert(List<Order> orders) {
    for (Order order : orders) {
        orderDao.insert(order);
    }
    // 全部成功才提交；任何一条失败，全部回滚
}

@Transactional
public void deductStock(Long productId, int qty) {
    Product p = productDao.findById(productId);  // 读
    if (p.getStock() < qty) throw new RuntimeException("库存不足");
    productDao.deductStock(productId, qty);      // 写
    // 同一事务内，读到的库存和写时的库存一致
}

@Transactional  // 默认只回滚 RuntimeException
public void save() throws IOException {
    fileService.write();   // IOException 是受检异常，不触发回滚！
    dao.insert(record);
}

// 修复：
@Transactional(rollbackFor = Exception.class)

@Service
public class OrderService {
    public void placeOrder() {
        saveOrder();   // ❌ 内部调用，@Transactional 不生效
    }

    @Transactional
    public void saveOrder() { ... }
}

@Transactional          // ❌ 无效，代理无法重写 private 方法
private void doSave() { ... }