Spring AOP 源码深挖
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);
}选择规则:
- 目标类实现了接口且未强制 CGLIB → JDK 动态代理。
- 目标类无接口 → CGLIB。
- 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:
| 通知 | 拦截器类 |
|---|---|
| @Before | MethodBeforeAdviceInterceptor |
| @After | AspectJAfterAdvice |
| @AfterReturning | AfterReturningAdviceInterceptor |
| @AfterThrowing | AspectJAfterThrowingAdvice |
| @Around | AspectJAroundAdvice |
- 通过
DefaultAdvisorAdapterRegistry把 Advice 适配成拦截器。 - 所有拦截器按固定顺序排进 chain,由
proceed()递归执行。
十、Spring AOP vs AspectJ
考察点:两者的区别。
| 对比 | Spring AOP | AspectJ |
|---|---|---|
| 织入方式 | 运行期(代理) | 编译期/类加载期 |
| 增强范围 | 只能增强方法 | 方法、字段、构造器 |
| 性能 | 略低(反射) | 高(编译期织入) |
| 依赖 | 无需特殊编译器 | 需 AspectJ 编译器 |
- Spring AOP 基于动态代理,实现简单,是主流。
- AspectJ 功能全,但需要额外工具,Spring 底层用
@AspectJ注解风格借用了 AspectJ 的切点表达式。
十一、面试话术总结
面试官问「讲讲 Spring AOP」,按这个层次答:
概念:AOP 面向切面编程,把横切逻辑(日志、事务、鉴权)与业务分离。
底层:基于动态代理——有接口用 JDK 动态代理,无接口用 CGLIB;SpringBoot 2.x 默认 CGLIB。
开启:
@EnableAspectJAutoProxy注册AnnotationAwareAspectJAutoProxyCreator(一个 BeanPostProcessor)。代理创建:Bean 生命周期
postProcessAfterInitialization阶段调用wrapIfNecessary,找匹配切面 →createProxy生成代理。调用链:方法调用进入
ReflectiveMethodInvocation.proceed(),递归执行拦截器链,最终调用目标方法。执行顺序:
@Around → @Before → 方法 → @AfterReturning/@AfterThrowing → @After。