Java代理模式：静态与动态代理的深度解析与实践

1. 代理模式的核心价值与适用场景

代理模式（Proxy Pattern）作为结构型设计模式的代表，其核心价值在于提供了一种非侵入式的对象功能扩展方式。想象这样一个场景：你正在维护一个成熟的支付系统，突然需要为所有核心接口添加调用日志和性能监控。按照传统做法，你可能需要修改数十个业务类的代码——这无疑是一场灾难。

代理模式的精妙之处在于，它通过引入一个中间层（代理对象），在不修改原有业务代码的前提下，实现了功能的横向扩展。这种"拦截-增强-转发"的机制，完美契合了软件开发中的"开闭原则"（对扩展开放，对修改关闭）。

实际工程经验表明，代理模式特别适合处理以下横切关注点：

• 访问控制与权限验证
• 日志记录与审计跟踪
• 性能监控与统计
• 事务管理与一致性保证
• 缓存加速与结果复用

2. 静态代理：基础实现与工程实践

2.1 静态代理的实现机制

静态代理是最直观的代理实现方式，其核心在于"编译时绑定"。我们需要三个基本组件：

1. 业务接口：定义契约
2. 真实实现类：完成核心业务
3. 代理类：实现相同接口并持有真实对象引用

java复制// 业务接口
public interface DataService {
    String fetchData(String key);
}

// 真实实现
public class DataServiceImpl implements DataService {
    @Override
    public String fetchData(String key) {
        // 模拟数据库查询
        return "data-for-" + key;
    }
}

// 代理类
public class DataServiceProxy implements DataService {
    private final DataService realService;
    
    public DataServiceProxy(DataService realService) {
        this.realService = realService;
    }
    
    @Override
    public String fetchData(String key) {
        long start = System.currentTimeMillis();
        System.out.println("[Proxy] 开始查询: " + key);
        
        try {
            String result = realService.fetchData(key);
            System.out.println("[Proxy] 查询成功");
            return result;
        } catch (Exception e) {
            System.out.println("[Proxy] 查询异常: " + e.getMessage());
            throw e;
        } finally {
            System.out.printf("[Proxy] 耗时: %dms%n", 
                System.currentTimeMillis() - start);
        }
    }
}

2.2 静态代理的工程考量

在实际项目中采用静态代理时，有几个关键决策点需要考虑：

1. 接口稳定性：如果业务接口频繁变更，维护代理类会成为负担
2. 方法数量：接口方法超过20个时，手写代理类的工作量会显著增加
3. 增强逻辑一致性：如果所有方法需要相同的增强逻辑（如日志格式），代码重复会降低可维护性

我曾在一个银行项目中见过典型的静态代理误用案例：为30多个方法的交易接口编写静态代理，结果每次接口变更都需要同步修改代理类，最终导致版本不同步的严重问题。

3. 动态代理：JDK实现原理与深度解析

3.1 JDK动态代理的实现原理

JDK动态代理的核心在于运行时动态生成代理类，其技术栈主要涉及：

• java.lang.reflect.Proxy：代理类工厂
• java.lang.reflect.InvocationHandler：调用处理器

java复制public class DynamicProxyHandler implements InvocationHandler {
    private final Object target;
    
    public DynamicProxyHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置处理
        System.out.printf("调用方法: %s，参数: %s%n",
            method.getName(), Arrays.toString(args));
        
        long start = System.nanoTime();
        try {
            Object result = method.invoke(target, args);
            // 后置处理
            System.out.printf("方法返回: %s (耗时: %.2fms)%n",
                result, (System.nanoTime()-start)/1e6);
            return result;
        } catch (InvocationTargetException e) {
            // 异常处理
            Throwable cause = e.getCause();
            System.out.println("调用异常: " + cause.getMessage());
            throw cause;
        }
    }
}

3.2 动态代理的字节码分析

通过设置系统属性sun.misc.ProxyGenerator.saveGeneratedFiles为true，我们可以将运行时生成的代理类保存到磁盘：

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

