代理模式（静态代理/动态代理）

代理模式（Proxy Pattern）

一 定义

为其他对象提供一种代理，以控制对这个对象的访问。
代理对象在客户端和目标对象之间起到了中介作用，起到保护或增强目标对象的作用。
属于结构型设计模式。

代理模式分为静态代理和动态代理。
静态代理是显式声明被代理对象，即硬编码出来的代理结构；
动态代理是动态配置和替换被代理对象，即通过在jvm中生成一个代理类来实现代理。

代理模式标准示例：

顶层会有 subject的接口，RealSubject 和 Proxy 都实现了 Subject接口。
Proxy中，拥有 RealSubject对象的引用，在Proxy的构造方法中，将RealSubject作为参数传入，然后在Proxy 的同名方法中，调用 RealSubject的方法。但是在调用 RealSubject的方法前后，可以加入Proxy的自有逻辑。

上述类图中各个类的代码如下：
subject 接口类：ISubject

public interface ISubject{void request();
}

被代理的类：RealSubject

public class RealSubject implements ISubject{public void request(){System.out.println("real reqeust");}
}

代理类：Proxy

public class Proxy implements ISubject{private ISubject target;public Proxy(ISubject target){this.target = target;}public void request(){before();//调用前逻辑target.request();after();//调用后逻辑}
}

客户端 ProxyClient

public class ProxyClient{public static void main(String[] args){Proxy proxy = new Proxy(new RealSubject());proxy.request();}
}

接下来，我们通过一个实际场景，来呈现出静态代理与动态代理的异同。

---

阿毛想租房，他首先考虑的是房产中介，因为房源集中在中介那里。

首先是静态代理的实现：

租户接口为：ITenant
中介类为：HouseProxy
实际租户有两个人：Amao 和 LaoSan
代码如下：

public interface ITenant {void require();
}

public class HouseProxy implements ITenant{private ITenant custom;public HouseProxy(ITenant custom){this.custom = custom;}public void require() {before();custom.require();after();}private void before() {System.out.println("当前代理权限通过验证，可以登录系统开始筛选房源。");}private void after() {System.out.println("按照上述要求找到的房源有：xxx");System.out.println();}
}

public class Amao implements ITenant {public void require() {System.out.println("阿毛的要求：一室一厅，2楼，朝南，2000元以内");}
}

public class LaoSan implements ITenant{public void require() {System.out.println("老三的要求：二室一厅，3楼以上，南北通透，4000元以内");}
}

客户端调用代码：

public class Client {public static void main(String[] args) {//中介为阿毛找房：HouseProxy proxy = new HouseProxy(new Amao());proxy.require();//中介为老三找房：HouseProxy proxy1 = new HouseProxy(new LaoSan());proxy1.require();}
}

执行结果为：

当前代理权限通过验证，可以登录系统开始筛选房源。
阿毛的要求：一室一厅，2楼，朝南，2000元以内
按照上述要求找到的房源有：xxx当前代理权限通过验证，可以登录系统开始筛选房源。
老三的要求：二室一厅，3楼以上，南北通透，4000元以内
按照上述要求找到的房源有：xxx

---

动态代理的实现

由于租户不是随时可以看房，所以要和中介约好看房时间，所以我们在ITenant 接口中，增加了看房时间。

public interface ITenant {void require();void lookHouseTime();
}

相应的，Amao和LaoSan 都需要实现这个方法：

public class Amao implements ITenant {public void require() {System.out.println("阿毛的要求：一室一厅，2楼，朝南，2000元以内");}public void lookHouseTime() {System.out.println("阿毛看房时间：周末");}
}

public class LaoSan implements ITenant {public void require() {System.out.println("老三的要求：二室一厅，3楼以上，南北通透，4000元以内");}public void lookHouseTime() {System.out.println("老三看房时间：周中");}
}

最后，是采用JDK动态代理实现的HouseProxy：

public class JDKHouseProxy implements InvocationHandler {private ITenant custom;public ITenant getInstance(ITenant custom){this.custom = custom;Class<?> clazz = custom.getClass();return (ITenant) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {if (!method.getName().equals("lookHouseTime")) {before();}Object result = method.invoke(this.custom,args);if (!method.getName().equals("lookHouseTime")) {after();}return result;}private void before() {System.out.println("--------------------");System.out.println("中介：当前代理权限通过验证，可以登录系统开始筛选房源。");}private void after() {System.out.println("中介：按照上述要求找到的房源有：xxx");}}

这里我们会发现，使用动态代理后，代理中介无需实现ITenant接口，如果ITenant接口发生变化，也不会对代理对象产生影响。
客户端调用类：

public class Client {public static void main(String[] args) {//中介为阿毛找房：JDKHouseProxy proxy = new JDKHouseProxy();ITenant tenantAmao = proxy.getInstance(new Amao());tenantAmao.require();tenantAmao.lookHouseTime();//中介为老三找房：JDKHouseProxy proxy1 = new JDKHouseProxy();ITenant laosan = proxy1.getInstance(new LaoSan());laosan.require();laosan.lookHouseTime();}
}

执行结果：

--------------------
中介：当前代理权限通过验证，可以登录系统开始筛选房源。
阿毛的要求：一室一厅，2楼，朝南，2000元以内
中介：按照上述要求找到的房源有：xxx
阿毛看房时间：周末
--------------------
中介：当前代理权限通过验证，可以登录系统开始筛选房源。
老三的要求：二室一厅，3楼以上，南北通透，4000元以内
中介：按照上述要求找到的房源有：xxx
老三看房时间：周中

动态代理除了JDK的API之外，还有cglib的方式。
二者区别在于，JDK的动态代理需要目标对象有继承体系（即实现接口）；而cglib则不需要被代理对象存在继承体系。
以下是cglib的示例：
cglib的中介代理类：CglibHouseProxy

public class CglibHouseProxy implements MethodInterceptor {public Object getInstance(Class<?> clazz){Enhancer enhancer = new Enhancer();enhancer.setSuperclass(clazz);enhancer.setCallback(this);return enhancer.create();}public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {if (!method.getName().equals("lookHouseTime")) {before();}Object result  = proxy.invokeSuper(obj,args);if (!method.getName().equals("lookHouseTime")) {after();}return result;}private void before() {System.out.println("--------------------");System.out.println("中介：当前代理权限通过验证，可以登录系统开始筛选房源。");}private void after() {System.out.println("中介：按照上述要求找到的房源有：xxx");}
}

客户端调用类：

public class CglibClient {public static void main(String[] args) {CglibHouseProxy proxy = new CglibHouseProxy();ITenant tenant = (ITenant) proxy.getInstance(Amao.class);tenant.require();tenant.lookHouseTime();}
}

执行结果：

--------------------
中介：当前代理权限通过验证，可以登录系统开始筛选房源。
阿毛的要求：一室一厅，2楼，朝南，2000元以内
中介：按照上述要求找到的房源有：xxx
阿毛看房时间：周末

补充：cglib pom.xml的引入

    <dependency><groupId>cglib</groupId><artifactId>cglib-nodep</artifactId><version>2.2</version></dependency>

以上就是本文全部内容。感谢您的阅读。