Skip to content

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 是编译期/加载期字节码织入,能力更强但接入方式不同。

  • 分层要点:

    1. 先定位 Spring AOP:它只支持 Spring Bean 的方法执行这一种 Join Point,底层是动态代理,不是字节码织入;@Aspect 只是借用了 AspectJ 的注解和切点表达式解析器,默认并没有 AspectJ Weaver。需要字段/构造器/静态方法织入时,才考虑 AspectJ + LTW/编译期织入。
    2. 代理创建时机:AnnotationAwareAspectJAutoProxyCreator 本身是 BPP,在 refresh 第 6 步注册;普通单例在第 11 步初始化时,postProcessAfterInitialization 调 wrapIfNecessary,找候选 Advisor、做切点匹配、生成代理。循环依赖时 getEarlyBeanReference 可能提前生成代理(3.1-4)。
    3. 代理选择: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。
    4. 核心模型:Pointcut 描述“切哪里”,Advice 描述“做什么”,Advisor = Pointcut + Advice;@Aspect 类由 AspectJAdvisorFactory 解析成多个 Advisor;ProxyFactory 把 Advisor 转成 MethodInterceptor 链;ReflectiveMethodInvocation 负责依次执行拦截器和目标方法。
    5. 执行链:JdkDynamicAopProxy.invoke / CglibAopProxy.DynamicAdvisedInterceptor.intercept 取出拦截器链,构造 ReflectiveMethodInvocation,proceed() 依次调用 MethodInterceptor.invoke,最后反射/直接调用目标方法。@Around 要执行目标就必须调 proceed();也可以有意不调,直接短路返回。
    6. 通知顺序:同一 @Aspect 内典型顺序是 @Around 前 → @Before → 目标 → @AfterReturning/@AfterThrowing → @After(finally)→ @Around 后;跨切面用 @Order/Ordered/@Priority,值越小优先级越高(越外层)。事务、缓存、异步都是 Advisor,和自定义切面一起排序。
    7. 自调用失效:外部调用先到代理,代理再调目标;目标方法内部 this.other() 是原始对象调用,不再经过代理,所以 @Transactional/@Async/@Cacheable 等基于代理的注解失效。解决方式是拆 Bean、自注入代理(@Lazy)、AopContext.currentProxy()(需 exposeProxy=true)或改用 TransactionTemplate 等显式 API。
    8. 常见边界:JDK 代理只能转成接口类型,注入实现类会 BeanNotOfRequiredTypeException;CGLIB 不能代理 final 类/final 方法/private/static;@Transactional 默认只对 public 方法生效(不同版本对 protected/包可见的支持有差异,按版本验证);@Aspect 必须是 Spring Bean;pointcut 写错/过宽会导致不生效或启动变慢。
  • 图/流程:

text
代理创建:
  refresh 第 6 步注册 AnnotationAwareAspectJAutoProxyCreator(BPP)
    → 单例初始化
      → postProcessAfterInitialization
        → wrapIfNecessary
          → findCandidateAdvisors(解析 @Aspect)
          → findAdvisorsThatCanApply(Pointcut 匹配)
          → sortAdvisors(@Order)
          → createProxy
            → ProxyFactory
              ├─ JDK Dynamic Proxy
              └─ CGLIB
text
调用链:
  client
    → proxy.invoke / intercept
      → getInterceptorsAndDynamicInterceptionAdvice
      → ReflectiveMethodInvocation.proceed
        → interceptor1.invoke
          → interceptor2.invoke
            → target method
text
自调用失效:
  external caller
    → proxy
      → interceptor(事务/异步/缓存)
        → target.methodA()
          → this.methodB()      ← 原始对象调用,绕过 proxy
            → methodB 上的注解不生效
text
通知顺序(同一 aspect 的典型形态):
  @Around before
    @Before
      target method
    @AfterReturning / @AfterThrowing
  @After(finally)
  @Around after
text
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 AOP 中的对应
Join Point可织入点仅 Spring Bean 方法执行
Pointcut匹配规则@Pointcut/execution 等
Advice增强逻辑@Before/@After/@Around...
AdvisorPointcut + AdviceDefaultPointcutAdvisor 等
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
@Afterfinally不能成功/异常都执行
@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参数类型注解运行时匹配
beanSpring Bean 名Spring 特有,非 AspectJ
  • Spring AOP vs AspectJ:
