设计模式之代理模式

代理模式在Java中是一个非常重要的设计模式，在Android中底层通信应用也十分广泛，例如AIDL，Activity的启动线程代理，Activity的binder通信等等都不是直接操作的，而是通过代理进行操作。代理模式是为其他对象提供一种代理以控制对这个对象的访问，通俗地讲代理人对信息进行拦截处理，从类型上来说，分为静态代理和动态代理两种类型。

静态代理

 静态代理相比动态代理更加简单，他是在编译期就可以确定。

代理接口的定义

代理模式中要求代理对象与被代理对象必须实现同一个接口，同时代理中持有一个被代理的引用。设置我们设想通过中介买房子，那么客户就是被代理对象，中介就是代理，行为就是买房，因此可以定义一个买房的接口。

    public interface Buy {
        void buyHouse(long money);
    }

被代理类

    被代理类实现定义的接口，并执行相关操作

 

    public class Buyer implements Buy{

        @Override
        public void buyHouse(long money) {
            System.out.println("买房子花了："+money+"元---");
        }
    }

代理类

 代理类也要实现定义的接口，并执行相关操作

    public class ProxyBuyer implements Buy {

        //被代理类(客户)，代理类持有被代理的对象，即Buyer
        private Buy buy;

        public ProxyBuyer(Buy buy) {
            this.buy = buy;
        }

        @Override
        public void buyHouse(long money) {
            buy.buyHouse(money);
            System.out.println("中介费：" + money*0.02 + "元");
        }
    }

测试

    public void staticProxy(View view){
        System.out.println("----------------静态代理-----------------");
        Buy buyer = new Buyer();
        ProxyBuyer proxyBuyer = new ProxyBuyer(buyer);
        proxyBuyer.buyHouse(500000);
    }

以上就是静态代理的理解，编译的时候ProxyBuyer就已经确定了，而动态代理是在运行期确定的，还以上上面的买房为例，因此这个中介是动态生成的而不是预先确定的。

动态代理

和静态代理相比他可以实现AOP编程，这是静态代理无法实现的，另外还可以解耦，无侵入式的扩展代码。Java中的动态代理要求必须实现InvocationHandler接口，和静态代理一样也必须持有被代理对象。定义一个类ProxyBuyer2实现InvocationHandler，重写invoke方法，在invoke方法中有三个参数：

    invoke(Object proxy, Method method, Object[] args)

•     参数一：代理类的实例，无实际作用。
•     参数二：要调用的方法。
•     参数三：方法的参数。

    public class ProxyBuyer2 implements InvocationHandler {

        //动态代理中持有被代理对象
        private Buy buy;

        public ProxyBuyer2(Buy buy) {
            this.buy = buy;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

            if (method.getName().equals("buyHouse")){
                //如果是买房子的方法的话，取出第一个参数money，这个money为接口中定义的参数，为已知数据
                long money = (long) args[0];
                System.out.print("中介费："+money*0.02);
                return method.invoke(buy,args);
            }
            return null;
        }
    }

测试

    public void motionProxy(View view){
        System.out.println("----------------d动态代理-----------------");
        Buy buyer = new Buyer();
        ProxyBuyer2 proxyBuyer2 = new ProxyBuyer2(buyer);
        Buy proxy = (Buy) Proxy.newProxyInstance(buyer.getClass().getClassLoader(),buyer.getClass().getInterfaces(),proxyBuyer2);
        proxy.buyHouse(500000);
    }

newProxyInstance方法接收三个参数：

• 参数一：被代理类的类加载器ClassLoader。
• 参数二：被代理类实现的自定义的接口。
• 参数三：被代理对象。

    通过源码分析得知newProxyInstance主要做了三件事情：
    1、校验传入参数的正确性。
    2、根据传入的参数生成一个新类的calss对象。
      Class<?> cl = getProxyClass0(loader, intfs);
    3、根据生成的class通过反射获取构造函数对象并生成代理类实例，实现定义的接口。

    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
            throws IllegalArgumentException {
        //1、检查h不为空，否则抛异常
        Objects.requireNonNull(h);
        //2、对传入的接口做安全检查
        final Class<?>[] intfs = interfaces.clone();
        //3、根据传入参数生成ProxyClass0对象class对象
        Class<?> cl = getProxyClass0(loader, intfs);
        //4、根据class使用反射生成代理对象的实例
        try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                cons.setAccessible(true);
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            --------------------------省略非核心的异常处理逻辑代理-------------------------------
         }
    }

总结

1、代理与被代理实现同一个接口，即拥有共同的行为，同时代理中持有一个被代理的引用。
2、代理的主要作用是方法增强，解耦，并且物侵入式的的扩展方法。
3、静态代理需要我们编码时就确定代理、被代理对象关系；动态代理通过反射的方式自动生成代理对象。
4、静态代理只能针对特定一种产品，而动态代理则可以对所有类型产品，因为他的代理类是动态生成。当代理对象比较多的时候需要写大量的代理类，因此动态代理更为常用。

源码地址：https://github.com/yoonerloop/ProxyDemo/tree/master