设计模式（三）代理模式

写在前面：

• 你好，欢迎你的阅读！
• 我热爱技术，热爱分享，热爱生活， 我始终相信：技术是开源的，知识是共享的！
• 博客里面的内容大部分均为原创，是自己日常的学习记录和总结，便于自己在后面的时间里回顾，当然也是希望可以分享自己的知识。目前的内容几乎是基础知识和技术入门，如果你觉得还可以的话不妨关注一下，我们共同进步！
• 除了分享博客之外，也喜欢看书，写一点日常杂文和心情分享，如果你感兴趣，也可以关注关注！
• 微信公众号：傲骄鹿先生
   

结构型模式主要涉及如何组合各种对象以便获得更好、更灵活的结构。虽然面向对象的继承机制提供了最基本的子类扩展父类的功能，但结构型模式不仅仅简单地使用继承，而更多地通过组合与运行期的动态组合来实现更灵活的功能。

一、代理模式（Proxy Pattern）：静态代理

1、介绍

• 定义：给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用

• 主要作用：通过代理对象的方式间接访问目标对象

• 解决的问题：防止直接访问目标对象给系统带来不必要的麻烦

2、UML图及简单实现

接下来将通过一个简单的实例来实现：

我想买一台最新的顶配Mac电脑，但是国内还没有上只有美国才有，想找人进行代购。即代购（代理对象）代替我（真实对象）去是买Mac（间接访问操作）

（1）创建抽象对象接口（ Subject ）： 声明我（真实对象）需要让代购（代理对象）帮忙做的事（买Mac）

public interface Subject {  
    public void buyMac();
}

（2） 步骤2： 创建真实对象类（RealSubject）,即”我“

public class RealSubject implement Subject{
  @Override
  public void buyMac() {  
      System.out.println(”买一台Mac“);  
  }  
}

（3） 步骤3：创建代理对象类（Proxy），即”代购“，并通过代理类创建真实对象实例并访问其方法

public class Proxy  implements Subject{
  
    @Override
    public void buyMac{
      
      //引用并创建真实对象实例，即”我“
      RealSubject realSubject = new RealSubject()；

      //调用真实对象的方法，进行代理购买Mac
      realSubject.buyMac（）；
      //代理对象额外做的操作
      this.WrapMac()；
    }

     public void WrapMac(){
      System.out.println(”用盒子包装好Mac“);  
    }
}

（4） 步骤4：客户端调用

public class ProxyPattern {

    public static void main(String[] args){
        Subject proxy = new Proxy（）；
        proxy.buyMac()；
    }
}

3、优缺点

（1）优点

• 协调调用者和被调用者，降低了系统的耦合度

• 代理对象作为客户端和目标对象之间的中介，起到了保护目标对象的作用

（2）缺点

• 由于在客户端和真实主题之间增加了代理对象，因此会造成请求的处理速度变慢；

• 实现代理模式需要额外的工作（有些代理模式的实现非常复杂），从而增加了系统实现的复杂度。

4、应用场景

一、代理模式（Proxy Pattern）：动态代理

1、为什么要使用动态代理？

代理模式中的静态代理模式存在一些特点：

• 1个静态代理 只服务1种类型的目标对象

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

在目标对象较多的情况下，若采用静态代理，则会出现 静态代理对象量多、代码量大，从而导致代码复杂的问题，因此可以使用动态代理来解决这个问题。

2、动态代理的实现

接下来还是通过一个实例来实现：

我想买一台最新的顶配Mac电脑，我朋友想买一台iPhone XS Max，但是国内还没有上只有美国才有，想找人进行代购。即代购（动态代理对象）同时代替我和朋友（目标对象）去买Mac、iPhone XS Max（间接访问操作）

（1）步骤一：声明调用处理器类 

<-- 作用 -->
// 1、生成动态代理对象
// 2、指定代理对象运行目标对象方法时需要完成的具体任务
// 注：需实现InvocationHandler接口 = 调用处理器接口
// 所以称为调用处理器类
public class DynamicProxy implements InvocationHandler {

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

    public Object newProxyInstance(Object ProxyObject){
        this.ProxyObject =ProxyObject;

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

    //  复写InvocationHandler接口的invoke（）
    //  动态代理对象调用目标对象的任何方法前，都会调用调用处理器类的invoke（）
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
        // 参数说明：
        // 参数1：动态代理对象（即哪个动态代理对象调用了method（）
        // 参数2：目标对象被调用的方法
        // 参数3：指定被调用方法的参数

        System.out.println("代购出门了");
        Object result = null;
        // 通过Java反射机制调用目标对象方法
        result = method.invoke(ProxyObject, args);
        return result;
    }

}

