文章定位：技术科普 + 原理讲解 + 代码示例 + 面试要点
目标读者：技术入门/进阶学习者、在校学生、面试备考者、Java开发工程师

对于每一位Java开发者来说，动态代理都是一个绕不开的核心技术点。它不仅是设计模式中代理模式的高级应用，更是Spring AOP（面向切面编程）、MyBatis、RPC框架等主流技术体系的底层基石-48。很多学习者面临一个共同的困境：工作中会调用框架API，却说不清JDK动态代理和CGLIB的本质区别；面试中被问到“AOP底层怎么实现的”，回答停留在“用了动态代理”就卡住了。本文将从痛点出发，由浅入深讲解Java动态代理的两大主流实现——JDK动态代理与CGLIB，涵盖原理讲解、代码示例和面试高频考点，帮助读者建立从概念到落地的完整知识链路。

一、痛点切入：从静态代理说起

传统实现方式

假设我们需要为业务方法添加日志记录，传统的静态代理实现如下：

// 目标接口
public interface UserService {
    void addUser(String name);
    void deleteUser(int id);
}

// 目标类
public class UserServiceImpl implements UserService {
    public void addUser(String name) {
        System.out.println("添加用户：" + name);
    }
    public void deleteUser(int id) {
        System.out.println("删除用户ID：" + id);
    }
}

// 静态代理类 —— 每增加一个功能都要手动编写
public class UserServiceLogProxy implements UserService {
    private UserService target;
    public UserServiceLogProxy(UserService target) { this.target = target; }
    
    public void addUser(String name) {
        System.out.println("日志：开始添加用户");
        target.addUser(name);
        System.out.println("日志：添加完成");
    }
    // deleteUser 也要同样重复写...
}

静态代理的四大痛点

1. 代码冗余严重：每个被代理的类都需要手动编写一个代理类，接口方法越多，重复代码越多

2. 耦合度高：代理类与目标类高度耦合，业务逻辑与增强逻辑混在一起

3. 维护成本高：新增一个需要代理的类，就要新建一个代理类；修改接口方法签名，所有相关代理类都要同步修改

4. 扩展性差：想新增一种增强逻辑（如事务管理、权限校验），每个代理类都要重新修改

动态代理的设计初衷，正是为了解决静态代理的这些固有缺陷——在运行时动态生成代理类，将增强逻辑与业务逻辑彻底解耦。

二、核心概念讲解：JDK动态代理

标准定义

JDK动态代理是Java标准库（java.lang.reflect包）提供的一种基于接口的动态代理机制。它通过Proxy类和InvocationHandler接口，在运行时为目标接口动态生成代理实例，所有方法调用都会转发给InvocationHandler的invoke方法-2。

拆解关键词

• 动态：区别于静态代理在编译期写好代理类，JDK动态代理的代理类在运行时才生成字节码并加载进JVM-1

• 基于接口：代理类只能代理接口，不能代理普通类（因为生成的代理类会继承Proxy类，Java不允许多重继承，无法同时继承目标类）-1

• InvocationHandler：即“调用处理器”，是开发者实现增强逻辑的地方——代理对象的方法被调用时，最终都会进入它的invoke方法

生活化类比

可以把JDK动态代理想象成客服呼叫中心：

• 接口 = 客服承诺的服务标准（比如“接听电话、处理投诉”）

• InvocationHandler = 接线调度系统（统一接收所有来电，再根据类型分配给具体客服）

• 代理对象 = 客服总机号码（用户拨打的唯一入口）

• 目标对象 = 实际处理业务的客服人员

无论用户打来的是咨询电话还是投诉电话，都先经过调度系统（invoke），调度系统可以记录日志、验证权限，再把请求转给对应客服处理-6。

核心作用与价值

JDK动态代理让开发者可以在不修改原有代码的情况下，为接口方法统一添加增强逻辑（日志、事务、权限校验、性能监控等），极大地提升了代码的复用性和可维护性-48。

三、关联概念讲解：CGLIB动态代理

标准定义

CGLIB（Code Generation Library，代码生成库） 是一个基于ASM字节码操作框架的开源动态代理库。它通过在运行时动态生成目标类的子类来实现代理，因此可以代理没有实现接口的普通类，但无法代理final修饰的类或方法--11。

核心组件

生活化类比

CGLIB可以理解为“克隆人工厂”：

• 你给工厂一张“本体”的照片（目标类），工厂直接复制出一个“克隆人”（代理子类）

• 克隆人会遗传本体的所有非私有行为（继承父类方法）

• 克隆人身边配一个“管家”（MethodInterceptor），做什么事都要先问管家

• 管家决定：是直接执行本体行为，还是先加点“特效”（增强逻辑）再执行-11

四、概念关系与区别总结

一句话概括

JDK动态代理是基于接口的“组合”思想，CGLIB是基于继承的“子类化”思想。JDK“必须要有接口”，CGLIB“可以没有接口”。

核心对比表

五、代码示例演示

JDK动态代理完整示例

// 1. 定义接口（必须）
public interface UserService {
    void addUser(String name);
}

// 2. 目标类实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("业务逻辑：添加用户 " + name);
    }
}

// 3. 实现InvocationHandler（增强逻辑在此编写）
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() + " 开始执行，参数：" + Arrays.toString(args));
        
        // 反射调用目标方法
        Object result = method.invoke(target, args);
        
        // 后置增强
        System.out.println("【日志】方法 " + method.getName() + " 执行完成，返回值：" + result);
        return result;
    }
}

