Java 代理模式完全指南：从静态到动态

步骤四：客户端调用

public class Client { 
    public static void main(String[] args) { 
        MessageService real = new MessageServiceImpl(); 
        MessageService proxy = new MessageServiceProxy(real); 
        proxy.deliver("Hello, Proxy Pattern!"); 
    } 
}

执行结果：

[代理] 开始处理消息，内容长度：22
正在发送消息：Hello, Proxy Pattern!
[代理] 消息处理完成，返回结果：Hello, Proxy Pattern!

三、动态代理：运行时生成代理类

动态代理将代理类的生成时机推迟到程序运行阶段，JVM 会在内存中动态构建代理类的字节码并加载。这彻底解决了静态代理"一个目标类对应一个代理类"的痛点。

技术价值：

• Spring AOP 的底层基石
• RPC 框架（如 Dubbo）的核心实现
• 事务管理、日志记录、权限校验的通用解决方案

Java 生态中主流的动态代理技术分为 JDK 内置实现 和 CGLIB 第三方库 两种。

四、JDK 动态代理：官方标准方案

4.1 技术架构

JDK 动态代理依赖两个核心组件：

Proxy.newProxyInstance() 方法签名：

public static Object newProxyInstance( 
    ClassLoader loader,      // 类加载器：用于加载动态生成的代理类 
    Class<?>[] interfaces,   // 接口数组：代理类需要实现的接口列表 
    InvocationHandler h      // 处理器：方法调用的实际处理者 
)

InvocationHandler.invoke() 方法：

public Object invoke( 
    Object proxy,    // 代理对象实例（慎用，避免循环调用） 
    Method method,   // 被调用的方法反射对象 
    Object[] args    // 方法参数数组 
)

4.2 实现流程

第一步：定义业务契约与实现

// 接口（JDK 动态代理必须基于接口）
public interface PaymentService { 
    boolean pay(String orderId, BigDecimal amount); 
}

// 真实实现
public class PaymentServiceImpl implements PaymentService { 
    @Override 
    public boolean pay(String orderId, BigDecimal amount) { 
        System.out.printf("执行支付：订单 [%s], 金额 [￥%s]%n", orderId, amount); 
        return true; 
    } 
}

第二步：实现调用处理器

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;

public class PerformanceInvocationHandler implements InvocationHandler { 
    private final Object targetObject;
    
    public PerformanceInvocationHandler(Object target) { 
        this.targetObject = target; 
    }
    
    @Override 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        long startTime = System.currentTimeMillis(); 
        System.out.printf("[监控] 方法：%s, 参数：%s%n", method.getName(), Arrays.toString(args)); 
        // 通过反射调用目标对象的真实方法
        Object result = method.invoke(targetObject, args); 
        long cost = System.currentTimeMillis() - startTime; 
        System.out.printf("[监控] 执行耗时：%dms, 返回值：%s%n", cost, result); 
        return result; 
    } 
}

第三步：创建代理工厂

import java.lang.reflect.Proxy;

public class ServiceProxyFactory { 
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T target) { 
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(), 
            target.getClass().getInterfaces(), 
            new PerformanceInvocationHandler(target)
        ); 
    } 
}

第四步：业务调用

public class Application { 
    public static void main(String[] args) { 
        PaymentService realService = new PaymentServiceImpl(); 
        PaymentService proxy = ServiceProxyFactory.createProxy(realService); 
        proxy.pay("ORD-2024-001", new BigDecimal("199.99")); 
    } 
}

输出：

[监控] 方法：pay, 参数：[ORD-2024-001, 199.99]
执行支付：订单 [ORD-2024-001], 金额 [￥199.99]
[监控] 执行耗时：12ms, 返回值：true

五、CGLIB 动态代理：无接口的继承方案

5.1 技术背景

JDK 动态代理有一个先天限制：只能代理实现了接口的类。对于没有接口的遗留类或第三方类，CGLIB（Code Generation Library）提供了基于继承的解决方案。

核心机制：

• 在运行时动态生成目标类的子类
• 通过方法重写（Override）插入增强逻辑
• 使用 ASM 字节码操作库生成类

关键组件：

5.2 依赖配置

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

5.3 完整实现

场景：为无接口的类添加缓存功能

第一步：定义目标类（无接口）

public class DataQueryService { 
    // 模拟耗时查询
    public String queryFromDatabase(String sql) { 
        System.out.println("执行数据库查询：" + sql); 
        try { 
            Thread.sleep(100); // 模拟耗时
        } catch (InterruptedException e) { 
            Thread.currentThread().interrupt(); 
        } 
        return "Result of: " + sql; 
    }
    
    public final String querySystemConfig(String key) { 
        // final 方法无法被代理
        return "SystemConfig:" + key; 
    } 
}

