代理模式-Java实现-静态代理、动态代理

代理模式

静态代理

动态代理

代理模式

代理模式指的是一个类代表另一个类的功能，也就是一个类可以作为另一个类的代理。

代理模式属于结构型模式。

代理类不仅拥有真实类的功能，还可以提供一些额外的附加功能。

代理模式有两种：静态代理、动态代理。

静态代理

静态代理中，代理类是要显示声明的，而且代理类和真实类要实现同一个接口。

步骤 1：创建真实类和代理类的公共接口

public interface CommonInterface {void action();
}

步骤 2：创建真实类、代理类

public class RealObject implements CommonInterface {@Overridepublic void action() {System.out.println("real object action invoke");}
}

public class ProxyObject implements CommonInterface {private CommonInterface realObject;@Overridepublic void action() {System.out.println("proxy : before action");    //代理对象的处理行为synchronized (this) {if (this.realObject == null) {this.realObject = new RealObject();}}this.realObject.action();   //调用真实对象的方法System.out.println("proxy :  after action");     //代理对象的处理行为}
}

步骤 3：使用代理类，而不是真实类

public class ProxyPatternDemo {public static void main(String[] args) {CommonInterface proxyObject = new ProxyObject();proxyObject.action();}
}

动态代理

如果有一个需求：项目中有多个不同的真实类，且这些真实类中的方法各不相同，现在要记录每个方法执行所花费的时间。

如果使用静态代理，这实现起来非常繁琐，因为这些真实类的方法各不相同，需要对不同的真实类创建对应的代理类。

这时动态代理就可以发挥很好的作用，动态代理中，不需要对真实类创建代理类，只需要创建一个调用处理器类（InvocationHandler）即可。

调用处理器类表示一个具体的处理行为，如上面需求中的记录每个方法执行所花费的时间，这就是一个处理行为。

动态代理中的代理对象是动态创建的，在创建时需要指定一个调用处理器，表示该代理对象不仅拥有真实对象的功能，还可以记录每个方法执行所花费的时间。

J2EE的很多框架都使用了动态代理，如：Spring、Hibernate等。例如：要对Controller层中所有控制类增加一个功能，用于记录Get和Post方法的请求和响应的日志信息，可以使用Spring的AOP来实现，而AOP就是使用了动态代理。

可以使用Java反射包中的 InvocationHandler 和 Proxy 来实现动态代理，实现如下：

步骤 1：创建真实类的接口

public interface CommonInterface {void action();
}

步骤 2：创建真实类

public class RealObject implements CommonInterface {@Overridepublic void action() {System.out.println("real object action invoke");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}
}

步骤 3：创建代理使用的调用处理器

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class ProxyInvocationHandler implements InvocationHandler {private Object realObject;public ProxyInvocationHandler() {}public ProxyInvocationHandler(Object realObject) {this.realObject = realObject;}public void setRealObject(Object realObject) {this.realObject = realObject;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("proxy : before action");    //代理对象的处理行为System.out.println("[ real Object : " + this.realObject.getClass().getSimpleName() + " ]");System.out.println("[ invoke method : " + method.getName() + " ]");long startTime = System.currentTimeMillis();Object object = method.invoke(this.realObject, args);   //调用真实对象的方法long endTime = System.currentTimeMillis();System.out.println("spend time(ms) : " + (endTime - startTime));    //记录真实对象的方法执行所花费的时间System.out.println("proxy :  after action");     //代理对象的处理行为return object;}
}

步骤 4：使用代理对象，而不是真实对象

import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;public class DynamicProxyPatternDemo {public static void main(String[] args) {System.out.println(" --------- RealObject代理对象------------ ");CommonInterface realObject = new RealObject(); //真实对象ProxyInvocationHandler invocationHandler = new ProxyInvocationHandler(realObject);  //代理对象使用的调用处理器Class<?> classType = invocationHandler.getClass();   //Class对象，用于提供代理对象使用的类加载器CommonInterface proxyObject = (CommonInterface) Proxy.newProxyInstance(     //创建代理对象classType.getClassLoader(),     //类加载器realObject.getClass().getInterfaces(),  //代理对象使用到的接口invocationHandler);      //代理对象使用的调用处理器proxyObject.action();    //使用代理对象System.out.println(" ---------List代理对象------------ ");List<String> realList = new ArrayList<>();invocationHandler.setRealObject(realList);List<String> proxyList = (List<String>) Proxy.newProxyInstance(     //创建代理对象classType.getClassLoader(),     //类加载器realList.getClass().getInterfaces(),  //代理对象使用到的接口invocationHandler);      //代理对象使用的调用处理器proxyList.add("hello_world");    //使用代理对象System.out.println(proxyList.get(0));}
}