代理设计模式全方位深度解析代理模式（Proxy Pattern）是结构型设计模式，为其他对象提供一种代理（或替身）

一、核心概念与设计意图

1.1 模式定义

代理模式（Proxy Pattern）是结构型设计模式，为其他对象提供一种代理（或替身） 以控制对这个对象的访问。代理模式在不改变原始类代码的情况下，通过引入代理类来增加或增强功能。

1.2 UML类图结构

复制
┌─────────────────┐      ┌─────────────────┐      ┌─────────────────┐
│    Subject      │      │   RealSubject   │      │     Proxy       │
├────────────────-┤      ├────────────────-┤      ├────────────────-┤
│ +request():void │<---->│ +request():void │      │ -realSubject    │
└─────────────────┘      └─────────────────┘      │ +request():void │
         ^                      ^                 └─────────────────┘
         |                      |                          ^
         └──────────────────────┼──────────────────────────┘
                                │
                     ┌─────────────────┐
                     │   Client        │
                     └─────────────────┘

二、三种实现方式详解（含完整Java源代码）

2.1 静态代理

2.1.1 基础实现

java
java
下载
复制
// 1. 定义接口
public interface UserService {
    void addUser(String username);
    void deleteUser(String username);
    User getUser(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);
    }
    
    @Override
    public User getUser(String username) {
        System.out.println("查询用户: " + username);
        return new User(username, "user@example.com");
    }
}

// 3. 静态代理类
public class UserServiceProxy implements UserService {
    private final UserService realService;
    private final boolean hasPermission;
    
    public UserServiceProxy(UserService realService, boolean hasPermission) {
        this.realService = realService;
        this.hasPermission = hasPermission;
    }
    
    @Override
    public void addUser(String username) {
        // 前置增强
        long startTime = System.currentTimeMillis();
        System.out.println("【代理】开始执行添加用户操作");
        
        // 权限校验
        if (!hasPermission) {
            System.out.println("【代理】权限不足，操作被拒绝");
            return;
        }
        
        // 调用真实对象
        realService.addUser(username);
        
        // 后置增强
        long endTime = System.currentTimeMillis();
        System.out.println("【代理】操作耗时: " + (endTime - startTime) + "ms");
    }
    
    @Override
    public void deleteUser(String username) {
        // 类似的增强逻辑
        System.out.println("【代理】开始删除用户...");
        realService.deleteUser(username);
    }
    
    @Override
    public User getUser(String username) {
        System.out.println("【代理】开始查询用户...");
        return realService.getUser(username);
    }
}

// 4. 客户端使用
public class StaticProxyDemo {
    public static void main(String[] args) {
        // 创建真实对象
        UserService realService = new UserServiceImpl();
        
        // 创建代理对象
        UserService proxy = new UserServiceProxy(realService, true);
        
        // 通过代理调用
        proxy.addUser("张三");
        proxy.getUser("张三");
    }
}

2.1.2 静态代理的局限性

需要为每个真实类编写代理类
接口方法变更时，代理类也需要同步修改
代码冗余度高，维护困难

2.2 JDK动态代理

2.2.1 核心实现原理

java
java
下载
复制
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

// 1. 通用增强处理器
public class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;
    private final boolean enableLogging;
    private final boolean enableTransaction;
    
    public LoggingInvocationHandler(Object target) {
        this(target, true, false);
    }
    
    public LoggingInvocationHandler(Object target, boolean enableLogging, 
                                   boolean enableTransaction) {
        this.target = target;
        this.enableLogging = enableLogging;
        this.enableTransaction = enableTransaction;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法调用前的增强
        if (enableLogging) {
            System.out.println("【动态代理】方法调用前: " + method.getName());
            System.out.println("【动态代理】参数: " + Arrays.toString(args));
        }
        
        // 事务控制
        if (enableTransaction) {
            beginTransaction();
        }
        
        Object result = null;
        try {
            // 调用真实对象的方法
            result = method.invoke(target, args);
            
            // 方法调用后的增强
            if (enableLogging) {
                System.out.println("【动态代理】方法调用后: " + method.getName());
                System.out.println("【动态代理】返回结果: " + result);
            }
            
            if (enableTransaction) {
                commitTransaction();
            }
            
        } catch (Exception e) {
            if (enableTransaction) {
                rollbackTransaction();
            }
            throw e;
        }
        
        return result;
    }
    
    private void beginTransaction() {
        System.out.println("【事务】开始事务");
    }
    
    private void commitTransaction() {
        System.out.println("【事务】提交事务");
    }
    
    private void rollbackTransaction() {
        System.out.println("【事务】回滚事务");
    }
}