第二步：实现方法拦截器

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class CacheMethodInterceptor implements MethodInterceptor { 
    private final Map<String, Object> cache = new HashMap<>();
    
    @Override 
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
        String cacheKey = method.getName() + ":" + args[0]; 
        // 检查缓存
        if (cache.containsKey(cacheKey)) { 
            System.out.println("[缓存] 命中：" + cacheKey); 
            return cache.get(cacheKey); 
        }
        // 执行真实方法（使用 MethodProxy 避免反射开销）
        System.out.println("[缓存] 未命中，执行真实方法：" + method.getName()); 
        Object result = proxy.invokeSuper(obj, args); 
        // 存入缓存
        cache.put(cacheKey, result); 
        System.out.println("[缓存] 已存储：" + cacheKey); 
        return result; 
    } 
}

第三步：创建代理生成器

import net.sf.cglib.proxy.Enhancer;

public class CglibProxyGenerator { 
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(Class<T> targetClass) { 
        Enhancer enhancer = new Enhancer(); 
        // 设置父类（被代理的类）
        enhancer.setSuperclass(targetClass); 
        // 设置回调（方法拦截器）
        enhancer.setCallback(new CacheMethodInterceptor()); 
        // 创建代理实例
        return (T) enhancer.create(); 
    } 
}

第四步：客户端调用

public class CglibDemo { 
    public static void main(String[] args) { 
        DataQueryService proxy = CglibProxyGenerator.createProxy(DataQueryService.class); 
        // 第一次调用：执行真实方法
        String result1 = proxy.queryFromDatabase("SELECT * FROM users"); 
        System.out.println("结果 1: " + result1); 
        System.out.println("---"); 
        // 第二次调用：命中缓存
        String result2 = proxy.queryFromDatabase("SELECT * FROM users"); 
        System.out.println("结果 2: " + result2); 
        // final 方法无法被代理，直接调用父类实现
        System.out.println("---"); 
        String config = proxy.querySystemConfig("timeout"); 
        System.out.println("配置：" + config); 
    } 
}

输出结果：

[缓存] 未命中，执行真实方法：queryFromDatabase
执行数据库查询：SELECT * FROM users
[缓存] 已存储：queryFromDatabase:SELECT * FROM users
结果 1: Result of: SELECT * FROM users
---
[缓存] 命中：queryFromDatabase:SELECT * FROM users
结果 2: Result of: SELECT * FROM users
---
配置：SystemConfig:timeout

重要提示：MethodProxy.invokeSuper() 是 CGLIB 的关键，它通过 FastClass 机制直接调用父类方法，避免了反射的性能损耗。如果误用 method.invoke(obj, args) 会导致循环调用（因为 obj 是代理对象，会再次触发拦截器）。

六、两种动态代理深度对比

6.1 技术实现差异

6.2 性能与适用场景

性能表现：

• JDK 动态代理：随着 JDK 版本升级（尤其是 JDK 8 之后），反射性能已大幅优化，在大多数场景下与 CGLIB 差距不大
• CGLIB：首次生成代理类较慢（需要生成字节码），但调用阶段通过 FastClass 机制略快

选型建议：

if (目标类实现了接口) {
    // 优先使用 JDK 动态代理（Spring 默认策略）
} else {
    // 使用 CGLIB 动态代理
}
// Spring 强制使用 CGLIB 的配置
@EnableAspectJAutoProxy(proxyTargetClass = true)

七、静态代理与动态代理全局对比

八、总结与实践建议

8.1 知识要点回顾

1. 代理模式本质：通过中间层控制访问，实现功能增强
2. 静态代理：手工编码，编译期确定，适合简单固定场景
3. JDK 动态代理：基于接口，使用 Proxy + InvocationHandler，官方标准方案
4. CGLIB 动态代理：基于继承，使用 Enhancer + MethodInterceptor，解决无接口类的代理问题

8.2 实际开发建议

• 日常业务开发：直接使用 Spring AOP（底层已封装两种代理，自动选择）
• 框架工具开发：根据目标类特性选择 JDK 或 CGLIB 原生 API
• 性能敏感场景：考虑使用字节码生成库（如 ByteBuddy、Javassist）获得更细粒度控制
• 调试技巧：设置系统属性保存生成的代理类文件，便于分析排查问题

// 保存 JDK 动态代理类
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
// 保存 CGLIB 代理类
System.setProperty("cglib.debugLocation", "/path/to/output");

掌握代理模式不仅是理解 Spring AOP、MyBatis、Dubbo 等框架的基础，更是写出高扩展性、低耦合代码的重要技能。建议通过手写 RPC 框架或简易 AOP 来加深理解。