一.概述

       代理模式也是平时比较常用的设计模式之一,代理模式其实就是提供了一个新的对象,实现了对真实对象的操作,或成为真实对象的替身.在日常生活中也是很常见的.例如A要租房,为了省麻烦A会去找中介,中介会替代A去筛选房子,A坐享中介筛选的结果,并且交房租也是交给中介,这就是一个典型的日常生活中代理模式的应用.平时打开网页,最先开到的一般都是文字,而图片等一些大的资源都会延迟加载,这里也是使用了代理模式.

       代理模式的组成:

       Abstract Subject:抽象主题-声明真实主题和代理主题共同的接口

       Real Subject:真实主题-真实的对象,需要被代理主题引用

       Proxy Subject:代理主题-因为ProxySubject引用了RealSubject,并且实现了跟RealSubject一样的接口,所以ProxySubject可以操作RealSubject,还可以提供一些附加操作,例如before & after

       代理模式常用基于场景的分类:

       1.Virtual Proxy:虚拟代理其实就是通过代理的模式对消耗资源比较大的对象做了一个延迟加载,就是什么时候用到这个对象才去创建它.

       2.Remote Proxy:远程代理是比较经典的应用了,类似于C/S模式(主要拦截并控制远程方法的调用,做代理防火墙之类的).

       3.Smart Reference Proxy:智能引用代理可以给引用的对象提供一些额外的操作,例如实现里面中介Searching和Prepare contract的动作.

       4.Access Proxy;保护代理可以控制一个对象的访问,必要时候提供一系列的权限管理.

       5.Copy-on-write Proxy:写时拷贝(克隆)代理其实是Virtual Proxy的分支,提供了拷贝大对象的时候只有在对象真正变化后才会进行拷贝(克隆)的操作(延迟拷贝).

       代理模式的优缺点:

       优点:

       1.代理作为调用着和真实对象的中间层,降低了模块间和系统的耦合性

       2.可以以一个小对象代理一个大对象,达到优化系统提高运行速度的目的

       3.提供RealSubject的权限管理

       4.容易扩展,RealSubject和ProxySubject都接口化了,RealSubject更改业务后只要接口不变,ProxySubject可以不做任何修改.

       缺点:

       1.同优点1,因为调用者和真实对象多了一个中间层,所以会增加调用响应的时间

二.实现

       这里就拿A找中介租房为Demo来构建代理模式.

1.普通代理

       根据场景先定义一个抽象主题,IHouse,提供三个方法,分别是获取房屋信息,签合同和付租金.

/**
 * Created by jesse on 15-7-24.
 */
public interface IHouse {
    void getHouseInfo();
    void signContract();
    void payFees();
}

public class House implements IHouse{
    private final String TAG = House.class.getSimpleName();
    private String name;
    private double price;

    public House(String name, double price){
        this.name = name;
        this.price = price;
    }

    @Override
    public void getHouseInfo() {
        Log.i(TAG, "House Info- name:" + name + "  ￥:" + price);
    }

    @Override
    public void signContract() {
        Log.i(TAG, "Contract:" + name + "  signed at" +
               new SimpleDateFormat("HH:mm:ss").format(SystemClock.uptimeMillis()));
    }

    @Override
    public void payFees() {
        Log.i(TAG, "Bill: name-" + name + "  $-" + price);
    }
}

public class ProxyHouse implements IHouse{
    private final String TAG = ProxyHouse.class.getSimpleName();
    private IHouse house;
    public ProxyHouse(IHouse house){
        this.house = house;
    }
    @Override
    public void getHouseInfo() {
        Log.i(TAG, "searching");
        house.getHouseInfo();
        Log.i(TAG, "search finished");
    }

    @Override
    public void signContract() {
        Log.i(TAG, "prepare contract");
        house.signContract();
    }

    @Override
    public void payFees() {
        house.payFees();
    }
}

        IHouse house = new House("Downton Abbey", 5000);
        IHouse proxyHouse = new ProxyHouse(house);
        Log.i(TAG, "looking for a perfect house");
        proxyHouse.getHouseInfo();
        Log.i(TAG, "thinking");
        proxyHouse.signContract();
        proxyHouse.payFees();
        Log.i(TAG, "so easy");

