1. 为什么要使用动态代理

1.1 背景

• 1个静态代理 只服务1种类型的目标对象
• 若要服务多类型的目标对象，则需要为每种目标对象都实现一个静态代理对象

在目标对象较多的情况下，若采用静态代理，则会出现 静态代理对象量多、代码量大，从而导致代码复杂的问题

解决方案
采用 动态代理模式

2. 动态代理模式介绍

2.1 实现原理

• 设计动态代理类（DynamicProxy）时，不需要显式实现与目标对象类（RealSubject）相同的接口，而是将这种实现推迟到程序运行时由 JVM来实现

• 通过Java 反射机制的method.invoke（），通过调用动态代理类对象方法，从而自动调用目标对象的方法

即：在使用时再创建动态代理类 & 实例
静态代理则是在代理类实现时就指定与目标对象类（RealSubject）相同的接口

2.2 优点

• 只需要1个动态代理类就可以解决创建多个静态代理的问题，避免重复、多余代码
• 更强的灵活性

1. 设计动态代理类（DynamicProxy）时，不需要显式实现与目标对象类（RealSubject）相同的接口，而是将这种实现推迟到程序运行时由 JVM来实现
2. 在使用时（调用目标对象方法时）才会动态创建动态代理类 & 实例，不需要事先实例化

2.3缺点

• 效率低 相比静态代理中 直接调用目标对象方法，动态代理则需要先通过Java反射机制 从而 间接调用目标对象方法
• 应用场景局限 因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口 创建 代理类，不能针对类 创建代理类

即只能动态代理 实现了接口的类

2.4应用场景

• 基于静态代理应用场景下，需要代理对象数量较多的情况下使用动态代理
• AOP 领域

1. 定义：即 Aspect Oriented Programming = 面向切面编程，是OOP的延续、函数式编程的一种衍生范型
2. 作用：通过预编译方式和运行期动态代理实现程序功能的统一维护。
3. 优点：降低业务逻辑各部分之间的耦合度 、 提高程序的可重用性 & 提高了开发的效率
4. 具体应用场景：日志记录、性能统计、安全控制、异常处理等

2.5 与静态代理模式的区别

3. 具体应用

3.1 实例概况

• 背景：小A 希望买一台最新的顶配 Mac 电脑；小B希望买一台 iPhone
• 冲突：国内还没上，只有美国才有
• 解决方案：寻找一个代购一起进行购买

1. 即1个代购（动态代理对象）同时 代替 小成 & 小何（目标对象） 去买Mac（间接访问的操作）
2. 该代购是代购任何商品 = 什么人有什么需求就会去代购任何东西（动态代理）

3.2 使用步骤

1. 声明 调用处理器类
2. 声明目标对象类的抽象接口
3. 声明目标对象类
4. 通过动态代理对象，调用目标对象的方法

3.3 步骤详解

步骤1： 声明 调用处理器类
DynamicProxy.java

/**
 * Created by zhang on 2019/7/22 0022.
 * Desc: 作用
 * 1.  生成 动态代理对象
 * 2.  指定 代理对象运行目标对象方法时需要完成的 具体任务
 * 注：需实现InvocationHandler接口 = 调用处理器 接口
 * 所以称为 调用处理器类
 */

public class DynamicProxy implements InvocationHandler {
    // 声明代理对象
    // 作用：绑定关系，即关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke（）
    private Object proxyObject;

    public Object newProxyInstance(Object proxyObject) {
        this.proxyObject = proxyObject;
        return Proxy.newProxyInstance(proxyObject.getClass().getClassLoader(),
                proxyObject.getClass().getInterfaces(),this);
        // Proxy类 = 动态代理类的主类
        // Proxy.newProxyInstance（）作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类实例，并最终返回
        // 参数说明：
        // 参数1：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
        // 参数2：指定目标对象的实现接口
        // 即要给目标对象提供一组什么接口。若提供了一组接口给它，那么该代理对象就默认实现了该接口，这样就能调用这组接口中的方法
        // 参数3：指定InvocationHandler对象。即动态代理对象在调用方法时，会关联到哪个InvocationHandler对象

    }

    //  复写InvocationHandler接口的invoke（）
    //  动态代理对象调用目标对象的任何方法前，都会调用调用处理器类的invoke（）
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 参数说明：
        // 参数1：动态代理对象（即哪个动态代理对象调用了method（）
        // 参数2：目标对象被调用的方法
        // 参数3：指定被调用方法的参数
        Log.e("===z","代购出门了");
        Object result = null;
        // 通过Java反射机制调用目标对象方法
        result = method.invoke(proxyObject, args);
        return result;
    }
}

步骤2： 声明目标对象的抽象接口
SubjectDynamic.java

/**
 * Created by zhang on 2019/7/22 0022.
 * Desc:
 */

public interface SubjectDynamic {
    // 定义目标对象的接口方法
    // 代购物品
    void buyBuyBuy();
}

步骤3： 声明目标对象类
Buyer1.java

/**
 * Created by zhang on 2019/7/22 0022.
 * Desc:
 * 小A，真正的想买Mac的对象 = 目标对象 = 被代理的对象
 * 实现抽象目标对象的接口
 */

public class Buyer1 implements SubjectDynamic {
    @Override
    public void buyBuyBuy() {
        Log.e("===z","小A要买Mac电脑");
    }
}

Buyer2.java

/**
 * Created by zhang on 2019/7/22 0022.
 * Desc:
 * 小B，真正的想买iPhone的对象 = 目标对象 = 被代理的对象
 * 实现抽象目标对象的接口
 */

public class Buyer2 implements SubjectDynamic {
    @Override
    public void buyBuyBuy() {
        Log.e("===z","小B要买iphone手机");
    }
}

步骤4： 通过动态代理对象，调用目标对象的方法
MainActivity.java

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 1. 创建调用处理器类对象
        DynamicProxy dynamicProxy = new DynamicProxy();

        // 2. 创建目标对象 对象
        Buyer1 buyer1 = new Buyer1();

        // 3. 创建动态代理类 & 对象：通过调用处理器类对象newProxyInstance（）
        // 传入上述目标对象对象
        SubjectDynamic buyer1_dynamic_proxy =
                (SubjectDynamic) dynamicProxy.newProxyInstance(buyer1);

        // 4. 通过调用动态代理对象方法从而调用目标对象方法
        // 实际上是调用了invoke（），再通过invoke（）里的反射机制调用目标对象的方法
        buyer1_dynamic_proxy.buyBuyBuy();
        //以上是代购为小A买Mac的过程

        Buyer2 buyer2 = new Buyer2();
        SubjectDynamic buyer2_dynamic_proxy =
                (SubjectDynamic) dynamicProxy.newProxyInstance(buyer2);
        buyer2_dynamic_proxy.buyBuyBuy();

    }

输出结果

4. 源码分析

5. 总结

时间紧迫 还没介绍完 下期 我们讲工厂方法模式