Java案例如何实现代理模式？

wen java案例 2026-06-11 13

Java代理模式实战：从静态代理到动态代理的完整案例解析

目录导读

代理模式的核心定义与适用场景
静态代理实现案例（含代码剖析）
动态代理实现案例（JDK与CGLIB对比）
常见问题解答（FAQ）
总结与最佳实践

代理模式的核心定义与适用场景

问：什么是代理模式？
代理模式（Proxy Pattern）是一种结构型设计模式，通过提供一个代理对象来控制对真实对象的访问，在Java中，代理类与真实类实现相同接口，客户端通过代理间接操作真实对象，从而在方法调用前后插入额外逻辑（如日志、权限校验、事务控制等）。

Java案例如何实现代理模式？

问：何时使用代理模式？

需要为某个对象添加功能,但不想修改其代码（开闭原则）。
真实对象创建成本高（如数据库连接池、大文件加载），可使用虚代理延迟实例化。
远程调用场景中（RMI、WebService），代理负责网络传输。
安全控制：禁止直接访问真实对象，仅通过代理进行权限验证。

核心角色：

Subject（抽象主题）：定义真实对象与代理的共同接口。
RealSubject（真实主题）：业务逻辑的真实实现。
Proxy（代理）：持有RealSubject引用，提供与其相同接口，并增强方法调用。

静态代理实现案例（含代码剖析）

场景：模拟一个用户服务，业务方法执行前后需要打印日志。
步骤：

定义接口 UserService。
编写真实实现 UserServiceImpl。
编写静态代理 UserServiceProxy，注入真实对象并在方法前后加日志。

代码示例：

// 1. 抽象接口
public interface UserService {
    void addUser(String username);
}
// 2. 真实业务类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
}
// 3. 静态代理类
public class UserServiceProxy implements UserService {
    private UserService target; // 持有真实对象
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    @Override
    public void addUser(String username) {
        System.out.println("[日志] 开始添加用户...");
        target.addUser(username);
        System.out.println("[日志] 添加完成。");
    }
}
// 客户端测试
public class Client {
    public static void main(String[] args) {
        UserService realService = new UserServiceImpl();
        UserService proxy = new UserServiceProxy(realService);
        proxy.addUser("张三");
    }
}

优点：实现简单，易于理解。
缺点：

一个代理类只能服务一种接口,若要代理多个接口需编写多个代理类。
真实方法增减时,代理类需同步修改，维护成本高。
代码侵入性强,业务逻辑与代理逻辑耦合。

动态代理实现案例（JDK与CGLIB对比）

问：动态代理如何解决静态代理的局限性？
动态代理在运行时动态生成代理类，无需为每个接口编写独立的代理类，Java提供了两种主流方式：

1 JDK动态代理（基于接口）

要求真实对象必须实现接口。
通过 java.lang.reflect.Proxy 和 InvocationHandler 实现。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class LogHandler implements InvocationHandler {
    private Object target; // 真实对象
    public LogHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[JDK动态代理] 前置日志");
        Object result = method.invoke(target, args);
        System.out.println("[JDK动态代理] 后置日志");
        return result;
    }
    // 封装获取代理对象的方法
    public static Object createProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new LogHandler(target)
        );
    }
}
// 使用（需接口 UserService）
UserService realService = new UserServiceImpl();
UserService proxy = (UserService) LogHandler.createProxy(realService);
proxy.addUser("李四");

运行原理：
Proxy.newProxyInstance 在内存中生成一个实现指定接口的匿名类，所有方法调用会分发给 InvocationHandler.invoke()。

2 CGLIB动态代理（基于子类）

无需接口,直接代理类。
通过ASM字节码框架生成真实类的子类,覆盖其方法。

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibLogInterceptor implements MethodInterceptor {
    private Object target;
    public CglibLogInterceptor(Object target) {
        this.target = target;
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("[CGLIB] 前置日志");
        Object result = proxy.invoke(target, args); // 调用真实对象方法
        System.out.println("[CGLIB] 后置日志");
        return result;
    }
    public static Object createProxy(Object target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(new CglibLogInterceptor(target));
        return enhancer.create();
    }
}
// 使用
UserServiceImpl realService = new UserServiceImpl();
UserServiceImpl proxy = (UserServiceImpl) CglibLogInterceptor.createProxy(realService);
proxy.addUser("王五");

注意：CGLIB不能代理 final 类或 final 方法，Spring AOP默认使用JDK动态代理（接口存在时），否则回退到CGLIB。

常见问题解答（FAQ）

Q1：JDK动态代理和CGLIB代理，哪个性能更好？

JDK动态代理基于反射调用,CGLIB基于ASM字节码生成子类并直接调用，在频繁方法调用的场景下，JDK反射性能略低于CGLIB，但差距随JDK版本（如JDK 8+）逐渐缩小。
建议：如果业务类实现了接口，优先JDK动态代理；否则使用CGLIB。

Q2：代理模式与装饰器模式的本质区别是什么？

代理模式：控制访问（如权限、延迟加载），客户端只与代理交互。
装饰器模式：动态添加功能，客户端直接与装饰链交互。
核心区别在于意图：代理侧重于控制，装饰器侧重于增强。

Q3：Spring AOP中如何选择代理模式？
Spring会判断目标Bean是否实现了接口：

实现接口 → 使用JDK动态代理。
未实现接口 → 使用CGLIB。
这行为可由 <aop:config proxy-target-class="true"/> 或 @EnableAspectJAutoProxy(proxyTargetClass=true) 强制使用CGLIB。

Q4：代理模式在哪些实际项目中常见？

远程调用框架（如Feign、Dubbo）。
事务管理（Spring @Transactional）。
延迟加载（MyBatis懒加载代理）。
权限框架（Apache Shiro、Spring Security）。

总结与最佳实践

代理模式是Java企业级开发中不可或缺的设计模式,本文将案例与理论结合，梳理了三种实现方式：

类型	优点	缺点	适用场景
静态代理	实现简单	扩展性差	单一接口，稳定不变
JDK动态代理	无侵入，面向接口	需接口实现	多接口、重抽象
CGLIB动态代理	无需接口	无法代理final类	无接口或难以抽象