AI助手小琴深度解析Java动态代理：从原理到面试通关

// 静态代理类
public class UserServiceProxy implements UserService {
    private UserService target;
    
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void addUser(String username) {
        System.out.println("开始执行：addUser");
        target.addUser(username);
        System.out.println("执行完成：addUser");
    }
    
    // deleteUser、updateUser... 每个方法都得重复写一遍！
}

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

// 步骤1：定义目标接口（JDK动态代理要求必须有接口）
public interface UserService {
    void addUser(String username);
    void deleteUser(String username);
}

// 步骤2：目标类（实现接口）
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
    
    @Override
    public void deleteUser(String username) {
        System.out.println("删除用户：" + username);
    }
}

// 步骤3：实现InvocationHandler（核心：代理逻辑）
public class JdkProxyHandler implements InvocationHandler {
    private Object target;  // 目标对象
    
    public JdkProxyHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强：调用前添加日志
        System.out.println("[JDK代理] 方法 " + method.getName() + " 开始执行");
        // 通过反射调用目标对象的原始方法
        Object result = method.invoke(target, args);
        // 后置增强：调用后添加日志
        System.out.println("[JDK代理] 方法 " + method.getName() + " 执行完成");
        return result;
    }
}

// 步骤4：生成代理对象并测试
public class JdkProxyTest {
    public static void main(String[] args) {
        // 创建目标对象
        UserService target = new UserServiceImpl();
        // 创建调用处理器
        JdkProxyHandler handler = new JdkProxyHandler(target);
        // 动态生成代理对象（核心方法）
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),  // 类加载器
            target.getClass().getInterfaces(),   // 目标类实现的接口数组
            handler                              // 调用处理器
        );
        // 调用代理对象的方法
        proxy.addUser("张三");
        proxy.deleteUser("李四");
    }
}

[JDK代理] 方法 addUser 开始执行
添加用户：张三
[JDK代理] 方法 addUser 执行完成
[JDK代理] 方法 deleteUser 开始执行
删除用户：李四
[JDK代理] 方法 deleteUser 执行完成
```[reference:8]

 关键要点
- 接口限制：目标类必须实现至少一个接口，否则无法使用JDK动态代理
- 方法转发：所有对代理对象的方法调用都会被转发到`InvocationHandler.invoke()`
- 反射调用：通过`method.invoke(target, args)`以反射方式调用目标方法[reference:9]

---

 四、CGLIB动态代理：基于继承的实现方式

当目标类没有实现接口时，JDK动态代理就无能为力了。这时候需要CGLIB（Code Generation Library）登场。

 定义与原理

CGLIB是一个基于ASM字节码处理框架的代码生成库，它通过继承的方式在运行时生成目标类的子类作为代理类，并重写所有非final、非private、非static的方法，在子类中植入增强逻辑[reference:10][reference:11]。

注意：CGLIB无法代理`final`类和`final`方法，因为Java中的final类不能被继承，final方法不能被重写。

 代码示例

```java
// 引入CGLIB依赖（Maven）
// <dependency>
//     <groupId>cglib</groupId>
//     <artifactId>cglib</artifactId>
//     <version>3.3.0</version>
// </dependency>

// 步骤1：目标类（无需实现接口）
public class UserService {
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
    
    public void deleteUser(String username) {
        System.out.println("删除用户：" + username);
    }
}

// 步骤2：实现MethodInterceptor（CGLIB的调用处理器）
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibMethodInterceptor 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：生成代理对象
import net.sf.cglib.proxy.Enhancer;

public class CglibProxyTest {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);              // 设置目标类
        enhancer.setCallback(new CglibMethodInterceptor());     // 设置回调处理器
        
        UserService proxy = (UserService) enhancer.create();    // 生成代理对象
        proxy.addUser("张三");
        proxy.deleteUser("李四");
    }
}

[CGLIB代理] 方法 addUser 开始执行
添加用户：张三
[CGLIB代理] 方法 addUser 执行完成
[CGLIB代理] 方法 deleteUser 开始执行
删除用户：李四
[CGLIB代理] 方法 deleteUser 执行完成
```[reference:12][reference:13]

---

 五、概念关系与区别总结

JDK动态代理和CGLIB动态代理的关系可以用一句话概括：JDK动态代理是“接口驱动”的思想体现，CGLIB是“继承驱动”的具体实现手段——前者依赖反射，后者依赖字节码增强。

| 对比维度 | JDK动态代理 | CGLIB动态代理 |
|---------|-----------|--------------|
| 代理方式 | 基于接口（实现相同接口） | 基于继承（生成目标类的子类） |
| 目标要求 | 必须有接口 | 不需要接口，但类不能是final |
| 底层技术 | 反射 + Proxy类 | ASM字节码增强 |
| 性能特点 | JDK 8以前反射调用慢；JDK 9+优化后差距缩小 | 生成代理类速度较慢，但方法调用快 |
| 依赖 | Java标准库（无需额外依赖） | 需要引入CGLIB库（Spring已内置） |
| 限制 | 只能代理接口中声明的方法 | 无法代理final类、final方法、private方法 |
| 典型场景 | Spring AOP中代理接口类 | Spring AOP中代理无接口的类、Hibernate懒加载 |

 性能对比（JDK版本差异）

性能会随JDK版本变化：
- JDK 6：调用次数少时两者差距不大，次数增加后CGLIB稍快
- JDK 7/8：少量调用（100万次）时JDK快约30%；大量调用（5000万次）时JDK快近1倍
- JDK 9+：反射机制持续优化，性能差距明显缩小[reference:14]

> 在实际开发中，Spring AOP会根据目标类是否实现接口自动选择代理方式：有接口时默认使用JDK动态代理，无接口时自动切换至CGLIB[reference:15]。

---

 六、底层原理：JDK动态代理如何工作？

要真正理解JDK动态代理，必须了解它的底层实现机制。

 核心工作流程

1. 调用`Proxy.newProxyInstance()`时，JDK根据传入的接口数组在内存中动态拼接生成代理类的Java代码（类名如`$Proxy0`）
2. 该源码由内部JavaCompiler编译成`.class`字节码
3. 通过`defineClass0`将字节码加载到JVM中
4. 创建代理类实例，并将其与`InvocationHandler`绑定
5. 当客户端调用代理对象的方法时，代理类内部将调用统一路由到`InvocationHandler.invoke()`[reference:16]

 底层依赖的技术栈

- Java反射机制：`method.invoke(target, args)`通过反射调用目标方法
- 字节码生成：ProxyGenerator类负责生成代理类的字节码
- 类加载器：使用与目标类相同的类加载器将代理类加载到JVM[reference:17]

 调试技巧：查看生成的代理类

可以通过系统属性让JDK保存生成的代理类文件：

```java
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");