在Java面试中，动态代理是几乎绕不开的高频考点——Spring AOP的底层实现、RPC框架的远程调用伪装、MyBatis的接口代理，都离不开它的身影-18。然而很多开发者“会用却不懂原理”：知道怎么写Proxy.newProxyInstance()，却说不出代理类是如何在运行时生成的；能说出JDK和CGLIB的区别，却回答不了“JDK动态代理为什么只能代理接口”；面试中被追问到底层原理时，更是容易卡壳。本文将从痛点场景 → 核心概念 → 代码实战 → 底层原理 → 面试考点层层递进，一次性帮你吃透Java动态代理。
一、痛点切入：为什么需要动态代理？
先看静态代理。假设有一个UserService接口及其实现类，现在想给每个方法加上日志记录：
// 接口public interface UserService { void createUser(String username); void deleteUser(Long id); } // 静态代理类 public class UserServiceProxy implements UserService { private UserService target; public UserServiceProxy(UserService target) { this.target = target; } @Override public void createUser(String username) { System.out.println("开始执行：createUser"); target.createUser(username); System.out.println("执行结束：createUser"); } @Override public void deleteUser(Long id) { System.out.println("开始执行：deleteUser"); target.deleteUser(id); System.out.println("执行结束：deleteUser"); } }
静态代理的致命缺陷是：每新增一个接口，就要手写一个代理类；接口里每新增一个方法，代理类就要追加对应的转发逻辑。当项目中有几十个Service接口时，代码重复和维护成本将急剧膨胀-。
动态代理正是为解决这一痛点而生：在运行时动态生成代理类，一套代理逻辑可复用于任意目标对象，真正实现“一次编写，处处生效”-18。
二、核心概念讲解：JDK动态代理
JDK动态代理（JDK Dynamic Proxy） 是Java官方提供的动态代理实现，位于java.lang.reflect包下。其核心定义：在程序运行时，通过反射机制动态生成一个实现了指定接口的代理类，并将所有方法调用统一转发给InvocationHandler的invoke方法进行处理。
生活化类比： 想象你开了一家连锁餐厅，原本每家分店都要自己处理顾客投诉、记录营收报表、应对卫生检查——这些“辅助工作”如同静态代理，每家店都得配一套人马。动态代理就像你聘请了一家统一的服务托管公司，所有分店的辅助工作都由它集中处理，你只管做好菜。无论新开多少家分店（对应任意目标类），只需一份托管协议（一套InvocationHandler），就能自动享有所有辅助功能。
JDK动态代理依赖三剑客：
| 组件 | 作用 |
|---|---|
InvocationHandler接口 | 定义代理逻辑的处理者，需实现invoke()方法 |
Method类 | 表示具体方法，通过它可在运行时反射调用目标方法 |
Proxy类 | 提供newProxyInstance()方法，动态生成代理类和实例 |
-18
三、关联概念讲解：CGLIB动态代理
CGLIB动态代理（Code Generation Library Dynamic Proxy） 是一个基于ASM字节码框架的第三方动态代理库。它通过动态生成目标类的子类来实现代理，因此不要求目标类实现接口-。
// CGLIB代理示例 Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(UserService.class); // 设置父类（目标类） enhancer.setCallback(new MethodInterceptor() { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("Before " + method.getName()); Object result = proxy.invokeSuper(obj, args); System.out.println("After " + method.getName()); return result; } }); UserService proxy = (UserService) enhancer.create();
核心限制：CGLIB无法代理final类或final方法，因为Java不允许继承final类-16。
四、概念关系与区别总结
JDK动态代理与CGLIB的核心差异如下-45：
| 对比维度 | JDK动态代理 | CGLIB动态代理 |
|---|---|---|
| 实现原理 | 基于接口，反射生成代理类 | 基于继承，字节码生成子类 |
| 接口要求 | 目标类必须实现接口 | 不要求接口 |
| 代理限制 | 只能代理接口方法 | 无法代理final类/方法 |
| 依赖 | JDK原生，无需第三方库 | 需引入cglib库 |
| 性能 | 创建代理快，调用略慢（反射） | 创建代理慢，调用快（直接调用） |
| 适用场景 | 目标类有接口 + 轻量级需求 | 目标类无接口 + 需拦截内部调用 |
一句话概括：JDK动态代理是“面向接口的思想”，CGLIB是“面向类的落地”——前者遵循“面向接口编程”的设计原则，后者在底层用继承解决了无接口类的代理问题。
五、代码/流程示例演示
下面通过一个完整示例，展示JDK动态代理的工作流程：
// 第1步：定义接口 public interface HelloService { String sayHello(String name); } // 第2步：实现类（目标对象） public class HelloServiceImpl implements HelloService { @Override public String sayHello(String name) { return "Hello, " + name; } } // 第3步：实现InvocationHandler，定义代理逻辑 import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class LoggingHandler implements InvocationHandler { private final Object target; // 持有目标对象 public LoggingHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 前置增强 System.out.println("[LOG] 开始执行方法：" + method.getName()); long start = System.currentTimeMillis(); // 反射调用目标方法 Object result = method.invoke(target, args); // 后置增强 long end = System.currentTimeMillis(); System.out.println("[LOG] 方法执行完毕，耗时：" + (end - start) + "ms"); return result; } } // 第4步：使用Proxy.newProxyInstance创建代理对象 public class Main { public static void main(String[] args) { // 创建目标对象 HelloService target = new HelloServiceImpl(); // 创建InvocationHandler InvocationHandler handler = new LoggingHandler(target); // 动态生成代理对象 HelloService proxy = (HelloService) Proxy.newProxyInstance( target.getClass().getClassLoader(), // 类加载器 target.getClass().getInterfaces(), // 接口数组 handler // 调用处理器 ); // 调用代理对象的方法 String result = proxy.sayHello("张三"); System.out.println("结果：" + result); } } // 输出： // [LOG] 开始执行方法：sayHello // [LOG] 方法执行完毕，耗时：0ms // 结果：Hello, 张三
关键流程解析：
Proxy.newProxyInstance()在运行时生成一个名为$Proxy0的代理类（继承Proxy并实现HelloService接口）-；调用
proxy.sayHello()时，实际执行的是代理类中重写的方法；代理类方法内部调用
super.h.invoke(...)，即执行我们编写的LoggingHandler.invoke()；invoke()中通过method.invoke(target, args)反射调用目标对象的真实方法；在反射调用前后插入日志、耗时统计等增强逻辑。
六、底层原理/技术支撑
动态代理的底层依赖两大关键技术：
1. 反射机制（Reflection）InvocationHandler.invoke()中通过Method.invoke()调用目标方法，本质是在运行时动态获取方法的元信息并执行，这是Java反射API提供的核心能力-。
2. 运行时字节码生成Proxy.newProxyInstance()内部调用ProxyGenerator.generateProxyClass()，直接拼装字节码生成$Proxy0类——不经过Java源码编译，跳过了语法校验和语义分析，属于字节码层面的硬编码操作-4。
生成的代理类继承了java.lang.reflect.Proxy，持有InvocationHandler引用，并实现了所有指定接口。正因为代理类已经继承了Proxy，而Java不支持多重继承，所以JDK动态代理只能代理接口，无法代理普通类-5。
七、高频面试题与参考答案
面试题1：JDK动态代理和CGLIB有什么区别？
参考答案：
实现原理：JDK基于接口，通过反射生成代理类；CGLIB基于继承，通过ASM字节码生成子类。
接口要求：JDK要求目标类必须实现接口；CGLIB不要求接口，但无法代理
final类/方法。依赖：JDK原生支持；CGLIB需引入第三方库。
性能：JDK创建代理对象快，但方法调用有反射开销；CGLIB创建代理慢，运行时调用更快。JDK 8后两者性能差距已显著缩小。
Spring AOP策略：默认优先使用JDK动态代理（有接口时），无接口时自动fallback到CGLIB。
-29
面试题2：为什么JDK动态代理只能代理接口？
参考答案：
JDK生成的代理类（如$Proxy0）已经继承了java.lang.reflect.Proxy类。Java是单继承语言，代理类无法再继承其他类，因此只能通过实现接口来代理目标对象的行为。若传入一个没有接口的类，Proxy.newProxyInstance()会抛出IllegalArgumentException: interface is required-5。
面试题3：Spring AOP的底层是如何实现的？
参考答案：
Spring AOP底层依赖动态代理技术。Spring容器在初始化时，会扫描匹配切点表达式的Bean，根据目标类是否实现接口自动选择代理方式：
目标类有接口 → 使用JDK动态代理
目标类无接口 → 使用CGLIB动态代理
可通过@EnableAspectJAutoProxy(proxyTargetClass = true)强制使用CGLIB-28。
面试题4：InvocationHandler的invoke()方法中，proxy参数是做什么用的？
参考答案：proxy是动态生成的代理对象本身。在invoke()中可通过它调用代理对象的方法（如proxy.toString()），但必须避免在invoke()中递归调用代理对象自身的方法，否则会无限循环导致StackOverflowError。
面试题5：动态代理有哪些典型应用场景？
参考答案：
Spring AOP的横切增强（日志、事务、权限控制）
RPC框架的远程调用伪装（如Dubbo）
MyBatis的Mapper接口代理
方法级缓存、性能监控、延迟加载
-19
八、结尾总结
回顾全文核心知识点：
动态代理解决了什么：静态代理的代码冗余和扩展性问题，实现“一套代理逻辑复用任意目标对象”。
JDK vs CGLIB：JDK面向接口，原生轻量；CGLIB面向类，功能更强。面试中务必分清两者原理差异和使用限制。
底层两大支撑：反射机制 + 运行时字节码生成。
高频考点：Spring AOP的代理策略、接口代理的原因、JDK与CGLIB的性能差异。
一句话记忆：动态代理 = 运行时生成 + 统一转发 + 方法增强。理解了这个公式，就能打通从概念到源码的完整知识链路。
下一篇我们将深入分析$Proxy0的字节码结构，拆解ProxyGenerator的生成策略，带你从字节码层面彻底看清动态代理的“黑盒”实现。