DataService proxy = (DataService) Proxy.newProxyInstance(
    DataService.class.getClassLoader(),
    new Class[]{DataService.class},
    new DynamicProxyHandler(new DataServiceImpl())
);

生成的代理类大致结构如下：

java复制public final class $Proxy0 extends Proxy implements DataService {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.example.DataService").getMethod("fetchData", Class.forName("java.lang.String"));
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }
    
    public $Proxy0(InvocationHandler h) {
        super(h);
    }
    
    @Override
    public final String fetchData(String var1) {
        try {
            return (String) super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error e) {
            throw e;
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }
}

3.3 性能优化实践

动态代理的性能瓶颈主要来自反射调用。在Java 8及以后版本，可以通过设置以下参数来优化：

bash复制-Djdk.proxy.ProxyGenerator.v49=true  # 启用新版代理生成器
-Djdk.internal.lambda.dumpProxyClasses=/tmp  # 保存生成的类用于分析

在热点路径上，可以考虑缓存Method对象或使用MethodHandle替代反射调用：

java复制private static final MethodHandle FETCH_DATA_MH;

static {
    try {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        FETCH_DATA_MH = lookup.findVirtual(
            DataServiceImpl.class, 
            "fetchData", 
            MethodType.methodType(String.class, String.class)
        );
    } catch (Exception e) {
        throw new ExceptionInInitializerError(e);
    }
}

// 在invoke方法中使用
Object result = FETCH_DATA_MH.bindTo(target).invokeWithArguments(args);

4. CGLIB深度应用与字节码工程

4.1 CGLIB核心架构

CGLIB（Code Generation Library）采用了不同于JDK动态代理的实现策略：

1. 字节码生成：通过ASM直接生成字节码
2. 继承机制：通过子类化实现方法拦截
3. 方法拦截：通过MethodInterceptor接口实现增强

java复制public class CglibProxy implements MethodInterceptor {
    private Object target;
    
    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, 
                          MethodProxy proxy) throws Throwable {
        System.out.println("CGLIB前置处理");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("CGLIB后置处理");
        return result;
    }
}

4.2 性能关键指标

在性能敏感场景下，CGLIB有几个关键配置项需要注意：

1. 回调过滤器（CallbackFilter）：允许对不同方法使用不同的拦截策略

java复制enhancer.setCallbackFilter(new CallbackFilter() {
    @Override
    public int accept(Method method) {
        return method.getName().startsWith("get") ? 0 : 1;
    }
});

2. 回调类型优化：

• MethodInterceptor：全功能拦截器
• LazyLoader：延迟加载实现
• Dispatcher：每次调用都重新加载

3. 字节码生成策略：

java复制// 使用策略模式优化生成过程
Enhancer enhancer = new Enhancer();
enhancer.setStrategy(new DefaultGeneratorStrategy() {
    @Override
    protected ClassGenerator transform(ClassGenerator cg) {
        // 自定义转换逻辑
        return new TransformingGenerator(cg);
    }
});

4.3 典型问题排查

1. Final方法无法拦截：

• 解决方案：使用@NonFinal注解或重构类设计

2. 构造函数多次调用：

• 原因：CGLIB会先实例化父类
• 解决：设置回调对象时使用ConstructorInterceptor

3. 内存泄漏风险：

• 现象：生成的类会缓存到ClassLoader
• 解决：定期清理或使用专用ClassLoader

5. Spring AOP代理机制深度剖析

5.1 代理选择策略

Spring框架的代理选择逻辑体现在DefaultAopProxyFactory中：

java复制public AopProxy createAopProxy(AdvisedSupport config) {
    if (config.isOptimize() || config.isProxyTargetClass() || 
        hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class");
        }
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        return new ObjenesisCglibAopProxy(config);
    }
    return new JdkDynamicAopProxy(config);
}

关键决策因素：

