【AOP系列】JDK動態代理源碼分析(三)

【AOP系列】JDK動態代理源碼分析

這裏通過JDK的源碼來查看一下JDK動態代理的實現。

輸出Class文件

我們嘗試把JDK動態生成的$Proxy0的class給生成出來。

public class JDKAop {

    //當前項目目錄
    private static String userDir = System.getProperty("user.dir");
    private static String pack = JDKAop.class.getPackage().getName();//當前包
    private static String packPath = pack.replace(".","/");
    private static String envDir = "/src/main/java/"; //環境目錄
    private static String currPackPath = userDir  + envDir + packPath;//當前包的絕對路徑

    public static void main(String[] args)throws Throwable {
        //這裏用的Log類和上一個例子中用到的是同一個
        List<String> aoplist = (List)Proxy.newProxyInstance(null, new Class[]{List.class}, new Log(new ArrayList<>()));
        //ProxyGenerator.generateProxyClass是JDK提供的一個方法，
        //可以生成某個接口的代理類  並返回字節碼數組
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{List.class});
        //我們把這個字節碼數組寫到當前目錄下的文件中，方便查看
        FileOutputStream fos = new FileOutputStream(currPackPath + "/$Proxy0.class");
        fos.write(classFile);
        fos.flush();

    }
    
}

$Proxy0

生成的委託類的.class文件反編譯後的代碼

//代理類都繼承 Proxy 類 並且實現代理接口List
public final class $Proxy0 extends Proxy implements List {
	//內部其實村的是一堆的Method對象。
    private static Method m1;
    private static Method m3;
	//......此處省略幾十行類似的代碼

