Skip to content

2.1-2 动态代理与字节码增强 ​

所属:02 Java 运行时 / 2.1 Java 基础 分级:A 状态:◐ 初稿 关联:2.1-1、2.1-3、2.1-5、3.1-5、3.3-2

  • 题型:原理 / 对比 / 场景

  • 一句话结论:动态代理是不改目标类、在调用链上插一层转发——JDK Proxy 生成接口实现类,CGLIB 生成目标类的子类;字节码增强是直接生成或改写 class——ASM 做底层、ByteBuddy 做高层封装。选型先看三个硬约束:有没有接口、目标能不能被继承、要不要在运行时改已加载的类;性能不是首要因素,现代 JDK 上 JDK Proxy 与 CGLIB 的差距要用 JMH 实测,不要背老结论。

  • 分层要点:

    1. 先分清三件事:静态代理在编译期手写代理类,一个目标一个类;动态代理在运行时生成代理类,把调用统一转发给处理器;字节码增强则是直接生成新类或改写已有类的字节码。代理的语义是“包一层”(调用方 → 代理 → 目标),增强的语义是“改本身”(调用方 → 被改写的类)。动态代理要回答两个问题:生成什么类、调用怎么转发。
    2. JDK Proxy 的生成物:Proxy.newProxyInstance(loader, interfaces, handler) 生成 $Proxy0——final class,extends Proxy 并 implements 指定接口;静态块里缓存 Object 和接口方法的 Method 对象,每个方法体统一调用 super.h.invoke(this, method, args)。因为已经继承了 Proxy,Java 单继承决定了它只能代理接口;代理类按 (ClassLoader, 接口列表) 缓存,JDK 9+ 生成在 jdk.proxyN 动态模块里(JDK 8 是 com.sun.proxy.$Proxy0)。
    3. JDK Proxy 的四个坑:equals/hashCode/toString 也会进 handler,处理不当会递归或破坏集合语义;handler 里必须 method.invoke(target, args),传 proxy 会回到 handler;接口方法没声明的受检异常会被包成 UndeclaredThrowableException;默认方法在 JDK 16 之前没有标准调法,16+ 用 InvocationHandler.invokeDefault。
    4. CGLIB 的机制与限制:用 ASM 生成目标类的子类,Enhancer + MethodInterceptor 拦截,MethodProxy.invokeSuper() 调父类原方法。靠继承意味着 final 类、final 方法、private 方法、static 方法都不能被代理;目标类没有无参构造器时要用 Objenesis 绕过或显式传参;Spring 4 起把 CGLIB 重打包进 spring-core(org.springframework.cglib),不要再单独引一份 CGLIB。
    5. ASM 的定位:ClassReader 读、ClassWriter 写、ClassVisitor/MethodVisitor 改,控制力最强;代价是要自己处理 class 文件版本、常量池、StackMapTable(COMPUTE_FRAMES 还可能需要加载类来求公共父类)、最大栈/局部变量表。ASM 版本必须与目标 JDK 的 class 文件版本匹配,否则读新类直接报错。
    6. ByteBuddy 的定位:在 ASM 上做高层 API,三种模式要分清——subclass 生成新子类、redefine 替换已有类的方法体(不能加方法/字段)、rebase 重命名原方法后新增(可以加)。Advice 把增强代码内联进目标方法,AgentBuilder 配合 Instrumentation 做 Java Agent;Mockito 的 inline mock maker、APM 插桩都走这条路。
    7. Spring AOP 的选型与自调用:DefaultAopProxyFactory 的规则是“有接口且 proxyTargetClass=false 用 JDK,否则 CGLIB”;Spring Boot 2.x/3.x 的 spring.aop.proxy-target-class 默认 true,所以线上常见的是 CGLIB。@Configuration 的代理是另一套(ConfigurationClassEnhancer),不是 AOP。自调用走 this,不经过代理,这是 @Transactional、@Async、自定义切面失效的头号原因。
    8. 性能、内存与排障:代理类/增强类都是动态生成的 class,占 Metaspace;按 loader + 接口或目标类缓存,ClassLoader 泄漏会连带这些类常驻。JDK Proxy 的调用开销取决于 handler 实现(反射 vs MethodHandle vs 直接调用),CGLIB 用 FastClass 索引避免反射;选型时用 JMH 测真实调用路径,不要用“CGLIB 一定更快”这种十年前的结论。排障看代理类型、代理类名、Metaspace 和 ClassLoader 引用链。
  • 图/流程:

