【2026年4月9日】AI人类助手解析Spring AOP：从动态代理到面试考点全掌握

// ❌ 传统方式：每个业务方法都要重复编写日志和事务代码
@Service
public class OrderService {
    public void createOrder(Order order) {
        System.out.println("【日志】开始创建订单，参数：" + order);  // 日志
        // 手动开启事务（代码略）
        try {
            // 核心业务逻辑...
            System.out.println("订单创建成功");
            // 手动提交事务
        } catch (Exception e) {
            // 手动回滚事务
            throw e;
        }
        System.out.println("【日志】订单创建完成");
    }
    
    public void updateOrder(Order order) {
        System.out.println("【日志】开始更新订单...");   // 重复！
        // 又是重复的事务、日志代码...
        System.out.println("【日志】更新完成");
    }
}

┌─────────────────────────────────────────────────────────┐
│                        切面（Aspect）                     │
│              = 切点（Pointcut） + 通知（Advice）           │
│              去哪里做 + 什么时候做 + 做什么                 │
└─────────────────────────────────────────────────────────┘
                              │
          ┌───────────────────┼───────────────────┐
          ▼                   ▼                   ▼
    ┌──────────┐      ┌─────────────┐      ┌──────────┐
    │  切点     │      │   通知       │      │  织入     │
    │（何处）   │      │（何时+何事）  │      │（如何生效）│
    │Pointcut  │      │   Advice    │      │ Weaving  │
    └──────────┘      └─────────────┘      └──────────┘
         │                    │                    │
         ▼                    ▼                    ▼
    匹配连接点           定义5种时机             创建代理对象
   JoinPoint集合        Before/After等        Proxy + Target

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

@Aspect                    // ① 标注这是一个切面类
@Component                 // ② 交由 Spring 容器管理
public class LoggingAspect {
    
    // ③ 定义切点：匹配 com.example.service 包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceLayer() {}
    
    // ④ 前置通知：在目标方法执行前记录参数
    @Before("serviceLayer()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("【前置通知】方法 " + joinPoint.getSignature().getName() 
                         + " 开始执行，参数：" + Arrays.toString(joinPoint.getArgs()));
    }
    
    // ⑤ 环绕通知：统计方法执行时间（最强大的通知类型）
    @Around("serviceLayer()")
    public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();   // 关键！执行目标方法
        long duration = System.currentTimeMillis() - start;
        
        if (duration > 1000) {
            System.err.println("【性能告警】方法 " + joinPoint.getSignature() 
                             + " 耗时：" + duration + "ms");
        }
        return result;
    }
    
    // ⑥ 返回通知：记录返回值
    @AfterReturning(pointcut = "serviceLayer()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【返回通知】方法 " + joinPoint.getSignature().getName() 
                         + " 执行完毕，返回值：" + result);
    }
}

@Service
public class OrderService {
    // 业务方法中没有任何日志代码，干净纯粹！
    public Order createOrder(String userId, Double amount) {
        // 只关注核心业务逻辑
        Order order = new Order(userId, amount);
        // ... 业务处理
        return order;
    }
}

1. 前置通知(@Before)    → 记录方法入参
2. 环绕通知开始(@Around)→ 开始计时
3. 目标方法执行         → OrderService.createOrder() 核心业务
4. 环绕通知结束(@Around)→ 计算耗时，判断是否超阈值
5. 返回通知(@AfterReturning)→ 记录返回值
   （如果抛异常，则触发 @AfterThrowing，而非返回通知）

// Spring AOP 代理选择核心逻辑
if (目标类实现了至少一个接口) {
    if (proxyTargetClass == true)  // 强制使用 CGLIB
        return CGLIB代理;
    else
        return JDK动态代理;        // 默认选择
} else {
    return CGLIB代理;              // 无接口只能用 CGLIB
}

spring:
  aop:
    proxy-target-class: true

通知执行顺序（以多个切面为例）：
┌─────────────────────────────────────────────────────────┐
│ 切面1 @Before → 切面2 @Before → 目标方法 → 切面2 @After → 切面1 @After │
└─────────────────────────────────────────────────────────┘

@Service
public class UserService {
    
    // ❌ 场景1：同类内部调用——AOP不生效！
    public void register(String username) {
        // 这里调用的是 this.updateLastLoginTime()，不是代理对象
        updateLastLoginTime(username);  // @Transactional 不会生效！
    }
    
    @Transactional
    public void updateLastLoginTime(String username) {
        // 事务逻辑...
    }
    
    // ❌ 场景2：private/final 方法——无法被代理
    @Transactional
    private void doInternal() { }  // 不生效！
    
    // ✅ 解决方案：通过代理对象调用自身方法
    @Autowired
    private UserService self;  // 注入自身代理
    
    public void registerFixed(String username) {
        self.updateLastLoginTime(username);  // 走代理，AOP生效
    }
}