Java代理模式详解：静态与动态代理的应用

代理模式简介：代理模式是一种设计模式，用于在不改变原有对象的前提下，通过代理对象来间接访问目标对象，从而在不修改原对象的基础上，添加额外的功能或控制访问权限。这种模式特别适用于需要在访问对象前或后进行特定操作的场景。

应用场景：例如，在房地产交易中，中介（代理对象）作为房东（目标对象）和租客（客户端）之间的桥梁，不仅帮助双方达成交易，还能在交易过程中收取中介费（附加操作），确保交易的安全性和合法性。

静态代理实现：

静态代理是指在编译时期就确定了代理类和被代理类的关系。具体实现上，代理类和被代理类都需要实现同一个接口。下面是一个简单的静态代理示例：

接口定义：

1 package com.example.designpattern.proxy;
2 
3 public interface Service {
4     void execute();
5 }

真实服务类：

1 package com.example.designpattern.proxy;
2 
3 public class RealService implements Service {
4     @Override
5     public void execute() {
6         System.out.println("Executing real service...");
7     }
8 }

代理服务类：

1 package com.example.designpattern.proxy;
2 
3 public class ProxyService implements Service {
4     private RealService realService;
5 
6     public ProxyService() {
7         this.realService = new RealService();
8     }
9 
10     @Override
11     public void execute() {
12         beforeExecute();
13         realService.execute();
14         afterExecute();
15     }
16 
17     private void beforeExecute() {
18         System.out.println("Before executing...");
19     }
20 
21     private void afterExecute() {
22         System.out.println("After executing...");
23     }
24 }

客户端调用：

1 package com.example.designpattern.proxy;
2 
3 public class Client {
4     public static void main(String[] args) {
5         Service service = new ProxyService();
6         service.execute();
7     }
8 }

静态代理的优点在于结构清晰，易于理解和实现。然而，它的缺点也很明显，即每个被代理类都需要一个对应的代理类，这会导致类的数量成倍增加，系统变得复杂且难以维护。

动态代理实现：

动态代理则是在运行时动态生成代理类，克服了静态代理的局限性。Java提供了内置的支持，通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现动态代理。

动态代理示例：

接口定义：

1 package design.dynamicproxy;
2 
3 public interface Service {
4     void execute(String param);
5 }

真实服务类：

1 package design.dynamicproxy;
2 
3 public class RealService implements Service {
4     @Override
5     public void execute(String param) {
6         System.out.println("Executing real service with parameter: " + param);
7     }
8 }

动态代理处理器：

1 package design.dynamicproxy;
2 
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5 
6 public class DynamicProxyHandler implements InvocationHandler {
7     private Object target;
8 
9     public DynamicProxyHandler(Object target) {
10         this.target = target;
11     }
12 
13     @Override
14     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
15         System.out.println("Before method execution.");
16         Object result = method.invoke(target, args);
17         System.out.println("After method execution.");
18         return result;
19     }
20 }

客户端调用：

1 package design.dynamicproxy;
2 
3 import java.lang.reflect.Proxy;
4 
5 public class Client {
6     public static void main(String[] args) {
7         Service realService = new RealService();
8         InvocationHandler handler = new DynamicProxyHandler(realService);
9         Service proxyService = (Service) Proxy.newProxyInstance(
10                 realService.getClass().getClassLoader(),
11                 realService.getClass().getInterfaces(),
12                 handler
13         );
14         proxyService.execute("dynamic parameter");
15         System.out.println(proxyService.getClass());
16     }
17 }

动态代理的主要优势在于其灵活性和扩展性。它允许在不修改现有代码的情况下，动态地为任何实现了特定接口的对象添加新的行为。此外，由于代理类是在运行时生成的，因此不会导致类数量的激增，从而保持了系统的简洁性。