Appearance
3.1-5 AOP 原理:代理选择、切点、执行链、自调用
所属:03 主流框架 / 3.1 Spring 分级:A 状态:◐ 初稿 关联:3.1-1、3.1-2、3.1-4、3.1-6、3.1-7、3.1-10、3.1-11
题型:原理 / 流程 / 排障
一句话结论:Spring AOP 是运行时基于代理的 AOP:
AnnotationAwareAspectJAutoProxyCreator作为BeanPostProcessor,在 Bean 初始化后解析@Aspect的Advisor(Pointcut + Advice),用ProxyFactory按目标类选择 JDK 动态代理或 CGLIB,把匹配的拦截器织入ReflectiveMethodInvocation链。只有走代理的调用才生效,自调用、private/final/static、JDK 代理非接口方法都会失效;AspectJ 是编译期/加载期字节码织入,能力更强但接入方式不同。分层要点:
- 先定位 Spring AOP:它只支持 Spring Bean 的方法执行这一种 Join Point,底层是动态代理,不是字节码织入;
@Aspect只是借用了 AspectJ 的注解和切点表达式解析器,默认并没有 AspectJ Weaver。需要字段/构造器/静态方法织入时,才考虑 AspectJ + LTW/编译期织入。 - 代理创建时机:
AnnotationAwareAspectJAutoProxyCreator本身是 BPP,在 refresh 第 6 步注册;普通单例在第 11 步初始化时,postProcessAfterInitialization调wrapIfNecessary,找候选 Advisor、做切点匹配、生成代理。循环依赖时getEarlyBeanReference可能提前生成代理(3.1-4)。 - 代理选择:
DefaultAopProxyFactory判断proxyTargetClass、目标类是否接口、是否有用户接口。目标有接口且proxyTargetClass=false→ JDK;无接口或proxyTargetClass=true→ CGLIB;目标本身是接口 → JDK。Spring Boot 2.x/3.x 的 AOP 自动配置默认spring.aop.proxy-target-class=true,所以类通常走 CGLIB;Framework 的@EnableAspectJAutoProxy默认proxyTargetClass=false。 - 核心模型:
Pointcut描述“切哪里”,Advice描述“做什么”,Advisor= Pointcut + Advice;@Aspect类由AspectJAdvisorFactory解析成多个Advisor;ProxyFactory把Advisor转成MethodInterceptor链;ReflectiveMethodInvocation负责依次执行拦截器和目标方法。 - 执行链:
JdkDynamicAopProxy.invoke/CglibAopProxy.DynamicAdvisedInterceptor.intercept取出拦截器链,构造ReflectiveMethodInvocation,proceed()依次调用MethodInterceptor.invoke,最后反射/直接调用目标方法。@Around要执行目标就必须调proceed();也可以有意不调,直接短路返回。 - 通知顺序:同一
@Aspect内典型顺序是@Around前 →@Before→ 目标 →@AfterReturning/@AfterThrowing→@After(finally)→@Around后;跨切面用@Order/Ordered/@Priority,值越小优先级越高(越外层)。事务、缓存、异步都是Advisor,和自定义切面一起排序。 - 自调用失效:外部调用先到代理,代理再调目标;目标方法内部
this.other()是原始对象调用,不再经过代理,所以@Transactional/@Async/@Cacheable等基于代理的注解失效。解决方式是拆 Bean、自注入代理(@Lazy)、AopContext.currentProxy()(需exposeProxy=true)或改用TransactionTemplate等显式 API。 - 常见边界:JDK 代理只能转成接口类型,注入实现类会
BeanNotOfRequiredTypeException;CGLIB 不能代理 final 类/final 方法/private/static;@Transactional默认只对 public 方法生效(不同版本对 protected/包可见的支持有差异,按版本验证);@Aspect必须是 Spring Bean;pointcut 写错/过宽会导致不生效或启动变慢。
- 先定位 Spring AOP:它只支持 Spring Bean 的方法执行这一种 Join Point,底层是动态代理,不是字节码织入;
图/流程:
text
代理创建:
refresh 第 6 步注册 AnnotationAwareAspectJAutoProxyCreator(BPP)
→ 单例初始化
→ postProcessAfterInitialization
→ wrapIfNecessary
→ findCandidateAdvisors(解析 @Aspect)
→ findAdvisorsThatCanApply(Pointcut 匹配)
→ sortAdvisors(@Order)
→ createProxy
→ ProxyFactory
├─ JDK Dynamic Proxy
└─ CGLIBtext
调用链:
client
→ proxy.invoke / intercept
→ getInterceptorsAndDynamicInterceptionAdvice
→ ReflectiveMethodInvocation.proceed
→ interceptor1.invoke
→ interceptor2.invoke
→ target methodtext
自调用失效:
external caller
→ proxy
→ interceptor(事务/异步/缓存)
→ target.methodA()
→ this.methodB() ← 原始对象调用,绕过 proxy
→ methodB 上的注解不生效text
通知顺序(同一 aspect 的典型形态):
@Around before
@Before
target method
@AfterReturning / @AfterThrowing
@After(finally)
@Around aftertext
Spring AOP vs AspectJ:
Spring AOP:运行时代理,只拦截 Spring Bean 方法调用
AspectJ:编译期/加载期织入字节码,可拦截字段/构造器/静态/初始化版本/源码锚点:
- Spring Framework 5.3.x / 6.x:
AnnotationAwareAspectJAutoProxyCreator、AspectJAwareAdvisorAutoProxyCreator、AbstractAdvisorAutoProxyCreator、AbstractAutoProxyCreator、DefaultAopProxyFactory、JdkDynamicAopProxy、CglibAopProxy、ReflectiveMethodInvocation。 - 切面解析:
ReflectiveAspectJAdvisorFactory、BeanFactoryAspectJAdvisorsBuilder、AspectJExpressionPointcut、InstantiationModelAwarePointcutAdvisorImpl。 - Spring Boot:
AopAutoConfiguration,spring.aop.auto、spring.aop.proxy-target-class;Boot 2.x/3.x 默认proxy-target-class=true。 - 注解开关:
@EnableAspectJAutoProxy(proxyTargetClass = ..., exposeProxy = ...);@EnableTransactionManagement;@EnableAsync;@EnableCaching。 - AspectJ:1.9.x,
aspectjweaver;Spring AOP 默认只用其注解/切点表达式,不做字节码织入。 - Spring 6 / Boot 3:Jakarta 命名空间;AOP 代理模型不变。
- Spring Framework 5.3.x / 6.x:
核心概念:
| 概念 | 含义 | Spring AOP 中的对应 |
|---|---|---|
| Join Point | 可织入点 | 仅 Spring Bean 方法执行 |
| Pointcut | 匹配规则 | @Pointcut/execution 等 |
| Advice | 增强逻辑 | @Before/@After/@Around... |
| Advisor | Pointcut + Advice | DefaultPointcutAdvisor 等 |
| Aspect | 切面 | @Aspect Bean |
| Target | 被代理对象 | 原始 Bean |
| Proxy | 代理对象 | JDK/CGLIB 生成 |
| Weaving | 织入 | 运行时创建代理 |
- JDK 代理 vs CGLIB:
| 维度 | JDK 动态代理 | CGLIB |
|---|---|---|
| 机制 | Proxy.newProxyInstance + InvocationHandler | 生成目标类子类,方法拦截 |
| 前提 | 目标实现接口 | 目标类非 final、方法可覆盖 |
| 可代理方法 | 接口中的 public 方法 | public/protected/包可见(非 final/private/static) |
| 类型转换 | 只能转接口 | 可转实现类(CGLIB 代理) |
| 构造器 | 反射调用目标 | 子类代理;目标实例独立 |
| 性能 | 反射调用,现代 JDK 已很快 | 调用快,生成类有成本/metaspace |
| 典型问题 | 注入实现类失败、接口方法缺失 | final/private/static 失效、类膨胀 |
- 通知类型:
| 注解 | 执行时机 | 能否改变结果 | 注意 |
|---|---|---|---|
@Before | 目标前 | 不能 | 抛异常会阻止目标 |
@AfterReturning | 正常返回后 | 不能改返回值(除非 around) | 可绑定 returning |
@AfterThrowing | 抛异常后 | 不能吞异常(除非 around) | 可绑定 throwing |
@After | finally | 不能 | 成功/异常都执行 |
@Around | 包围目标 | 能 | 要执行目标就调 proceed();可有意短路/改返回值 |
- 切点表达式:
| 指示符 | 匹配对象 | 示例/注意 |
|---|---|---|
execution | 方法签名 | execution(* com.example.service..*.*(..)) |
within | 类/包 | within(com.example.service..*) |
this | 代理对象类型 | 与 target 不同 |
target | 目标对象类型 | 常用来匹配实现类 |
args | 运行时参数类型 | 可能需运行时匹配 |
@annotation | 方法注解 | @annotation(org.springframework.transaction.annotation.Transactional) |
@within | 类注解 | 匹配标注类中的方法 |
@target | 目标类注解 | 运行时匹配 |
@args | 参数类型注解 | 运行时匹配 |
bean | Spring Bean 名 | Spring 特有,非 AspectJ |
- Spring AOP vs AspectJ:
| 维度 | Spring AOP | AspectJ |
|---|---|---|
| 织入方式 | 运行时动态代理 | 编译期/加载期字节码织入 |
| Join Point | Spring Bean 方法执行 | 方法/构造器/字段/静态/初始化等 |
| 自调用 | 失效(绕过代理) | 生效(字节码已织入) |
| 性能 | 有代理/反射开销 | 接近原生,无代理 |
| 依赖 | Spring AOP | ajc/aspectjweaver/LTW |
| 适用 | 业务事务/日志/权限 | 深度监控/字段访问/框架级 |
- Boot 配置与代理选择:
| 配置/注解 | 默认 | 效果 |
|---|---|---|
spring.aop.auto | true | 自动配置 Spring AOP |
spring.aop.proxy-target-class | Boot 2.x/3.x true | 类默认 CGLIB;接口目标仍 JDK |
@EnableAspectJAutoProxy | proxyTargetClass=false | 有接口用 JDK |
@EnableAspectJAutoProxy(proxyTargetClass=true) | 显式 | 类用 CGLIB |
@EnableAspectJAutoProxy(exposeProxy=true) | 默认 false | 可用 AopContext.currentProxy() |
- 常见失效与定位:
| 现象 | 原因 | 处理 |
|---|---|---|
@Transactional 不生效 | 自调用/private/final/非 Spring Bean | 拆 Bean/改 public/去 final/交给容器 |
@Async 不生效 | 自调用/同类调用/代理未生成 | 拆 Bean/@Lazy 自注入 |
@Cacheable 不生效 | 自调用/代理类型不匹配 | 拆 Bean/接口注入 |
BeanNotOfRequiredTypeException | JDK 代理注入实现类 | 注入接口或 proxyTargetClass=true |
@Aspect 不生效 | 不是 Spring Bean/未开 AOP | @Component/@Bean/@EnableAspectJAutoProxy |
| 目标方法没执行 | @Around 没调 proceed() | 调 proceed() 或改通知类型 |
| 切点不匹配 | this/target/@annotation 写错 | 用 target/@within 或调试匹配 |
| 启动变慢 | pointcut 过宽/代理过多 | 缩小切点/排除基础设施 Bean |
AopContext.currentProxy() 报错 | 未开 exposeProxy | 开启或改自注入 |
| 事务没回滚 | 自定义切面吞异常/顺序问题 | 调整 @Order/不要吞异常 |
深挖点(面试官常追的 6 个):
- 代理是怎么创建出来的:
AnnotationAwareAspectJAutoProxyCreator在postProcessAfterInitialization调wrapIfNecessary;先通过BeanFactoryAspectJAdvisorsBuilder解析所有@AspectBean,生成Advisor列表;再用AopUtils.findAdvisorsThatCanApply做类/方法匹配;排序后ProxyFactory设置 target、interfaces、advisors,调用getProxy。JDK/CGLIB 的选择在DefaultAopProxyFactory,不是由@Aspect决定。 - JDK 和 CGLIB 怎么选:目标有接口且
proxyTargetClass=false用 JDK;无接口、proxyTargetClass=true、optimize=true用 CGLIB;目标本身是接口仍用 JDK。Boot 默认spring.aop.proxy-target-class=true,所以 Service 类通常是 CGLIB;但如果你注入的是接口,CGLIB 代理也能转接口。JDK 代理只能转接口,这是BeanNotOfRequiredTypeException的常见来源。 - 执行链怎么走:代理拿到方法后,
AdvisedSupport.getInterceptorsAndDynamicInterceptionAdvice把 Advisor 转成MethodInterceptor列表;ReflectiveMethodInvocation.proceed按索引执行拦截器,拦截器内部调用invocation.proceed()推进;最后invokeJoinpoint调目标方法。@Around就是MethodInterceptor,不调proceed()就直接返回,目标不会执行。 - 自调用为什么失效:代理对象持有目标对象;外部调用先到代理,代理执行拦截器后调用目标方法;目标方法里的
this.methodB()是目标对象自身调用,不经过代理,所以 methodB 上的切面/事务/异步都不生效。解决不是“加注解”,而是让调用经过代理:拆到另一个 Bean、自注入代理、AopContext.currentProxy()(exposeProxy=true)或显式 API。 - 切点匹配的细节:
execution匹配方法签名,within匹配类,@annotation匹配方法注解,@within匹配类注解;this匹配代理类型,target匹配目标类型,JDK 代理下两者可能不同。args/@args/this/target可能需要在运行时判断,性能高于纯静态匹配;pointcut 过宽会让所有 Bean 都被代理,启动变慢、metaspace 增大。 - 事务/异步/缓存和 AOP 的关系:它们都是 Advisor + 代理:
@Transactional由BeanFactoryTransactionAttributeSourceAdvisor+TransactionInterceptor实现;@Async由AsyncAnnotationBeanPostProcessor+AsyncAnnotationAdvisor实现;@Cacheable由BeanFactoryCacheOperationSourceAdvisor实现。它们和自定义切面按@Order排序;自定义@Around如果在内层吞掉异常,事务可能看不到异常而提交,顺序和异常传播必须一起考虑。
- 代理是怎么创建出来的:
追问链:
- 什么是 AOP? → 面向切面,把横切逻辑从业务代码中抽离。
- Spring AOP 和 AspectJ 区别? → 运行时代理 vs 编译/加载期织入。
- Spring AOP 基于什么? → 动态代理。
- 代理什么时候创建? → Bean 初始化后,BPP
postProcessAfterInitialization。 - 谁创建代理? →
AnnotationAwareAspectJAutoProxyCreator+ProxyFactory。 - JDK 和 CGLIB 怎么选? → 接口/
proxyTargetClass/无接口。 - Boot 默认用哪个? → 默认 CGLIB(
proxy-target-class=true)。 proxyTargetClass=true一定 CGLIB 吗? → 目标本身是接口时仍 JDK。- JDK 代理限制? → 只能代理接口方法,只能转接口。
- CGLIB 限制? → final 类/final 方法/private/static 不能代理。
- 为什么注入实现类会失败? → JDK 代理不是实现类子类。
- 自调用为什么失效? →
this绕过代理。 - 怎么解决自调用? → 拆 Bean/自注入/
AopContext/显式 API。 @Lazy自注入原理? → 注入自身代理,调用走代理。AopContext.currentProxy()前提? →exposeProxy=true,且线程绑定。@Aspect怎么变成 Advisor? →AspectJAdvisorFactory解析通知方法。- Advisor/Advice/Pointcut 关系? → Advisor = Pointcut + Advice。
@Around执行链? → 包住其他通知和目标,调proceed()。- 不调
proceed()会怎样? → 目标方法不执行。 - 通知顺序? → Around 前/Before/目标/AfterReturning/AfterThrowing/After/Around 后。
@Order规则? → 值越小优先级越高,越外层。- 多个切面顺序? → 按
@Order/Ordered/@Priority。 @AfterThrowing能吞异常吗? → 不能,除非@Around捕获。@AfterReturning能改返回值吗? → 不能,除非@Around。@After什么时候执行? → finally,成功/异常都执行。- pointcut 有哪些指示符? → execution/within/this/target/args/@annotation/@within/@target/@args/bean。
this和target区别? → 代理类型 vs 目标类型。@annotation和@within区别? → 方法注解 vs 类注解。bean()是 AspectJ 的吗? → 不是,Spring 特有。- pointcut 过宽有什么问题? → 代理过多、启动慢、metaspace 大。
- 事务 AOP 怎么实现? →
TransactionInterceptor+ Advisor。 @Transactional为什么失效? → 自调用/private/final/非 Bean/异常被吞。@Async为什么失效? → 自调用/代理未生效/返回类型。@Cacheable为什么失效? → 自调用/代理类型。- 事务和自定义切面顺序? →
@Order,注意异常传播/回滚。 @Transactional+@Async? → 异步线程不继承事务上下文,需拆分/编程式事务。- AOP 和循环依赖? → early proxy,见 3.1-4。
- early proxy 怎么保证一致? →
earlyProxyReferences。 - 怎么判断是不是代理? →
AopUtils.isAopProxy。 - 怎么判断 JDK/CGLIB? →
isJdkDynamicProxy/isCglibProxy。 - 怎么看代理的 Advisor? → 转
Advised调getAdvisors()。 - 怎么拿原始类? →
AopProxyUtils.ultimateTargetClass。 - 怎么调试 pointcut? → 日志/
AopUtils.canApply/断点。 - AOP 性能开销? → 代理/反射/拦截器链;CGLIB 生成/metaspace。
- CGLIB 为什么会 metaspace 膨胀? → 每个代理类生成字节码/类加载。
- Spring AOP 能拦截构造器吗? → 不能,AspectJ 可以。
- 能拦截字段访问吗? → Spring AOP 不能,AspectJ 可以。
- 能拦截 static 方法吗? → Spring AOP 不能,AspectJ 可以。
- 什么时候用 AspectJ? → 需要字段/构造器/静态织入或绕过代理限制。
- 面试怎么总结? → 代理创建 → JDK/CGLIB → Advisor/执行链 → 自调用失效 → 事务/异步组合。
生产案例/取舍(示例,替换成你的项目):
@Transactional在同类方法自调用,事务不生效;拆到独立 Bean 或TransactionTemplate。@Async自调用,任务同步执行;拆 Bean/@Lazy自注入。- private 方法加
@Transactional,完全不生效;改 public 或改用 AspectJ/编程式事务。 - final 类/方法用 CGLIB,代理失败或方法不拦截;去 final/改接口/JDK 代理。
- JDK 代理注入实现类,启动报
BeanNotOfRequiredTypeException;注入接口/开proxyTargetClass。 - 自定义
@Around在内层吞异常,事务提交了但业务失败;不要吞异常/调整@Order。 @Around忘记proceed(),接口直接返回 null;补proceed()。@Aspect没加@Component,切面不生效;注册为 Bean。- pointcut
execution(* com..*.*(..))过宽,启动慢/代理多;缩小到 service 包。 this(...)和target(...)写反,切点不匹配;用target匹配实现类。AopContext.currentProxy()未开exposeProxy,运行时异常;开启或改自注入。@Cacheable自调用,缓存不生效;拆 Bean。- 事务切面和自定义切面顺序错,异常被转换后不回滚;
@Order+ 异常传播。 @Async+@Transactional期待同一事务;异步线程无事务上下文,拆开。- 取舍:JDK 代理换接口解耦,代价是实现类注入受限;CGLIB 换类代理,代价是 final/构造/metaspace;Spring AOP 换低侵入,代价是自调用/方法级限制;AspectJ 换完整织入,代价是构建/agent/复杂度。
易错点:
- 认为 Spring AOP 是 AspectJ 编译期织入。
- 认为 Spring AOP 能拦截字段/构造器/静态方法。
- 认为 JDK 代理能代理类。
- 认为 CGLIB 能代理 final/private/static。
- 认为
proxyTargetClass=true一定用 CGLIB。 - 认为 Boot 默认用 JDK 代理。
- 认为自调用会走代理。
- 认为 private 方法
@Transactional生效。 - 认为 final 方法
@Transactional生效。 - 认为
@Around不调proceed()也会执行目标。 - 认为
@AfterThrowing能吞异常。 - 认为
@After只在成功时执行。 - 认为
@Order值越大越优先。 - 认为事务和自定义切面顺序无关。
- 认为 pointcut 的
this和target一样。 - 认为
@annotation和@within一样。 - 认为
@Aspect不需要注册为 Bean。 - 认为不用开 AOP 自动配置也能生效。
- 认为 JDK 代理能 cast 成实现类。
- 认为代理对象
getClass()是目标类。 - 认为
AopContext.currentProxy()随时可用。 - 认为
@Transactional+@Async一定按预期组合。 - 认为 Spring AOP 能拦截同类私有调用。
- 认为
@Around返回值可以随意。 - 认为
@AfterReturning能修改返回值。 - 认为 pointcut 越宽越好。
- 认为代理没有性能成本。
- 认为 Spring 的
@Aspect和 AspectJ 完全不兼容(注解兼容,织入方式不同)。
30 秒口述稿:
Spring AOP 是运行时代理:
AnnotationAwareAspectJAutoProxyCreator在 Bean 初始化后解析@Aspect成 Advisor,做 pointcut 匹配,再用 ProxyFactory 生成 JDK 或 CGLIB 代理。有接口且proxyTargetClass=false用 JDK,否则 CGLIB;Boot 默认 CGLIB。调用走代理,拦截器链由ReflectiveMethodInvocation执行;@Around要执行目标就调proceed(),也可以有意短路。自调用、private/final/static、JDK 代理非接口方法都会失效;解决靠拆 Bean、自注入、AopContext或显式 API。AspectJ 是编译/加载期织入,能解决自调用和字段/构造器拦截。
- 3 分钟展开顺序:结论(运行时代理)→ 代理创建流程 → JDK/CGLIB 选择与限制 → Advisor/Pointcut/Advice → 执行链与通知顺序 → 自调用失效与解决 → 事务/异步/缓存组合 → Spring AOP vs AspectJ → 生产坑与取舍。