Spring AOP 源码深挖

2026-11-01

AOP 是 Spring 两大核心之一,源码重点:代理如何创建、拦截器链如何执行、通知的执行顺序、JDK vs CGLIB 的选择。


一、AOP 核心概念

考察点:五大概念 + 能举例。

概念说明
切面 Aspect横切逻辑的模块(如日志切面)
切点 Pointcut匹配哪些方法(表达式)
通知 Advice切面在切点执行的动作(Before/After/Around)
连接点 JoinPoint程序执行的某个点(方法调用)
织入 Weaving把切面应用到目标对象的过程
@Aspect
@Component
public class LogAspect {
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void pointcut() {}

    @Before("pointcut()")
    public void before(JoinPoint jp) { /* 前置通知 */ }
}

二、AOP 的实现原理:动态代理

考察点:AOP 底层就是动态代理。

  • JDK 动态代理:基于接口,Proxy + InvocationHandler,目标类必须实现接口。
  • CGLIB:基于继承,生成目标类的子类,无需接口,但不能代理 final 类/方法。
graph LR
    A[目标对象 Target] --> B{有接口?}
    B -->|是| C[JDK 动态代理<br/>Proxy + InvocationHandler]
    B -->|否| D[CGLIB<br/>生成子类]
    style C fill:#fff3cd
    style D fill:#e6f7e6

三、@EnableAspectJAutoProxy 如何开启 AOP

考察点:从注解到注册 BeanPostProcessor。

@EnableAspectJAutoProxy   // 开启 AOP
public class AppConfig {}
  • 该注解 @Import(AspectJAutoProxyRegistrar.class)。
  • Registrar 注册 AnnotationAwareAspectJAutoProxyCreator。
  • 它是一个 BeanPostProcessor(继承 AbstractAutoProxyCreator),负责在 Bean 初始化后创建代理。

四、AOP 代理创建的时机

考察点:AOP 在 Bean 生命周期哪个阶段介入。

AOP 代理在 Bean 生命周期的 postProcessAfterInitialization 阶段创建:

// AbstractAutoProxyCreator(BeanPostProcessor 实现)
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            return wrapIfNecessary(bean, beanName, cacheKey); // 创建代理
        }
    }
    return bean;
}
graph LR
    A["实例化"] --> B["属性填充"] --> C["初始化"]
    C --> D["postProcessAfterInitialization<br/>wrapIfNecessary 创建代理"]
    D --> E["代理对象放入容器"]
    style D fill:#fff3cd

五、代理创建的完整流程

考察点:wrapIfNecessary 内部三步。

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // ① 找匹配的 Advisor(切面)
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        // ② 创建代理
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        return proxy;
    }
    return bean; // 无匹配切面,返回原对象
}
graph TD
    A["wrapIfNecessary"] --> B["① getAdvicesAndAdvisorsForBean<br/>找匹配的切面"]
    B --> C{有匹配切面?}
    C -->|否| D["返回原对象(不代理)"]
    C -->|是| E["② createProxy 创建代理"]
    E --> F["③ getProxy 生成代理对象"]
    style E fill:#e6f7e6

六、JDK vs CGLIB 的选择逻辑

考察点:DefaultAopProxyFactory 的判断。

public AopProxy createAopProxy(AdvisedSupport config) {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        // 配置了 proxyTargetClass=true 或没有接口 → CGLIB
        return new ObjenesisCglibAopProxy(config);
    }
    // 有接口 → JDK 动态代理
    return new JdkDynamicAopProxy(config);
}

选择规则:

  1. 目标类实现了接口且未强制 CGLIB → JDK 动态代理。
  2. 目标类无接口 → CGLIB。
  3. SpringBoot 2.x 默认 proxyTargetClass=true → 优先 CGLIB。

七、代理对象调用方法的拦截链

考察点:方法调用时如何执行通知链,核心难点。

代理对象的方法被调用时,进入拦截器链逐个执行:

// JdkDynamicAopProxy.invoke 核心
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
    return invokeJoinpointUsingReflection(target, method, args); // 无拦截直接调
}
// 构造 MethodInvocation,递归执行拦截链
MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
return invocation.proceed();

ReflectiveMethodInvocation.proceed() 是递归核心:

public Object proceed() {
    // 拦截器执行完,调用目标方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint(); // 真正调用目标方法
    }
    // 逐个执行拦截器(递归)
    Object interceptor = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    return ((MethodInterceptor) interceptor).invoke(this);
}
graph LR
    A["调用代理方法"] --> B["拦截器1(Around前/Before)"]
    B --> C["拦截器2(After等)"]
    C --> D["目标方法 invokeJoinpoint"]
    D --> E["拦截器2 后置"]
    E --> F["拦截器1 后置(Around后)"]
    F --> G["返回结果"]
    style D fill:#e6f7e6

八、通知的执行顺序

考察点:五类通知的调用顺序,常考。

graph TD
    A["@Around 进入"] --> B["@Before"]
    B --> C["目标方法执行"]
    C --> D{"是否异常?"}
    D -->|正常| E["@AfterReturning"]
    D -->|异常| F["@AfterThrowing"]
    E --> G["@After"]
    F --> G
    G --> H["@Around 退出"]
    style C fill:#e6f7e6

执行顺序:@Around(前) → @Before → 目标方法 → @AfterReturning/@AfterThrowing → @After → @Around(后)。

  • 正常:Around 前 → Before → 方法 → AfterReturning → After → Around 后。
  • 异常:Around 前 → Before → 方法 → AfterThrowing → After → Around 后。

九、通知是如何包装成拦截器的

考察点:Advice → MethodInterceptor 的适配。

五类通知最终都被包装成 MethodInterceptor:

通知拦截器类
@BeforeMethodBeforeAdviceInterceptor
@AfterAspectJAfterAdvice
@AfterReturningAfterReturningAdviceInterceptor
@AfterThrowingAspectJAfterThrowingAdvice
@AroundAspectJAroundAdvice
  • 通过 DefaultAdvisorAdapterRegistry 把 Advice 适配成拦截器。
  • 所有拦截器按固定顺序排进 chain,由 proceed() 递归执行。

十、Spring AOP vs AspectJ

考察点:两者的区别。

对比Spring AOPAspectJ
织入方式运行期(代理)编译期/类加载期
增强范围只能增强方法方法、字段、构造器
性能略低(反射)高(编译期织入)
依赖无需特殊编译器需 AspectJ 编译器
  • Spring AOP 基于动态代理,实现简单,是主流。
  • AspectJ 功能全,但需要额外工具,Spring 底层用 @AspectJ 注解风格借用了 AspectJ 的切点表达式。

十一、面试话术总结

面试官问「讲讲 Spring AOP」,按这个层次答:

  1. 概念:AOP 面向切面编程,把横切逻辑(日志、事务、鉴权)与业务分离。

  2. 底层:基于动态代理——有接口用 JDK 动态代理,无接口用 CGLIB;SpringBoot 2.x 默认 CGLIB。

  3. 开启:@EnableAspectJAutoProxy 注册 AnnotationAwareAspectJAutoProxyCreator(一个 BeanPostProcessor)。

  4. 代理创建:Bean 生命周期 postProcessAfterInitialization 阶段调用 wrapIfNecessary,找匹配切面 → createProxy 生成代理。

  5. 调用链:方法调用进入 ReflectiveMethodInvocation.proceed(),递归执行拦截器链,最终调用目标方法。

  6. 执行顺序:@Around → @Before → 方法 → @AfterReturning/@AfterThrowing → @After。