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

代理模式（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的引入

    
      cglib
      cglib-nodep
      2.2
    

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