1. proxyTargetClass属性强制设置为true时使用CGLIB
2. 目标类没有实现接口时自动选择CGLIB
3. 存在接口时默认使用JDK动态代理

5.2 典型问题解决方案

问题1：自调用失效

java复制@Service
public class OrderService {
    public void placeOrder() {
        this.validate(); // 不会触发AOP
    }
    
    @Transactional
    public void validate() {
        // 事务不会生效
    }
}

解决方案：

1. 通过ApplicationContext获取代理对象
2. 使用AspectJ编译时织入
3. 重构代码结构，避免自调用

问题2：代理对象类型转换异常

java复制@Autowired
private SomeService someService; // 实际是代理对象

public void someMethod() {
    ((SomeServiceImpl) someService).internalMethod(); // ClassCastException
}

解决方案：

1. 使用AopProxyUtils获取目标对象
2. 通过接口暴露所有需要的方法
3. 使用@Autowired SomeServiceImpl（需配合@Scope(proxyMode=NO)）

6. 性能对比与选型指南

6.1 基准测试数据

通过JMH（Java Microbenchmark Harness）测试不同代理实现的性能表现（测试环境：JDK17，MacBook Pro M1）：

6.2 选型决策树

mermaid复制graph TD
    A[需要代理?] --> B{有接口?}
    B -->|是| C[方法数量<10?]
    B -->|否| D[使用CGLIB]
    C -->|是| E[考虑静态代理]
    C -->|否| F[使用JDK动态代理]
    E --> G{增强逻辑复杂?}
    G -->|是| F
    G -->|否| H[维护静态代理]
    D --> I[注意final限制]
    F --> J[考虑缓存代理实例]

6.3 生产环境建议

1. Web层代理：优先使用CGLIB，避免接口变更影响
2. 服务层代理：推荐JDK动态代理，保持接口契约明确
3. 基础设施层：考虑AspectJ编译时织入，追求极致性能
4. 测试环境：结合Mockito等框架使用动态代理

7. 设计模式结合实践

7.1 代理模式与其他模式的协同

1. 装饰器模式：两者都使用组合，但装饰器侧重增强功能，代理侧重控制访问

java复制// 装饰器示例
public class DataServiceDecorator implements DataService {
    private final DataService wrappee;
    
    public DataServiceDecorator(DataService wrappee) {
        this.wrappee = wrappee;
    }
    
    @Override
    public String fetchData(String key) {
        // 直接增强功能
        return wrappee.fetchData(key) + "-decorated";
    }
}

2. 策略模式：动态切换代理行为

java复制public class DynamicStrategyProxy implements InvocationHandler {
    private Object target;
    private InvocationStrategy strategy;
    
    public void setStrategy(InvocationStrategy strategy) {
        this.strategy = strategy;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        return strategy.execute(target, method, args);
    }
}

3. 责任链模式：构建多层代理

java复制public class ChainProxy implements InvocationHandler {
    private final List<InvocationHandler> handlers;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        InvocationContext context = new InvocationContext(target, method, args);
        for (InvocationHandler handler : handlers) {
            handler.handle(context);
            if (context.isStopped()) {
                break;
            }
        }
        return context.getResult();
    }
}

7.2 领域特定代理实现

1. MyBatis的MapperProxy：将接口方法映射为SQL执行

java复制public class MapperProxy<T> implements InvocationHandler {
    private final SqlSession sqlSession;
    private final Class<T> mapperInterface;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        // 将方法调用转换为SQL命令
        String commandName = mapperInterface.getName() + "." + method.getName();
        MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(commandName);
        return sqlSession.selectOne(commandName, args[0]);
    }
}

2. RPC框架的Stub代理：将本地调用转换为远程调用

java复制public class RpcProxy implements InvocationHandler {
    private final Class<?> serviceInterface;
    private final String serviceUrl;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        RpcRequest request = new RpcRequest();
        request.setInterfaceName(serviceInterface.getName());
        request.setMethodName(method.getName());
        request.setParameters(args);
        
        // 网络传输
        return transport.send(request).getResult();
    }
}

