[動態代理三部曲：上] - 動態代理是如何"坑掉了"我4500塊錢

前言

不知道，起這個名字算不算是標題黨呢？不過如果小伙伴們可以耐心看下去，因為會覺得不算標題黨~
這是一個系列文章，目的在于通過動態代理這個很基礎的技術，進而深入挖掘諸如：動態生成class；Class文件的結構；用到動態代理的框架源碼分析。
對于三部曲來說，我初步打算：

• 上：從源碼處看JDK實現的動態代理的方式。
• 中：了解Class文件的結構，看懂.class文件。
• 下：Retrofit中動態代理的源碼實現。

對于這個系列的上篇來說，開篇我們先帶著幾個問題：

• 1.、動態代理，所謂的“動態”，“代理”都在哪？
• 2、動態代理如何生成 Class 文件？

自己一直很想好好了解一波動態代理，無論是從技術角度，還是工作角度。
因為作為Android開發，我們日常開發離不開擁有著動態代理思想的Retrofit。而且就沖這個很洋氣的名字，學是必須得學的。就算餓死,死外邊,從這跳下去，我也要學明白動態代理。

按照正常動態代理的套路，我們需要寫一個接口，然后實現接口，然后巴拉巴拉寫一堆...寫這么多為了干啥？誰呀？咋滴了？不知道啊？

不知道小伙伴們百度動態代理的文章時，是什么感受，反正我是上述的感受。寫幾行demo，就說深入理解動態代理了？那我學會寫demo豈不是資深開發了？所以我個人認為，如果脫離業務去聊技術，恐怕沒辦法去深入理解這個項技術。所以關于動態代理我們（MDove+一支彩筆）會想辦法寫成一篇系列文章。后續我（MDove）會結合Android的部分，寫一寫能真正用起來的效果~

個人理解

首先，先談一談我們對動態代理的理解。網上很多資源喜歡把動態代理和靜態代理放在一起去對比。這里我們就先不這么來做了，個人感覺靜態代理本身重的是一種思想，而本篇動態代理著重去思考它代碼套路背后的流程，所以就不放在一起啦。如果有對靜態代理感興趣的小伙伴，可以直接自行了解吧~

關于動態代理，個人喜歡把動態和代理分開理解：

動態：可隨時變化的。對應我們編程，可以理解為在運行期去搞事情。

代理：接管我們真正的事務，去代我們執行。在我們生活中有很多充當代理的角色，比如：租房中介。

接下來讓我們通過一個：租客通過中介租房子的demo，來展開動態代理的過程。（demo結束之后，我們會從源碼的角度，去理解動態代理）

由淺

Demo效果

demo的開始，我們依舊是按照動態代理的語法規則開始入手。簡單交代一下demo的劇情~我們有一個租客，身上揣著5000元錢，來到一個陌生的城市里。他想租一個房子，但是人生地不熟的，所以他選擇了一個房屋中介...結果中介收了他4500元錢，我們的租客被坑了...

編寫代碼之前，讓我們先看一下效果。

記住這個效果，接下來讓我們一步步，看看租客是怎么被坑的~

開始編碼

第一步，我們先把上當受騙的租客寫出來，定義一個租客的接口

public interface IRentHouseProcessor {
    String rentHouse(String price);
}

接下來，便是實現InvocationHandler，編寫我們動態代理的重頭角色。

按照官方的docs文章，對InvocationHandler的解釋：每個代理實例（Proxy,這里提到的Proxy代理實例是哪個？不要著急，往下看。）都有一個關聯的調用處理程序（InvocationHandler）。在代理實例上調用方法時，方法會被調度到invoke中。

InvocationHandler是我們動態代理核心方法的一個核心參數。它的實例會在構建Proxy實例的時候以參數的形式傳遞進入，并在Proxy實例被調用的時候，將真正執行的方法，調度到自身的invoke方法里（形成代理）。后文從我們反編譯的Proxy.class可以證實這個問題。

public class RentHouseProcessorHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Log.d(MainActivity.TAG, "-----------------------------");
        Log.d(MainActivity.TAG, "我是中介，有人找我租房子了，看看他能出多少錢：" + args[0]);
        Log.d(MainActivity.TAG, "我既然是中介，那我收他4000元的好處費，500塊錢給你組個地下室，不過分吧？！！");
        Object result = method.invoke(target, new Object[]{"500"});
        Log.d(MainActivity.TAG, "賺了一大筆錢，美滋滋~");
        return result;
    }
}