2.虚拟代理

       虚拟代理前面有介绍,就是基于代理模式又做了延迟加载来节省内存,但是如果某个对象要在多个没有固定时序地方使用的时候就要进行判空,也会一定程度上牺牲性能(有点像代理模式+懒汉模式).这里还是拿租房的例子来展示.

       这里就假设House是一个很庞大的对象,在创建的时候很耗费资源,那我们就更改成当Custom需要用它的时候才去初始化.这里就在ProxyHouse构造的时候先判House的引用是否为空,然后才会初始化House,当然如果这里有多线程并发的话可以根据不同的场景进行加锁或者双检锁来保证线程安全.

    public ProxyHouse(){
        if (null == house)
            house = new House("Downton Abbey", 5000);
    }

        IHouse proxyHouse = new ProxyHouse();
        Log.i(TAG, "looking for a perfect house");
        proxyHouse.getHouseInfo();
        Log.i(TAG, "thinking");
        proxyHouse.signContract();
        proxyHouse.payFees();
        Log.i(TAG, "so easy");

       强制代理是反其道而行之的代理模式,一般情况下代理模式都是通过代理来找到真实的对象,而强制代理则是通过真实对象才能找到代理也就是说由真实对象指定代理,当然最终访问还是通过代理模式访问的.从名字还能看出它跟其他代理的一个不同,就是强制用代理.拿上面普通代理的例子来说,Custom看不到实体的House的时候它只能通过代理来访问,但是由于没有限制,Custom也可以直接绕过ProxyHouse来访问House,但是强制代理就多了一个限制,Custom必须通过ProxyHouse才能访问House.就像一些房东嫌麻烦,有房客直接电话过来说要看房,房东给出一个中介的电话说你跟中介联系吧.

       首先需要在接口里面添加一个获取代理的接口

public interface IHouse {
    void getHouseInfo();
    void signContract();
    void payFees();
    IHouse getProxy();
}

public class House implements IHouse{
    private final String TAG = House.class.getSimpleName();
    private String name;
    private double price;
    private IHouse proxy;

    public House(String name, double price){
        this.name = name;
        this.price = price;
    }

    @Override
    public void getHouseInfo() {
        if (isProxy())
            Log.i(TAG, "House Info- name:" + name + "  ￥:" + price);
        else
            Log.i(TAG, "Please use correct proxy");
    }

    @Override
    public void signContract() {
        if (isProxy())
            Log.i(TAG, "Contract:" + name + "  signed at" +
                    new SimpleDateFormat("HH:mm:ss").format(SystemClock.uptimeMillis()));
        else
            Log.i(TAG, "Please use correct proxy");

    }

    @Override
    public void payFees() {
        if (isProxy())
            Log.i(TAG, "Bill: name-" + name + "  $-" + price);
        else
            Log.i(TAG, "Please use correct proxy");
    }

    @Override
    public IHouse getProxy() {
        if (null == proxy)
            proxy = new ProxyHouse(this);
        return proxy;
    }

    private boolean isProxy(){
        if (null == proxy)
            return false;
        else
            return true;
    }
}

       所以我们必须使用由真实对象指定的代理才可以正常得访问.

        IHouse house = new House("Downton Abbey", 5000);
        house = house.getProxy();
        Log.i(TAG, "looking for a perfect house");
        house.getHouseInfo();
        Log.i(TAG, "thinking");
        house.signContract();
        house.payFees();

       但是这里的强制代理有个Bug,强制代理其实并没有生效,Custom还是可以直接访问House,例如我通过下面的方式来进行访问,只是通过getProxy创建并获取代理,但是我不用代理还是直接用House的实例进行访问,这个时候还是可以正常访问的.后续会想办法解了这个Bug并且更新上来的.

        IHouse house = new House("Downton Abbey", 5000);
        house.getProxy();//这里只是通过getProxy创建出代理
        Log.i(TAG, "looking for a perfect house");
        house.getHouseInfo();
        Log.i(TAG, "thinking");
        house.signContract();
        house.payFees();

4.动态代理

       既然是动态代理就不需要ProxyHouse也不需要实现IHouse接口了,这里写一个ProxyHandler实现InvocationHandler的invoke接口,并且提供一个根据Proxy构建出来的代理实例给Custom.在通过反射调用真实对象具体的方法之前打印出该方法的名字.

public class ProxyHandler implements InvocationHandler{
    private final String TAG = ProxyHandler.class.getSimpleName();
    Object targetObj;

    public Object newProxyInstance(Object targetObj){
        this.targetObj = targetObj;
        return Proxy.newProxyInstance(targetObj.getClass().getClassLoader(),
                    targetObj.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object ret;
        Log.i(TAG, "method name:" + method.getName());
        ret = method.invoke(targetObj, args);
        return ret;
    }
}

        ProxyHandler proxy = new ProxyHandler();
        IHouse house = (IHouse) proxy.newProxyInstance(new House("Downton Abbey", 5000));
        Log.i(TAG, "looking for a perfect house");
        house.getHouseInfo();
        Log.i(TAG, "thinking");
        house.signContract();
        house.payFees();
        Log.i(TAG, "so easy");

       这个时候整个过程的时序图就变成下面的样子了,通过JDK的Proxy对象和反射的机制来支撑起来动态代理的核心功能.

三.总结