面向切面编程：把 30 个接口的横切逻辑收进一个类

调用方 ──调用──> 代理对象（CGLIB 子类）
                   │ 按切点匹配：不匹配 → 直接透传给目标
                   │ 匹配 → 依次执行通知链
                   ▼
              目标方法（你的业务代码）

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

@Service
public class OrderService {

    public String create(String sku) {
        return "订单已创建：" + sku;
    }

    public String pay(String orderId) {
        throw new IllegalStateException("支付渠道超时");
    }
}

@Around 前半 → @Before → 目标方法 → @Around 后半 → @After → @AfterReturning（或 @AfterThrowing）

@Aspect
@Component
public class AllAdviceAspect {

    private static final String PC = "execution(* com.example.aop.OrderService.*(..))";

    @Around(PC)
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("1 @Around 前半");
        try {
            Object result = pjp.proceed();               // 放行到目标方法
            System.out.println("4 @Around 后半");
            return result;
        } catch (Throwable t) {
            System.out.println("4 @Around 后半（异常路径）");
            throw t;
        }
    }

    @Before(PC)
    public void before() {
        System.out.println("2 @Before");
    }

    @After(PC)
    public void after() {
        System.out.println("5 @After");
    }

    @AfterReturning(PC)
    public void afterReturning() {
        System.out.println("6 @AfterReturning");
    }

    @AfterThrowing(PC)
    public void afterThrowing() {
        System.out.println("6 @AfterThrowing");
    }
}

1 @Around 前半
2 @Before
（目标方法执行）
4 @Around 后半
5 @After
6 @AfterReturning

1 @Around 前半
2 @Before
（目标方法抛出异常）
4 @Around 后半（异常路径）
5 @After
6 @AfterThrowing

execution(* com.example.aop.OrderService.*( .. ))
          │  │                    │   │
          │  │                    │   └─ 参数：.. 表示任意个任意类型
          │  │                    └─ 方法名：* 匹配所有方法，find* 匹配 find 开头
          │  └─ 全限定类名：包内 .. 表示本包及子包，* 表示任意类
          └─ 返回类型：* 任意，String 精确匹配

execution(* com.example.service..*.*(..))              // service 包及子包所有类所有方法
execution(* com.example.service.*.find*(String))       // find 开头且首参为 String
execution(public * com.example..*.*(..))               // 显式限定 public，一般省略

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)          // 必须保留到运行期，反射才读得到
public @interface Monitor {

    String value() default "";
}

@Around("@annotation(monitor)")              // 通知方法的注解形参名与占位符对上，完成绑定
public Object around(ProceedingJoinPoint pjp, Monitor monitor) throws Throwable {
    // monitor.value() 能直接读到注解上的配置
    return pjp.proceed();
}

@Aspect
@Component
public class ApiTimingAspect {

    private static final Logger log = LoggerFactory.getLogger(ApiTimingAspect.class);
    private static final long SLOW_MS = 500;

    @Around("execution(* com.example.aop.controller..*(..))")
    public Object time(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.nanoTime();                  // nanoTime 单调，不受系统对时影响
        try {
            return pjp.proceed();
        } finally {
            long costMs = (System.nanoTime() - start) / 1_000_000;
            String sig = pjp.getSignature().toShortString();
            if (costMs >= SLOW_MS) {
                log.warn("慢接口 {} 耗时 {} ms", sig, costMs);
            } else {
                log.info("{} 耗时 {} ms", sig, costMs);
            }
        }
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {

    int limit();                       // 窗口内最大次数

    long windowMs() default 1000;      // 窗口长度
}

@Aspect
@Component
public class RateLimitAspect {

    private final ConcurrentHashMap<String, long[]> windows = new ConcurrentHashMap<>();
    // long[0] 窗口起点毫秒，long[1] 计数

    @Around("@annotation(rateLimit)")
    public Object limit(ProceedingJoinPoint pjp, RateLimit rateLimit) throws Throwable {
        String key = pjp.getSignature().toShortString();
        long[] window = windows.computeIfAbsent(key, k -> new long[]{System.currentTimeMillis(), 0});
        long now = System.currentTimeMillis();
        synchronized (window) {
            if (now - window[0] >= rateLimit.windowMs()) {
                window[0] = now;                       // 旧窗口过期，开新窗口
                window[1] = 0;
            }
            if (++window[1] > rateLimit.limit()) {
                throw new IllegalStateException("请求过于频繁，请稍后再试");
            }
        }
        return pjp.proceed();
    }
}

@PostMapping("/api/sms/send")
@RateLimit(limit = 5, windowMs = 60_000)
public String send(@RequestParam String phone) {
    return "已发送";
}

@Aspect
@Component
public class ErrorAuditAspect {

    @AfterThrowing(pointcut = "execution(* com.example.aop.service..*(..))", throwing = "ex")
    public void audit(JoinPoint jp, Throwable ex) {
        // 真实项目里这里是推送到监控平台、写异常表
        System.out.println("异常打点：" + jp.getSignature().toShortString()
                + " -> " + ex.getClass().getSimpleName());
    }
}