讓我們通過一張圖來，仔細的理解一下invoke方法的每個參數的含義。

1.1.3、代理開始

編輯好了我們demo故事中的角色，那就讓我們開始動態代理之路吧：
首先，我們不使用代理，直接通過租客的實例調用自身實現的接口。這里沒啥好說的~只是為了劇情需要，更好的理解流程。

RentHouseProcessorImpl dpImpl = new RentHouseProcessorImpl();
dpImpl.rentHouse("5000");
Log.d(TAG,"我準備找中介去組個房子。");

使用動態代理:

RentHouseProcessorHandler handler = new RentHouseProcessorHandler(dpImpl);
IRentHouseProcessor proxy = (IRentHouseProcessor) Proxy.newProxyInstance(
        dpImpl.getClass().getClassLoader(),
        dpImpl.getClass().getInterfaces(),
        handler);

String content = proxy.rentHouse("5000");
Log.d(TAG, content);

這一步執行完畢，就會得到我們開篇的那個效果。我們的租客本來身上揣了5000元錢，當找了代理之后，真正租房的過程變成了中介（代理）去完成，所以租房的過程變得并不透明（invoke中，進行了一些額外的操作），因此我們的租客被坑了。

這一步我們來解釋一下上述提到的那個疑問：代理實例在哪？這個代理實例其實就是Proxy.newProxyInstance()的返回值，也就是IRentHouseProcessor proxy這個對象。這里有一個很嚴肅的問題？IRentHouseProcessor是一個接口，接口是不可能被new出來的。

所以說proxy對象是一個特別的存在。沒錯它就是：動態代理動態生成出來的代理實例。而這個實例被動態的實現了我們的IRentHouseProcessor接口，因此它可以被聲明為我們的接口對象。

上述docs文檔提到，當我們調用proxy對象中的接口方法時，實際上會調度到InvocationHandler方法中的invoke方法中（這個操作同樣是在動態生成的Proxy對象中被調度過去的）。

當方法到invoke中，那么問題就出現了：invoke是我們自己重寫的，那也就是說：我們擁有至高無上的權利！

所以在我們的租房這個故事中，中介就是在這個invoke方法中，黑掉了我們租戶的錢！因為invoke方法中它擁有絕對的操作權限。想干什么就干什么，甚至不執行我們真正想要執行的方法，我們的租客也沒辦法怎么樣。

1.2、入深：“代理”在哪？

接下來讓我們走進源碼，來解決第一個大問題：1、動態代理，所謂的“動態”，“代理”都在哪？

走到這，不知道小伙伴對動態代理的流程是不是有了一個清晰的認識。動態代理的過程還是套路性比較強的：實現一個InvocationHandler類，在invoke中接受處理proxy對象調度過來的方法（Method）信息，方法執行到此，我們就可以為所欲為的做我們想做的事情啦。而我們的代理類實例是由系統幫我們創建了，我們只需要處理invoke中被調度的方法即可。

接下來讓我們了解一下這個被動態生成的代理類實例。“代理”是如何被創建出來的~

1.2.1、“代理”在哪里呀？

第一步，讓我們通過動態代理最開始的方法，Proxy.newProxyInstance()入手。

下面的代碼，省略了一些判空/try-catch的過程，如果覺得省略不當，可以自行搜索對應的源碼。

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h) throws IllegalArgumentException {
    //省略：一些判空，權限校驗的操作

    //[ 標注1 ]
    //想辦法獲取一個代理類的Class對象（$Proxy0）
    Class<?> cl = getProxyClass0(loader, intfs);

    //省略：try-catch/權限檢驗

    //獲取參數類型是InvocationHandler.class的代理類的構造方法對象($Proxy的構造方法的參數就是InvocationHandler類型)
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    final InvocationHandler ih = h;

    //省略：cons.setAccessible(true)過程

    //傳入InvocationHandler的實例去，構造一個代理類的實例
    return cons.newInstance(new Object[]{h});
    }
}

[ 標注1 ]

這部分代碼，我們可以看到，調用了一個參數是ClassLoader、以及接口類型數組的方法。并且返回值是一個Class對象。實際上這里返回的c1實際上是我們的代理類的Class對象。何以見得？讓我們點進去一看究竟：

