[動(dòng)態(tài)代理三部曲：上] - 動(dòng)態(tài)代理是如何"坑掉了"我4500塊錢

前言

不知道，起這個(gè)名字算不算是標(biāo)題黨呢？不過(guò)如果小伙伴們可以耐心看下去，因?yàn)闀?huì)覺(jué)得不算標(biāo)題黨~
這是一個(gè)系列文章，目的在于通過(guò)動(dòng)態(tài)代理這個(gè)很基礎(chǔ)的技術(shù)，進(jìn)而深入挖掘諸如：動(dòng)態(tài)生成class；Class文件的結(jié)構(gòu)；用到動(dòng)態(tài)代理的框架源碼分析。
對(duì)于三部曲來(lái)說(shuō)，我初步打算：

• 上：從源碼處看JDK實(shí)現(xiàn)的動(dòng)態(tài)代理的方式。
• 中：了解Class文件的結(jié)構(gòu)，看懂.class文件。
• 下：Retrofit中動(dòng)態(tài)代理的源碼實(shí)現(xiàn)。

對(duì)于這個(gè)系列的上篇來(lái)說(shuō)，開(kāi)篇我們先帶著幾個(gè)問(wèn)題：

• 1.、動(dòng)態(tài)代理，所謂的“動(dòng)態(tài)”，“代理”都在哪？
• 2、動(dòng)態(tài)代理如何生成 Class 文件？

自己一直很想好好了解一波動(dòng)態(tài)代理，無(wú)論是從技術(shù)角度，還是工作角度。
因?yàn)樽鳛锳ndroid開(kāi)發(fā)，我們?nèi)粘ｉ_(kāi)發(fā)離不開(kāi)擁有著動(dòng)態(tài)代理思想的Retrofit。而且就沖這個(gè)很洋氣的名字，學(xué)是必須得學(xué)的。就算餓死,死外邊,從這跳下去，我也要學(xué)明白動(dòng)態(tài)代理。

按照正常動(dòng)態(tài)代理的套路，我們需要寫一個(gè)接口，然后實(shí)現(xiàn)接口，然后巴拉巴拉寫一堆...寫這么多為了干啥？誰(shuí)呀？咋滴了？不知道啊？

不知道小伙伴們百度動(dòng)態(tài)代理的文章時(shí)，是什么感受，反正我是上述的感受。寫幾行demo，就說(shuō)深入理解動(dòng)態(tài)代理了？那我學(xué)會(huì)寫demo豈不是資深開(kāi)發(fā)了？所以我個(gè)人認(rèn)為，如果脫離業(yè)務(wù)去聊技術(shù)，恐怕沒(méi)辦法去深入理解這個(gè)項(xiàng)技術(shù)。所以關(guān)于動(dòng)態(tài)代理我們（MDove+一支彩筆）會(huì)想辦法寫成一篇系列文章。后續(xù)我（MDove）會(huì)結(jié)合Android的部分，寫一寫能真正用起來(lái)的效果~

個(gè)人理解

首先，先談一談我們對(duì)動(dòng)態(tài)代理的理解。網(wǎng)上很多資源喜歡把動(dòng)態(tài)代理和靜態(tài)代理放在一起去對(duì)比。這里我們就先不這么來(lái)做了，個(gè)人感覺(jué)靜態(tài)代理本身重的是一種思想，而本篇?jiǎng)討B(tài)代理著重去思考它代碼套路背后的流程，所以就不放在一起啦。如果有對(duì)靜態(tài)代理感興趣的小伙伴，可以直接自行了解吧~

關(guān)于動(dòng)態(tài)代理，個(gè)人喜歡把動(dòng)態(tài)和代理分開(kāi)理解：

動(dòng)態(tài)：可隨時(shí)變化的。對(duì)應(yīng)我們編程，可以理解為在運(yùn)行期去搞事情。

代理：接管我們真正的事務(wù)，去代我們執(zhí)行。在我們生活中有很多充當(dāng)代理的角色，比如：租房中介。

接下來(lái)讓我們通過(guò)一個(gè)：租客通過(guò)中介租房子的demo，來(lái)展開(kāi)動(dòng)態(tài)代理的過(guò)程。（demo結(jié)束之后，我們會(huì)從源碼的角度，去理解動(dòng)態(tài)代理）

由淺

Demo效果

