Appearance
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 实测,不要背老结论。
分层要点:
- 先分清三件事:静态代理在编译期手写代理类,一个目标一个类;动态代理在运行时生成代理类,把调用统一转发给处理器;字节码增强则是直接生成新类或改写已有类的字节码。代理的语义是“包一层”(调用方 → 代理 → 目标),增强的语义是“改本身”(调用方 → 被改写的类)。动态代理要回答两个问题:生成什么类、调用怎么转发。
- 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)。 - JDK Proxy 的四个坑:
equals/hashCode/toString也会进 handler,处理不当会递归或破坏集合语义;handler 里必须method.invoke(target, args),传proxy会回到 handler;接口方法没声明的受检异常会被包成UndeclaredThrowableException;默认方法在 JDK 16 之前没有标准调法,16+ 用InvocationHandler.invokeDefault。 - CGLIB 的机制与限制:用 ASM 生成目标类的子类,
Enhancer+MethodInterceptor拦截,MethodProxy.invokeSuper()调父类原方法。靠继承意味着 final 类、final 方法、private 方法、static 方法都不能被代理;目标类没有无参构造器时要用 Objenesis 绕过或显式传参;Spring 4 起把 CGLIB 重打包进spring-core(org.springframework.cglib),不要再单独引一份 CGLIB。 - ASM 的定位:
ClassReader读、ClassWriter写、ClassVisitor/MethodVisitor改,控制力最强;代价是要自己处理 class 文件版本、常量池、StackMapTable(COMPUTE_FRAMES还可能需要加载类来求公共父类)、最大栈/局部变量表。ASM 版本必须与目标 JDK 的 class 文件版本匹配,否则读新类直接报错。 - ByteBuddy 的定位:在 ASM 上做高层 API,三种模式要分清——
subclass生成新子类、redefine替换已有类的方法体(不能加方法/字段)、rebase重命名原方法后新增(可以加)。Advice把增强代码内联进目标方法,AgentBuilder配合Instrumentation做 Java Agent;Mockito 的 inline mock maker、APM 插桩都走这条路。 - 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、自定义切面失效的头号原因。 - 性能、内存与排障:代理类/增强类都是动态生成的 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
→ 即使有接口,默认也是 CGLIBtext
自调用失效:
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 Proxy | CGLIB | ASM | ByteBuddy |
|---|---|---|---|---|
| 原理 | 生成实现接口的代理类 | 生成目标类的子类 | 直接读/改/生成字节码 | 高层 API 生成/改写 |
| 代理对象 | 接口类型 | 目标类子类 | 自定义 | 自定义 |
| 硬限制 | 只能接口 | final 类/方法、private/static | 需自己保证字节码合法 | 取决于模式 |
| 生成物 | $Proxy0 | Target$$EnhancerByCGLIB$$... + FastClass | 任意 class | 任意 class |
| 依赖 | JDK 自带 | CGLIB(Spring 已重打包) | ASM | ByteBuddy + ASM |
| 复杂度 | 低 | 中 | 高 | 中 |
| 典型场景 | MyBatis Mapper、Spring JDK 代理 | Spring AOP、@Configuration | 框架、Agent、字节码分析 | Mockito、APM、Java Agent |
- JDK Proxy 与 CGLIB 细节对比:
| 维度 | JDK Proxy | CGLIB |
|---|---|---|
| 目标 | 接口 | 类(可同时实现接口) |
| final 类 | 不适用 | 不能代理 |
| final 方法 | 不适用 | 不能拦截 |
| private/static 方法 | 不适用 | 不能拦截 |
| 构造器 | 无要求 | 无默认构造器需 Objenesis/传参 |
| 默认方法 | JDK 16+ invokeDefault | 子类可直接 super 调用 |
| 受检异常 | 未声明时包成 UndeclaredThrowableException | 原样抛出 |
| 可见方法 | 只有接口方法 | 类方法(受可见性限制) |
| 调用开销 | 反射/MethodHandle,取决于 handler | FastClass 索引,接近直接调用 |
| 生成类位置 | jdk.proxyN 动态模块 | 目标类同包/同 ClassLoader |
- Spring AOP 选型表:
| 条件 | 代理类型 | 配置/说明 |
|---|---|---|
有接口 + proxyTargetClass=false | JDK | @EnableAspectJAutoProxy(proxyTargetClass=false) |
| 无接口 | CGLIB | 自动选择 |
proxyTargetClass=true | CGLIB | Spring Boot 默认 |
@Configuration | CGLIB | proxyBeanMethods=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 递归/StackOverflow | handler 里 method.invoke(proxy, args) | 改成 invoke(target, args),单独处理 Object 方法 |
调用默认方法抛 AbstractMethodError | JDK 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 8 | com.sun.proxy.$Proxy0;MethodHandle 成熟 | 代理类在 com.sun.proxy 包 |
| JDK 9 | 代理类进入 jdk.proxyN 动态模块;强封装起点 | 类名、模块访问变化 |
| JDK 16 | InvocationHandler.invokeDefault | 默认方法可以标准代理 |
| JDK 17 | 强封装 | 部分字节码库需 --add-opens 或升级 |
| Spring 4 | CGLIB 重打包到 org.springframework.cglib | 避免与独立 CGLIB 冲突 |
| Spring Boot 2.0+ | spring.aop.proxy-target-class=true 默认 | 默认 CGLIB |
| Spring 6 / Boot 3 | Java 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 |
| 看 Metaspace | jcmd <pid> VM.metaspace(JDK 11+)、jstat -gcmetacapacity |
| 看动态类数量 | jcmd <pid> GC.class_histogram 里 $Proxy/$$EnhancerBy 计数 |
| 看 ClassLoader 泄漏 | jcmd <pid> VM.class_hierarchy、MAT 查 loader 引用链 |
深挖点(面试官常追的 6 个):
$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同样被转发,所以代理对象和目标对象在集合里的语义可能不一致。- 默认方法在 JDK 16 前后怎么处理:16 之前
method.invoke(proxy)会递归或抛IllegalAccessException,常见 hack 是MethodHandles.privateLookupIn(declaringClass, lookup).unreflectSpecial(method, declaringClass).bindTo(proxy),但受模块访问限制;JDK 16+ 直接用InvocationHandler.invokeDefault(proxy, method, args),这是标准做法。 - CGLIB 的 FastClass 与
invokeSuper/invoke的区别:FastClass 为每个方法生成一个 int 索引,调用时按索引直接跳转,避免Method.invoke的反射开销;invokeSuper(proxy, args)调的是父类(目标类)的实现,invoke(target, args)调的是传入对象上的方法——如果传的是代理对象,会再次进入拦截器。Spring 的CglibAopProxy持有真实 target,所以用invoke(target, args)。 - Spring 的代理选择逻辑:
DefaultAopProxyFactory在proxyTargetClass=true、optimize=true或没有用户提供的接口时走 CGLIB,否则走 JDK;Spring Boot 的AopAutoConfiguration把spring.aop.proxy-target-class默认设为true,所以“有接口也用 CGLIB”。@Configuration的 CGLIB 是ConfigurationClassEnhancer,拦截@Bean方法保证单例,和 AOP 代理不是一回事。 - 自调用为什么失效、怎么修:调用
this.methodB()时this是目标对象,不是代理,拦截器没有入口。四种修法各有代价:拆到另一个 Bean 最干净;自注入代理要加@Lazy破循环依赖;AopContext.currentProxy()需要exposeProxy=true,且绑定 ThreadLocal;TransactionTemplate最显式但要改代码结构。@Async、自定义注解切面同理。 - 字节码增强的边界:
Instrumentation.retransformClasses/redefineClasses只能改方法体,不能加/删字段、不能改方法签名(2.1-3);ByteBuddy 的redefine同样不能加成员,要加就用rebase或subclass;所有动态类都占 Metaspace,ClassLoader 不释放就泄漏;JDK 17+ 强封装下,老版本 CGLIB/ASM 可能直接失败,升级或--add-opens是两条路。
追问链:
- 什么是动态代理? → 运行时生成代理类,把调用统一转发给处理器。
- 和静态代理的区别? → 编译期手写 vs 运行时生成;一个目标一个类 vs 统一处理器。
- 动态代理解决什么问题? → 横切逻辑复用、解耦、框架扩展(AOP、RPC、Mapper、Mock)。
- 代理和字节码增强的区别? → 代理是包一层,增强是改本身或生成新类。
- JDK Proxy 怎么生成代理类? →
Proxy.newProxyInstance生成$Proxy0。 $Proxy0继承什么? →Proxy,并实现指定接口。- 为什么只能代理接口? → 已经
extends Proxy,Java 单继承。 $Proxy0的方法体做什么? →super.h.invoke(this, method, args)。InvocationHandler.invoke的 proxy 参数是什么? → 代理对象本身,不是目标对象。- handler 里能
method.invoke(proxy)吗? → 会递归回到 handler,应该 invoke target。 equals/hashCode/toString会进 handler 吗? → 会,需要单独处理。- 受检异常怎么处理? → 接口未声明时包成
UndeclaredThrowableException。 - 默认方法怎么代理? → JDK 16+
invokeDefault;更早用MethodHandles特殊处理。 - 代理类会缓存吗? → 按
(ClassLoader, 接口列表)缓存。 - 代理类在哪个包? → JDK 8
com.sun.proxy,JDK 9+jdk.proxyN。 - 怎么把代理类落盘? →
-Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true。 - CGLIB 的原理? → 用 ASM 生成目标类的子类。
- CGLIB 怎么拦截? →
MethodInterceptor.intercept。 - CGLIB 怎么调原方法? →
MethodProxy.invokeSuper。 invokeSuper和invoke的区别? → 前者调父类实现,后者调传入对象的方法。- FastClass 是什么? → 方法索引表,避免反射调用。
- CGLIB 不能代理什么? → final 类/方法、private/static 方法。
- 目标类没有无参构造器怎么办? → Objenesis 绕过或显式传参。
- CGLIB 生成的类名? →
$$EnhancerByCGLIB$$,Spring 版是$$EnhancerBySpringCGLIB$$。 - Spring 里的 CGLIB 从哪来? → Spring 4 起重打包在
spring-core。 - 能同时引入独立 CGLIB 吗? → 容易版本冲突,不要引。
- ASM 是什么? → 低层字节码读写库。
- ASM 的核心类? →
ClassReader/ClassWriter/ClassVisitor/MethodVisitor。 - 为什么要算栈映射帧? → 验证器要求,
COMPUTE_FRAMES自动算。 COMPUTE_FRAMES有什么代价? → 可能加载类求公共父类,慢且可能失败。- ASM 版本要注意什么? → 必须支持目标 class 文件版本。
- ByteBuddy 是什么? → ASM 上的高层封装。
subclass/redefine/rebase的区别? → 新子类 / 替换方法体 / 重命名后新增。redefine能加方法吗? → 不能,要加用rebase或subclass。Advice是什么? → 把增强代码内联进目标方法。AgentBuilder用在哪? → Java Agent 的插桩。- Spring AOP 怎么选代理? → 有接口且
proxyTargetClass=false用 JDK,否则 CGLIB。 - Spring Boot 默认用什么? → CGLIB(
proxy-target-class=true)。 @Configuration的代理是 AOP 吗? → 不是,是ConfigurationClassEnhancer。- 自调用为什么失效? →
this不是代理,不经过拦截器。 - 自调用怎么修? → 拆 Bean、自注入代理、
AopContext、TransactionTemplate。 @Transactional在 private/final 上为什么不行? → 不被代理或不能重写。- 动态代理会导致 Metaspace 问题吗? → 会,动态类 + ClassLoader 泄漏。
- JDK Proxy 和 CGLIB 性能怎么选? → 现代 JDK 差距小,JMH 测真实路径。
- 面试怎么总结? → 代理 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 类直接不可用。
- MyBatis Mapper 没有实现类,
易错点:
- 认为 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/排障命令 → 案例与取舍收尾。