動態代理原理

簡介

java.lang.reflect.Proxy是整個jdk中實現動態代理的核心 類，本文主要介紹Proxy類的實現，關於Proxy類的使用請自行查閱其他資料。

Field

• constructorParams：構造函數的參數，用於代理類的核心的邏輯實現，關於InvocationHandler這個介面的介紹不是本文的重點，此處不做介紹。

private static final Class<?>[] constructorParams =
    { InvocationHandler.class };

• proxyClassCache： 代理類的緩存，此類是一個二級緩存的實現，利用WeakReference的特性，當記憶體占用過高的時候會JVM自動進行回收緩存中的數據。

private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

• h： InvocationHandler介面，用於此代理實例的調用處理程式。

Inner Class

• KeyFactory：顧名思義，緩存代理的key的工廠實現，此類僅一個方法，實現了BiFunction介面，具體代碼如下

private static final class KeyFactory
    implements BiFunction<ClassLoader, Class<?>[], Object>
{
    @Override
    public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
        switch (interfaces.length) {
            case 1: return new Key1(interfaces[0]); // the most frequent
            case 2: return new Key2(interfaces[0], interfaces[1]);
            case 0: return key0;
            default: return new KeyX(interfaces);
        }
    }
}

由以上代碼可見，該類的實現分為委托給了Key0,Key1,Key2,KeyX這四個類實現，其中key0是一個Object，其他的類Key1,Key2,KeyX則是分別用不同的實現對hashcode和equals方法進行了不同的實現，大同小異。這裡則分別簡單的做一下解釋。

private static final class Key1 extends WeakReference<Class<?>> {
    private final int hash;
​
    Key1(Class<?> intf) {
        super(intf);
        this.hash = intf.hashCode();
    }
​
    @Override
    public int hashCode() {
        return hash;
    }
​
    @Override
    public boolean equals(Object obj) {
        Class<?> intf;
        return this == obj ||
               obj != null &&
               obj.getClass() == Key1.class &&
               (intf = get()) != null &&
               intf == ((Key1) obj).get();
    }
}

private static final class Key2 extends WeakReference<Class<?>> {
    private final int hash;
    private final WeakReference<Class<?>> ref2;
​
    Key2(Class<?> intf1, Class<?> intf2) {
        super(intf1);
        hash = 31 * intf1.hashCode() + intf2.hashCode();
        ref2 = new WeakReference<Class<?>>(intf2);
    }
​
    @Override
    public int hashCode() {
        return hash;
    }
​
    @Override
    public boolean equals(Object obj) {
        Class<?> intf1, intf2;
        return this == obj ||
               obj != null &&
               obj.getClass() == Key2.class &&
               (intf1 = get()) != null &&
               intf1 == ((Key2) obj).get() &&
               (intf2 = ref2.get()) != null &&
               intf2 == ((Key2) obj).ref2.get();
    }
}

private static final class KeyX {
    private final int hash;
    private final WeakReference<Class<?>>[] refs;
​
    @SuppressWarnings("unchecked")
    KeyX(Class<?>[] interfaces) {
        hash = Arrays.hashCode(interfaces);
        refs = (WeakReference<Class<?>>[])new WeakReference<?>[interfaces.length];
        for (int i = 0; i < interfaces.length; i++) {
            refs[i] = new WeakReference<>(interfaces[i]);
        }
    }
​
    @Override
    public int hashCode() {
        return hash;
    }
​
    @Override
    public boolean equals(Object obj) {
        return this == obj ||
               obj != null &&
               obj.getClass() == KeyX.class &&
               equals(refs, ((KeyX) obj).refs);
    }
​
    private static boolean equals(WeakReference<Class<?>>[] refs1,
                                  WeakReference<Class<?>>[] refs2) {
        if (refs1.length != refs2.length) {
            return false;
        }
        for (int i = 0; i < refs1.length; i++) {
            Class<?> intf = refs1[i].get();
            if (intf == null || intf != refs2[i].get()) {
                return false;
            }
        }
        return true;
    }
}

• ProxyClassFactory： 顧名思義， 代理類的生產工廠類，用於生成代理類，此類也是實現了BiFunction,技能一個apply方法，最終根據ClassLoader,Interface,proxyName參數調用java.lang.reflect.Proxy#defineClass0這個本地方法生成代理類。

private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    // 代理類名稱的首碼，我們看到的代理類的名稱都有這個首碼就是這個原因
    private static final String proxyClassNamePrefix = "$Proxy";