demo的開(kāi)始，我們依舊是按照動(dòng)態(tài)代理的語(yǔ)法規(guī)則開(kāi)始入手。簡(jiǎn)單交代一下demo的劇情~我們有一個(gè)租客，身上揣著5000元錢，來(lái)到一個(gè)陌生的城市里。他想租一個(gè)房子，但是人生地不熟的，所以他選擇了一個(gè)房屋中介...結(jié)果中介收了他4500元錢，我們的租客被坑了...

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

記住這個(gè)效果，接下來(lái)讓我們一步步，看看租客是怎么被坑的~

開(kāi)始編碼

第一步，我們先把上當(dāng)受騙的租客寫出來(lái)，定義一個(gè)租客的接口

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

接下來(lái)，便是實(shí)現(xiàn)InvocationHandler，編寫我們動(dòng)態(tài)代理的重頭角色。

按照官方的docs文章，對(duì)InvocationHandler的解釋：每個(gè)代理實(shí)例（Proxy,這里提到的Proxy代理實(shí)例是哪個(gè)？不要著急，往下看。）都有一個(gè)關(guān)聯(lián)的調(diào)用處理程序（InvocationHandler）。在代理實(shí)例上調(diào)用方法時(shí)，方法會(huì)被調(diào)度到invoke中。

InvocationHandler是我們動(dòng)態(tài)代理核心方法的一個(gè)核心參數(shù)。它的實(shí)例會(huì)在構(gòu)建Proxy實(shí)例的時(shí)候以參數(shù)的形式傳遞進(jìn)入，并在Proxy實(shí)例被調(diào)用的時(shí)候，將真正執(zhí)行的方法，調(diào)度到自身的invoke方法里（形成代理）。后文從我們反編譯的Proxy.class可以證實(shí)這個(gè)問(wèn)題。

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元的好處費(fèi)，500塊錢給你組個(gè)地下室，不過(guò)分吧？！！");
        Object result = method.invoke(target, new Object[]{"500"});
        Log.d(MainActivity.TAG, "賺了一大筆錢，美滋滋~");
        return result;
    }
}

讓我們通過(guò)一張圖來(lái)，仔細(xì)的理解一下invoke方法的每個(gè)參數(shù)的含義。

1.1.3、代理開(kāi)始

編輯好了我們demo故事中的角色，那就讓我們開(kāi)始動(dòng)態(tài)代理之路吧：
首先，我們不使用代理，直接通過(guò)租客的實(shí)例調(diào)用自身實(shí)現(xiàn)的接口。這里沒(méi)啥好說(shuō)的~只是為了劇情需要，更好的理解流程。

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

使用動(dòng)態(tài)代理:

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

這一步執(zhí)行完畢，就會(huì)得到我們開(kāi)篇的那個(gè)效果。我們的租客本來(lái)身上揣了5000元錢，當(dāng)找了代理之后，真正租房的過(guò)程變成了中介（代理）去完成，所以租房的過(guò)程變得并不透明（invoke中，進(jìn)行了一些額外的操作），因此我們的租客被坑了。

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

所以說(shuō)proxy對(duì)象是一個(gè)特別的存在。沒(méi)錯(cuò)它就是：動(dòng)態(tài)代理動(dòng)態(tài)生成出來(lái)的代理實(shí)例。而這個(gè)實(shí)例被動(dòng)態(tài)的實(shí)現(xiàn)了我們的IRentHouseProcessor接口，因此它可以被聲明為我們的接口對(duì)象。

上述docs文檔提到，當(dāng)我們調(diào)用proxy對(duì)象中的接口方法時(shí)，實(shí)際上會(huì)調(diào)度到InvocationHandler方法中的invoke方法中（這個(gè)操作同樣是在動(dòng)態(tài)生成的Proxy對(duì)象中被調(diào)度過(guò)去的）。

當(dāng)方法到invoke中，那么問(wèn)題就出現(xiàn)了：invoke是我們自己重寫的，那也就是說(shuō)：我們擁有至高無(wú)上的權(quán)利！

所以在我們的租房這個(gè)故事中，中介就是在這個(gè)invoke方法中，黑掉了我們租戶的錢！因?yàn)閕nvoke方法中它擁有絕對(duì)的操作權(quán)限。想干什么就干什么，甚至不執(zhí)行我們真正想要執(zhí)行的方法，我們的租客也沒(méi)辦法怎么樣。

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