text
三种形态:

  静态代理:编译期手写 FooProxy implements Foo
            → 一个目标一个类,横切逻辑重复

  动态代理:运行时生成代理类
            → 调用统一转发给 InvocationHandler / MethodInterceptor

  字节码增强:直接生成或改写 class
            → ASM / ByteBuddy / Instrumentation

  代理 = 包一层(调用方 → 代理 → 目标)
  增强 = 改本身(调用方 → 被改写/生成的类)
text
$Proxy0 的结构(JDK 8: com.sun.proxy.$Proxy0;JDK 9+: jdk.proxy1.$Proxy0):

  public final class $Proxy0 extends Proxy implements Foo {
      private static Method m0, m1, m2, m3;      // Object + 接口方法
      static { m3 = Class.forName("Foo").getMethod("bar", ...); }

      public $Proxy0(InvocationHandler h) { super(h); }

      public final void bar() {
          try { super.h.invoke(this, m3, (Object[]) null); }
          catch (RuntimeException | Error e) { throw e; }
          catch (Throwable e) { throw new UndeclaredThrowableException(e); }
      }
  }
text
CGLIB 的调用链:

  Target$$EnhancerByCGLIB$$xxx extends Target
      └─ MethodInterceptor.intercept(proxy, method, args, methodProxy)
            ├─ methodProxy.invokeSuper(proxy, args) → FastClass 索引 → Target 原方法
            └─ methodProxy.invoke(target, args)     → 目标对象上的方法

  FastClass:把「方法名 + 签名」映射成 int 索引,避免反射调用
text
Spring AOP 的代理选择:

  proxyTargetClass = true ? ──是──► CGLIB
          │否
          ▼
  目标实现了接口? ──是──► JDK Proxy
          │否
          ▼
        CGLIB

  Spring Boot 2.x/3.x:spring.aop.proxy-target-class 默认 true
  → 即使有接口,默认也是 CGLIB
text
自调用失效:

  Controller → 代理对象.methodA() → 事务拦截器 → target.methodA()
                                                   │
                                                   └─ this.methodB()  ← 不走代理
                                                         @Transactional 失效

  修复:拆到另一个 Bean / 自注入代理(@Lazy)/ AopContext.currentProxy() / TransactionTemplate
  • 版本/源码锚点:

    • java.lang.reflect.Proxy、InvocationHandler、Proxy.newProxyInstance;JDK 9+ 代理类进入 jdk.proxyN 动态模块;JDK 16+ InvocationHandler.invokeDefault。
    • -Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true(JDK 9+,旧版本是 sun.misc.ProxyGenerator.saveGeneratedFiles)把生成的 $Proxy0.class 落盘。
    • CGLIB:net.sf.cglib.proxy.Enhancer、MethodInterceptor、MethodProxy、FastClass;Spring 内为 org.springframework.cglib.proxy。
    • Spring:DefaultAopProxyFactory、JdkDynamicAopProxy、CglibAopProxy、ObjenesisCglibAopProxy、AopUtils、AopContext;@EnableAspectJAutoProxy(proxyTargetClass, exposeProxy);@Configuration(proxyBeanMethods)。
    • ASM 9.x:ClassReader、ClassWriter、ClassVisitor、MethodVisitor、ClassWriter.COMPUTE_FRAMES/COMPUTE_MAXS。
    • ByteBuddy 1.x:ByteBuddy、DynamicType.Unloaded、MethodDelegation、Advice、AgentBuilder、ElementMatchers。
    • 容器/JDK 17+:强封装下部分字节码库需要 --add-opens 或升级到适配版本;Spring 6 / Boot 3 以 Java 17 为基线。
  • 四种方案对比:

维度JDK ProxyCGLIBASMByteBuddy
原理生成实现接口的代理类生成目标类的子类直接读/改/生成字节码高层 API 生成/改写
代理对象接口类型目标类子类自定义自定义
硬限制只能接口final 类/方法、private/static需自己保证字节码合法取决于模式
生成物$Proxy0Target$$EnhancerByCGLIB$$... + FastClass任意 class任意 class
依赖JDK 自带CGLIB(Spring 已重打包)ASMByteBuddy + ASM
复杂度低中高中
典型场景MyBatis Mapper、Spring JDK 代理Spring AOP、@Configuration框架、Agent、字节码分析Mockito、APM、Java Agent
  • JDK Proxy 与 CGLIB 细节对比:
维度JDK ProxyCGLIB
目标接口类(可同时实现接口)
final 类不适用不能代理
final 方法不适用不能拦截
private/static 方法不适用不能拦截
构造器无要求无默认构造器需 Objenesis/传参
默认方法JDK 16+ invokeDefault子类可直接 super 调用
受检异常未声明时包成 UndeclaredThrowableException原样抛出
可见方法只有接口方法类方法(受可见性限制)
调用开销反射/MethodHandle,取决于 handlerFastClass 索引,接近直接调用
生成类位置jdk.proxyN 动态模块目标类同包/同 ClassLoader
  • Spring AOP 选型表:
条件代理类型配置/说明
有接口 + proxyTargetClass=falseJDK@EnableAspectJAutoProxy(proxyTargetClass=false)
无接口CGLIB自动选择
proxyTargetClass=trueCGLIBSpring Boot 默认
@ConfigurationCGLIBproxyBeanMethods=true 默认
final 类 + CGLIB启动失败去掉 final 或改为接口代理
类内自调用不经过代理拆 Bean/自注入/AopContext
@Transactional 在 private/final 方法不生效事务默认只对 public 可代理方法生效
  • 失效场景表(现象 → 根因 → 处理):
现象根因处理
@Transactional 加了但不回滚自调用、private/final 方法、类未被代理看 AopUtils.isAopProxy,拆 Bean 或改可见性
final 类启动报代理创建失败CGLIB 不能继承 final 类去掉 final,或改用接口 + JDK 代理
ClassCastException 强转目标类JDK 代理对象只实现接口,不是目标类按接口注入,或改 CGLIB
equals 递归/StackOverflowhandler 里 method.invoke(proxy, args)改成 invoke(target, args),单独处理 Object 方法
调用默认方法抛 AbstractMethodErrorJDK 16 前没有 invokeDefault升级 JDK,或用 MethodHandles 特殊处理
NoSuchMethodError/NoClassDefFoundError独立 CGLIB 与 Spring 重打包版本冲突移除独立 CGLIB 依赖
Metaspace 持续上涨动态生成类过多/ClassLoader 泄漏限制生成、修 ClassLoader 引用、看 VM.metaspace
@Async 不生效与事务同因:自调用/未被代理拆 Bean、自注入代理
Mockito mock final 类失败默认 mock maker 走子类启用 inline mock maker(Instrumentation)
代理对象放进 Set 行为异常equals/hashCode 被转发到目标或未处理handler 显式委托目标对象
  • 版本演进表:
版本变化影响
JDK 8com.sun.proxy.$Proxy0;MethodHandle 成熟代理类在 com.sun.proxy 包
JDK 9代理类进入 jdk.proxyN 动态模块;强封装起点类名、模块访问变化
JDK 16InvocationHandler.invokeDefault默认方法可以标准代理
JDK 17强封装部分字节码库需 --add-opens 或升级
Spring 4CGLIB 重打包到 org.springframework.cglib避免与独立 CGLIB 冲突
Spring Boot 2.0+spring.aop.proxy-target-class=true 默认默认 CGLIB
Spring 6 / Boot 3Java 17 基线字节码库版本要匹配
ASM 9.x支持较新 class 文件版本ASM 版本必须 ≥ 目标 JDK
  • 排障手段表:
