Android之代理模式

静态代理

基本概念

目标对象为其对象提供一种代理对象，其他对象通过代理对象来控制对目标对象的访问。

角色划分

Proxy（美['prɑksi]）：代理对象,其他对象直接控制的对象。
Subject（[ˈsʌbdʒɪkt]）：目标接口，目标对象的抽象。
RealSubject：具体目标对象，目标接口的实现，即真正控制的对象。

简单理解：
当其他对象对某个目标对象进行操作且需要对目标对象进行更改时，若目标对象被多个对象引用，或目标对象不可以更改，此时使用代理模式，通过对代理对象的修改，而完成最终的业务需求。

来源于生活的案例

• 案例描述： 我通过代购，买了一台iphone X。

我想要买一台港版的iphone X，但是我在大陆，不能直接购买港版的iphone X。于是，我找到了代购公司，代购公司帮我买一个iphoneX。

目标接口：买手机动作，行为抽象
目标对象：我->买手机的人->买手机的行为
代理对象：代购的人->同学或者朋友->代理买手机的行为
其他对象：调用购买手机的对象

• 案例理解: 我为什么是目标对象？

  在考虑整个案例之后，大多数人一定会主观认为目标对象应该是手机，但是将每个对象进行行为划分，即可理解为目标对象是我，即我买手机的这个行为。
  整个案例的核心，是我想要买手机，代购的核心是帮我买手机，而手机却是具有其他行为的，与买手机行为无关的对象。
  所以，以买手机的行为方向，进行思考，可以得出以下结论：

目标接口：买手机动作，行为抽象
目标对象：我->买手机的人->买手机的行为
代理对象：代购的人->同学或者朋友->代理买手机的行为
其他对象：调用购买手机的对象

• 案例代码实现： 代码实现三步走；

1.将行为抽象，实现目标接口

 目标接口：IShopPhone（购物->手机）

2.实现行为，完成购买动作

目标对象：ShopPhone
特点：实现目标接口

3.实现代理对象，改变由代理对象完成。

代理对象：WJProxy
        特点一：实现目标接口（可有可无）
        特点二：持有目标对象的引用（必需）

源码展示

/**
 * 目标接口，抽象购买行为
 */
public interface IShopPhone {
    /**
     * 购买手机
     * @param str
     */
    void shopPhone(String str);
}

/**
 * 目标接口的实现类，实现具体的行为
 */
public class ShopPhone implements IShopPhone {
    @Override
    public void shopPhone(String str) {
        System.out.println(str);
    }

}

/**
 * 代理类，代理购买手机的行为。
 */
public class ProxyShopPhone implements IShopPhone {
    IShopPhone mTarget;

    /**
     * 目标
     */
    public ProxyShopPhone(IShopPhone target) {
        this.mTarget = target;
    }

    @Override
    public void shopPhone(String str) {
        System.out.println("-----start----");
        mTarget.shopPhone(str);
        System.out.println("-----end----");
    }
}

/**
 * 用户类，用户进行买手机的操作
 */
public class User {
    public static void main(String[] args) {
        /*在大陆买手机*/
        ShopPhone shopPhone = new ShopPhone();
        shopPhone.shopPhone("在大陆买了一个iPhone X，一共花了8888元");
        /*在香港买手机*/
        ProxyShopPhone proxyShopPhone = new ProxyShopPhone(shopPhone);
        proxyShopPhone.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
    }
}


————————————————————控制台显示的结果—————————————————————

在大陆买了一个iPhone X，一共花了8888元
-----start----
通过代购，在香港买了一个iphone X，一共花了6666元
-----end----

Process finished with exit code 0

——————————————END——————————————

动态代理

与静态代理的区别

动态创建代理类（虚拟机->框架、系统帮助我们来完成创建过程）

动态代理的特点

1.代理对象不需要实现接口。
2.不需要自己实现代理对象，由虚拟机动态生成（内部通过java反射实现）。
3.动态代理也叫做JDK代理或接口代理。

代码实现

将动态代理中，不使用静态代理中的代理对象，通过jdk中自带的代理方法实现动态代理。

/**
 * 操作类---测试类
 */
public class Main {
    public static void main(String[] args) {
        /*在大陆买手机*/
        ShopPhone shopPhone = new ShopPhone();
        shopPhone.shopPhone("在大陆买了一个iPhone X，一共花了8888元");
        /*动态代理---在香港买手机*/
        IShopPhone proxy = (IShopPhone) Proxy.newProxyInstance(shopPhone.getClass().getClassLoader(), shopPhone.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("-----动态代理 start----");
                Object returnValue = method.invoke(shopPhone, args);
                System.out.println("-----动态代理 end----");
                return returnValue;
            }
        });
        proxy.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
    }

• newProxyInstance详解：

ClassLoader loader: 指定当前目标对象使用类加载器,即目标对象的类加载器。获取方法是固定的：[shopPhone.getClass().getClassLoader()]。

Class<?>[] interfaces: 目标对象实现的接口的类型,使用泛型方式确认类型。获取方法是固定的：[shopPhone.getClass().getInterfaces()]。

InvocationHandler h: 事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入。即动态代理类接口的实现，通过JAVA反射实现。

封装动态代理工厂代码实现

/**
 * 动态代理工厂
 */
public class ProxyFactory {
    private Object mTarget;

    /**
     * 维护一个目标对象
     */
    public ProxyFactory(Object target) {
        this.mTarget = target;
    }

    /**
     * 获取动态代理对象
     *
     * @return
     */
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(mTarget.getClass().getClassLoader(), mTarget.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("--------start-------");
                Object returnValue = method.invoke(mTarget,args);
                System.out.println("---------end--------");
                return returnValue;
            }
        });
    }
}


——————————————————————使用方法—————————————————————
 proxy.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
        IShopPhone proxy2 = (IShopPhone) new ProxyFactory(shopPhone).getProxyInstance();
        proxy2.shopPhone("通过代购商店，在香港买了一个iphone X，一共花了6666元");

——————————————————————控制台输出结果—————————————————————
在大陆买了一个iPhone X，一共花了8888元
--------start-------
通过代购商店，在香港买了一个iphone X，一共花了6666元
---------end--------

Process finished with exit code 0

cglib动态代理

基本概述

可继承式的动态代理（java仅允许单继承，而JDK中的代理类，自身就会继承Proxy），在android开发中，一般不会使用。
使用该方式实现动态代理，需要倒入cglib.jar，或使用spring框架，即该方式的动态代理，大多在后台服务器中使用，在本片文章中不会过多讲解；

代码实现

/**

/**
 * 通过继承实现的动态代理类
 */
public class CGLibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();
    public Object getProxy(Class<?> clazz){
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    /**
     * 拦截所有目标类方法的调用
     * 参数：
     * obj目标实例对象
     *method 目标方法的反射对象
     * args方法的参数
     * proxy代理类的实例
     */
    public Object intercept(Object obj, Method method, Object[] args,
                            MethodProxy proxy) throws Throwable {
        //代理类调用父类的方法
        System.out.println("日志开始");
        proxy.invokeSuper(obj, args);
        System.out.println("日志结束");
        return null;
    }
}
——————————————————————使用方法—————————————————————
 /*通过cglib.jar实现可继承的动态代理*/
    IShopPhone proxy3 = (IShopPhone) new CGLibProxy().getProxy(ShopPhone.class);
    proxy3.shopPhone("通过代购，在香港买了一个iphone X，一共花了6666元");
       

使用场景

例如：开发当中->类似框架（代理模式）
    XUtils框架、Retrofit框架、MVP架构设计、插件化架构设计等等...