Android设计模式-代理模式

一. 前言

1. 定义

Proxy Pattern：给目标对象提供一个代理对象，并由代理对象控制对目标对象的访问。

二. 静态代理

1. 概况

背景：有一个人想找代购，购买口红。

2. 代码

/**
 * 静态代理
 */
public class StaticProxy {
    /**
     * 抽象的需求类
     */
    public interface Person {
        //买东西
        void buy();
    }

    /**
     * 真实的需求类
     */
    public static class Demand implements Person {

        String thing;

        public Demand(String thing) {
            this.thing = thing;
        }

        @Override
        public void buy() {
            System.out.println("被代理者-需求者：我想买"+thing);
        }
    }

    /**
     * 代理类
     */
    public static class Purchase implements Person {
        Person person;

        public Purchase(Person person) {
            this.person = person;
        }

        @Override
        public void buy() {
            System.out.println("代理者-代购：你想买什么东西");

            //调用被代理者自己的buy方法
            person.buy();
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        //需求者
        Demand demand = new Demand("口红");

        //代理者
        Purchase purchase = new Purchase(demand);
        purchase.buy();
    }
}

1
2
3

//运行结果
代理者-代购：你想买什么东西
被代理者-需求者：我想买口红

三. 动态代理

1. 概况

背景：有一个人张三想找代购，购买口红。又有一个人李四想找代购，购买面膜。

2. 代码

/**
 * 动态代理
 */
public class DynamicProxy {
    /**
     * 抽象的需求类
     */
    public interface Person {
        //买东西
        void buy();
    }

    /**
     * 真实的需求类
     */
    public static class Demand implements Person {
        String name;
        String thing;

        public Demand(String name, String thing) {
            this.name = name;
            this.thing = thing;
        }

        @Override
        public void buy() {
            System.out.println("被代理者-"+name+"：我想买"+thing);
        }
    }

    /**
     * 代理类
     */
    public static class Purchase implements InvocationHandler {
        //绑定被代理的对象
        Object object;

        public Object newPurchase(Object object) {
            //存储
            this.object = object;

            //返回实例对象
            return Proxy.newProxyInstance(
                    object.getClass().getClassLoader(),
                    object.getClass().getInterfaces(),
                    this
                    );
        }

        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
            System.out.println("代理者-代购：你想买什么东西");

            //调用被代理者对象的方法
            return method.invoke(object, objects);
        }
    }

    /**
     * 测试
     */
    public static void main(String[] args) {
        //需求者
        Demand demand1 = new Demand("张三", "口红");
        Demand demand2 = new Demand("李四", "面膜");

        //动态代理者
        Purchase purchase = new Purchase();

        //获取代理类
        Person person1 = (Person) purchase.newPurchase(demand1);
        Person person2 = (Person) purchase.newPurchase(demand2);

        //代理购买
        person1.buy();
        person2.buy();
    }
}

//运行结果
代理者-代购：你想买什么东西
被代理者-张三：我想买口红
代理者-代购：你想买什么东西
被代理者-李四：我想买面膜

3. 关于代码中一些接口或方法的理解

① InvocationHandler接口

InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。

每一个动态代理类的调用处理程序都必须实现InvocationHandler接口，并且每个代理类的实例都关联到了实现该接口的动态代理类调用处理程序中，当我们通过动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用，看如下invoke方法：

/**
 * proxy:代理类代理的真实代理对象com.sun.proxy.$Proxy0
 * method:我们所要调用某个对象真实的方法的Method对象
 * args:指代代理对象方法传递的参数
 */
public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

② Proxy类

/**
 * loader：一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载
 * interfaces：一个interface对象数组，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
 * 一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用。
 */
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler i) throws IllegalArgumentException