代理模式

距离上次写东西，已经是快两个月了，时光匆匆如流水啊。感觉做Android开发要学的东西真的是太多了，首先Java得继续深入，Android也得继续深入，各种新框架都得学习，感觉时间真是紧张，而且自己还想玩玩游戏，锻炼锻炼身体。2018还有四个多月，继续努力。

代理模式定义：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

使用场景：按职责来划分，通常有以下使用场景：
1、远程代理。
2、虚拟代理。
3、Copy-on-Write 代理。
4、保护（Protect or Access）代理。
5、Cache代理。
6、防火墙（Firewall）代理。
7、同步化（Synchronization）代理。
8、智能引用（Smart Reference）代理。

注意事项：
1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。
2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

举一个保护（Protect or Access）代理的例子

静态代理

举个例子，买火车票
过年回家买火车票，在12306上买不到票，怎么办。用携程啊，携程在手，说走就走，搞个30块钱的加速包，（这30块钱是不是12306和携程一人15啊）估计就十拿九稳了。你自己买不到票，就让携程帮你买，那么携程就是你的代理了。下面用代码说明
1.首先定义一个买票的接口

public interface BuyTicket {

    /**
     * 买票的方法
     */
    void buy();

}

真正想买票的人，就是被代理者

public class MyselfBuyTicket implements BuyTicket {

    @Override
    public void buy() {
        providerInfo();
        System.out.println("老板，我想买票");
    }
    
    private void providerInfo() {
        System.out.println("提供所需购票信息");
    }
}

代理者，持有被代理者的引用

/**
 * 代理类：代理类同样也要实现BuyTicket接口，并且要持有被代理者
 */
public class CtripBuyTicket implements BuyTicket {

    /**
     * 被代理者，小赤佬
     */
    private BuyTicket xiaochilao;

    public CtripBuyTicket(BuyTicket buyTicket) {
        this.xiaochilao = buyTicket;
    }

    @Override
    public void buy() {
        System.out.println("30块钱到手，哈哈");
        xiaochilao.buy();
    }
}

搞一个测试类测试一下

/**
 * 测试静态代理
 */
public class Client {

    public static void main(String[] args) {
        BuyTicket xiaochilao = new MyselfBuyTicket();
        BuyTicket purchasing = new CtripBuyTicket(xiaochilao);
        purchasing.buy();
    }
}

输出

30块钱到手，哈哈
提供所需购票信息
老板，我想买票

妥妥的，买到票了，哈哈。
静态代理：我们在代码运行前就已经存在了代理类CtripbuyTicket的class编译文件

动态代理

动态代理则是在代码运行时通过反射来动态的生成代理类的对象，并确定到底来代理谁。也就是我们在编码阶段不需要知道代理谁，代理谁我们将会在代码运行时决定。Java提供了Proxy这个类和InvocationHandler这个接口来实现动态代理。

每个代理实例都有一个关联的调用处理者，当代理实例调用一个方法的时候，这个方法调用会被转发到调用处理者的invoke方法中

public class CtripInvocationHandler implements InvocationHandler {

    /**
     * 在动态代理类中我们声明一个Object的引用，该引用指向被代理类
     */
    private Object obj;

    public CtripInvocationHandler(Object obj) {
        this.obj = obj;
    }

    public void buy() {
        System.out.println("亲，已抢到第一车厢3号座位");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("30块钱到手，哈哈");
        return method.invoke(obj, args);
    }
}

测试动态代理

public class DynamicClient {

    public static void main(String[] args) {
        BuyTicket xiaochilao = new MyselfBuyTicket();
        /**
         *创建调用处理者
         */
        CtripInvocationHandler invocationHandler = new CtripInvocationHandler(xiaochilao);
        /**
         * 动态代理者
         */
        BuyTicket purchasing = (BuyTicket) Proxy.newProxyInstance(
                xiaochilao.getClass().getClassLoader(),
                xiaochilao.getClass().getInterfaces(),
                invocationHandler);
        /**
         *调用代理实例的buy()方法，该方法会转发到CtripInvocationHandler的invoke方法中，
         * 最终会调用被代理者xiaochilao的buy方法，实现真正的买票逻辑
         */
        purchasing.buy();
    }
}

输出结果

30块钱到手，哈哈
提供所需购票信息
老板，我想买票

在上面这个例子中，动态体现在哪里呢？体现在，我们现在并不需要一个CtripBuyTicket这样一个类了。现在我们使用Proxy .newProxyInstance()方法在运行时，动态创建一个MyselfBuyTicket的代理者。

注：关于动态代理者的创建过程，还有方法调用如何转发的，暂时先不去细究。

参考链接:
1：设计模式之死磕代理模式（原创）
2：设计模式（六）代理模式