Java JDK動態代理的基本原理詳細介紹

2019-11-26 13:19:12

字體：大中小

來源：轉載

供稿：網友

JDK動態代理詳解

本文主要介紹JDK動態代理的基本原理，讓大家更深刻的理解JDK Proxy,知其然知其所以然。明白JDK動態代理真正的原理及其生成的過程，我們以后寫JDK Proxy可以不用去查demo，就可以徒手寫個完美的Proxy。下面首先來個簡單的Demo,后續的分析過程都依賴這個Demo去介紹，例子采用JDK1.8運行。

JDK Proxy HelloWorld

package com.yao.proxy;/** * Created by robin */public interface Helloworld {  void sayHello();}

package com.yao.proxy;import com.yao.HelloWorld;/** * Created by robin */public class HelloworldImpl implements HelloWorld {  public void sayHello() {    System.out.print("hello world");  }}

package com.yao.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;/** * Created by robin */public class MyInvocationHandler implements InvocationHandler{  private Object target;  public MyInvocationHandler(Object target) {    this.target=target;  }  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    System.out.println("method :"+ method.getName()+" is invoked!");    return method.invoke(target,args);  }}

package com.yao.proxy;import com.yao.HelloWorld;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Proxy;/** * Created by robin */public class JDKProxyTest {  public static void main(String[]args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {    //這里有兩種寫法，我們采用略微復雜的一種寫法，這樣更有助于大家理解。    Class<?> proxyClass= Proxy.getProxyClass(JDKProxyTest.class.getClassLoader(),HelloWorld.class);    final Constructor<?> cons = proxyClass.getConstructor(InvocationHandler.class);    final InvocationHandler ih = new MyInvocationHandler(new HelloworldImpl());    HelloWorld helloWorld= (HelloWorld)cons.newInstance(ih);    helloWorld.sayHello();    //下面是更簡單的一種寫法，本質上和上面是一樣的    /*     HelloWorld helloWorld=(HelloWorld)Proxy.         newProxyInstance(JDKProxyTest.class.getClassLoader(),            new Class<?>[]{HelloWorld.class},            new MyInvocationHandler(new HelloworldImpl()));    helloWorld.sayHello();    */  }}

運行上面的代碼，這樣一個簡單的JDK Proxy就實現了。

代理生成過程

我們之所以天天叫JDK動態代理，是因為這個代理class是由JDK在運行時動態幫我們生成。在解釋代理生成過程前，我們先把-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 這個參數加入到JVM 啟動參數中，它的作用是幫我們把JDK動態生成的proxy class 的字節碼保存到硬盤中，幫助我們查看具體生成proxy的內容。我用的Intellij IDEA ,代理class生成后直接放在項目的根目錄下的，以具體的包名為目錄結構。

代理類生成的過程主要包括兩部分：

代理類字節碼生成
把字節碼通過傳入的類加載器加載到虛擬機中

Proxy類的getProxyClass方法入口：需要傳入類加載器和interface

然后調用getProxyClass0方法，里面的注解解釋很清楚，如果實現當前接口的代理類存在，直接從緩存中返回，如果不存在，則通過ProxyClassFactory來創建。這里可以明顯看到有對interface接口數量的限制，不能超過65535。其中proxyClassCache具體初始化信息如下：

proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

其中創建代理類的具體邏輯是通過ProxyClassFactory的apply方法來創建的。

ProxyClassFactory里的邏輯包括了包名的創建邏輯，調用ProxyGenerator. generateProxyClass生成代理類，把代理類字節碼加載到JVM。

1.包名生成邏輯默認是com.sun.proxy，如果被代理類是 non-public proxy interface ，則用和被代理類接口一樣的包名，類名默認是$Proxy 加上一個自增的整數值。

2.包名類名準備好后，就是通過ProxyGenerator. generateProxyClass根據具體傳入的接口創建代理字節碼，-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 這個參數就是在該方法起到作用，如果為true則保存字節碼到磁盤。代理類中，所有的代理方法邏輯都一樣都是調用invocationHander的invoke方法，這個我們可以看后面具體代理反編譯結果。

3.把字節碼通過傳入的類加載器加載到JVM中: defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);。

 private static final class ProxyClassFactory    implements BiFunction<ClassLoader, Class<?>[], Class<?>>  {    // prefix for all proxy class names    private static final String proxyClassNamePrefix = "$Proxy";    // next number to use for generation of unique proxy class names    private static final AtomicLong nextUniqueNumber = new AtomicLong();    @Override    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {      Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);      for (Class<?> intf : interfaces) {        /*         * Verify that the class loader resolves the name of this         * interface to the same Class object.         */        Class<?> interfaceClass = null;        try {          interfaceClass = Class.forName(intf.getName(), false, loader);        } catch (ClassNotFoundException e) {        }        if (interfaceClass != intf) {          throw new IllegalArgumentException(            intf + " is not visible from class loader");        }        /*         * Verify that the Class object actually represents an         * interface.         */        if (!interfaceClass.isInterface()) {          throw new IllegalArgumentException(            interfaceClass.getName() + " is not an interface");        }        /*         * Verify that this interface is not a duplicate.         */        if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {          throw new IllegalArgumentException(            "repeated interface: " + interfaceClass.getName());        }      }      String proxyPkg = null;   // package to define proxy class in      int accessFlags = Modifier.PUBLIC | Modifier.FINAL;      /*       * Record the package of a non-public proxy interface so that the       * proxy class will be defined in the same package. Verify that       * all non-public proxy interfaces are in the same package.       */      //生成包名和類名邏輯      for (Class<?> intf : interfaces) {        int flags = intf.getModifiers();        if (!Modifier.isPublic(flags)) {          accessFlags = Modifier.FINAL;          String name = intf.getName();          int n = name.lastIndexOf('.');          String pkg = ((n == -1) ? "" : name.substring(0, n + 1));          if (proxyPkg == null) {            proxyPkg = pkg;          } else if (!pkg.equals(proxyPkg)) {            throw new IllegalArgumentException(              "non-public interfaces from different packages");          }        }      }      if (proxyPkg == null) {        // if no non-public proxy interfaces, use com.sun.proxy package        proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";      }      /*       * Choose a name for the proxy class to generate.       */      long num = nextUniqueNumber.getAndIncrement();      String proxyName = proxyPkg + proxyClassNamePrefix + num;      /*       * Generate the specified proxy class. 生成代理類的字節碼       * -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 在該部起作用       */      byte[] proxyClassFile = ProxyGenerator.generateProxyClass(        proxyName, interfaces, accessFlags);      try {        //加載到JVM中        return defineClass0(loader, proxyName,                  proxyClassFile, 0, proxyClassFile.length);      } catch (ClassFormatError e) {        /*         * A ClassFormatError here means that (barring bugs in the         * proxy class generation code) there was some other         * invalid aspect of the arguments supplied to the proxy         * class creation (such as virtual machine limitations         * exceeded).         */        throw new IllegalArgumentException(e.toString());      }    }  }

我們可以根據代理類的字節碼進行反編譯，可以得到如下結果，其中HelloWorld只有sayHello方法，但是代理類中有四個方法包括了Object上的三個方法：equals,toString,hashCode。

代理的大概結構包括4部分：

靜態字段：被代理的接口所有方法都有一個對應的靜態方法變量；
靜態塊：主要是通過反射初始化靜態方法變量；
具體每個代理方法：邏輯都差不多就是 h.invoke，主要是調用我們定義好的invocatinoHandler邏輯,觸發目標對象target上對應的方法;
構造函數：從這里傳入我們InvocationHandler邏輯；

package com.sun.proxy;import com.yao.HelloWorld;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy0 extends Proxy implements HelloWorld {  private static Method m1;  private static Method m3;  private static Method m2;  private static Method m0;  public $Proxy0(InvocationHandler var1) throws {    super(var1);  }  public final boolean equals(Object var1) throws {    try {      return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();    } catch (RuntimeException | Error var3) {      throw var3;    } catch (Throwable var4) {      throw new UndeclaredThrowableException(var4);    }  }  public final void sayHello() throws {    try {      super.h.invoke(this, m3, (Object[])null);    } catch (RuntimeException | Error var2) {      throw var2;    } catch (Throwable var3) {      throw new UndeclaredThrowableException(var3);    }  }  public final String toString() throws {    try {      return (String)super.h.invoke(this, m2, (Object[])null);    } catch (RuntimeException | Error var2) {      throw var2;    } catch (Throwable var3) {      throw new UndeclaredThrowableException(var3);    }  }  public final int hashCode() throws {    try {      return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();    } catch (RuntimeException | Error var2) {      throw var2;    } catch (Throwable var3) {      throw new UndeclaredThrowableException(var3);    }  }  static {    try {      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});      m3 = Class.forName("com.yao.HelloWorld").getMethod("sayHello", new Class[0]);      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);    } catch (NoSuchMethodException var2) {      throw new NoSuchMethodError(var2.getMessage());    } catch (ClassNotFoundException var3) {      throw new NoClassDefFoundError(var3.getMessage());    }  }}

常見問題：

1.toString() hashCode() equal()方法調用邏輯：這個三個Object上的方法，如果被調用將和其他接口方法方法處理邏輯一樣，都會經過invocationHandler邏輯，從上面的字節碼結果就可以明顯看出。其他Object上的方法將不會走代理處理邏輯，直接走Proxy繼承的Object上方法邏輯。

2.interface 含有equals,toString hashCode方法時，和處理普通接口方法一樣，都會走invocation handler邏輯，以目標對象重寫的邏輯為準去觸發方法邏輯；

3.interface含有重復的方法簽名,以接口傳入順序為準，誰在前面就用誰的方法，代理類中只會保留一個，不會有重復的方法簽名；

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

上一篇：詳解Spring學習總結――Spring實現AOP的多種方式

下一篇：詳解Java利用實現對稱加密（DES、3DES、AES）