// 2. 业务接口
public interface OrderService {
    void createOrder(String orderId, String product);
    void cancelOrder(String orderId);
    double getOrderPrice(String orderId);
}

// 3. 真实业务类
public class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder(String orderId, String product) {
        System.out.println("创建订单: " + orderId + ", 商品: " + product);
    }
    
    @Override
    public void cancelOrder(String orderId) {
        System.out.println("取消订单: " + orderId);
    }
    
    @Override
    public double getOrderPrice(String orderId) {
        System.out.println("查询订单价格: " + orderId);
        return 100.0;
    }
}

// 4. 动态代理工厂
public class DynamicProxyFactory {
    
    public static <T> T createProxy(T target, Class<T> interfaceType) {
        return createProxy(target, interfaceType, true, false);
    }
    
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T target, Class<T> interfaceType, 
                                   boolean enableLogging, boolean enableTransaction) {
        
        // 创建InvocationHandler
        InvocationHandler handler = new LoggingInvocationHandler(
            target, enableLogging, enableTransaction
        );
        
        // 创建动态代理
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            new Class<?>[] { interfaceType },
            handler
        );
    }
}

// 5. 客户端使用
public class JdkDynamicProxyDemo {
    public static void main(String[] args) {
        // 创建真实对象
        OrderService realService = new OrderServiceImpl();
        
        // 创建动态代理
        OrderService proxy = DynamicProxyFactory.createProxy(
            realService, 
            OrderService.class,
            true,  // 开启日志
            true   // 开启事务
        );
        
        // 通过代理调用
        proxy.createOrder("ORD001", "笔记本电脑");
        System.out.println("订单价格: " + proxy.getOrderPrice("ORD001"));
        
        // 保存生成的代理类到文件（用于分析）
        saveProxyClassToFile(OrderService.class, proxy);
    }
    
    private static void saveProxyClassToFile(Class<?> interfaceType, Object proxy) {
        // 设置系统属性，保存动态生成的代理类
        System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
    }
}

2.2.2 JDK动态代理生成的类分析

java
java
下载
复制
// 生成的代理类类似如下结构（简化版）
public final class $Proxy0 extends Proxy implements OrderService {
    private static Method m1, m2, m3, m4;
    
    static {
        try {
            m1 = Class.forName("OrderService").getMethod("createOrder", 
                   String.class, String.class);
            m2 = Class.forName("OrderService").getMethod("cancelOrder", 
                   String.class);
            m3 = Class.forName("OrderService").getMethod("getOrderPrice", 
                   String.class);
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }
    
    public $Proxy0(InvocationHandler h) {
        super(h);
    }
    
    @Override
    public void createOrder(String orderId, String product) {
        try {
            h.invoke(this, m1, new Object[]{orderId, product});
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }
    
    // 其他方法类似...
}

2.3 CGLIB动态代理

2.3.1 完整实现

java
java
下载
复制
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.CallbackFilter;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

// 1. 目标类（不需要接口）
public class ProductService {
    private Map<String, Double> productPrices = new HashMap<>();
    
    public ProductService() {
        productPrices.put("iPhone", 6999.0);
        productPrices.put("MacBook", 12999.0);
        productPrices.put("iPad", 3299.0);
    }
    
    public void addProduct(String name, double price) {
        System.out.println("添加产品: " + name + ", 价格: " + price);
        productPrices.put(name, price);
    }
    
    public double getProductPrice(String name) {
        System.out.println("查询产品价格: " + name);
        return productPrices.getOrDefault(name, 0.0);
    }
    
    public final void clearCache() {
        // final方法不能被代理
        System.out.println("清空缓存");
        productPrices.clear();
    }
}

// 2. CGLIB方法拦截器
public class CglibMethodInterceptor implements MethodInterceptor {
    private final Object target;
    private final boolean enableCache;
    private Map<String, Object> cache = new HashMap<>();
    
    public CglibMethodInterceptor(Object target) {
        this(target, true);
    }
    
    public CglibMethodInterceptor(Object target, boolean enableCache) {
        this.target = target;
        this.enableCache = enableCache;
    }
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, 
                           MethodProxy proxy) throws Throwable {
        
        String methodName = method.getName();
        String cacheKey = buildCacheKey(methodName, args);
        
        // 缓存逻辑
        if (enableCache && cache.containsKey(cacheKey)) {
            System.out.println("【CGLIB代理】从缓存获取结果: " + cacheKey);
            return cache.get(cacheKey);
        }
        
        // 方法执行前
        System.out.println("【CGLIB代理】方法执行前: " + methodName);
        long startTime = System.currentTimeMillis();
        
        // 执行目标方法
        Object result = null;
        try {
            // 使用MethodProxy比Method.invoke()性能更高
            result = proxy.invokeSuper(obj, args);
        } catch (Exception e) {
            System.out.println("【CGLIB代理】方法执行异常: " + e.getMessage());
            throw e;
        }
        
        // 方法执行后
        long endTime = System.currentTimeMillis();
        System.out.println("【CGLIB代理】方法执行耗时: " + (endTime - startTime) + "ms");
        
        // 缓存结果
        if (enableCache && result != null) {
            cache.put(cacheKey, result);
            System.out.println("【CGLIB代理】结果已缓存: " + cacheKey);
        }
        
        return result;
    }
    
    private String buildCacheKey(String methodName, Object[] args) {
        StringBuilder key = new StringBuilder(methodName);
        if (args != null) {
            for (Object arg : args) {
                key.append("_").append(arg);
            }
        }
        return key.toString();
    }
}

// 3. 回调过滤器（可选）
class ProductServiceCallbackFilter implements CallbackFilter {
    @Override
    public int accept(Method method) {
        String methodName = method.getName();
        if ("getProductPrice".equals(methodName)) {
            return 0; // 使用第一个回调（带缓存的拦截器）
        } else if ("addProduct".equals(methodName)) {
            return 1; // 使用第二个回调（不带缓存的拦截器）
        } else {
            return 2; // 使用第三个回调（不增强）
        }
    }
}

// 4. CGLIB代理工厂
public class CglibProxyFactory {
    
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(Class<T> targetClass) {
        return createProxy(targetClass, true, false);
    }
    
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(Class<T> targetClass, 
                                   boolean enableCache, 
                                   boolean useCallbackFilter) {
        
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass);
        