8. 常见反模式与最佳实践

8.1 代理模式误用案例

1. 过度代理：每个方法调用经过多层代理，导致调用栈过深

java复制// 反例：多层嵌套代理
Service proxy = new LoggingProxy(
                 new MetricsProxy(
                   new CacheProxy(
                     new RealService())));

2. 循环代理：代理A依赖代理B，代理B又依赖代理A

java复制// 反例：循环依赖
public class ProxyA implements Service {
    private Service next;  // 实际是ProxyB
}

public class ProxyB implements Service {
    private Service next;  // 实际是ProxyA
}

3. 忽略equals/hashCode：代理对象身份识别问题

java复制// 必须正确实现
@Override
public boolean equals(Object obj) {
    if (obj instanceof Proxy) {
        return target.equals(Proxy.getInvocationHandler(obj).getTarget());
    }
    return target.equals(obj);
}

8.2 性能优化检查清单

1. 代理实例缓存：避免重复创建代理对象

java复制private static final Map<Object, Object> proxyCache = new WeakHashMap<>();

public static <T> T getCachedProxy(T target) {
    synchronized (proxyCache) {
        return (T) proxyCache.computeIfAbsent(target, 
            k -> Proxy.newProxyInstance(...));
    }
}

2. 方法调用缓存：优化反射性能

java复制private static final ConcurrentMap<Method, MethodHandle> methodCache = 
    new ConcurrentHashMap<>();

MethodHandle mh = methodCache.computeIfAbsent(method, m -> {
    try {
        return MethodHandles.lookup().unreflect(method);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
});

3. 选择性代理：只代理真正需要的方法

java复制@Override
public Object invoke(Object proxy, Method method, Object[] args) {
    String methodName = method.getName();
    if (methodName.startsWith("get")) {
        return method.invoke(target, args);
    }
    // 只增强非getter方法
    return doWithProfiling(() -> method.invoke(target, args));
}

9. 现代Java中的代理演进

9.1 JDK新特性影响

1. 模块系统（JPMS）：需要为代理类开放反射权限

java复制module com.example {
    opens com.example.service to spring.core;
}

2. 记录类（Record）：代理final类的新挑战

java复制public record User(String name, int age) {}

// 无法直接代理，需要特殊处理

3. 模式匹配：简化代理对象的类型检查

java复制if (service instanceof Proxy p) {
    InvocationHandler handler = Proxy.getInvocationHandler(p);
    // ...
}

9.2 替代方案比较

1. Byte Buddy：更现代的字节码操作库

java复制new ByteBuddy()
    .subclass(Object.class)
    .method(ElementMatchers.any())
    .intercept(MethodDelegation.to(LoggingInterceptor.class))
    .make()
    .load(getClass().getClassLoader())
    .getLoaded();

2. AspectJ编译时织入：无运行时开销

java复制@Aspect
public class LoggingAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object log(ProceedingJoinPoint pjp) throws Throwable {
        // 增强逻辑
        return pjp.proceed();
    }
}

3. Manifold运行时代理：基于Java Agent实现

java复制ProxyFactory factory = new ProxyFactory();
factory.setSuperclass(TargetClass.class);
factory.setFilter(m -> !m.getName().equals("finalMethod"));
return factory.createClass().newInstance();

10. 实战：构建生产级代理工厂

10.1 可配置代理工厂实现