​
    // 用於生成代理類名稱的唯一的序號
    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) {
            /*
             * 驗證類載入器是否將此介面的名稱解析為同一類對象
             */
            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");
            }
            /*
             * 驗證此類實際是否是一個介面
             */
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            /*
             * 校驗介面是不重覆的
             */
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }
        // 代理類包名
        String proxyPkg = null;  
        //代理類的訪問修飾符
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
​
        /*
         * 記錄非public的代理介面的包，以至於代理類的定義是相同的包，驗證所有的非public的代理介面在相同的包中。
         */
        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) {
            //如果沒有非public的代理介面，則用com.sun.proxy這個包
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
​
        /*
         * 為生成的代理類選擇一個名稱
         */
        long num = nextUniqueNumber.getAndIncrement();
        //代理類名稱
        String proxyName = proxyPkg + proxyClassNamePrefix + num;
​
        /*
         * 生成代理類
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            /*
             * 如果出現了ClassFormatError則意味著提供給代理類創建的參數還有其他一些無效方面或者生成代理的代碼有bug。（例如超出虛擬機限制）
             */
            throw new IllegalArgumentException(e.toString());
        }
    }
}
​
/**
*生成代理類的本地方法
*/
private static native Class<?> defineClass0(ClassLoader loader, String name,
                                                byte[] b, int off, int len);

核心方法

• newProxyInstance： 返回一個指定介面的代理類的實例，將該代理類調度到指定的處理方法。

  arguments:

  • ClassLoader：生成代理類的類載入器

  • Class<?>[]： 被代理的類實現的介面

  • InvocationHandler： 處理被代理類的方法，每一個被代理的類都將由指定的InvocationHandler處理。

  public static Object newProxyInstance(ClassLoader loader,
                                        Class<?>[] interfaces,
                                        InvocationHandler h)
      throws IllegalArgumentException
  {
      Objects.requireNonNull(h);
  ​
      final Class<?>[] intfs = interfaces.clone();
      final SecurityManager sm = System.getSecurityManager();
      if (sm != null) {
          checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
      }
  ​
      /*
       * 根據類載入器和代理類實現的介面查找或者生成代理類
       */
      Class<?> cl = getProxyClass0(loader, intfs);
  ​
      try {
          if (sm != null) {
              checkNewProxyPermission(Reflection.getCallerClass(), cl);
          }
          //獲取構造函數
          final Constructor<?> cons = cl.getConstructor(constructorParams);
          //處理程式
          final InvocationHandler ih = h;
          //訪問修飾符不是public則利用AccessController做許可權控制，設置可訪問
          if (!Modifier.isPublic(cl.getModifiers())) {
              AccessController.doPrivileged(new PrivilegedAction<Void>() {
                  public Void run() {
                      cons.setAccessible(true);
                      return null;
                  }
              });
          }
          //使用構造器反射創建代理類的實例
          return cons.newInstance(new Object[]{h});
      } catch (IllegalAccessException|InstantiationException e) {
          throw new InternalError(e.toString(), e);
      } catch (InvocationTargetException e) {
          Throwable t = e.getCause();
          if (t instanceof RuntimeException) {
              throw (RuntimeException) t;
          } else {
              throw new InternalError(t.toString(), t);
          }
      } catch (NoSuchMethodException e) {
          throw new InternalError(e.toString(), e);
      }
  }

疑問

至此，代理類的實例已經創建完成，但是我們仍可能有以下幾個疑問

• 1：代理類defineClass0方法是如何生成的？

• 2：如何使用代理類？

• 3：getProxyClass0是如何創建實例的？

我們帶著以上幾個疑問深入深入探討一下其中的原理。

1：代理類defineClass0方法是如何生成的？這個問題已經超綱了，僅能結合已有的只是淺顯的說一下（好像又沒說）。我們都知道Java是通過虛擬機編譯.java文件生成.class文件，而defineClass0方法就是通過模擬JVM編譯Java文件的過程生成class文件的過程，這個過程包括編譯原理，虛擬機的一些底層原理，已經不再本文的探討範文之內了，也希望有瞭解的朋友科普一下，在此表示感謝！

2：如何使用代理類，我們在使用newProxyInstance方法創建代理類的時候傳入了一個InvocationHandler參數，這個介面裡面有一個方法就是用來處理代理類的方法的，該類僅有一個invoke方法，可以通過反射去調用代理了的原有的邏輯，併在處理原有的邏輯的基礎上增加一些額外的邏輯，方法原型如下。

public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;

3：getProxyClass0是如何創建實例的,此方法沒有什麼特別的邏輯，僅做了一下簡單的校驗，然後就調用了proxyClassCache的get方法或者代理類對象，是不是感覺上面的KeyFactory和ProxyClassFactory沒有用到呢？這個時候我們就需要重新看一下Field裡面的proxyClassCache初始化的時候傳入了keyFactory和ProxyClassFactory具體的邏輯都在該類的get方法裡面了。具體的實現邏輯請參照WeakCache，為了文章的專一性，本文就不再對WeakCache做介紹了，後面會有一篇專門的文章介紹WeakCache。

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    //假如代理類已經在被給的ClassLoader和代理類實現的介面已存在，那就簡單的返回緩存的副本，否則的話，就通過ProxyClassFactory創建一個新的代理類
    return proxyClassCache.get(loader, interfaces);
}

結語

到此為止，我們已經把Proxy中如何創建代理類的過程和原理有了完整的瞭解，當然還一些不完整的地方和不恰當的地方希望熱心的朋友指出和補充。