2019-05-05设计模式-代理模式

将自己不想或者不能去做的事情交给另外一个对象去做

举个例子，你要去银行取钱，自己不能直接到银行中拿钱，只能让柜台帮你从银行拿钱；这就是代理。其中 代理对象为：柜台；被代理对象为：自己。转换为代码实现：

定义操作，代理对象和被代理对象都实现该操作：

    interface IBank {
        String getMoney();
    }

只定义取钱操作，实现被代理对象：

    public static class Man implements IBank {
        private String name;

        public Man(String name) {
            this.name = name;
        }

        @Override
        public String getMoney() {
            System.out.println(name + " 开始取钱......");
            return "得到钱";
        }
    }

实现代理对象：

    public static class Counter implements IBank {

        private IBank man;

        public Counter(IBank man) {
            this.man = man;
        }

        @Override
        public String getMoney() {
            System.out.println("有人过来取钱.....从银行拿钱...");
            //调用被代理对象的方法
            String money = man.getMoney();
            System.out.println("给钱完毕......下一位....");
            return money;
        }
    }

代理对象也实现 IBank 接口，但是在 getMoney 中做了一下 Man 对象不能操作的事情，在Clien中使用：

    public static void main(String[] args) {
        Man liang = new Man("liang");
        Counter counter = new Counter(liang);
        String money = counter.getMoney();
        System.out.println(money);
    }

输出结果为：

WechatIMG60.jpeg
静态代理到这就完成，实际的应用有：RecyclerView实现多布局
静态代理结束，进入到动态代理，这里只描述 jdk 中动态代理的使用。

动态代理使用

动态代理不需要我们自己书写代理对象(Counter 类)，只需要被代理对象：

    public static void main(String[] args) {
        Man realBank = new Man("liang");
        MyInvocationHandler handler = new MyInvocationHandler(realBank);
        //动态得到代理对象
        IBank bank = (IBank) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{IBank.class}, handler);
        String money = bank.getMoney();
        System.out.println(money);
    }

只需要使用 Proxy.newProxyInstance 得到代理对象(Counter 类)，其中 MyInvocationHandler 为：

    
    public static class MyInvocationHandler implements InvocationHandler {

        private IBank realBank;

        public MyInvocationHandler(IBank bank) {
            this.realBank = bank;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("交给代理对象使用,柜台给钱");
            Object invoke = method.invoke(realBank, args);
            System.out.println("代理对象给回用户,完成---->");
            //注意，这里的返回值就是该方法的返回内容
            return invoke;
        }
    }

每当使用代理对象调用方法时，都会进入到 MyInvocationHandler 中的 invoke 方法，需要留意的是 invoke 的返回值就是代理对象调用的方法的返回值，这里直接通过反射调用的被代理对象(Man)的方法。其输出结果为：

WechatIMG471.jpeg

动态代理到这里就结束，实际的应用有 ：Retrofit

注意，当使用kotlin写动态代理是，需要这样书写MyInvocationHandler

    class MyInvocationHandler(private val bank: IBank) : InvocationHandler {
        @Throws(Throwable::class)
        override fun invoke(proxy: Any, method: Method, args: Array<Any>?): Any? {
            //需要判断args是否为null
            val invoke = method.invoke(bank, *(args ?: arrayOfNulls(0)))
            return invoke
        }
    }