接下來(lái)讓我們走進(jìn)源碼，來(lái)解決第一個(gè)大問(wèn)題：1、動(dòng)態(tài)代理，所謂的“動(dòng)態(tài)”，“代理”都在哪？

走到這，不知道小伙伴對(duì)動(dòng)態(tài)代理的流程是不是有了一個(gè)清晰的認(rèn)識(shí)。動(dòng)態(tài)代理的過(guò)程還是套路性比較強(qiáng)的：實(shí)現(xiàn)一個(gè)InvocationHandler類，在invoke中接受處理proxy對(duì)象調(diào)度過(guò)來(lái)的方法（Method）信息，方法執(zhí)行到此，我們就可以為所欲為的做我們想做的事情啦。而我們的代理類實(shí)例是由系統(tǒng)幫我們創(chuàng)建了，我們只需要處理invoke中被調(diào)度的方法即可。

接下來(lái)讓我們了解一下這個(gè)被動(dòng)態(tài)生成的代理類實(shí)例?！按怼笔侨绾伪粍?chuàng)建出來(lái)的~

1.2.1、“代理”在哪里呀？

第一步，讓我們通過(guò)動(dòng)態(tài)代理最開(kāi)始的方法，Proxy.newProxyInstance()入手。

下面的代碼，省略了一些判空/try-catch的過(guò)程，如果覺(jué)得省略不當(dāng)，可以自行搜索對(duì)應(yīng)的源碼。

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

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

    //省略：try-catch/權(quán)限檢驗(yàn)

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

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

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

[ 標(biāo)注1 ]

這部分代碼，我們可以看到，調(diào)用了一個(gè)參數(shù)是ClassLoader、以及接口類型數(shù)組的方法。并且返回值是一個(gè)Class對(duì)象。實(shí)際上這里返回的c1實(shí)際上是我們的代理類的Class對(duì)象。何以見(jiàn)得？讓我們點(diǎn)進(jìn)去一看究竟：

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

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

1.2.2、跳過(guò)緩存，看背后

上述getProxyClass0方法中，進(jìn)來(lái)之后我們會(huì)發(fā)現(xiàn)，代碼量及其的少。這里很明顯是通過(guò)了一個(gè)Cache對(duì)象去想辦法獲取我們所需要的Class對(duì)象。這部分設(shè)計(jì)到了動(dòng)態(tài)代理的緩存過(guò)程，其中用的思想和數(shù)據(jù)結(jié)構(gòu)比較的多，暫時(shí)就先不展開(kāi)了（篇幅原因，以及也不是我們本次文章重點(diǎn)關(guān)注的對(duì)象）。如果有感興趣的小伙伴，可以自行搜索了解呦~

Cache的get過(guò)程，最終會(huì)轉(zhuǎn)向ProxyClassFactory這個(gè)類，由這個(gè)類先生成需要的代理類的Class對(duì)象。

private static final class ProxyClassFactory 
                implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
    //代理類名稱前綴
    private static final String proxyClassNamePrefix = "$Proxy";
    //用原子類來(lái)生成代理類的序號(hào), 以此來(lái)確定唯一的代理類
    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數(shù)組進(jìn)行驗(yàn)證：是否可以由指定的類加載進(jìn)行加載；是否是一個(gè)接口；是否有重復(fù)
        }
        //生成代理類的包名
        String proxyPkg = null;
        //生成代理類的訪問(wèn)權(quán)限, 默認(rèn)是public和final
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
        for (Class<?> intf : interfaces) {
            //[ 標(biāo)注1 ]
            // 省略：驗(yàn)證所有非public的代理接口是否在同一個(gè)包中。不在則拋異常
            throw new IllegalArgumentException("non-public interfaces from different packages");
        }

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

        //！！接下來(lái)便進(jìn)入重點(diǎn)了，用ProxyGenerator來(lái)生成字節(jié)碼, 以byte[]的形式存放
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,
                                  interfaces, accessFlags);
        //省略try-catch，根據(jù)二進(jìn)制文件生成相應(yīng)的Class實(shí)例
        return defineClass0(loader, proxyName, proxyClassFile, 
                              0, proxyClassFile.length);
    }
}

[ 標(biāo)注1 ]

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

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

1.2.3、構(gòu)造代理Class