	//構造函數的入參爲 例子中InvokerHandler的實例
	//也就是 Proxy.newProxyInstance(classLoader,{List.class},handler); 的入參 handler
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);//調用父類的構造函數，父類中會執行 this.h = h;及下文中用到的this.h.invoke
    }
    /*
    Proxy類中的代碼
   	protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }
    */

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
    
    public final void add(int var1, Object var2) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }
	//......此處省略幾個類似的方法

	//靜態塊執行會先執行，所以對象初始化的時候會把上面的成員變量都初始化賦值。
    static {
        try {
        //由於List沒有重寫Object的equals，所以還是拿java.lang.Object的方法
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            //拿list的方法給m3賦值
            m3 = Class.forName("java.util.List").getMethod("add", Class.forName("java.lang.Object"));
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

其中

public final class $Proxy0 extends Proxy implements List

通過這行代碼我們可以得到一下信息

• 1.既然他實現了List接口，那麼我們當然可以用List來存放這個$Proxy的對象實例。
• 2.而且前面還生成了final,所以$Proxy也自然不會有子類了。
• 3.因爲Java是單繼承的，雖然不知道爲啥要繼承Proxy，但是這裏既然繼承了Proxy，那麼$Proxy0就不能同時有其他的父類了。這裏也可能是爲啥JDK只能生成接口類型的派生類的原因，僅僅是可以能【先暫時放一下，後面自己實現一下JDK的動態代理試試，再詳細分析】

$Proxy0的詳細生成過程

Proxy.newProxyInstance方法

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);//非空檢測

        final Class<?>[] intfs = interfaces.clone();//將接口Class數組克隆一份
        final SecurityManager sm = System.getSecurityManager();//調用系統的安全管理器
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);//檢測ClassLoader
        }

        /*
         * Look up or generate the designated proxy class.
         * 查找或生成指定的代理類
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         * 使用指定的調用處理程序調用其構造函數。
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);//檢測新代理類的權限
            }
            //通過反射獲取代理類的構造方法
            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});//返回一個代理類的對象
        } 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);
        }
    }

主要的幾行代碼

//生成代理類
Class<?> cl = getProxyClass0(loader, intfs);
//通過反射獲取代理類的構造器
final Constructor<?> cons = cl.getConstructor(constructorParams);
//使用反射拿到構造器對象後創建一個代理對象，並返回
return cons.newInstance(new Object[]{h});

進一步看一下getProxyClass0這個方法

return proxyClassCache.get(loader, interfaces);

點擊進入，其中調用了apply(key,parameter);

這裏都不是關鍵的點，

進入ProxyClassFactory類中

private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // class名前綴
        private static final String proxyClassNamePrefix = "$Proxy";
        //$Proxy0,1,2,3
        private static final AtomicLong nextUniqueNumber = new AtomicLong();
        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
			//定義給Map存放接口
            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
          		//驗證類加載器
                Class<?> interfaceClass = null;
                interfaceClass = Class.forName(intf.getName(), false, loader);
                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 final
			//拼接代理類的一些權限信息
            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) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            //名字遞增
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
            
            //生成代理類的字節數組
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            //用JDK內部的ClassLoader將byte數組加載到內存，如何成功，則返滬Class對象    
			return defineClass0(loader, proxyName,proxyClassFile, 0,proxyClassFile.length);

        }
    }

其中主要做了一下幾件事情

• 1.一些規則檢測，如類加載器是否有效，Class是否爲接口，接口數組中的接口是否有重複等
• 2.拼接代理需要的一些信息，如類名$Proxy+遞增數字
• 3.代理類的byte[]生成
• 4.加載byte[]到內存，並返回Class

接下來我們看一下byte[]是怎麼生成的

ProxyGenerator.generateProxyClass();

（如果點擊無法進入，需要添加JDK中的tool.jar，如圖所圖所示）

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-3SO5gYcm-1586825857143)(C:\Users\bigfire\AppData\Roaming\Typora\typora-user-images\1584892177343.png)]

進入後主要的兩行代碼

ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();

進入generateClassFile()方法

private byte[] generateClassFile() {
        this.addProxyMethod(hashCodeMethod, Object.class);//添加hashCode代理方法
        this.addProxyMethod(equalsMethod, Object.class);//添加equals代理方法
        this.addProxyMethod(toStringMethod, Object.class);//添加toString代理方法
        Class[] var1 = this.interfaces;
        int var2 = var1.length;

		//循環添加代理方法
        int var3;
        Class var4;
        for(var3 = 0; var3 < var2; ++var3) {
            var4 = var1[var3];
            Method[] var5 = var4.getMethods();
            int var6 = var5.length;

            for(int var7 = 0; var7 < var6; ++var7) {
                Method var8 = var5[var7];
                this.addProxyMethod(var8, var4);//循環添加代理方法
            }
        }

        Iterator var11 = this.proxyMethods.values().iterator();

        List var12;
        while(var11.hasNext()) {
            var12 = (List)var11.next();
            checkReturnTypes(var12);//循環檢測返回值類型
        }

        Iterator var15;
        try {
            this.methods.add(this.generateConstructor());
            var11 = this.proxyMethods.values().iterator();
			//循環生成方法
            while(var11.hasNext()) {
                var12 = (List)var11.next();
                var15 = var12.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                    this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                    this.methods.add(var16.generateMethod());
                }
            }
			//添加靜態初始化方法
            this.methods.add(this.generateStaticInitializer());
        } catch (IOException var10) {
            throw new InternalError("unexpected I/O Exception", var10);
        }

        if (this.methods.size() > 65535) {
            throw new IllegalArgumentException("method limit exceeded");
        } else if (this.fields.size() > 65535) {
            throw new IllegalArgumentException("field limit exceeded");
        } else {
            this.cp.getClass(dotToSlash(this.className));
            this.cp.getClass("java/lang/reflect/Proxy");
            var1 = this.interfaces;
            var2 = var1.length;

            for(var3 = 0; var3 < var2; ++var3) {
                var4 = var1[var3];
                this.cp.getClass(dotToSlash(var4.getName()));
            }

            this.cp.setReadOnly();
            ByteArrayOutputStream var13 = new ByteArrayOutputStream();
            DataOutputStream var14 = new DataOutputStream(var13);
			//按照JVM規範寫class的格式寫byte[]
            try {
                var14.writeInt(-889275714);//magic 對應16進制CAFE BABE‬
                var14.writeShort(0);	//minor_version次版本號
                var14.writeShort(49);	//major_version主版本號
                this.cp.write(var14);	//constant_pool_count常量池長度
                var14.writeShort(this.accessFlags);//access_flags訪問標識符
                var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
                var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
                var14.writeShort(this.interfaces.length);
                Class[] var17 = this.interfaces;//獲取接口類
                int var18 = var17.length;

				//循環往DataOutputStream中寫如數據
                for(int var19 = 0; var19 < var18; ++var19) {
                    Class var22 = var17[var19];
                    var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
                }

                var14.writeShort(this.fields.size());
                var15 = this.fields.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                    var20.write(var14);
                }

                var14.writeShort(this.methods.size());
                var15 = this.methods.iterator();

                while(var15.hasNext()) {
                    ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                    var21.write(var14);
                }
				
                var14.writeShort(0);
                return var13.toByteArray();//最後把拼接好的數據整體以byte[]的形式返回
            } catch (IOException var9) {
                throw new InternalError("unexpected I/O Exception", var9);
            }
        }
    }

其中主要做了一下幾件事情

• 1.Object對象中的方法特殊處理
• 2.循環添加方法，及Method對象
• 3.循環檢測返回值類型
• 4.靜態代碼塊，初始化代碼的生成，
• 5.class標準文件頭的拼接
• 6.最終把所有的數據轉換成byte數組返回

有些方法細節就不再具體分析了。到此，基本上已經把JDK的源代碼過了一遍了.

總結

通過閱讀JDK的源代碼，我們可以知道。JDK實現動態代理類的主要方法如下

• 1.組合要代理的方法，和自己要插入的代碼，按照class文件的格式生成byte[]，
• 2.然後通過ClassLoader，將byte[]加載到內存，並獲得Class對象。(其中的class文件的加載涉及到JVM相關知識，內容包括：裝載，鏈接，檢查，準備，解析和初始化等，感興趣讀者可自行查找相關內容。)
• 3.最後通過反射獲取到一個代理$Proxy類的構造函數，並創建一個對象返回。

{
	"author": "大火yzs",
	"title": "【AOP系列】JDK動態代理源碼分析",
	"tag": "AOP,List,日誌",
	"createTime": "2020-03-23  17:40"
}