// 4. 使用代理
public class Demo {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),  // 类加载器
            target.getClass().getInterfaces(),   // 接口数组
            new LogInvocationHandler(target)     // 调用处理器
        );
        proxy.addUser("张三");
    }
}
// 输出：
// 【日志】方法 addUser 开始执行，参数：[张三]
// 业务逻辑：添加用户 张三
// 【日志】方法 addUser 执行完成，返回值：null

CGLIB动态代理完整示例

// 1. 定义普通类（无需接口）
public class UserService {
    public void addUser(String name) {
        System.out.println("业务逻辑：添加用户 " + name);
    }
}

// 2. 实现MethodInterceptor
public class LogMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("【日志】方法 " + method.getName() + " 开始执行");
        // ⚠️ 注意：必须使用 invokeSuper，而不是 method.invoke()
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("【日志】方法 " + method.getName() + " 执行完成");
        return result;
    }
}

// 3. 使用代理
public class Demo {
    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("张三");
    }
}

关键要点总结

1. JDK动态代理必须基于接口，如果目标类没有实现接口，调用Proxy.newProxyInstance会抛出IllegalArgumentException

2. CGLIB代理必须在intercept()中使用proxy.invokeSuper()，如果误用method.invoke()会导致无限递归

3. 两者生成的代理对象类型不同：JDK代理类名形如$Proxy0，CGLIB代理类名形如UserService$$EnhancerByCGLIB$$xxx-13

六、底层原理与技术支撑

JDK动态代理底层原理

当调用Proxy.newProxyInstance()时，JDK内部会执行三个步骤-1-6：

1. 生成字节码：根据传入的接口数组，在内存中拼装出一个实现所有这些接口的Java类字节码。这个代理类会继承Proxy，所有接口方法的实现都统一调用InvocationHandler.invoke()

2. 类加载：使用指定的ClassLoader将生成的字节码加载进JVM，得到代理类的Class对象

3. 实例化：通过反射调用代理类的构造函数（构造器固定为public $Proxy0(InvocationHandler h)），传入InvocationHandler实例，生成代理对象

技术依赖：JDK动态代理底层依赖Java反射机制（Method.invoke），同时使用内部的sun.misc.ProxyGenerator来生成字节码-13。

CGLIB动态代理底层原理

CGLIB通过ASM（一个轻量级的Java字节码操作框架） 来动态生成类字节码--。核心流程如下-11：

1. 创建Enhancer：配置代理的目标父类（setSuperclass）和回调拦截器（setCallback）

2. ASM字节码生成：扫描目标类的所有非final方法，通过ASM生成目标类的子类字节码

3. 方法重写：生成的子类会重写父类中的所有非final方法，在方法体内调用MethodInterceptor.intercept()

4. 类加载与实例化：加载子类字节码并创建实例

关键技术：CGLIB使用FastClass机制为代理类和目标类生成方法索引表，通过索引直接调用方法（类似数组下标访问），避免了反射调用，这是其执行效率更高的底层原因-46。

七、高频面试题与参考答案

面试题1：JDK动态代理和CGLIB有什么区别？

答案要点：从原理、限制条件、性能、依赖四个维度回答，体现逻辑层次。

面试题2：JDK动态代理为什么只能代理接口？

标准答案：因为JDK动态代理生成的代理类会继承Proxy类，而Java是单继承的，所以代理类无法再继承目标类。但代理类可以实现多个接口，因此只能通过实现接口的方式来代理目标对象-1。

面试题3：Spring AOP默认使用哪种动态代理？如何强制切换？

标准答案：

• 默认策略：如果目标类实现了接口，Spring默认使用JDK动态代理；如果没有实现接口，则自动切换为CGLIB-21

• 强制切换：通过@EnableAspectJAutoProxy(proxyTargetClass = true)强制使用CGLIB-12

• 配置方式：在application.properties中配置spring.aop.proxy-target-class=true

面试题4：动态代理的“动态”体现在哪里？

标准答案：体现在代理类在运行时动态生成，而非编译期手动编写。

• JDK动态代理：运行时根据接口和InvocationHandler，通过ProxyGenerator生成字节码并加载

• CGLIB：运行时通过ASM生成目标类的子类字节码并加载

• 核心优势：只需一套增强逻辑，即可动态为任意多个目标对象生成代理，无需为每个类单独编写代理类-58

八、结尾总结

核心知识点回顾

1. 动态代理的核心价值：解决静态代理的代码冗余和耦合问题，实现增强逻辑与业务逻辑的解耦

2. JDK动态代理：基于接口、反射机制，JDK原生支持，生成快调用稍慢

3. CGLIB：基于继承、ASM字节码增强，可代理无接口类，生成慢但调用快

4. Spring AOP选型策略：有接口优先JDK，无接口自动CGLIB

5. 底层技术栈：JDK依赖反射+ProxyGenerator，CGLIB依赖ASM字节码操作

高频易错点提醒

• 误区一：CGLIB比JDK动态代理“全面更好”——实际上生成速度更慢，且无法代理final类

• 误区二：在MethodInterceptor.intercept()中误用method.invoke()导致无限递归——必须使用proxy.invokeSuper()

• 误区三：认为Spring AOP全部使用同一种代理——实际是智能选择

下篇预告

下一篇将深入讲解Spring AOP的底层实现源码分析，从ProxyFactory的代理选择逻辑到JdkDynamicAopProxy和CglibAopProxy的实现细节，结合源码剖析Spring如何优雅地融合两种代理机制。敬请期待！

📌 本文适合收藏：概念讲解 + 代码示例 + 面试考点，一文覆盖动态代理全链路知识。如有疑问，欢迎在评论区留言交流！