（2）步骤二：声明目标对象类的抽象接口

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

（3）步骤三：声明目标对象类、

// 我，真正的想买Mac的对象 = 目标对象 = 被代理的对象// 实现抽象目标对象的接口
public class Buyer1 implements Subject  {
    @Override
    public void buybuybuy() {
        System.out.println("我要买Mac");
    }
}

// 朋友，真正的想买iPhone的对象 = 目标对象 = 被代理的对象// 实现抽象目标对象的接口
public class Buyer2 implements Subject  {
    @Override
    public void buybuybuy() {
        System.out.println("朋友要买iPhone");
    }
}

（4）步骤四：通过动态代理对象，调用目标对象的方法

public class MainActivity extends AppCompatActivity {

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

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

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

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

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

        // 以下是代购为朋友代购iPhone
        Buyer2 mBuyer2 = new Buyer2();
        Subject Buyer2_DynamicProxy = (Subject) DynamicProxy.newProxyInstance(mBuyer2);
        Buyer2_DynamicProxy.buybuybuy();
    }
}

3、实现原理、优缺点

（1）实现原理

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

• 即：在使用时再创建动态代理类 & 实例

• 静态代理则是在代理类实现时就指定与目标对象类（RealSubject）相同的接口

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

（2）优点

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

• 更强的灵活性

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

  • 在使用时（调用目标对象方法时）才会动态创建动态代理类 & 实例，不需要事先实例化

（3）缺点

• 效率低

  相比静态代理中直接调用目标对象方法，动态代理则需要先通过Java反射机制 从而 间接调用目标对象方法

• 应用场景局限

  因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口创建代理类，不能针对类创建代理类

4、应用场景、与静态代理的区别

（1）应用场景

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

• AOP 领域

  • 定义：即 Aspect Oriented Programming = 面向切面编程，是OOP的延续、函数式编程的一种衍生范型

  • 作用：通过预编译方式和运行期动态代理实现程序功能的统一维护。

  • 优点：降低业务逻辑各部分之间的耦合度 、 提高程序的可重用性 & 提高了开发的效率

  • 具体应用场景：日志记录、性能统计、安全控制、异常处理

（2）与静态代理的区别

五、源码分析

在步骤（4）中有两个值得重要的源码分析点：

a、创建动态代理类 & 对象：通过调用处理器类对象newProxyInstance（）

b、通过调用动态代理对象方法从而调用目标对象方法

关注一：创建动态代理类 & 对象：通过调用处理器类对象newProxyInstance（）

我们直接进入到DynamicProxy.newProxyInstance()：

<-- 关注1：调用处理器 类的newProxyInstance（） -->// 即步骤1中实现的类：DynamicProxy
// 作用：
// 1、生成动态代理对象
// 2、指定代理对象运行目标对象方法时需要完成的具体任务
// 注：需实现InvocationHandler接口 = 调用处理器 接口

public class DynamicProxy implements InvocationHandler {

    // 声明代理对象
    private Object ProxyObject;

    public Object newProxyInstance(Object ProxyObject){
        this.ProxyObject =ProxyObject;
        return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
                ProxyObject.getClass().getInterfaces(),this);
        // Proxy.newProxyInstance（）作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类实例，并最终返回
        // ->>关注2
    }

    // 以下暂时忽略，下文会详细介绍
    // 复写InvocationHandler接口的invoke（）
    // 动态代理对象调用目标对象的任何方法前，都会调用调用处理器类的invoke（）
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            // 参数1：动态代理对象（即哪个动态代理对象调用了method（）
            // 参数2：目标对象被调用的方法
            // 参数3：指定被调用方法的参数
            throws Throwable {
                System.out.println("代购出门了");
                Object result = null;
                // 通过Java反射机制调用目标对象方法
                result = method.invoke(ProxyObject, args);
        return result;
    }

// 至此，关注1分析完毕，跳出}

<-- 关注2：newProxyInstance（）源码解析-->
// 作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类及其对象实例，并最终返回
      
public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException {
    // 参数说明：
    // 参数1：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
    // 参数2：指定目标对象的实现接口
    // 即要给目标对象提供一组什么接口。若提供了一组接口给它，那么该代理对象就默认实现了该接口，这样就能调用这组接口中的方法
    // 参数3：指定InvocationHandler对象。即动态代理对象在调用方法时，会关联到哪个InvocationHandler对象

    ...  
    // 仅贴出核心代码
    // 1. 通过为Proxy类指定类加载器对象 & 一组interface，从而创建动态代理类
    // >>关注3
    Class cl = getProxyClass(loader, interfaces);

    // 2. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
    Constructor cons = cl.getConstructor(constructorParams);

    // 3. 通过动态代理类的构造函数创建代理类实例（传入调用处理器对象）
    return (Object) cons.newInstance(new Object[] { h });

   // 特别注意
   // 1. 动态代理类继承 Proxy 类 & 并实现了在Proxy.newProxyInstance()中提供的一系列接口（接口数组）// 2. Proxy 类中有一个映射表
   // 映射关系为：(<ClassLoader>,(<Interfaces>,<ProxyClass>) )
   // 即：1级key = 类加载器，根据1级key 得到 2级key = 接口数组
   // 因此：1类加载器对象 + 1接口数组 = 确定了一个代理类实例...


// 回到调用关注2的原处
}