//從緩存中取代理類的Class對象，如果沒有通過ProxyClassFactory->ProxyGenerator去生成
private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // 如果存在實現給定接口的給定加載器定義的代理類，則只返回緩存副本; 否則，它將通過ProxyClassFactory創建代理類
    return proxyClassCache.get(loader, interfaces);
}

1.2.2、跳過緩存，看背后

上述getProxyClass0方法中，進來之后我們會發現，代碼量及其的少。這里很明顯是通過了一個Cache對象去想辦法獲取我們所需要的Class對象。這部分設計到了動態代理的緩存過程，其中用的思想和數據結構比較的多，暫時就先不展開了（篇幅原因，以及也不是我們本次文章重點關注的對象）。如果有感興趣的小伙伴，可以自行搜索了解呦~

Cache的get過程，最終會轉向ProxyClassFactory這個類，由這個類先生成需要的代理類的Class對象。

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) {
            //這里遍歷interfaces數組進行驗證：是否可以由指定的類加載進行加載；是否是一個接口；是否有重復
        }
        //生成代理類的包名
        String proxyPkg = null;
        //生成代理類的訪問權限, 默認是public和final
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
        for (Class<?> intf : interfaces) {
            //[ 標注1 ]
            // 省略：驗證所有非public的代理接口是否在同一個包中。不在則拋異常
            throw new IllegalArgumentException("non-public interfaces from different packages");
        }

        //省略部分代碼：生成代理類的全限定名, 包名+前綴+序號, 例如：com.sun.proxy.$Proxy0
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        //！！接下來便進入重點了，用ProxyGenerator來生成字節碼, 以byte[]的形式存放
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,
                                  interfaces, accessFlags);
        //省略try-catch，根據二進制文件生成相應的Class實例
        return defineClass0(loader, proxyName, proxyClassFile, 
                              0, proxyClassFile.length);
    }
}

[ 標注1 ]

這部分，可能省略的比較多，因為內容主要是一些判斷。這部分的做的事情是：遍歷所有接口，看一下是不是public。如果不是，需要看一些些接口是不是在同一個包下，如果不是拋異常。這個很容易理解，非public接口還不在同一個包下，這沒得搞啊~

接下來，讓我們重點看一下ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);也就是代理類生成的方法。ProxyGenerator類可以通過查看OpenJDK獲取

1.2.3、構造代理Class

接下來我們需要注意的是generateProxyClass，這個方法便是：這個Class被構造出來的緣由：

private byte[] generateClassFile() {
    //首先為代理類生成toString, hashCode, equals等代理方法（組裝成ProxyMethod對象）
    addProxyMethod(hashCodeMethod, Object.class);
    addProxyMethod(equalsMethod, Object.class);
    addProxyMethod(toStringMethod, Object.class);

    //省略：遍歷每一個接口的每一個方法, 并且為其生成ProxyMethod對象（遍歷，調用addProxyMethod()方法）。省略校驗過程。

    //省略try-catch：組裝要生成的class文件的所有的字段信息和方法信息
    //添加構造器方法（methods：MethodInfo類型的ArrayList）
    methods.add(generateConstructor());
    //遍歷緩存中的代理方法
    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
        for (ProxyMethod pm : sigmethods) {
            //添加代理類的靜態字段, 例如:private static Method m1;
            fields.add(new FieldInfo(pm.methodFieldName,
                        "Ljava/lang/reflect/Method;", ACC_PRIVATE | ACC_STATIC));
            //添加代理類的代理方法
            methods.add(pm.generateMethod());
        }
    }
    //添加代理類的靜態字段初始化方法
    methods.add(generateStaticInitializer());

    //省略校驗

    //通過class文件規則，最終生成我們的$Proxy.class文件
    //驗證常量池中存在代理類的全限定名
    cp.getClass(dotToSlash(className));
    //驗證常量池中存在代理類父類的全限定名, 父類名為:"java/lang/reflect/Proxy"
    cp.getClass(superclassName);
    //驗證常量池存在代理類接口的全限定名
    for (int i = 0; i < interfaces.length; i++) {
        cp.getClass(dotToSlash(interfaces[i].getName()));
    }
    //接下來要開始寫入文件了,設置常量池只讀
    cp.setReadOnly();

    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    DataOutputStream dout = new DataOutputStream(bout);

    //省略try-catch：1、寫入魔數
    dout.writeInt(0xCAFEBABE);
    //2、寫入次版本號
    dout.writeShort(CLASSFILE_MINOR_VERSION);
    //3、寫入主版本號
    dout.writeShort(CLASSFILE_MAJOR_VERSION);

    // 省略其他寫入過程

    //轉換成二進制數組輸出
    return bout.toByteArray();
}

