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

Java 代理模式完全指南：从静态到动态 | 极客日志

public interface MessageService { 
    String deliver(String content); 
}

public class MessageServiceImpl implements MessageService { 
    @Override 
    public String deliver(String content) { 
        System.out.println("正在发送消息：" + content); 
        return content; 
    } 
}

public class MessageServiceProxy implements MessageService { 
    private final MessageService realService;
    
    public MessageServiceProxy(MessageService service) { 
        this.realService = service; 
    }
    
    @Override 
    public String deliver(String content) { 
        // 前置处理
        System.out.println("[代理] 开始处理消息，内容长度：" + content.length()); 
        // 调用真实对象
        String result = realService.deliver(content); 
        // 后置处理
        System.out.println("[代理] 消息处理完成，返回结果：" + result); 
        return result; 
    } 
}

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!

组件	类型	职责
`java.lang.reflect.Proxy`	类	工厂类，负责生成代理对象
`java.lang.reflect.InvocationHandler`	接口	回调接口，定义方法拦截逻辑

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

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

// 接口（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

组件	类型	职责
`net.sf.cglib.proxy.Enhancer`	类	配置并生成代理类
`net.sf.cglib.proxy.MethodInterceptor`	接口	定义方法拦截逻辑
`net.sf.cglib.proxy.MethodProxy`	类	高性能方法调用（避免反射）

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

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

对比维度	JDK 动态代理	CGLIB 动态代理
实现原理	实现接口（生成接口的实现类）	继承类（生成目标类的子类）
强制要求	目标类必须实现接口	目标类不能是 final 类
方法限制	接口定义的所有方法	非 final、非 private 方法
核心类	`Proxy`、`InvocationHandler`	`Enhancer`、`MethodInterceptor`
方法调用	Java 反射（相对较慢）	FastClass 机制（方法索引，更快）
包归属	JDK 内置（`java.lang.reflect`）	第三方库（`net.sf.cglib`）
生成类名	`com.sun.proxy.$Proxy0`	`Target$$EnhancerByCGLIB$$hash`

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

特性	静态代理	动态代理
代理类生成时机	编译期（预先编写 `.java` 文件）	运行期（内存中生成字节码）
实现方式	手动编写代理类，需与目标类实现同一接口，一对一绑定	无需手动编写代理类，通过 `Handler`/`Interceptor` 封装增强逻辑，一对多复用
代码维护成本	高（接口变更需同步修改代理类）	低（与接口解耦，逻辑复用）
灵活性	低（一对一绑定）	高（一个处理器服务多个目标类）
编码工作量	代码量大（目标类越多，代理类越多），维护成本高；接口新增方法时，目标类与代理类需同步修改	代码量极少（通用增强逻辑可复用），维护性好；与接口解耦，接口变更不影响代理逻辑
学习曲线	平缓（纯 Java 语法）	较陡（需理解反射/字节码）
典型应用	设计模式学习、简单装饰场景	框架开发（AOP、RPC、ORM）

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

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

一、理解代理模式本质

二、静态代理：手动编码的代理方式

2.1 核心特点

2.2 完整实现示例

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

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

4.1 技术架构

4.2 实现流程

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

5.1 技术背景

5.2 依赖配置

5.3 完整实现

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

6.1 技术实现差异

6.2 性能与适用场景

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

八、总结与实践建议

8.1 知识要点回顾

8.2 实际开发建议

更多推荐文章

相关免费在线工具

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

一、理解代理模式本质

二、静态代理：手动编码的代理方式

2.1 核心特点

2.2 完整实现示例

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

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

4.1 技术架构

4.2 实现流程

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

5.1 技术背景

5.2 依赖配置

5.3 完整实现

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

6.1 技术实现差异

6.2 性能与适用场景

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

八、总结与实践建议

8.1 知识要点回顾

8.2 实际开发建议

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具