接下來(lái)我們需要注意的是generateProxyClass，這個(gè)方法便是：這個(gè)Class被構(gòu)造出來(lái)的緣由：

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

    //省略：遍歷每一個(gè)接口的每一個(gè)方法, 并且為其生成ProxyMethod對(duì)象（遍歷，調(diào)用addProxyMethod()方法）。省略校驗(yàn)過(guò)程。

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

    //省略校驗(yàn)

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

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

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

    // 省略其他寫入過(guò)程

    //轉(zhuǎn)換成二進(jìn)制數(shù)組輸出
    return bout.toByteArray();
}

// 封裝構(gòu)造方法
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;
}

以上注釋的內(nèi)容，如果小伙伴們看過(guò)字節(jié)碼格式的話，應(yīng)該不陌生。這一部分內(nèi)容就是去創(chuàng)建我們的代理類的Class字節(jié)碼文件（字段/方法的描述符）。并通過(guò)ByteArrayOutputStream的作用，將我們手動(dòng)生成的字節(jié)碼內(nèi)容轉(zhuǎn)成byte[]，并調(diào)用defineClass0方法，將其加載到內(nèi)存當(dāng)中。

如果對(duì)class文件結(jié)構(gòu)感覺(jué)的小伙伴，可以查找一些相關(guān)的資料，或者《Java虛擬機(jī)規(guī)范》。當(dāng)然也可以繼續(xù)往下看：3、 Class 文件的格式。

末尾return方法，是一個(gè)native方法，我們不需要看實(shí)現(xiàn)，應(yīng)該也能猜到，這里的內(nèi)容是把我們的構(gòu)造的byte[]加載到內(nèi)存當(dāng)中，然后獲得對(duì)應(yīng)的Class對(duì)象，也就是我們的代理類的Class。

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

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

OK，到這一步，我們的代理類的Class對(duì)象就生成出來(lái)了。因此我們Proxy.newProxyInstance()所返回出來(lái)的類也就很明確了。就是一個(gè)：擁有我們所實(shí)現(xiàn)接口類的所有方法結(jié)構(gòu)的全新Class對(duì)象。也就是我們所說(shuō)的代理類。

因?yàn)閾碛形覀兘涌诘姆椒ńY(jié)構(gòu)，所以可能調(diào)用我們的方法。不過(guò)著這個(gè)過(guò)程中，我們所調(diào)用的方法，被調(diào)度到InvocationHandler中的invoke方法里了。這一步，可能有小伙伴會(huì)問(wèn)，為什么說(shuō)我們的方法被調(diào)度到invoke之中了？要回答這個(gè)問(wèn)題，我們需要看一下我們生成的Proxy代理類是什么樣子的。

我總結(jié)了網(wǎng)上各種各樣查看動(dòng)態(tài)代理生成的.class文件的方法，貼一種成本最小的方式：
使用Eclipse，運(yùn)行我們的動(dòng)態(tài)代理的方法。運(yùn)行之前，加上這么一行代碼：

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

當(dāng)然這樣運(yùn)行大概率，ide會(huì)報(bào)錯(cuò)

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

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

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的代碼，為什么會(huì)被調(diào)度到invoke方法中就很清晰了吧？

1.3、入深：“動(dòng)態(tài)”在哪？

我們走完上訴1.2的過(guò)程，其實(shí)“動(dòng)態(tài)”在哪這個(gè)問(wèn)題的答案已經(jīng)很明確了吧？ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);方法之中JDK本身就直接幫我們動(dòng)態(tài)的構(gòu)建了我們所需要的$Proxy0類。

1.4、動(dòng)態(tài)代理如何生成 Class 文件？

這個(gè)問(wèn)題的答案，我們也可以從上訴的過(guò)程之中找到答案。在對(duì)應(yīng)生成$Proxy的過(guò)程中，我們往DataOutputStream之中寫入我們class文件所規(guī)定的內(nèi)容；此外寫入了我們字段/方法的描述符。然后通過(guò)DataOutputStram將我們的內(nèi)容轉(zhuǎn)成二進(jìn)制數(shù)組。最后交由我們的native方法，去將此class文件加載到內(nèi)存之中。

結(jié)語(yǔ)

小伙伴們一步步追了下來(lái)，不知道有沒(méi)有對(duì)動(dòng)態(tài)代理的過(guò)程有了比較清晰的認(rèn)識(shí)。
接下來(lái)的內(nèi)容，會(huì)針對(duì)動(dòng)態(tài)代理進(jìn)行實(shí)際應(yīng)用場(chǎng)景的編寫；以及對(duì)Retrofit動(dòng)態(tài)代理相關(guān)內(nèi)容的分析。