维度Spring AOPAspectJ
织入方式运行时动态代理编译期/加载期字节码织入
Join PointSpring Bean 方法执行方法/构造器/字段/静态/初始化等
自调用失效(绕过代理)生效(字节码已织入)
性能有代理/反射开销接近原生,无代理
依赖Spring AOPajc/aspectjweaver/LTW
适用业务事务/日志/权限深度监控/字段访问/框架级
  • Boot 配置与代理选择:
配置/注解默认效果
spring.aop.autotrue自动配置 Spring AOP
spring.aop.proxy-target-classBoot 2.x/3.x true类默认 CGLIB;接口目标仍 JDK
@EnableAspectJAutoProxyproxyTargetClass=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/接口注入
BeanNotOfRequiredTypeExceptionJDK 代理注入实现类注入接口或 proxyTargetClass=true
@Aspect 不生效不是 Spring Bean/未开 AOP@Component/@Bean/@EnableAspectJAutoProxy
目标方法没执行@Around 没调 proceed()调 proceed() 或改通知类型
切点不匹配this/target/@annotation 写错用 target/@within 或调试匹配
启动变慢pointcut 过宽/代理过多缩小切点/排除基础设施 Bean
AopContext.currentProxy() 报错未开 exposeProxy开启或改自注入
事务没回滚自定义切面吞异常/顺序问题调整 @Order/不要吞异常
  • 深挖点(面试官常追的 6 个):

    1. 代理是怎么创建出来的:AnnotationAwareAspectJAutoProxyCreator 在 postProcessAfterInitialization 调 wrapIfNecessary;先通过 BeanFactoryAspectJAdvisorsBuilder 解析所有 @Aspect Bean,生成 Advisor 列表;再用 AopUtils.findAdvisorsThatCanApply 做类/方法匹配;排序后 ProxyFactory 设置 target、interfaces、advisors,调用 getProxy。JDK/CGLIB 的选择在 DefaultAopProxyFactory,不是由 @Aspect 决定。
    2. JDK 和 CGLIB 怎么选:目标有接口且 proxyTargetClass=false 用 JDK;无接口、proxyTargetClass=true、optimize=true 用 CGLIB;目标本身是接口仍用 JDK。Boot 默认 spring.aop.proxy-target-class=true,所以 Service 类通常是 CGLIB;但如果你注入的是接口,CGLIB 代理也能转接口。JDK 代理只能转接口,这是 BeanNotOfRequiredTypeException 的常见来源。
    3. 执行链怎么走:代理拿到方法后,AdvisedSupport.getInterceptorsAndDynamicInterceptionAdvice 把 Advisor 转成 MethodInterceptor 列表;ReflectiveMethodInvocation.proceed 按索引执行拦截器,拦截器内部调用 invocation.proceed() 推进;最后 invokeJoinpoint 调目标方法。@Around 就是 MethodInterceptor,不调 proceed() 就直接返回,目标不会执行。
    4. 自调用为什么失效:代理对象持有目标对象;外部调用先到代理,代理执行拦截器后调用目标方法;目标方法里的 this.methodB() 是目标对象自身调用,不经过代理,所以 methodB 上的切面/事务/异步都不生效。解决不是“加注解”,而是让调用经过代理:拆到另一个 Bean、自注入代理、AopContext.currentProxy()(exposeProxy=true)或显式 API。
    5. 切点匹配的细节:execution 匹配方法签名,within 匹配类,@annotation 匹配方法注解,@within 匹配类注解;this 匹配代理类型,target 匹配目标类型,JDK 代理下两者可能不同。args/@args/this/target 可能需要在运行时判断,性能高于纯静态匹配;pointcut 过宽会让所有 Bean 都被代理,启动变慢、metaspace 增大。
    6. 事务/异步/缓存和 AOP 的关系:它们都是 Advisor + 代理:@Transactional 由 BeanFactoryTransactionAttributeSourceAdvisor + TransactionInterceptor 实现;@Async 由 AsyncAnnotationBeanPostProcessor + AsyncAnnotationAdvisor 实现;@Cacheable 由 BeanFactoryCacheOperationSourceAdvisor 实现。它们和自定义切面按 @Order 排序;自定义 @Around 如果在内层吞掉异常,事务可能看不到异常而提交,顺序和异常传播必须一起考虑。
  • 追问链:

    1. 什么是 AOP? → 面向切面,把横切逻辑从业务代码中抽离。
    2. Spring AOP 和 AspectJ 区别? → 运行时代理 vs 编译/加载期织入。
    3. Spring AOP 基于什么? → 动态代理。
    4. 代理什么时候创建? → Bean 初始化后,BPP postProcessAfterInitialization。
    5. 谁创建代理? → AnnotationAwareAspectJAutoProxyCreator + ProxyFactory。
    6. JDK 和 CGLIB 怎么选? → 接口/proxyTargetClass/无接口。
    7. Boot 默认用哪个? → 默认 CGLIB(proxy-target-class=true)。
    8. proxyTargetClass=true 一定 CGLIB 吗? → 目标本身是接口时仍 JDK。
    9. JDK 代理限制? → 只能代理接口方法,只能转接口。
    10. CGLIB 限制? → final 类/final 方法/private/static 不能代理。
    11. 为什么注入实现类会失败? → JDK 代理不是实现类子类。
    12. 自调用为什么失效? → this 绕过代理。
    13. 怎么解决自调用? → 拆 Bean/自注入/AopContext/显式 API。
    14. @Lazy 自注入原理? → 注入自身代理,调用走代理。
    15. AopContext.currentProxy() 前提? → exposeProxy=true,且线程绑定。
    16. @Aspect 怎么变成 Advisor? → AspectJAdvisorFactory 解析通知方法。
    17. Advisor/Advice/Pointcut 关系? → Advisor = Pointcut + Advice。
    18. @Around 执行链? → 包住其他通知和目标,调 proceed()。
    19. 不调 proceed() 会怎样? → 目标方法不执行。
    20. 通知顺序? → Around 前/Before/目标/AfterReturning/AfterThrowing/After/Around 后。
    21. @Order 规则? → 值越小优先级越高,越外层。
    22. 多个切面顺序? → 按 @Order/Ordered/@Priority。
    23. @AfterThrowing 能吞异常吗? → 不能,除非 @Around 捕获。
    24. @AfterReturning 能改返回值吗? → 不能,除非 @Around。
    25. @After 什么时候执行? → finally,成功/异常都执行。
    26. pointcut 有哪些指示符? → execution/within/this/target/args/@annotation/@within/@target/@args/bean。
    27. this 和 target 区别? → 代理类型 vs 目标类型。
    28. @annotation 和 @within 区别? → 方法注解 vs 类注解。
    29. bean() 是 AspectJ 的吗? → 不是,Spring 特有。
    30. pointcut 过宽有什么问题? → 代理过多、启动慢、metaspace 大。
    31. 事务 AOP 怎么实现? → TransactionInterceptor + Advisor。
    32. @Transactional 为什么失效? → 自调用/private/final/非 Bean/异常被吞。
    33. @Async 为什么失效? → 自调用/代理未生效/返回类型。
    34. @Cacheable 为什么失效? → 自调用/代理类型。
    35. 事务和自定义切面顺序? → @Order,注意异常传播/回滚。
    36. @Transactional + @Async? → 异步线程不继承事务上下文,需拆分/编程式事务。
    37. AOP 和循环依赖? → early proxy,见 3.1-4。
    38. early proxy 怎么保证一致? → earlyProxyReferences。
    39. 怎么判断是不是代理? → AopUtils.isAopProxy。
    40. 怎么判断 JDK/CGLIB? → isJdkDynamicProxy/isCglibProxy。
    41. 怎么看代理的 Advisor? → 转 Advised 调 getAdvisors()。
    42. 怎么拿原始类? → AopProxyUtils.ultimateTargetClass。
    43. 怎么调试 pointcut? → 日志/AopUtils.canApply/断点。
    44. AOP 性能开销? → 代理/反射/拦截器链;CGLIB 生成/metaspace。
    45. CGLIB 为什么会 metaspace 膨胀? → 每个代理类生成字节码/类加载。
    46. Spring AOP 能拦截构造器吗? → 不能,AspectJ 可以。
    47. 能拦截字段访问吗? → Spring AOP 不能,AspectJ 可以。
    48. 能拦截 static 方法吗? → Spring AOP 不能,AspectJ 可以。
    49. 什么时候用 AspectJ? → 需要字段/构造器/静态织入或绕过代理限制。
    50. 面试怎么总结? → 代理创建 → 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 → 生产坑与取舍。