Spring AOP：动态代理、通知链与 AspectJ

本文从 Kiczales 1997 年提出 AOP 范式出发，阐明"横切关注点"问题的本质，逐层深入 Spring AOP 的代理机制、Advice 执行链路源码，并厘清 Spring AOP 与 AspectJ 的边界。

目录

理论基础

横切关注点问题

1997 年，Gregor Kiczales 等人在施乐 PARC 研究中心提出 AOP（发表于 ECOOP '97），动机是解决 OOP 的一个固有局限：横切关注点（crosscutting concerns）无法被 OOP 干净地模块化。

典型的横切关注点：

日志记录    安全鉴权    事务管理    缓存    监控/埋点    异常处理

用 OOP 实现时，这些关注点会导致两种问题：

AOP 的解法：将横切关注点抽取为独立的切面（Aspect），通过织入（Weaving） 机制在不修改业务代码的前提下将其应用到目标位置。

"AOP complements OOP by providing another way of thinking about program structure." — Spring Framework 官方文档

核心术语

织入时机的三种选择

编译时织入（Compile-time weaving）
  → AspectJ 编译器（ajc）在编译阶段修改字节码
  → 性能最好，但需特殊编译流程

加载时织入（Load-time weaving, LTW）
  → JVM 加载类时通过 Java Agent 修改字节码
  → AspectJ 支持（-javaagent:aspectjweaver.jar）

运行时织入（Runtime weaving）
  → 通过动态代理在运行时创建增强对象 ← Spring AOP 采用此方式
  → 无需修改字节码，纯 Java 实现，灵活但有局限

Spring AOP vs AspectJ

Spring 的选择：Spring AOP 使用 AspectJ 的注解语法（@Aspect、@Pointcut、@Before 等），但底层是自己的动态代理实现，而非 AspectJ 织入器。两者共用语法，实现独立。

实现原理

JDK 动态代理

// JdkDynamicAopProxy 实现 InvocationHandler
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 获取该方法对应的拦截器链
    List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
    if (chain.isEmpty()) {
        // 无拦截器，直接调用目标方法
        return AopUtils.invokeJoinpointUsingReflection(target, method, args);
    }
    // 有拦截器，构建责任链
    MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
    return invocation.proceed();
}

条件：目标类实现了至少一个接口。代理类实现相同接口，Proxy.newProxyInstance() 生成。

CGLIB 代理

CGLIB 通过 ASM 操作字节码，生成目标类的子类，覆盖父类方法并在其中嵌入拦截逻辑。

限制：

• 目标类不能是 final（无法继承）
• 目标方法不能是 final / private（无法覆盖）
• 构造器会被调用两次（生成子类 + 实例化）

选择策略

// DefaultAopProxyFactory#createAopProxy
public AopProxy createAopProxy(AdvisedSupport config) {
    if (config.isOptimize() || config.isProxyTargetClass()
            || hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config); // 目标本身是接口/代理类 → JDK
        }
        return new ObjenesisCglibAopProxy(config); // 否则 → CGLIB
    }
    return new JdkDynamicAopProxy(config); // 有接口且不强制 CGLIB → JDK
}

Spring Boot 2.x 起默认 spring.aop.proxy-target-class=true，强制 CGLIB。

源码链路

代理创建：BeanPostProcessor 阶段

Bean 初始化完成
  → AbstractAutoProxyCreator#postProcessAfterInitialization()
  → wrapIfNecessary(bean, beanName, cacheKey)
  → getAdvicesAndAdvisorsForBean()   // 找所有匹配该 Bean 的 Advisor
  → createProxy(beanClass, beanName, advisors, targetSource)
  → ProxyFactory#getProxy(classLoader)
  → DefaultAopProxyFactory#createAopProxy()  // 决定 JDK / CGLIB
  → 返回代理对象，替换容器中的原始 Bean

Advisor 匹配过程

// AbstractAdvisorAutoProxyCreator#findEligibleAdvisors（精简）
// 1. 从容器获取所有 Advisor Bean
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 2. 过滤出能匹配当前 Bean 的 Advisor
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
// 3. 排序（@Order / PriorityOrdered）
sortAdvisors(eligibleAdvisors);

Advice 执行：责任链模式

