Spring AOP 核心概念与实战解析

关键点说明：

• @Aspect：标识这是一个切面类。
• @Component：交给 Spring 容器管理，支持自动扫描注入。
• @Around：指明通知生效的范围，这是最强大的通知类型。
• ProceedingJoinPoint：代表被代理的目标对象，调用 proceed() 才能继续执行原方法。

Spring AOP 的核心术语

理解这些术语是掌握 AOP 的关键：

1. Aspect（切面）：横切关注点的模块化。它是一个类，包含了需要织入到业务代码中的各种通知（Advice），如切点、连接点等。
2. Join Point（连接点）：程序执行过程中可以插入切面的点。在 Spring AOP 中，连接点总是代表执行的方法。
3. Pointcut（切点）：一个表达式，用于定义在哪些连接点上应用通知。它回答了'在哪里'执行切面代码的问题。例如匹配 com.example.service 包下以 delete 开头的方法。
4. Advice（通知）：切面在特定连接点上执行的动作。指具体要做的操作，回答了'什么时候'和'做什么'的问题。
   • @Before：目标方法执行之前。
   • @After：目标方法执行之后（无论是否成功）。
   • @AfterReturning：目标方法成功执行并返回结果后。
   • @AfterThrowing：目标方法抛出异常后。
   • @Around：包围连接点，可控制是否继续执行、修改返回值或抛出异常。

通知类型注解实战

为了验证不同通知的执行时机，我们准备两个测试 Controller 方法：一个正常返回，一个抛出异常。

package com.example.springaopdemo.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/t1")
    public String t1() {
        log.info("执行 t1");
        return "t1";
    }

    @RequestMapping("/t2")
    public boolean t2() {
        log.info("执行 t2");
        throw new RuntimeException("模拟异常");
    }
}

对应的切面代码如下：

package com.example.springaopdemo.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TestAspect {

    // 抽取公共切点
    @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))")
    public void pt() {}

    @Before("pt()")
    public void doBefore() {
        log.info("前置通知：doBefore");
    }

    @After("pt()")
    public void doAfter() {
        log.info("后置通知：doAfter");
    }

    @AfterReturning("pt()")
    public void doAfterReturning() {
        log.info("返回后通知：doAfterReturning");
    }

    @AfterThrowing("pt()")
    public void doAfterThrowing() {
        log.info("异常后通知：doAfterThrowing");
    }

    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        log.info("环绕通知：开始");
        try {
            Object result = joinPoint.proceed();
            log.info("环绕通知：结束");
            return result;
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }
}

执行结果观察：

• 访问 /t1 接口时，日志会依次显示 Before -> Around Start -> Around End -> AfterReturning -> After。
• 访问 /t2 接口发生异常时，流程变为 Before -> Around Start -> Around End -> AfterThrowing -> After。注意 @AfterReturning 不会触发。

@PointCut 与 @Order

复用切点表达式

如果多个通知需要匹配相同的规则，直接复制表达式不仅冗余且难以维护。使用 @Pointcut 定义公共切点方法即可解决。

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}

// 在其他通知中引用
@Before("serviceLayer()")
public void beforeService() { /* ... */ }

控制切面优先级

当存在多个切面作用于同一连接点时，可以使用 @Order 设置优先级。数字越小，优先级越高。

@Component
@Aspect
@Slf4j
@Order(1)
public class TestAspect3 {
    // ... 逻辑
}

默认情况下，若未指定 @Order，Spring 可能按照 Bean 名称排序，显式配置能确保业务逻辑符合预期。

自定义注解切点

除了基于方法签名的 execution 表达式，还可以使用 @annotation 切点。这适用于没有规律可循，但标记了特定注解的方法。

1. 定义自定义注解：

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

2. 在切面中使用：

@Around("@annotation(com.example.springaopdemo.aspect.TimeRecord)")
public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long end = System.currentTimeMillis();
    log.info("{} 耗时{}ms", joinPoint.getSignature(), (end - start));
    return result;
}

只需在目标方法上添加 @TimeRecord 注解，即可自动启用计时功能。

代理模式原理

Spring AOP 的本质是动态代理。它在不修改原始对象代码的前提下，通过代理对象增强或控制对目标对象的访问。

主要分为两种实现方式：

1. JDK 动态代理：要求目标类必须实现至少一个接口。代理对象会实现与目标类相同的接口。
2. CGLIB 字节码增强：当目标类没有实现接口时，Spring 会使用 CGLIB。它通过生成目标类的子类来创建代理，因此无法代理 final 类或方法。

底层原理与配置

Spring AOP 通过 ProxyFactory 创建代理对象，并将通知封装成拦截器链。工作流程如下：

1. 容器启动时扫描 @Aspect 注解的类。
2. 根据切点表达式找到匹配的 Bean（目标对象）。
3. 创建代理对象（JDK/CGLIB），封装拦截器链。
4. 调用代理方法时，触发拦截器链，按顺序执行通知逻辑。

关于代理类型的选择，可以通过配置项 spring.aop.proxy-target-class 控制：

• Spring Boot 默认为 true（优先使用 CGLIB）。
• 原生 Spring 默认为 false（优先使用 JDK 动态代理）。

在 application.properties 中可手动调整：

spring.aop.proxy-target-class=true

这一配置决定了 Spring 在遇到无接口类时是否强制使用 CGLIB 进行代理。