        if (useCallbackFilter) {
            // 使用回调过滤器
            enhancer.setCallbackFilter(new ProductServiceCallbackFilter());
            
            // 设置多个回调
            CglibMethodInterceptor cacheInterceptor = 
                new CglibMethodInterceptor(targetClass, true);
            CglibMethodInterceptor noCacheInterceptor = 
                new CglibMethodInterceptor(targetClass, false);
            
            enhancer.setCallbacks(new Callback[] {
                cacheInterceptor,     // 索引0：带缓存
                noCacheInterceptor,   // 索引1：不带缓存
                null                  // 索引2：不增强
            });
        } else {
            // 使用单个拦截器
            enhancer.setCallback(new CglibMethodInterceptor(targetClass, enableCache));
        }
        
        return (T) enhancer.create();
    }
}

// 5. 客户端使用
public class CglibProxyDemo {
    public static void main(String[] args) {
        // 创建CGLIB代理
        ProductService proxy = CglibProxyFactory.createProxy(ProductService.class);
        
        // 测试代理
        System.out.println("=== 第一次查询（会被缓存）===");
        double price1 = proxy.getProductPrice("iPhone");
        System.out.println("价格: " + price1);
        
        System.out.println("\n=== 第二次查询（从缓存获取）===");
        double price2 = proxy.getProductPrice("iPhone");
        System.out.println("价格: " + price2);
        
        System.out.println("\n=== 添加新产品 ===");
        proxy.addProduct("Watch", 2999.0);
        
        // 测试final方法
        System.out.println("\n=== 调用final方法 ===");
        proxy.clearCache(); // 这个方法不会被代理增强
    }
}

三、应用场景深度分析

3.1 远程代理（Remote Proxy）

java
java
下载
复制
// 模拟远程服务代理
public interface RemoteDatabaseService {
    List<User> queryUsers(String sql);
    int executeUpdate(String sql);
}

public class RemoteDatabaseProxy implements RemoteDatabaseService {
    private final String serverAddress;
    private final int port;
    
    public RemoteDatabaseProxy(String address, int port) {
        this.serverAddress = address;
        this.port = port;
    }
    
    private void connect() {
        System.out.println("连接到远程服务器: " + serverAddress + ":" + port);
    }
    
    private void disconnect() {
        System.out.println("断开远程连接");
    }
    
