jdk 動態代理源碼分析

時間 2021-02-17

標籤 java spring 數組緩存 app ide 函數工具測試欄目 Java 简体版

原文原文鏈接

閒來無事，擼擼源碼java

食用方法

直接看代碼吧。。spring

package com.test.demo.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 每一個代理對象 內部都有一個實現了InvocationHandler接口的 類的實例
 *
 * InvocationHandler 顧名思義就是 代理對象的方法調用的處理類(調用它的invoke方法)
 *
 * @author lizhecao 2018/4/19
 * @version 1.0
 */
public class InvocationHandlerImpl implements InvocationHandler {
  // 目標對象
  private Object target;

  public InvocationHandlerImpl(Object target) {
    this.target = target;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 代理方法簡單地打下日誌，這其實就是spring aop的簡單實現
    System.out.println("start");

	// 調用目標對象的實際方法
    Object result = method.invoke(target, args);

    System.out.println("end");

    return  result;
  }

  /**
   * 經過Proxy.newProxyInstance 生成代理對象（重要的方法）
   */
  public Object getProxy() {
    return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
        target.getClass().getInterfaces(), this);
  }

  public static void main(String[] args) {
    // 實例化目標對象
    User user = new UserImpl();

    // 用目標對象實例化InvocationHandler
    InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(user);

    // 生成代理對象
    User proxyUser = (User) invocationHandler.getProxy();

    // 調用代理對象的方法，實際上就是調用了invocationHandler的invoke方法
    proxyUser.sayHello();
  }
}

package com.test.demo.proxy;

/**
 * 目標類的接口，jdk動態代理的類必定要實現某一個接口
 *
 * @author lizhecao 2018/4/19
 * @version 1.0
 */
public interface User {
  void sayHello();
}

package com.test.demo.proxy;

/**
 * 目標對象的具體類
 *
 * @author lizhecao 2018/4/19
 * @version 1.0
 */
public class UserImpl implements User {
  @Override
  public void sayHello() {
    System.out.println("hello");
  }
}

運行了InvocationHandlerImpl中的main方法咱們會獲得結果：數組

start
hello
end

理解原理

經過上面的例子能夠看到，生成代理對象的重點是緩存

Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
        target.getClass().getInterfaces(), this);

這個方法，咱們進入這個方法看看jdk動態代理的具體實現。
去繁就簡，刪掉一些不關注的東西，有興趣的本身一一過下app

/**
     * 返回指定接口的代理類實例，並分配方法的調用給指定的invocationHandler
     *
     * @param   loader 用來define代理類的 類加載器
     * @param   interfaces 代理類要實現的接口（這裏也說明了jdk動態代理對象必須實現接口）
     * @param   h 用來分配方法調用的 invocation handler
     * @return  一個實現了特定接口，用特定的class loader define的包含特定的invocation hanlder的代理類的實例
     */
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
	    // 不容許hanlder 爲空（否則搞啥）
        Objects.requireNonNull(h);
		// 防止接口被改
        final Class<?>[] intfs = interfaces.clone();

        /*
         * 查找或生產指定代理類（也就是說有緩存機制）（這裏是重點，生產了代理類的Class！！）
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * 用咱們的handler 做爲proxy class的構造方法的參數，建立proxy class實例
         */
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        // 強行修改構造方法訪問權限爲公有
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    }

繼續看這個getProxyClass0(loader, intfs) 是怎麼生產代理類的ide

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        // 接口的數量不能超過65535個（呵呵）
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        
        // 從WeakCache的緩存中獲取，若是沒有就建立
        return proxyClassCache.get(loader, interfaces);
    }

這裏是經過WeakCache緩存了代理類的實例，就是這貨函數

/**
     * a cache of proxy classes
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

這裏簡單講下WeakCache，否則沒玩過的朋友可能看不下去了。
WeakCache<K, P, V> 緩存的是<key, sub-key> -> value這樣的鍵值對，key和value是弱引用的，sub-key是強引用的（固然，這不重要）K， P， V分別表示key，參數，value的類型。有人會好奇，那sub-key呢？參數用來幹嗎？咱們重點看它的構造方法工具

/**
     * @param subKeyFactory 一個這樣 (key, parameter) -> sub-key 的函數
     * @param valueFactory  一個那樣 (key, parameter) -> value的函數
     */
    public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                     BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }

能夠看到，只要傳入兩個函數類，就能夠經過key 和 parameter 分別生成 sub-key和value了，這樣咱們就能夠理解生成代理對象的這一句測試