<-- 关注3：getProxyClass（）源码分析 -->
// 作用：创建动态代理类

public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces) throws IllegalArgumentException {
    
  ...
  // 仅贴出关键代码
<-- 1. 将目标类所实现的接口加载到内存中 -->
    // 遍历目标类所实现的接口  
    for (int i = 0; i < interfaces.length; i++) {  
          
        // 获取目标类实现的接口名称
        String interfaceName = interfaces[i].getName();  
        Class interfaceClass = null;  
        try {  
        // 加载目标类实现的接口到内存中  
        interfaceClass = Class.forName(interfaceName, false, loader);  
        } catch (ClassNotFoundException e) {
        }  
        if (interfaceClass != interfaces[i]) {  
        throw new IllegalArgumentException(  
            interfaces[i] + " is not visible from class loader");  
        }  
    }  
       
<-- 2. 生成动态代理类 -->       
        // 根据传入的接口 & 代理对象 创建动态代理类的字节码
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);  
        // 根据动态代理类的字节码 生成 动态代理类
        proxyClass = defineClass0(loader, proxyName,  
        proxyClassFile, 0, proxyClassFile.length);  
       
        }  
    // 最终返回动态代理类
    return proxyClass;  
}  

// 回到调用关注3的原处

总结：

• 通过调用处理器类对象的.newProxyInstance()创建动态代理类 及其实例对象（需传入目标类对象）

• 具体过程如下：

  1. 通过 为Proy类指定类加载器对象 & 一组接口，从而创建动态代理类的字节码；再根据类字节码创建动态代理类

  2. 通过反射机制获取动态代理类的构造函数（参数类型 = 调用处理器接口类型）

  3. 通过动态代理类的构造函数 创建 代理类实例（传入调用处理器对象）

关注二：通过调用动态代理对象方法从而调用目标对象方法

在关注1中的 DynamicProxy.newProxyInstance()生成了一个动态代理类及其实例，该动态代理类记为 ：$Proxy0

下面我们直接看该类实现及其 buybuybuy()：

<-- 动态代理类 $Proxy0 实现-->
// 继承：Java 动态代理机制的主类：java.lang.reflect.Proxy
// 实现：与目标对象一样的接口（即上文例子的Subject接口）
public final class $Proxy0 extends Proxy implements Subject {

    // 构造函数
    public ProxySubject(InvocationHandler invocationhandler){   
        super(invocationhandler);   
    }  

    // buybuybuy()是目标对象实现接口（Subject）中的方法
    // 即$Proxy0类必须实现
    // 所以在使用动态代理类对象时，才可以调用目标对象的同名方法（即上文的buybuybuy()）
    public final void buybuybuy(){
        try {
            super.h.invoke(this, m3, null);
            // 该方法的逻辑实际上是调用了父类Proxy类的h参数的invoke()
            // h参数即在Proxy.newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
            // 即调用了调用处理器的InvocationHandler.invoke()
            // 而复写的invoke（）利用反射机制：Object result=method.invoke(proxied,args)
            // 从而调用目标对象的的方法 ->>关注4
            return;
        } catch (Error e) {
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

<-- 关注4：调用处理器 类复写的invoke（） -->
// 即步骤1中实现的类：DynamicProxy
// 内容很多都分析过了，直接跳到复写的invoke()中
public class DynamicProxy implements InvocationHandler {

    private Object ProxyObject;

    public Object newProxyInstance(Object ProxyObject){
        this.ProxyObject =ProxyObject;
        return Proxy.newProxyInstance(ProxyObject.getClass().getClassLoader(),
                ProxyObject.getClass().getInterfaces(),this);
    }

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

总结：

• 动态代理类实现了与目标类一样的接口，并实现了需要目标类对象需要调用的方法

• 该方法的实现逻辑 = 调用父类 Proxy类的 h.invoke（）

         其中h参数 = 在创建动态代理实例中newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象

• 在 InvocationHandler.invoke（） 中通过反射机制，从而调用目标类对象的方法

6、总结