java复制public class ProxyFactory {
    private static final int JDK_PROXY = 1;
    private static final int CGLIB_PROXY = 2;
    
    private int proxyType = JDK_PROXY;
    private Class<?>[] interfaces;
    private Class<?> superClass;
    private InvocationHandler handler;
    private MethodInterceptor interceptor;
    
    public <T> T createProxy(Object target) {
        if (proxyType == JDK_PROXY) {
            return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                interfaces,
                new DelegatingHandler(handler, target));
        } else {
            Enhancer enhancer = new Enhancer();
            if (superClass != null) {
                enhancer.setSuperclass(superClass);
            }
            enhancer.setCallback(new DelegatingInterceptor(interceptor, target));
            return (T) enhancer.create();
        }
    }
    
    // Builder模式配置
    public static class Builder {
        private final ProxyFactory factory = new ProxyFactory();
        
        public Builder jdkProxy(Class<?>... interfaces) {
            factory.proxyType = JDK_PROXY;
            factory.interfaces = interfaces;
            return this;
        }
        
        public Builder cglibProxy(Class<?> superClass) {
            factory.proxyType = CGLIB_PROXY;
            factory.superClass = superClass;
            return this;
        }
        
        // 其他配置方法...
    }
}

10.2 线程安全考量

1. 有状态拦截器：需要处理并发访问

java复制public class StatefulInterceptor implements MethodInterceptor {
    private final ThreadLocal<Long> callDepth = new ThreadLocal<>();
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, 
                          MethodProxy proxy) throws Throwable {
        Long depth = callDepth.get();
        if (depth == null) depth = 0L;
        
        try {
            callDepth.set(depth + 1);
            return proxy.invokeSuper(obj, args);
        } finally {
            callDepth.set(depth);
        }
    }
}

2. 代理对象池：避免频繁创建销毁

java复制public class ProxyPool<T> {
    private final Queue<T> pool = new ConcurrentLinkedQueue<>();
    private final Supplier<T> factory;
    
    public ProxyPool(Supplier<T> factory, int size) {
        this.factory = factory;
        for (int i = 0; i < size; i++) {
            pool.add(factory.get());
        }
    }
    
    public T borrow() {
        T obj = pool.poll();
        return obj != null ? obj : factory.get();
    }
    
    public void release(T obj) {
        pool.offer(obj);
    }
}

10.3 监控与诊断

1. 代理类生成监控：

java复制// 注册生成监听器
ProxyGenerator.setGeneratorListener(new ProxyGenerator.Listener() {
    @Override
    public void onGenerate(Class<?> proxyClass) {
        Metrics.counter("proxy.generated")
              .tag("type", proxyClass.getSimpleName())
              .increment();
    }
});

2. 调用链追踪：

java复制public class TracingInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, 
                          MethodProxy proxy) throws Throwable {
        Span span = Tracer.startSpan(method.getName());
        try {
            return proxy.invokeSuper(obj, args);
        } catch (Exception e) {
            span.recordException(e);
            throw e;
        } finally {
            span.finish();
        }
    }
}

11. 前沿趋势与未来展望

11.1 GraalVM原生镜像支持

构建原生镜像时需要特别处理代理类：

bash复制# 注册反射配置
-H:ReflectionConfigurationFiles=proxy-reflect.json
# 注册动态代理
-H:DynamicProxyConfigurationFiles=proxy-config.json

11.2 云原生时代的代理模式

1. Service Mesh：将代理提升到基础设施层
2. Sidecar模式：每个服务实例伴生一个代理进程
3. eBPF技术：内核层面的网络代理

11.3 量子计算影响

量子纠缠态可能催生新的代理范式：

qsharp复制operation QuantumProxy(target: Qubit, control: Qubit) : Unit {
    within {
        H(control);
    } apply {
        Controlled X([control], target);
    }
}

12. 终极决策框架

当面临代理技术选型时，建议考虑以下维度：

最终决策应基于：

1. 团队技术储备
2. 项目生命周期
3. 性能需求等级
4. 维护成本预算
5. 未来扩展计划

13. 个人实践心得

在多年的架构实践中，我总结了代理模式应用的几个关键认知：

1. 代理边界：明确区分哪些逻辑属于代理层，哪些属于业务层。曾经在一个电商项目中，我们将优惠计算逻辑错误地放在代理层，导致系统难以维护。

2. 失败设计：代理应该透明，业务代码不应感知代理存在。早期版本我们要求业务方法显式检查代理状态，这违反了迪米特法则。