// 第一次獲取proxy class就會經過loader 和 interfaces 分別生成緩存的subkey 和 value， 而且返回value
return proxyClassCache.get(loader, interfaces);

那麼咱們也知道了這個value是經過valueFactory生成的，參數是loader 和 interface，那麼看下proxyClassCache的實例化方法： new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) 就知道了這個ProxyClassFactory類就是真正實現了(loader, interface) -> proxyClass 的函數式類了，趕忙看下ui

/**
     * 使用給定的ClassLoader 和 接口數組來 生成，define，返回代理類的函數工廠
     */
    private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 全部代理類名稱的前綴（有時候debug不是會常常看到這個名稱嗎哈哈）
        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 loader根據類的名稱 解析出來的 class跟咱們傳進來的是否同樣（至關於看下是否是同一個loader加載的吧）
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                // 若是不同，拋異常（loader說我不認識這個接口class）
                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;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * 這下面一大段就是肯定下代理類要放在哪一個包下
             * 若是存在非public的接口，那麼proxy class就要放在跟她同一個目錄下
             * 並且非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");
                    }
                }
            }

			// 若是接口都public，那麼就是放到com.sun.proxy 包下
            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * 用原子數字自增產生的一個代理類的惟一的代號
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * 上面啪啦啪啦一大堆，其實都是一些驗證啊，肯定包的位置啊，名稱啊的細碎的東西
             * 下面這一句纔是重點，經過ProxyGenerator產生了代理類的 class 文件的字節數組
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
	            // 最後經過native方法 來生成Class 對象
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

ProxyGenerator 是sun.misc包裏面的方法，沒有開源，因此咱們簡單擼一下便可

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
    ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
    // 生成class文件的字節數組
    final byte[] var4 = var3.generateClassFile();
    // 若是saveGeneratedFiles爲true，那麼將.class文件寫到硬盤中
    if (saveGeneratedFiles) {
      // 省略具體保存文件方法
    }

    return var4;
  }

看下這個保存文件的條件

private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();

也就是說只要咱們設置了這個"sun.misc.ProxyGenerator.saveGeneratedFiles" 系統值爲true就能夠保存文件了
話很少說來看看jdk動態代理給咱們自動生成的這個class文件長什麼樣吧，用如下代碼來測試

package com.test.demo.proxy;

import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 寫代理類文件到磁盤中
 *
 * @author lizhecao 2018/4/20
 * @version 1.0
 */
public class ProxyClassGen {
  public static void main(String[] args) throws IOException {

//    // 第一種方法，直接將生成的字節數組寫到文件中
//    byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy33", UserImpl.class.getInterfaces());
//
//    try(FileOutputStream outputStream = new FileOutputStream(
//        "/Users/lizhecao/java/demo/src/main/java/com/test/demo/proxy/$Proxy33.class")) {
//      outputStream.write(bytes);
//    }
    // 第二種方法，設置系統屬性值，有jdk自動寫
    System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    ProxyGenerator.generateProxyClass("$Proxy34", UserImpl.class.getInterfaces());
  }
}

運行以後能夠看到在項目的根目錄下產生了$Proxy34.class 這麼一個文件，用ide直接打開能夠看到以下內容

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import com.test.demo.proxy.User;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy34 extends Proxy implements User {
  private static Method m1;
  private static Method m3;
  private static Method m2;
  private static Method m0;

  public $Proxy34(InvocationHandler var1) throws  {
    super(var1);
  }

  // 除了接口方法以外，還實現了Object的equals, hashCode和toString方法
  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);
    }
  }
  // 實現了咱們的User接口的sayHello方法
  public final void sayHello() throws  {
    try {
      // 內部其實就是調用了invokeHandler實例的invoke方法
      // 在最下面能夠看到m3 就是經過反射獲取的User接口的sayHello Method
      // Class.forName("com.test.demo.proxy.User").getMethod("sayHello");
      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", Class.forName("java.lang.Object"));
      m3 = Class.forName("com.test.demo.proxy.User").getMethod("sayHello");
      m2 = Class.forName("java.lang.Object").getMethod("toString");
      m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
      throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
      throw new NoClassDefFoundError(var3.getMessage());
    }
  }
}

到了這裏，jdk動態代理就已是撥開雲霧見青天，一清二楚了

感謝如下的博主分享：
JDK動態代理實現原理