    @Override
    public List<User> queryUsers(String sql) {
        connect();
        try {
            // 模拟网络调用
            System.out.println("执行查询: " + sql);
            // 实际网络通信代码...
            return Collections.emptyList();
        } finally {
            disconnect();
        }
    }
    
    @Override
    public int executeUpdate(String sql) {
        connect();
        try {
            System.out.println("执行更新: " + sql);
            // 实际网络通信代码...
            return 1;
        } finally {
            disconnect();
        }
    }
}

3.2 虚拟代理（Virtual Proxy）

java
java
下载
复制
// 大对象延迟加载
public interface HighResolutionImage {
    void display();
    int getWidth();
    int getHeight();
}

public class RealHighResolutionImage implements HighResolutionImage {
    private final String filename;
    
    public RealHighResolutionImage(String filename) {
        this.filename = filename;
        loadFromDisk(); // 耗时的加载操作
    }
    
    private void loadFromDisk() {
        System.out.println("从磁盘加载图片: " + filename);
        // 模拟耗时操作
        try { Thread.sleep(2000); } catch (InterruptedException e) {}
    }
    
    @Override
    public void display() {
        System.out.println("显示图片: " + filename);
    }
    
    @Override
    public int getWidth() { return 1920; }
    
    @Override
    public int getHeight() { return 1080; }
}

public class ImageProxy implements HighResolutionImage {
    private RealHighResolutionImage realImage;
    private final String filename;
    
    public ImageProxy(String filename) {
        this.filename = filename;
    }
    
    @Override
    public void display() {
        if (realImage == null) {
            // 延迟加载真实对象
            realImage = new RealHighResolutionImage(filename);
        }
        realImage.display();
    }
    
    @Override
    public int getWidth() {
        if (realImage == null) {
            return 0; // 返回默认值
        }
        return realImage.getWidth();
    }
    
    @Override
    public int getHeight() {
        if (realImage == null) {
            return 0;
        }
        return realImage.getHeight();
    }
}

3.3 保护代理（Protection Proxy）

java
java
下载
复制
// 权限控制代理
public interface SensitiveOperation {
    void modifyData();
    String viewData();
    void deleteData();
}

public class RealSensitiveOperation implements SensitiveOperation {
    @Override
    public void modifyData() {
        System.out.println("修改敏感数据");
    }
    
    @Override
    public String viewData() {
        System.out.println("查看敏感数据");
        return "敏感数据内容";
    }
    
    @Override
    public void deleteData() {
        System.out.println("删除敏感数据");
    }
}

public class ProtectionProxy implements SensitiveOperation {
    private final RealSensitiveOperation realObject;
    private final User user;
    
    public ProtectionProxy(RealSensitiveOperation realObject, User user) {
        this.realObject = realObject;
        this.user = user;
    }
    
    @Override
    public void modifyData() {
        if (hasPermission("MODIFY")) {
            realObject.modifyData();
        } else {
            System.out.println("权限不足: 需要MODIFY权限");
        }
    }
    
    @Override
    public String viewData() {
        if (hasPermission("VIEW")) {
            return realObject.viewData();
        } else {
            System.out.println("权限不足: 需要VIEW权限");
            return "";
        }
    }
    
    @Override
    public void deleteData() {
        if (hasPermission("DELETE")) {
            realObject.deleteData();
        } else {
            System.out.println("权限不足: 需要DELETE权限");
        }
    }
    
    private boolean hasPermission(String permission) {
        // 实际的权限检查逻辑
        return user.getRoles().stream()
            .flatMap(role -> role.getPermissions().stream())
            .anyMatch(p -> p.equals(permission));
    }
}

3.4 缓存代理（Cache Proxy）

java
java
下载
复制
public class CacheProxy implements ExpensiveService {
    private final ExpensiveService realService;
    private final Map<String, Object> cache = new HashMap<>();
    private final Map<String, Long> cacheTime = new HashMap<>();
    private final long cacheTimeout;
    
    public CacheProxy(ExpensiveService realService, long timeoutMillis) {
        this.realService = realService;
        this.cacheTimeout = timeoutMillis;
    }
    
    @Override
    public Object compute(String key) {
        // 检查缓存是否有效
        if (isCacheValid(key)) {
            System.out.println("从缓存获取: " + key);
            return cache.get(key);
        }
        
        // 重新计算
        System.out.println("计算: " + key);
        Object result = realService.compute(key);
        
        // 更新缓存
        cache.put(key, result);
        cacheTime.put(key, System.currentTimeMillis());
        
        return result;
    }
    