3. 性能陷阱：不要为了代理而代理。某金融系统最初对所有DAO方法添加代理，后来发现80%的代理逻辑从未被使用。

4. 调试技巧：在代理类中加入唯一标识，便于日志追踪：

java复制public class TraceableProxy implements InvocationHandler {
    private final String proxyId = UUID.randomUUID().toString();
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        MDC.put("proxyId", proxyId);
        // ...
    }
}

5. 文档规范：为代理类添加特殊注解，方便后续维护：

java复制@ProxyMeta(
    author = "架构组",
    since = "2023-06",
    purpose = "添加分布式锁支持"
)
public class LockingProxy implements InvocationHandler {
    // ...
}

14. 推荐工具链

1. 分析工具：

   • JDK自带：jhsdb、jconsole
   • 第三方：JProfiler、YourKit

2. 字节码查看：

   • JDK：javap -v -p
   • ASM：ASM Bytecode Viewer插件
   • 在线工具：javap -c配合CFR反编译器

3. 测试框架：

   • JMH：微基准测试
   • JUnit：代理行为测试
   • Mockito：结合代理的测试替身

4. 监控方案：

   • Prometheus + Grafana：指标监控
   • ELK：日志分析
   • SkyWalking：分布式追踪

15. 持续学习路径

1. 基础夯实：

   • 《设计模式：可复用面向对象软件的基础》代理模式章节
   • Java反射机制深度理解

2. 进阶提升：

   • ASM字节码操作框架
   • JVMTI接口与Java Agent技术
   • Java动态性的实现原理

3. 专家领域：

   • JEP 181（嵌套访问控制）
   • JEP 371（隐藏类）
   • GraalVM Truffle框架

4. 社区资源：

   • Java字节码工程组（JBE）
   • ASM开发者邮件列表
   • Byte Buddy官方文档

16. 典型问题解答

Q1：什么时候应该避免使用代理模式？

A：以下情况应慎重考虑：

• 性能敏感的底层方法（如hashCode、equals）
• 构造函数和final方法
• 简单的POJO对象
• 已经存在复杂继承结构的类

Q2：如何调试动态生成的代理类？

A：可以采用以下策略：

1. 保存生成的字节码到文件：

java复制System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");

2. 使用JD-GUI等工具反编译class文件
3. 在代理逻辑中加入详细日志
4. 使用条件断点调试InvocationHandler

Q3：代理模式会导致内存泄漏吗？

A：可能的风险点包括：

1. 代理类缓存未清理
2. 拦截器持有大对象引用
3. ClassLoader未正确释放

解决方案：

• 使用WeakReference存储目标对象
• 定期清理代理缓存
• 为短生命周期对象使用独立ClassLoader

Q4：如何选择JDK动态代理和CGLIB？

A：决策矩阵：

17. 真实案例复盘

案例1：电商平台优惠系统

背景：需要为商品价格计算添加多重优惠叠加逻辑

错误实现：

java复制public class PriceServiceProxy implements PriceService {
    private PriceService target;
    
    @Override
    public BigDecimal calculatePrice(Order order) {
        // 直接嵌入复杂的优惠计算逻辑
        BigDecimal base = target.calculatePrice(order);
        base = applyCoupon(base, order.getCoupons());
        base = applyPromotion(base, order.getPromotions());
        return applyVipDiscount(base, order.getUser());
    }
}

问题：

1. 代理类变得臃肿
2. 优惠策略变更需要修改代理类
3. 难以单独测试优惠逻辑

重构方案：

java复制public class PriceServiceProxy implements PriceService {
    private PriceService target;
    private List<DiscountStrategy> strategies;
    
    @Override
    public BigDecimal calculatePrice(Order order) {
        BigDecimal price = target.calculatePrice(order);
        for (DiscountStrategy strategy : strategies) {
            price = strategy.apply(price, order);
        }
        return price;
    }
}

收益：

