上海羊羽卓进出口贸易有限公司在Java后端开发体系中，动态代理是一项你每天都在“用”、但未必说得清原理的核心技术。无论是Spring框架的AOP（Aspect-Oriented Programming，面向切面编程）、MyBatis的Mapper接口实现，还是RPC（Remote Procedure Call，远程过程调用）框架的客户端代理，底层都离不开动态代理的支持——它被称为Java框架开发的“基础设施”毫不为过。许多学习者面临的尴尬是：代码跑得通，但问到“JDK动态代理和CGLIB有什么区别”时却答不完整；理解停留在“知道有反射”的层面，面对面试官的追问往往底气不足。本文将从传统实现方式的痛点出发，系统讲解JDK动态代理与CGLIB两大核心技术，通过代码示例让你真正吃透“动态代理到底是什么、怎么用、底层怎么跑”，最后梳理高频面试考点，帮你建立从原理到实战的完整知识链路。
一、痛点切入：为什么需要动态代理
先来看一个非常常见的业务场景：你想给系统中的某些方法添加日志记录或性能统计功能。在不使用任何代理技术的情况下，你可能写出这样的代码：
public class TaskService {public void dealTask(String taskName) { // 非业务逻辑：记录开始时间 long startTime = System.currentTimeMillis(); // 核心业务逻辑 System.out.println("执行任务：" + taskName); try { Thread.sleep(500); } catch (InterruptedException e) { } // 非业务逻辑：计算执行时间 long cost = System.currentTimeMillis() - startTime; System.out.println("任务执行耗时：" + cost + "ms"); } }
这种写法存在几个明显的问题：耦合严重——统计逻辑与业务逻辑混杂在一起，修改统计规则必须改动业务代码，违反开闭原则；代码冗余——如果多个方法都需要统计时间，就要在每个方法中重复编写相同的时间记录代码；职责混乱——一个方法同时负责“业务执行”和“性能统计”，不符合单一职责原则-24。
静态代理虽然可以解决部分问题——通过手动编写一个代理类，让它实现与目标类相同的接口，在方法调用前后附加增强逻辑——但静态代理的局限性同样明显：每个接口都需要单独编写一个代理类，代码重复度高，维护成本大-20。当系统中的接口数量增加时，静态代理类会成倍增长，维护工作变得极其繁琐。
正是在这样的背景下，动态代理应运而生。它的核心思想是：在程序运行时，由JVM动态生成代理类和代理对象，无需开发者手动编写任何代理类代码，真正实现了“一次编写，处处生效”的效果-20。
二、JDK动态代理：基于接口的原生方案
1. 标准定义
JDK动态代理是Java标准库（java.lang.reflect包）提供的原生动态代理机制，它要求目标类必须实现至少一个接口，通过在运行时动态生成实现了这些接口的代理类，并将方法调用转发给InvocationHandler来处理，从而实现对目标对象方法的拦截与增强-3。
2. 核心组件
JDK动态代理由三个核心组件共同完成：
java.lang.reflect.Proxy：工具类，负责在运行时动态生成代理类并创建代理实例。核心方法是newProxyInstance(ClassLoader, Class<?>[], InvocationHandler)-14。java.lang.reflect.InvocationHandler：调用处理器接口，开发者需要实现该接口，在invoke()方法中编写增强逻辑。所有对代理对象的方法调用都会被转发到此接口的invoke()方法中-14。java.lang.reflect.Method：表示被调用方法的对象，通过它可以利用反射机制调用目标对象的对应方法-14。
3. 工作原理
JDK动态代理的运行机制可以概括为三步：
动态生成代理类：通过
Proxy.newProxyInstance()，JVM在运行时为指定的接口集合动态生成一个代理类（类名通常为$Proxy0），该代理类实现了目标对象的所有接口。方法调用拦截：当客户端调用代理对象的方法时，JVM不会直接执行该方法，而是将调用转发给与该代理对象绑定的
InvocationHandler实例的invoke()方法。增强逻辑执行：在
invoke()方法中，开发者可以插入前置增强（如日志、权限校验）、调用目标对象的方法（通过Method.invoke()反射调用），以及执行后置增强（如事务提交）-1-11。
4. 代码示例
// 1. 定义业务接口 public interface UserService { void addUser(String name); String getUser(int id); } // 2. 目标实现类（专注核心业务） public class UserServiceImpl implements UserService { @Override public void addUser(String name) { System.out.println("添加用户: " + name); } @Override public String getUser(int id) { return "用户" + id; } } // 3. 实现InvocationHandler（封装增强逻辑） import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class LogInvocationHandler implements InvocationHandler { private final Object target; public LogInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 前置增强：日志记录 System.out.println("--- 方法调用前: " + method.getName()); if (args != null) { for (Object arg : args) System.out.println("参数: " + arg); } // 反射调用目标方法 Object result = method.invoke(target, args); // 后置增强 System.out.println("--- 方法调用后: " + method.getName()); return result; } } // 4. 生成代理对象并使用 public class JdkProxyDemo { public static void main(String[] args) { UserService target = new UserServiceImpl(); InvocationHandler handler = new LogInvocationHandler(target); UserService proxy = (UserService) Proxy.newProxyInstance( target.getClass().getClassLoader(), // 类加载器 target.getClass().getInterfaces(), // 目标接口数组 handler // 调用处理器 ); proxy.addUser("张三"); // 调用代理方法，增强逻辑会自动生效 String user = proxy.getUser(1); System.out.println("获取用户: " + user); } }
生成的代理类大致结构如下（理解原理即可）：
public final class $Proxy0 extends Proxy implements UserService { private InvocationHandler h; public $Proxy0(InvocationHandler h) { super(h); } public void addUser(String name) { h.invoke(this, addUserMethod, new Object[]{name}); } public String getUser(int id) { return (String) h.invoke(this, getUserMethod, new Object[]{id}); } }
三、CGLIB动态代理：无需接口的继承方案
1. 标准定义
CGLIB（Code Generation Library，代码生成库） 是一个基于ASM字节码操作框架的第三方动态代理库。它不要求目标类实现接口，而是通过在运行时动态生成目标类的子类来实现代理，子类会重写父类的所有非final、非private、非static方法，并将方法调用拦截到MethodInterceptor接口中进行处理--3。
2. 工作原理
CGLIB的核心机制是通过ASM字节码技术，在运行时直接生成目标类的子类字节码：
生成子类：使用
Enhancer增强器类，设置目标类作为父类，通过ASM动态生成一个子类。方法重写：生成的子类会重写父类中所有可被继承的方法（final和private方法除外）。
调用拦截：当调用代理子类的方法时，会被拦截到
MethodInterceptor.intercept()方法中，开发者在此处织入增强逻辑，再通过MethodProxy.invokeSuper()调用父类的原始方法-2。
3. 代码示例
// 1. 目标类（无需实现任何接口） public class UserService { public void addUser(String name) { System.out.println("添加用户: " + name); } public String getUser(int id) { return "用户" + id; } } // 2. 实现MethodInterceptor import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class LogMethodInterceptor implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("--- CGLIB 前置: " + method.getName()); Object result = proxy.invokeSuper(obj, args); // 调用父类原始方法 System.out.println("--- CGLIB 后置: " + method.getName()); return result; } } // 3. 使用Enhancer生成代理对象 import net.sf.cglib.proxy.Enhancer; public class CglibProxyDemo { public static void main(String[] args) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(UserService.class); // 设置父类（目标类） enhancer.setCallback(new LogMethodInterceptor()); // 设置回调 UserService proxy = (UserService) enhancer.create(); proxy.addUser("李四"); // 调用代理方法 System.out.println(proxy.getUser(2)); } }
四、概念关系与核心区别
JDK动态代理与CGLIB的关系可以用一句话概括：JDK动态代理是“基于接口”的原生方案，CGLIB是“基于继承”的补充方案，二者互为补位，共同支撑起Java生态的动态代理体系。
两者的核心区别总结如下：
| 对比维度 | JDK动态代理 | CGLIB动态代理 |
|---|---|---|
| 代理方式 | 基于接口 | 基于继承（生成子类） |
| 必要条件 | 目标类必须实现至少一个接口 | 目标类不能是final类 |
| 底层技术 | 反射 + Proxy | ASM字节码增强 |
| 方法限制 | 只能代理接口中声明的方法 | 无法代理final方法、private方法、static方法 |
| 依赖 | JDK原生，无需额外依赖 | 需要引入CGLIB库（Spring已内置） |
| 代理类生成时机 | 运行时动态生成接口实现类 | 运行时动态生成子类字节码 |
| 常见应用场景 | Spring AOP中代理有接口的Bean | Spring AOP中代理无接口的Bean、Hibernate懒加载 |
-1-2-32
性能方面，两者随着JDK版本的变化而有所不同。在JDK 8及以下版本中，CGLIB由于直接生成子类、避免反射调用，在大量方法调用时性能略优于JDK动态代理；但JDK 9及以上版本对反射机制进行了深度优化，二者性能差距已大幅缩小，实际项目中无须过度纠结于性能差异--1。
五、底层原理：动态代理的技术基石
动态代理之所以能够“动态”生成代理类，底层依赖的核心技术主要有两个：
1. 反射机制：JDK动态代理的底层基石就是Java反射。Proxy.newProxyInstance()通过反射在运行时动态生成代理类字节码并加载到JVM中；InvocationHandler.invoke()内部通过Method.invoke()反射调用目标对象的方法。反射使得程序可以在运行时获取类的信息并动态操作对象，是动态代理能够绕过编译期限制的关键--1。
2. 字节码操作：CGLIB依赖的ASM框架直接操作Java字节码，能够在运行时生成、修改类的字节码，从而实现动态创建子类的效果。ASM的底层可控性极高，可以代理任意类、修改字节码，是众多框架级工具的核心引擎-。
这两种技术各有侧重：反射适合“调用”层面的动态操作，字节码操作适合“生成”层面的深度定制。理解这两个底层技术，就抓住了动态代理的“根”，后续学习Spring AOP源码时会更加得心应手。
六、高频面试题与参考答案
1. JDK动态代理和CGLIB动态代理有什么区别？
答题要点：从代理方式、必要条件、底层技术、限制条件、性能对比五个维度作答。
参考答案：① 代理方式不同：JDK动态代理基于接口，CGLIB基于继承（生成子类）；② 必要条件不同：JDK要求目标类必须实现至少一个接口，CGLIB要求目标类不能是final类；③ 底层技术不同：JDK基于Java反射和Proxy类，CGLIB基于ASM字节码增强框架；④ 限制条件不同：JDK只能代理接口中声明的方法，CGLIB无法代理final方法、private方法和static方法；⑤ 性能表现：JDK 9及以上版本两者性能差距已大幅缩小，实际项目中差距不明显。-32
2. 静态代理和动态代理有什么区别？
参考答案：① 创建时机不同：静态代理的代理类在编译期手动编写并存在.class文件；动态代理的代理类在运行期通过反射/字节码技术动态生成，无物理.class文件；② 灵活性不同：静态代理一对一绑定，接口变更需同步修改代理类，复用性差；动态代理可通用适配多个目标类，灵活性高；③ 性能差异：静态代理编译期优化，性能略优；动态代理有轻微运行时开销，但JDK 8+已大幅优化，差距极小。-32
3. Spring AOP底层是如何实现方法增强的？
参考答案：Spring AOP的底层实现基于动态代理技术，默认策略为：目标类实现了接口时使用JDK动态代理，未实现接口时使用CGLIB动态代理。Spring在运行时为目标对象动态生成代理对象，代理对象中织入了切面逻辑（如@Before、@After、@Around通知），当调用代理对象的方法时，会先执行增强逻辑，再通过反射调用目标对象的原始方法。开发者也可通过配置强制使用CGLIB代理。-32
4. 为什么CGLIB不能代理final类或final方法？
参考答案：CGLIB的实现原理是通过继承目标类并重写其方法来实现代理。final类不能被继承，因此CGLIB无法为final类生成代理子类；final方法不能被重写，因此CGLIB无法拦截对final方法的调用，代理效果会失效。-1
5. 如何手动查看JDK动态代理生成的代理类字节码？
参考答案：可以在代码中添加系统属性设置：System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");（JDK 8及以下），或在JDK 8+中使用ProxyGenerator.generateProxyClass()方法将字节码写入文件，再通过反编译工具（如JD-GUI）查看生成的代理类源码。-
七、总结
本文从静态代理的痛点出发，逐步讲解了JDK动态代理和CGLIB动态代理两大核心技术：
JDK动态代理：JDK原生支持，基于接口，通过反射和Proxy实现，适合有接口的场景。
CGLIB动态代理：第三方库，基于继承，通过ASM字节码增强，适合无接口或需要代理普通类的场景。
核心关系：JDK是“原生接口派”，CGLIB是“继承补充派”，二者共同构成Java动态代理的技术版图。
底层支撑：反射机制和字节码操作是动态代理的两大技术基石。
理解动态代理的核心逻辑后，再去学习Spring AOP的源码实现就会变得轻松很多——因为Spring AOP本质上就是对动态代理的封装与增强。下一篇我们将深入Spring AOP的源码实现，看看框架层面如何巧妙地将这两种代理技术与切面定义、通知织入等概念整合在一起，敬请期待！