// 封裝構造方法
private MethodInfo generateConstructor() throws IOException {
    MethodInfo minfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V",ACC_PUBLIC);    
    DataOutputStream out = new DataOutputStream(minfo.code);
    code_aload(0, out);
    code_aload(1, out);

    out.writeByte(opc_invokespecial);
    out.writeShort(cp.getMethodRef(superclassName,"<init>", "(Ljava/lang/reflect/InvocationHandler;)V"));

    out.writeByte(opc_return);

    minfo.maxStack = 10;
    minfo.maxLocals = 2;
    minfo.declaredExceptions = new short[0];

    return minfo;
}

以上注釋的內容，如果小伙伴們看過字節碼格式的話，應該不陌生。這一部分內容就是去創建我們的代理類的Class字節碼文件（字段/方法的描述符）。并通過ByteArrayOutputStream的作用，將我們手動生成的字節碼內容轉成byte[]，并調用defineClass0方法，將其加載到內存當中。

如果對class文件結構感覺的小伙伴，可以查找一些相關的資料，或者《Java虛擬機規范》。當然也可以繼續往下看：3、 Class 文件的格式。

末尾return方法，是一個native方法，我們不需要看實現，應該也能猜到，這里的內容是把我們的構造的byte[]加載到內存當中，然后獲得對應的Class對象，也就是我們的代理類的Class。

private static native Class<?> defineClass0(ClassLoader var0, String var1, byte[] var2, int var3, int var4);

1.2.4、$Proxy0.class是什么樣子？

OK，到這一步，我們的代理類的Class對象就生成出來了。因此我們Proxy.newProxyInstance()所返回出來的類也就很明確了。就是一個：擁有我們所實現接口類的所有方法結構的全新Class對象。也就是我們所說的代理類。

因為擁有我們接口的方法結構，所以可能調用我們的方法。不過著這個過程中，我們所調用的方法，被調度到InvocationHandler中的invoke方法里了。這一步，可能有小伙伴會問，為什么說我們的方法被調度到invoke之中了？要回答這個問題，我們需要看一下我們生成的Proxy代理類是什么樣子的。

我總結了網上各種各樣查看動態代理生成的.class文件的方法，貼一種成本最小的方式：
使用Eclipse，運行我們的動態代理的方法。運行之前，加上這么一行代碼：

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); 

當然這樣運行大概率，ide會報錯

Exception in thread "main" java.lang.InternalError: 
I/O exception saving generated file: java.io.FileNotFoundException: com\sun\proxy\$Proxy0.class (系統找不到指定的路徑。)

那怎么辦呢？很簡單，在src同級的建三級的文件夾分別是：com/sun/proxy。然后運行，就可以看到我們的$Proxy0.class啦。然后我們把它拖到AndroidStudio當中，查看反編譯之后的結果：

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

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

    public final String rentHouse(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 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);
        }
    }

    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);
        }
    }

    static {
        try {
            m3 = Class.forName("proxy.IRentHouseProcessor").getMethod("rentHouse", new Class[]{Class.forName("java.lang.String")});
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

看了Proxy的代碼，為什么會被調度到invoke方法中就很清晰了吧？

1.3、入深：“動態”在哪？

我們走完上訴1.2的過程，其實“動態”在哪這個問題的答案已經很明確了吧？ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);方法之中JDK本身就直接幫我們動態的構建了我們所需要的$Proxy0類。

1.4、動態代理如何生成 Class 文件？

這個問題的答案，我們也可以從上訴的過程之中找到答案。在對應生成$Proxy的過程中，我們往DataOutputStream之中寫入我們class文件所規定的內容；此外寫入了我們字段/方法的描述符。然后通過DataOutputStram將我們的內容轉成二進制數組。最后交由我們的native方法，去將此class文件加載到內存之中。

結語

小伙伴們一步步追了下來，不知道有沒有對動態代理的過程有了比較清晰的認識。
接下來的內容，會針對動態代理進行實際應用場景的編寫；以及對Retrofit動態代理相關內容的分析。