Spring AOP 入门

这一课你将能做到

1. 给全部 Service 方法加上耗时统计切面，业务代码零改动
2. 写对 execution 切点表达式，并用自定义注解 + @annotation 精确控制拦截范围
3. 复现并解释「内部调用导致切面/事务失效」的 self-invocation 问题

为什么要学

你需要在每个 Service 方法上打印「方法名 + 参数 + 耗时」。手写的话：几十个类、几百个方法，全是复制粘贴，改一次日志格式要全局替换。这类横切多个模块的通用逻辑（日志、计时、权限、事务、限流），就是 AOP（面向切面编程）的主场。

人话：AOP 把「通用动作」写成一份切面，容器在运行时用代理自动把它「包」在目标方法外面。你写 taskService.create(...)，实际执行的是代理的 create(...)，它先做日志、再调用你的真方法、再收尾。事务注解 @Transactional 的底层正是 AOP——学懂这课，后面第 11 课的「事务失效」你一眼就能看穿。

先建立图像

代理的执行模型（@Around 通知最直观）：

调用方 taskService.create(task)
        ↓ 实际进入的是代理对象
┌─────────────── 代理 ───────────────┐
│ 前置动作（记录开始时间、日志）        │
│     ↓ proceed() 放行                │
│   你的真实 TaskService.create(...)   │
│     ↓ 真方法返回/抛异常              │
│ 后置动作（计算耗时、异常日志）        │
└────────────────────────────────────┘

核心术语人话对照：

术语	人话
切面 @Aspect	装着「通用动作」的类
连接点 JoinPoint	每一个可被拦截的方法调用点
切点 Pointcut	用表达式圈出「拦哪些方法」
通知 Advice	拦到之后干什么：@Before / @After / @Around 等
织入 Weaving	把切面套到目标上的过程（Spring 用运行时代理实现）

跟着做

步骤 1：引入 AOP starter

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

Spring Boot 检测到该依赖即自动开启 AOP（spring.aop.auto=true 是默认值，无需手动 @EnableAspectJAutoProxy）。

步骤 2：第一个切面——Service 全量耗时日志

先补一个真实的业务方法（配合前面课程的 TaskService）：

package com.example.taskflow.service;

import org.springframework.stereotype.Service;

import java.util.UUID;

@Service
public class ReportService {

    public String generate(String type) throws InterruptedException {
        Thread.sleep(150);                      // 模拟耗时
        return "报表[" + type + "]-" + UUID.randomUUID().toString().substring(0, 8);
    }
}

写切面：

package com.example.taskflow.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Aspect           // 我是切面
@Component        // 切面本身也要交给容器
public class PerfLogAspect {

    private static final Logger log = LoggerFactory.getLogger(PerfLogAspect.class);

    // 拦截 service 包（含子包）下所有类的所有方法
    @Around("execution(* com.example.taskflow.service..*.*(..))")
    public Object timeLog(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        String target = pjp.getSignature().toShortString();      // 如 ReportService.generate(..)
        try {
            Object result = pjp.proceed();                        // 放行：执行真实方法
            long cost = System.currentTimeMillis() - start;
            log.info("[性能] {} 参数={} 耗时={}ms", target, Arrays.toString(pjp.getArgs()), cost);
            return result;
        } catch (Throwable e) {
            long cost = System.currentTimeMillis() - start;
            log.error("[性能] {} 执行异常 耗时={}ms 异常={}", target, cost, e.getMessage());
            throw e;                                              // 异常必须继续抛出，不能吞
        }
    }
}