代理方法调用
  → ReflectiveMethodInvocation#proceed()
  → 遍历 interceptorList（MethodInterceptor 列表）
     ├── ExposeInvocationInterceptor（暴露 invocation 到 ThreadLocal）
     ├── AspectJAroundAdvice（Around → 调用 proceed() 推进链）
     ├── MethodBeforeAdviceInterceptor（Before）
     ├── AspectJAfterAdvice（After，finally 块执行）
     ├── AfterReturningAdviceInterceptor（AfterReturning）
     └── AspectJAfterThrowingAdvice（AfterThrowing）
  → 所有 interceptor 走完后调用目标方法

责任链用递归索引推进（currentInterceptorIndex++），Around 通知通过调用 joinPoint.proceed() 驱动链条继续。

通知类型与执行顺序

5 种通知

@Around 最强大，可以修改参数、返回值，吞掉或替换异常。@Before / @After 只能"观察"，无法改变结果。

单切面内执行顺序（Spring 5.2.7+ 修正版）

正常执行：
  @Around（前半）→ @Before → 目标方法 → @Around（后半）→ @AfterReturning → @After

异常执行：
  @Around（前半）→ @Before → 目标方法（抛异常）→ @AfterThrowing → @After

⚠️ Spring 5.2.7 之前，同一切面内 @AfterReturning 和 @After 的顺序与上述相反（@After 先于 @AfterReturning），5.2.7 修正为更符合直觉的顺序。

多切面执行顺序

多个切面作用于同一方法时，按 @Order 值排序，值越小优先级越高：

@Order(1) 切面 Around 前
  @Order(2) 切面 Around 前
    目标方法
  @Order(2) 切面 Around 后 / AfterReturning / After
@Order(1) 切面 Around 后 / AfterReturning / After

外层切面先进后出（类似 Filter 链）。不指定 @Order 时顺序不确定，多切面务必显式指定。

切入点表达式

execution（最常用）

execution([访问修饰符] 返回类型 [类路径.]方法名(参数类型) [throws 异常])

// 示例
execution(* com.example.service.*.*(..))          // service 包下所有方法
execution(public * com.example..*.save*(..))       // 所有 save 开头的 public 方法
execution(* *(..) throws IOException)              // 声明抛出 IOException 的方法

通配符：

• * 匹配任意单个元素（单个包名、方法名、类型）
• .. 匹配任意多个（多级包路径、任意参数列表）

其他常用表达式

切入点复合

@Aspect
@Component
public class LogAspect {

    // 定义可复用的切入点
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    @Pointcut("@annotation(com.example.annotation.Log)")
    public void logAnnotated() {}

    // 复合：service 层 且 有 @Log 注解
    @Around("serviceLayer() && logAnnotated()")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        // ...
        return pjp.proceed();
    }
}

常见坑

坑 1 详解：自调用失效

@Service
public class OrderService {

    // ❌ this.audit() 直接调用，绕过代理，@Log 切面不触发
    public void placeOrder() {
        this.audit("place");
    }

    @Log
    public void audit(String action) { ... }
}

// ✅ 注入自身
@Service
public class OrderService {

    @Autowired
    private OrderService self;

    public void placeOrder() {
        self.audit("place"); // 通过代理调用，切面生效
    }

    @Log
    public void audit(String action) { ... }
}

坑 5 详解：@Around 必须 proceed

// ❌ 忘记 proceed，目标方法永远不会执行
@Around("execution(* com.example.service.*.*(..))")
public Object around(ProceedingJoinPoint pjp) {
    log.info("before");
    // 漏了 pjp.proceed()！
    return null;
}

// ✅ 正确写法
@Around("execution(* com.example.service.*.*(..))")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    log.info("before: {}", pjp.getSignature());
    Object result = pjp.proceed(); // 推进责任链/执行目标方法
    log.info("after: {}", result);
    return result; // 必须返回，否则调用方拿到 null
}

参考资料

• Spring Framework Reference — Aspect Oriented Programming with Spring
• The AspectJ™ Programming Guide
• Gregor Kiczales et al., "Aspect-Oriented Programming", ECOOP 1997
• Spring IoC 与 Bean 生命周期（BeanPostProcessor 是代理创建的触发点）
• Spring 事务管理（事务是 AOP 最典型的应用）