    private boolean isCacheValid(String key) {
        if (!cache.containsKey(key)) {
            return false;
        }
        long cachedTime = cacheTime.get(key);
        return (System.currentTimeMillis() - cachedTime) < cacheTimeout;
    }
}

四、优缺点深度解析

4.1 优点分析

4.1.1 代码解耦

java
java
下载
复制
// 代理模式实现关注点分离
public class LoggingProxy implements Service {
    private Service realService;
    private Logger logger;
    
    public LoggingProxy(Service realService) {
        this.realService = realService;
        this.logger = LoggerFactory.getLogger(realService.getClass());
    }
    
    @Override
    public void process() {
        // 日志逻辑与业务逻辑分离
        logger.info("开始处理");
        try {
            realService.process();  // 业务逻辑
            logger.info("处理成功");
        } catch (Exception e) {
            logger.error("处理失败", e);
            throw e;
        }
    }
}

4.1.2 开闭原则支持

可以在不修改原始类的情况下增加新功能
符合单一职责原则

4.2 缺点分析

4.2.1 性能开销

java
java
下载
复制
public class PerformanceTest {
    public static void main(String[] args) {
        int iterations = 1000000;
        
        // 直接调用
        long start1 = System.nanoTime();
        RealService real = new RealService();
        for (int i = 0; i < iterations; i++) {
            real.process();
        }
        long time1 = System.nanoTime() - start1;
        
        // 代理调用
        long start2 = System.nanoTime();
        Service proxy = new ProxyService(real);
        for (int i = 0; i < iterations; i++) {
            proxy.process();
        }
        long time2 = System.nanoTime() - start2;
        
        System.out.println("直接调用: " + time1 + "ns");
        System.out.println("代理调用: " + time2 + "ns");
        System.out.println("性能开销: " + (time2 - time1) + "ns");
    }
}

4.2.2 复杂性增加

增加了一层间接调用
调试困难度增加
可能产生循环依赖

五、使用要点与最佳实践

5.1 代理选择指南

代理类型	适用场景	性能	限制
静态代理	接口稳定，方法少	高	代码冗余
JDK动态代理	基于接口的代理	中	必须实现接口
CGLIB代理	无接口的类代理	中低	不能代理final方法

5.2 性能优化技巧

java
java
下载
复制
// 1. 缓存代理实例
public class ProxyCache {
    private static final Map<Class<?>, Object> proxyCache = new ConcurrentHashMap<>();
    
    @SuppressWarnings("unchecked")
    public static <T> T getProxy(Class<T> interfaceClass, Object target) {
        return (T) proxyCache.computeIfAbsent(interfaceClass, 
            key -> createProxy(interfaceClass, target));
    }
    
    private static Object createProxy(Class<?> interfaceClass, Object target) {
        // 创建代理逻辑
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            new Class<?>[]{interfaceClass},
            new CachedInvocationHandler(target)
        );
    }
}

// 2. 方法级缓存
class CachedInvocationHandler implements InvocationHandler {
    private final Object target;
    private final Map<Method, Object> methodCache = new ConcurrentHashMap<>();
    
    public CachedInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 缓存方法对象
        return methodCache.computeIfAbsent(method, m -> {
            try {
                // 实际的调用逻辑
                return m.invoke(target, args);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
    }
}

5.3 避免常见陷阱

java
java
下载
复制
// 陷阱1：自调用问题
public class SelfInvocationProblem {
    
    public void methodA() {
        System.out.println("执行methodA");
        this.methodB();  // 自调用，不会走代理
    }
    
    public void methodB() {
        System.out.println("执行methodB");
    }
}

// 解决方案：通过AOP上下文获取代理
@Component
public class SelfInvocationSolution {
    
    @Autowired
    private ApplicationContext context;
    
    public void methodA() {
        System.out.println("执行methodA");
        // 从上下文获取代理对象
        SelfInvocationSolution proxy = context.getBean(SelfInvocationSolution.class);
        proxy.methodB();  // 通过代理调用
    }
    
    @Transactional
    public void methodB() {
        System.out.println("执行methodB（有事务）");
    }
}

六、在Spring框架中的应用

6.1 Spring AOP实现原理

java
java
下载
复制
// Spring AOP配置示例
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true) // 使用CGLIB代理
public class AopConfig {
    
    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect();
    }
}

@Aspect
@Component
public class LoggingAspect {
    
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}
    
    @Around("serviceLayer()")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        
        Object result = joinPoint.proceed();
        
        long executionTime = System.currentTimeMillis() - start;
        System.out.println(joinPoint.getSignature() + " 执行时间: " + executionTime + "ms");
        
        return result;
    }
}