1. 符合单一职责原则
2. 策略可动态配置
3. 每种优惠可独立测试

案例2：金融交易系统审计

需求：记录所有资金变动方法的调用参数和结果

初始方案：在每个业务方法中手动添加日志

问题：

1. 代码重复严重
2. 日志格式不一致
3. 业务逻辑与审计逻辑耦合

代理方案：

java复制public class AuditProxy implements InvocationHandler {
    private final AuditLogger logger;
    private final Object target;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        if (method.isAnnotationPresent(Audited.class)) {
            AuditEntry entry = logger.begin(method.getName(), args);
            try {
                Object result = method.invoke(target, args);
                logger.success(entry, result);
                return result;
            } catch (Exception e) {
                logger.fail(entry, e);
                throw e;
            }
        }
        return method.invoke(target, args);
    }
}

收益：

1. 审计逻辑集中管理
2. 通过注解灵活控制
3. 业务代码保持纯净

18. 扩展思考题

1. 如何设计一个支持热替换的代理系统，可以在运行时动态修改增强逻辑？

2. 在微服务架构下，代理模式如何与Service Mesh中的Sidecar模式协同工作？

3. 对于需要代理的final类，除了使用AspectJ编译时织入，还有哪些可行的技术方案？

4. 如何实现一个跨JVM的分布式代理，使得本地调用可以透明地转发到远程服务？

5. 在函数式编程范式下，代理模式应该如何演进？考虑Java的Function接口和Lambda表达式特性。

19. 关键代码片段库

19.1 安全代理示例

java复制public class SecurityProxy implements InvocationHandler {
    private final Object target;
    private final SecurityManager security;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        if (method.isAnnotationPresent(RequiresRole.class)) {
            String role = method.getAnnotation(RequiresRole.class).value();
            if (!security.hasRole(role)) {
                throw new SecurityException("Missing role: " + role);
            }
        }
        return method.invoke(target, args);
    }
}

19.2 熔断代理实现

java复制public class CircuitBreakerProxy implements InvocationHandler {
    private final CircuitBreaker breaker;
    private final Object target;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        if (!breaker.allowRequest()) {
            throw new CircuitBreakerOpenException();
        }
        
        try {
            Object result = method.invoke(target, args);
            breaker.recordSuccess();
            return result;
        } catch (Exception e) {
            breaker.recordFailure();
            throw e;
        }
    }
}

19.3 缓存代理模板

java复制public class CacheProxy implements InvocationHandler {
    private final CacheStore cache;
    private final Object target;
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        if (!method.isAnnotationPresent(Cacheable.class)) {
            return method.invoke(target, args);
        }
        
        CacheKey key = new CacheKey(method, args);
        Object cached = cache.get(key);
        if (cached != null) {
            return cached;
        }
        
        Object result = method.invoke(target, args);
        cache.put(key, result);
        return result;
    }
}

20. 总结与行动指南

经过对代理模式的全面探讨，我们可以得出以下行动建议：

1. 评估阶段：

   • 明确横切关注点的边界
   • 统计需要代理的方法数量和调用频率
   • 评估团队对不同代理技术的掌握程度

2. 设计阶段：

   • 绘制代理层与业务层的交互流程图
   • 设计代理对象的生命周期管理策略
   • 制定代理类的命名和文档规范

3. 实现阶段：

   • 优先使用标准库提供的代理机制
   • 为代理类编写单元测试
   • 实现代理对象的监控埋点

4. 优化阶段：

   • 分析代理调用的性能热点
   • 考虑缓存策略优化
   • 定期审查代理逻辑的必要性

5. 维护阶段：

   • 建立代理变更的评审机制
   • 文档记录每个代理的用途和配置
   • 监控代理层的异常情况

记住，代理模式就像一把瑞士军刀——功能强大但需要正确使用。用得好，它能让你系统更整洁；用不好，反而会增加复杂度。每次考虑引入代理时，都问问自己："这个逻辑真的应该放在代理层吗？"