目的手段
看 JDK 代理类-Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true(JDK 9+)
看 CGLIB 生成类-Dcglib.debugLocation=<dir>(按 CGLIB/Spring 版本确认)
判断代理类型AopUtils.isJdkDynamicProxy、isCglibProxy、proxy.getClass()
拿目标对象/目标类AopProxyUtils.getSingletonTarget、AopUtils.getTargetClass
看 Metaspacejcmd <pid> VM.metaspace(JDK 11+)、jstat -gcmetacapacity
看动态类数量jcmd <pid> GC.class_histogram 里 $Proxy/$$EnhancerBy 计数
看 ClassLoader 泄漏jcmd <pid> VM.class_hierarchy、MAT 查 loader 引用链
  • 深挖点(面试官常追的 6 个):

    1. $Proxy0 到底长什么样,invoke 的 proxy 参数是什么:生成类是 final,继承 Proxy,静态块缓存 Method,方法体只做 h.invoke(this, method, args)。invoke 的第一个参数是代理对象本身,不是目标对象;handler 里写 method.invoke(proxy, args) 会再次进入 handler,形成递归,正确写法是持有目标引用并 method.invoke(target, args)。equals/hashCode/toString 同样被转发,所以代理对象和目标对象在集合里的语义可能不一致。
    2. 默认方法在 JDK 16 前后怎么处理:16 之前 method.invoke(proxy) 会递归或抛 IllegalAccessException,常见 hack 是 MethodHandles.privateLookupIn(declaringClass, lookup).unreflectSpecial(method, declaringClass).bindTo(proxy),但受模块访问限制;JDK 16+ 直接用 InvocationHandler.invokeDefault(proxy, method, args),这是标准做法。
    3. CGLIB 的 FastClass 与 invokeSuper/invoke 的区别:FastClass 为每个方法生成一个 int 索引,调用时按索引直接跳转,避免 Method.invoke 的反射开销;invokeSuper(proxy, args) 调的是父类(目标类)的实现,invoke(target, args) 调的是传入对象上的方法——如果传的是代理对象,会再次进入拦截器。Spring 的 CglibAopProxy 持有真实 target,所以用 invoke(target, args)。
    4. Spring 的代理选择逻辑:DefaultAopProxyFactory 在 proxyTargetClass=true、optimize=true 或没有用户提供的接口时走 CGLIB,否则走 JDK;Spring Boot 的 AopAutoConfiguration 把 spring.aop.proxy-target-class 默认设为 true,所以“有接口也用 CGLIB”。@Configuration 的 CGLIB 是 ConfigurationClassEnhancer,拦截 @Bean 方法保证单例,和 AOP 代理不是一回事。
    5. 自调用为什么失效、怎么修:调用 this.methodB() 时 this 是目标对象,不是代理,拦截器没有入口。四种修法各有代价:拆到另一个 Bean 最干净;自注入代理要加 @Lazy 破循环依赖;AopContext.currentProxy() 需要 exposeProxy=true,且绑定 ThreadLocal;TransactionTemplate 最显式但要改代码结构。@Async、自定义注解切面同理。
    6. 字节码增强的边界:Instrumentation.retransformClasses/redefineClasses 只能改方法体,不能加/删字段、不能改方法签名(2.1-3);ByteBuddy 的 redefine 同样不能加成员,要加就用 rebase 或 subclass;所有动态类都占 Metaspace,ClassLoader 不释放就泄漏;JDK 17+ 强封装下,老版本 CGLIB/ASM 可能直接失败,升级或 --add-opens 是两条路。
  • 追问链:

    1. 什么是动态代理? → 运行时生成代理类,把调用统一转发给处理器。
    2. 和静态代理的区别? → 编译期手写 vs 运行时生成;一个目标一个类 vs 统一处理器。
    3. 动态代理解决什么问题? → 横切逻辑复用、解耦、框架扩展(AOP、RPC、Mapper、Mock)。
    4. 代理和字节码增强的区别? → 代理是包一层,增强是改本身或生成新类。
    5. JDK Proxy 怎么生成代理类? → Proxy.newProxyInstance 生成 $Proxy0。
    6. $Proxy0 继承什么? → Proxy,并实现指定接口。
    7. 为什么只能代理接口? → 已经 extends Proxy,Java 单继承。
    8. $Proxy0 的方法体做什么? → super.h.invoke(this, method, args)。
    9. InvocationHandler.invoke 的 proxy 参数是什么? → 代理对象本身,不是目标对象。
    10. handler 里能 method.invoke(proxy) 吗? → 会递归回到 handler,应该 invoke target。
    11. equals/hashCode/toString 会进 handler 吗? → 会,需要单独处理。
    12. 受检异常怎么处理? → 接口未声明时包成 UndeclaredThrowableException。
    13. 默认方法怎么代理? → JDK 16+ invokeDefault;更早用 MethodHandles 特殊处理。
    14. 代理类会缓存吗? → 按 (ClassLoader, 接口列表) 缓存。
    15. 代理类在哪个包? → JDK 8 com.sun.proxy,JDK 9+ jdk.proxyN。
    16. 怎么把代理类落盘? → -Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true。
    17. CGLIB 的原理? → 用 ASM 生成目标类的子类。
    18. CGLIB 怎么拦截? → MethodInterceptor.intercept。
    19. CGLIB 怎么调原方法? → MethodProxy.invokeSuper。
    20. invokeSuper 和 invoke 的区别? → 前者调父类实现,后者调传入对象的方法。
    21. FastClass 是什么? → 方法索引表,避免反射调用。
    22. CGLIB 不能代理什么? → final 类/方法、private/static 方法。
    23. 目标类没有无参构造器怎么办? → Objenesis 绕过或显式传参。
    24. CGLIB 生成的类名? → $$EnhancerByCGLIB$$,Spring 版是 $$EnhancerBySpringCGLIB$$。
    25. Spring 里的 CGLIB 从哪来? → Spring 4 起重打包在 spring-core。
    26. 能同时引入独立 CGLIB 吗? → 容易版本冲突,不要引。
    27. ASM 是什么? → 低层字节码读写库。
    28. ASM 的核心类? → ClassReader/ClassWriter/ClassVisitor/MethodVisitor。
    29. 为什么要算栈映射帧? → 验证器要求,COMPUTE_FRAMES 自动算。
    30. COMPUTE_FRAMES 有什么代价? → 可能加载类求公共父类,慢且可能失败。
    31. ASM 版本要注意什么? → 必须支持目标 class 文件版本。
    32. ByteBuddy 是什么? → ASM 上的高层封装。
    33. subclass/redefine/rebase 的区别? → 新子类 / 替换方法体 / 重命名后新增。
    34. redefine 能加方法吗? → 不能,要加用 rebase 或 subclass。
    35. Advice 是什么? → 把增强代码内联进目标方法。
    36. AgentBuilder 用在哪? → Java Agent 的插桩。
    37. Spring AOP 怎么选代理? → 有接口且 proxyTargetClass=false 用 JDK,否则 CGLIB。
    38. Spring Boot 默认用什么? → CGLIB(proxy-target-class=true)。
    39. @Configuration 的代理是 AOP 吗? → 不是,是 ConfigurationClassEnhancer。
    40. 自调用为什么失效? → this 不是代理,不经过拦截器。
    41. 自调用怎么修? → 拆 Bean、自注入代理、AopContext、TransactionTemplate。
    42. @Transactional 在 private/final 上为什么不行? → 不被代理或不能重写。
    43. 动态代理会导致 Metaspace 问题吗? → 会,动态类 + ClassLoader 泄漏。
    44. JDK Proxy 和 CGLIB 性能怎么选? → 现代 JDK 差距小,JMH 测真实路径。
    45. 面试怎么总结? → 代理 vs 增强 → JDK/CGLIB 的生成物与限制 → ASM/ByteBuddy → Spring 选型与自调用 → 排障与内存。
  • 生产案例/取舍(按你的项目替换):

    • MyBatis Mapper 没有实现类,MapperProxy 实现 InvocationHandler,把接口方法转发成 SQL 执行;MapperProxyFactory 缓存代理对象,避免每次调用重复生成。
    • @Transactional 加在同类方法上,A 调 B 时事务不生效;根因是 this 调用绕过代理,改成拆 Bean 或自注入代理后恢复。
    • @Transactional 加在 final 方法上,CGLIB 无法重写,事务静默失效;去掉 final 或改接口代理。
    • 无接口的 final 类开启 proxyTargetClass=true,启动时报代理创建失败;改为接口 + JDK 代理,或去掉 final。
    • 自定义 InvocationHandler 里用 method.invoke(proxy, args),调用 toString 时 StackOverflow;改成持有 target 并 invoke(target, args)。
    • 代理对象强转成目标类抛 ClassCastException;根因是 JDK 代理只实现接口,改成按接口注入。
    • 调用接口默认方法抛 AbstractMethodError;升级到 JDK 16+ 用 invokeDefault 修复。
    • 项目同时引入独立 CGLIB 和 Spring,出现 NoSuchMethodError;移除独立依赖,统一用 Spring 重打包版本。
    • Mockito mock final 类失败;切换到 inline mock maker,走 Instrumentation 而不是子类。
    • APM Agent 用 ByteBuddy 在方法前后插桩,retransform 只能改方法体;需要加字段时改用启动期 subclass 或改设计。
    • 动态脚本/表达式每次请求生成新类,Metaspace 持续上涨;加缓存并限制生成数量,修 ClassLoader 引用。
    • @Async 自调用不生效,和事务同因;拆 Bean 后恢复。
    • 取舍:JDK Proxy 简单、无依赖、只支持接口;CGLIB 能代理类,但受 final 限制并增加 Metaspace;ASM 控制力最强但维护成本最高;ByteBuddy 平衡能力与开发效率,适合 Agent/Mock;Spring Boot 默认 CGLIB 换来“无接口也能代理”,代价是 final 类直接不可用。
  • 易错点:

    • 认为 JDK 动态代理可以代理类,实际只能代理接口。
    • 认为 CGLIB 可以代理 final 方法,实际不能,事务注解也会失效。
    • 认为 Spring AOP 默认一定用 JDK 代理,实际 Boot 默认 CGLIB。
    • 认为 @Transactional 加在 private 方法上生效,实际默认只对可代理的 public 方法生效。
    • 认为类内自调用会经过代理,实际走 this,拦截器不执行。
    • 认为代理对象就是目标对象,实际是包装,强转会失败。
    • 认为 handler 里可以 method.invoke(proxy, args),实际会递归。
    • 认为 equals/hashCode/toString 不会进 handler,实际会。
    • 认为受检异常会原样抛出,实际未声明时被包装。
    • 认为默认方法一直能正常代理,实际 JDK 16 前没有标准调法。
    • 认为代理类不占 Metaspace,实际每个动态类都占。
    • 认为每次调用都会重新生成代理类,实际按 loader + 接口缓存。
    • 认为 CGLIB 一定比 JDK Proxy 快,实际要看版本、调用路径和 JIT。
    • 认为 JDK 代理能拦截目标类的特有方法,实际只能看到接口方法。
    • 认为 @Configuration 的代理就是 AOP,实际是配置类增强。
    • 认为 proxyBeanMethods=false 没有影响,实际 @Bean 方法不再保证单例语义。
    • 认为 invokeSuper 和 invoke 等价,实际一个调父类、一个调传入对象。
    • 认为 FastClass 还是反射,实际是索引跳转。
    • 认为 ASM 改字节码不用管栈帧,实际验证器会拒绝。
    • 认为 ASM 版本可以随便选,实际必须匹配 class 文件版本。
    • 认为 ByteBuddy redefine 能加字段/方法,实际不能。
    • 认为 Java Agent 能随便改类结构,实际 retransform 只能改方法体。
    • 认为 CGLIB 可以代理 static 方法,实际不能。
    • 认为动态生成的类不会被回收,实际 ClassLoader 释放后可以回收。
    • 认为 Mockito 只能 mock 接口,实际 inline mock maker 可 mock final 类。
    • 认为 AopContext.currentProxy() 拿来就用,实际要开 exposeProxy=true。
    • 认为自注入和拆 Bean 完全等价,实际自注入要处理循环依赖和 @Lazy。
    • 认为性能结论一成不变,实际 JDK 版本和 JIT 会改变结论。
  • 30 秒口述稿:

动态代理是不改目标类、在调用链上插一层转发。JDK Proxy 生成一个实现接口的 $Proxy0,它继承 Proxy,所以只能代理接口,方法体统一交给 InvocationHandler;CGLIB 用 ASM 生成目标类的子类,用 MethodInterceptor 拦截,所以 final 类、final 方法、private 和 static 都不能代理。ASM 直接读写字节码,控制力最强但最复杂;ByteBuddy 在它上面做高层封装,Mockito 和 APM 都用它。Spring AOP 有接口且 proxyTargetClass=false 用 JDK,Boot 默认是 CGLIB;@Configuration 的代理是另一套机制。线上最常见的两个坑是自调用不走代理导致事务/异步失效,以及动态生成类太多导致 Metaspace 上涨。

  • 3 分钟展开顺序:结论(代理 vs 增强 + 三个选型约束)→ 静态/动态/增强的区别 → $Proxy0 的生成物与 handler 转发 → JDK Proxy 的四个坑(Object 方法、递归、受检异常、默认方法)→ CGLIB 的子类、FastClass 与 final 限制 → ASM/ByteBuddy 的定位与模式 → Spring AOP 的选型与 Boot 默认值 → 自调用失效与四种修复 → 性能/Metaspace/排障命令 → 案例与取舍收尾。