代理模式（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>
以上就是本文全部内容。感谢您的阅读。