// Spring事务代理
@Service
public class OrderService {
    
    @Transactional
    public Order createOrder(Order order) {
        // 事务性操作
        order = orderRepository.save(order);
        inventoryService.reduceStock(order.getProductId(), order.getQuantity());
        return order;
    }
}

6.2 代理模式选择策略

yaml
yaml
复制
# application.yml
spring:
  aop:
    proxy-target-class: true  # true使用CGLIB，false使用JDK动态代理
    auto: true
    
# 编程式配置
@Configuration
public class ProxyConfig implements ImportAware {
    
    @Bean
    public DefaultAdvisorAutoProxyCreator proxyCreator() {
        DefaultAdvisorAutoProxyCreator creator = new DefaultAdvisorAutoProxyCreator();
        creator.setProxyTargetClass(true);  // 强制使用CGLIB
        creator.setOptimize(true);           // 优化代理创建
        return creator;
    }
}

七、高级应用：组合代理模式

java
java
下载
复制
// 责任链式代理
public interface Handler {
    void handle(String request);
    void setNext(Handler next);
}

public abstract class AbstractHandler implements Handler {
    protected Handler next;
    
    @Override
    public void setNext(Handler next) {
        this.next = next;
    }
}

// 具体处理器
public class ValidationHandler extends AbstractHandler {
    @Override
    public void handle(String request) {
        System.out.println("验证请求: " + request);
        if (next != null) {
            next.handle(request);
        }
    }
}

public class LoggingHandler extends AbstractHandler {
    @Override
    public void handle(String request) {
        System.out.println("记录日志: " + request);
        if (next != null) {
            next.handle(request);
        }
    }
}

public class ProcessingHandler extends AbstractHandler {
    @Override
    public void handle(String request) {
        System.out.println("处理请求: " + request);
        if (next != null) {
            next.handle(request);
        }
    }
}

// 代理链工厂
public class HandlerChainFactory {
    
    public static Handler createChain() {
        Handler validation = new ValidationHandler();
        Handler logging = new LoggingHandler();
        Handler processing = new ProcessingHandler();
        
        validation.setNext(logging);
        logging.setNext(processing);
        
        return validation;
    }
}

八、性能测试与对比

java
java
下载
复制
public class ProxyPerformanceBenchmark {
    
    public static void main(String[] args) throws Exception {
        int warmup = 1000;
        int iterations = 100000;
        
        // 预热
        benchmark("预热", warmup);
        
        // 正式测试
        System.out.println("\n=== 性能测试结果 ===");
        benchmark("直接调用", iterations);
        benchmark("静态代理", iterations);
        benchmark("JDK动态代理", iterations);
        benchmark("CGLIB代理", iterations);
    }
    
    private static void benchmark(String name, int iterations) throws Exception {
        Service realService = new RealServiceImpl();
        Service staticProxy = new StaticProxy(realService);
        Service jdkProxy = JdkProxyFactory.createProxy(realService);
        Service cglibProxy = CglibProxyFactory.createProxy(RealServiceImpl.class);
        
        Service testService;
        switch (name) {
            case "直接调用": testService = realService; break;
            case "静态代理": testService = staticProxy; break;
            case "JDK动态代理": testService = jdkProxy; break;
            case "CGLIB代理": testService = cglibProxy; break;
            default: return;
        }
        
        long start = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            testService.process();
        }
        long time = System.nanoTime() - start;
        
        System.out.printf("%-15s: %,d ns (%,d ops/ms)%n", 
            name, time, (iterations * 1000000L) / time);
    }
}

九、总结与选择建议

9.1 选择矩阵

场景特征	推荐方案	理由
目标类有接口	JDK动态代理	标准、性能好
目标类无接口	CGLIB代理	唯一选择
需要final方法代理	静态代理	CGLIB不支持final
性能要求极高	静态代理/手动编码	无反射开销
Spring集成	跟随Spring配置	一致性重要

9.2 最佳实践总结

优先使用接口：为关键服务定义接口，便于使用JDK动态代理
合理使用缓存：对昂贵的对象创建或计算使用代理缓存
注意代理边界：明确代理的职责范围，避免过度设计
性能监控：在生产环境监控代理性能
文档记录：记录代理的使用场景和配置

代理模式是Java企业开发的核心模式之一，深入理解其原理和实现方式，能够帮助开发者构建更灵活、可维护的系统架构。