Java 深入学习（28） —— 静态代理与动态代理

代理是基本的设计模式之一，它是为了提供额外的或不同的操作，而插入的用来代替“实际”对象的对象。这些操作通常涉及与“实际”对象的通信，因此代理通常充当中间人的角色。

---

1 静态代理

---

代理这种设计模式其实很好理解，基本就是最简单的一个“组合”。

比如说下面这个例子，我们有 RealObject 这个类，本来可以直接调用 RealObject 类的 doSomething() 和 somethingElse()方法。

但代理模式就非要把RealObject 类当成 SimpleProxy类的一个成员字段放在 SimpleProxy 类里面。然后因为RealObject类和 SimpleProxy类都实现了Interface这个接口，所以SimpleProxy类里也有doSomething()和somethingElse()方法。而且 SimpleProxy 类里的 doSomething() 和somethingElse()方法就是傻瓜式的调用 RealObject类的doSomething()和 somethingElse() 方法。

package com.test.class_obj;

interface Interface {
    void doSomething();

    void somethingElse(String arg);
}

class RealObject implements Interface {
    public void doSomething() {
        System.out.println("doSomething");
    }

    public void somethingElse(String arg) {
        System.out.println("somethingElse " + arg);
    }
}

class SimpleProxy implements Interface {
    private Interface proxied;

    public SimpleProxy(Interface proxied) {
        this.proxied = proxied;
    }

    public void doSomething() {
        System.out.println("SimpleProxy doSomething");
        proxied.doSomething();
    }

    public void somethingElse(String arg) {
        System.out.println("SimpleProxy somethingElse " + arg);
        proxied.somethingElse(arg);
    }
}

public class SimpleProxyDemo {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

    public static void main(String[] args) {
        consumer(new RealObject());
        System.out.println("-----------------------");
        consumer(new SimpleProxy(new RealObject()));
    }
}

SimpleProxy 被插入到了“客户端”与 RealObject 之间，因此它会执行操作，然后调用 RealObject 上相同的方法。

在任何时刻，只要想将额外的操作从“实际”对象中分离到不同的地方，特别是希望能够很容易的做出修改，从 没有使用额外操作 转为 使用额外操作，或者反过来，代理就显得很有用（设计模式的关键就是封装修改）。

例如：如果想要跟踪对 RealObject 中的方法的调用，或者想要度量这些调用的开销，这些额外的操作时，因为这些额外操作而添加的代码不能合并到 RealObject 的代码中，使用代理便可以很容易的添加或移除它们。

代理类里能非常好地控制，辅助被代理类，甚至是增加额外的功能。而且一般来说代理类B和被代理A都会实现同样的接口，这样对用户端（就是上面例子里的Consumer类）的代码没有任何影响，耦合很低。

---

2 动态代理

Java 的动态代理可以动态地创建代理并动态地处理对所代理方法的调用。

package com.test.class_obj;

import java.lang.reflect.*;

class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    public DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("**** proxy: " + proxy.getClass() +
                ", method: " + method + ", args: " + args);

        if (args != null)
            for (Object arg : args)
                System.out.println("  " + arg);
        return method.invoke(proxied, args);
    }
}

class SimpleDynamicProxy {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
        System.out.println("----------------------");
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);
        // 创建动态代理
        Interface proxy = (Interface) Proxy.newProxyInstance(
                // 类加载器（可以从已经被加载的对象中获取其类加载器）
                Interface.class.getClassLoader(),
                // 希望代理实现的接口列表
                new Class[]{Interface.class},
                // InvocationHandler 接口的一个实现
                new DynamicProxyHandler(real));
        consumer(proxy);
    }
}

doSomething
somethingElse bonobo
----------------------
**** proxy: class com.test.class_obj.$Proxy0, method: public abstract void com.test.class_obj.Interface.doSomething(), args: null
doSomething
**** proxy: class com.test.class_obj.$Proxy0, method: public abstract void com.test.class_obj.Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@4b67cf4d
  bonobo
somethingElse bonobo
----------------------

Process finished with exit code 0

动态代理可以将所有调用重定向到调用处理器（DynamicProxyHandler）。因此通常会向调用处理器的构造器传递一个“实际”对象的引用（real），从而使得调用处理器在执行其中介任务（iface.doSomething();）时，可以将请求转发（invoke()）。

invoke（）方法中传递进来了代理对象（Object proxy），以防需要区分请求的来源。

在 invoke（）内部，在代理上调用方法时需要格外当心，因为对接口的调用将被重定向为对代理的调用。

Method.invoke() 将请求转发给被代理的对象，并传入必要的参数。

---

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

• 第一个ClassLoader是为了生成B类的Class对象。作用是根据一组类的字节码byte[]直接生成这个类的Class对象。
• 第二个参数是由委托类实现的接口的Class对象数组。主要是包含了最重要的代理类需要实现的接口方法的信息。
• 最后一个最重要的就是一个实现了 InvocationHandler接口 的对象。InvocationHandler接口在java.lang.reflect包里。最主要的就是定义了invoke( )方法。它就是假设在已经动态生成了最后的proxy代理对象，以及所有接口定义的方法Method对象以及方法的参数的情况下，定义我们要怎么调用这些方法的地方。

• ---

  3 通过传递参数，过滤方法调用

  ---

  package com.test.class_obj;
  
  import java.lang.reflect.*;
  
  class MethodSelector implements InvocationHandler {
      private Object proxied;
  
      public MethodSelector(Object proxied) {
          this.proxied = proxied;
      }
  
      public Object invoke(Object proxy, Method method, Object[] args)
              throws Throwable {
          // 通过方法名来过滤方法的调用
          if (method.getName().equals("interesting")) {
              System.out.println("----通过传入的参数来过滤方法的调用----");
              System.out.println("Proxy detected the interesting method");
              System.out.println("----------------------------------");
          }
          return method.invoke(proxied, args);
      }
  }
  
  interface SomeMethods {
      void boring1();
  
      void boring2();
  
      void interesting(String arg);
  
      void boring3();
  }
  
  class Implementation implements SomeMethods {
      public void boring1() {
          System.out.println("boring1");
      }
  
      public void boring2() {
          System.out.println("boring2");
      }
  
      public void interesting(String arg) {
          System.out.println("interesting " + arg);
      }
  
      public void boring3() {
          System.out.println("boring3");
      }
  }
  
  class SelectingMethods {
      public static void main(String[] args) {
          SomeMethods proxy = (SomeMethods) Proxy.newProxyInstance(
                  SomeMethods.class.getClassLoader(),
                  new Class[]{SomeMethods.class},
                  new MethodSelector(new Implementation()));
          proxy.boring1();
          proxy.boring2();
          proxy.interesting("bonobo");
          proxy.boring3();
      }
  }
  

  

  

  这里我们只是查看了方法名，其实还可以查看方法签名的其他方面，甚至可以搜索特定的参数值。

  ---

  4 参考资料

  ---

  1、《Java编程思想》

  2、Java 动态代理作用是什么？
  https://www.zhihu.com/question/20794107

  3、Java JDK动态代理Proxy类的原理是什么？
  https://www.zhihu.com/question/49337471?rf=49332059