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

時間 2019-11-24

標籤動態代理三部曲如何掉了简体版

原文原文鏈接

前言

不知道，起這個名字算不算是標題黨呢？內容很長，若是小夥伴們能夠耐心看下去，相信會以爲不算標題黨~前端

本身一直很想好好了解一波動態代理，不管是從技術角度，仍是工做角度。並且就衝這個很洋氣的名字，學是必須得學的。就算餓死,死外邊,從這跳下去，我也要學明白動態代理。java

若是感受太囉嗦，能夠直接拉至結尾處，看總結~

我的理解

首先，先談一談咱們對動態代理的理解。網上不少資源喜歡把動態代理和靜態代理放在一塊兒去對比。這裏咱們就先不這麼來作了，我的感受靜態代理自己重的是一種思想，而本篇動態代理着重去思考它代碼套路背後的流程，因此就不放在一塊兒啦。若是有對靜態代理感興趣的小夥伴，能夠直接自行了解吧~算法

關於動態代理，我的喜歡把動態和代理分開理解：編程

動態：可隨時變化的。對應咱們編程，能夠理解爲在運行期去搞事情。數組

代理：接管咱們真正的事務，去代咱們執行。在咱們生活中有不少充當代理的角色，好比：租房中介。緩存

接下來讓咱們經過一個：租客經過中介租房子的demo，來展開動態代理的過程。（demo結束以後，咱們會從源碼的角度，去理解動態代理）網絡

由淺

Demo效果

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

編寫代碼以前，讓咱們先看一下效果。app

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

開始編碼

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

public interface IRentHouseProcessor {
    String rentHouse(String price);
}
複製代碼

接下來，實現這個接口，充當咱們倒黴的租客：

public class RentHouseProcessorImpl implements IRentHouseProcessor {
    @Override
    public String rentHouse(String price) {
        Log.d(MainActivity.TAG, "我還剩："+price+"元");
        String content = "我是租客，我找中介租了一個房子，我感受被坑了";
        return content;
    }
}
複製代碼

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

按照官方的docs文章，對InvocationHandler的解釋：每一個代理實例（Proxy）都有一個關聯的調用處理程序（InvocationHandler）。在代理實例上調用方法時，方法會被調度到invoke中。

這裏提到的Proxy代理實例是哪一個？不要着急，往下看。

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;
    }
}
複製代碼

開始執行

開始咱們的動態代理之路：咱們不使用代理，咱們直接經過租客的實例調用自身實現的接口。這裏沒啥好說的~只是爲了劇情須要，更好的理解流程。

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);
複製代碼

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

因此說proxy對象是一個特別的存在。沒錯它就是：動態代理，動態生成出來的代理實例。而這個實例擁有咱們接口對象的方法結構，所以它能夠是咱們的接口類型，進而也就能夠調用咱們的接口方法。

上述docs文檔提到，當咱們調用proxy對象中的接口方法時，實際上會調度到InvocationHandler方法中的invoke方法中。

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

因此在咱們的租房這個故事中，中介就是在這個invoke方法中，黑掉了咱們租戶的錢！由於invoke方法中它擁有絕對的操做權限。想幹什麼就幹什麼，甚至不執行咱們真正想要執行的方法咱們也沒辦法怎麼樣。

入深

走到這，不知道小夥伴對動態代理的流程是否是有了一個清晰的感覺。動態代理的過程仍是比較的套路性很強的：咱們實現一個InvocationHandler類，在invoke中接受處理proxy對象調度過來的方法（Method）信息，方法執行到此，咱們就能夠隨心所欲的作咱們想作的事情啦。而咱們的代理類實例是由系統幫咱們建立了，咱們只須要處理invoke中被調度的方法便可。

接下來讓咱們瞭解一下這個被動態生成的代理類實例。是如何被建立出來的~

開啓代碼之旅

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

下面的代碼，省略了一些判空/try-catch的過程，若是以爲省略不當，能夠自行搜索對應的源碼。

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

    //[ 標註1 ]
    //想辦法獲取一個代理類的Class對象
    Class<?> cl = getProxyClass0(loader, intfs);
	
	//省略：try-catch/權限檢驗
        
    //獲取參數類型是InvocationHandler.class的代理類的構造方法對象
    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);
}
複製代碼

跳過緩存，看背後

進來以後咱們會發現，代碼量及其的少。這裏很明顯是經過了一個Cache對象去想辦法獲取咱們所須要的Class對象。這部分設計到了動態代理的緩存過程，其中用的思想和數據結構比較的多，暫時就先不展開了。若是有感興趣的小夥伴，能夠自行搜索瞭解呦。

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

//代理類生成工廠
//一個工廠函數，在給定ClassLoader和接口數組的狀況下生成，定義和返回代理類。
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數組進行驗證, 主要作三件事情
            //1.intf是否能夠由指定的類加載進行加載
            //2.intf是不是一個接口
            //3.intf在數組中是否有重複
        }
        //生成代理類的包名
        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");
        }

        //若是接口都是public的話, 那生成的代理類都放到默認的包下：com.sun.proxy
        if (proxyPkg == null) {
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        //生成代理類的序號
        long num = nextUniqueNumber.getAndIncrement();

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

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

[ 標註1 ]

這部分，可能省略的比較多，由於內容主要是一些判斷。這部分的作的事情是：遍歷全部接口，看一下是否是public。若是不是，須要看一些些接口是否是在同一個包下，若是不是拋異常。這個很容易理解，非public接口還不在同一個包下，這沒得搞啊~

構造代理Class

接下來咱們須要注意的是generateProxyClass，這個方法即是：這個Class被構造出來的原因：

private byte[] generateClassFile() {
    //第一步, 將全部的方法組裝成ProxyMethod對象
    //首先爲代理類生成toString, hashCode, equals等代理方法
    addProxyMethod(hashCodeMethod, Object.class);
    addProxyMethod(equalsMethod, Object.class);
    addProxyMethod(toStringMethod, Object.class);
    //遍歷每個接口的每個方法, 而且爲其生成ProxyMethod對象
    for (int i = 0; i < interfaces.length; i++) {
        Method[] methods = interfaces[i].getMethods();
        for (int j = 0; j < methods.length; j++) {
            addProxyMethod(methods[j], interfaces[i]);
        }
    }
    //對於具備相同簽名的代理方法, 檢驗方法的返回值是否兼容
    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
        checkReturnTypes(sigmethods);
    }
    
    //第二步, 組裝要生成的class文件的全部的字段信息和方法信息
    try {
        //添加構造器方法
        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());
    } catch (IOException e) {
        throw new InternalError("unexpected I/O Exception");
    }
    
    //驗證方法和字段集合不能大於65535
    if (methods.size() > 65535) {
        throw new IllegalArgumentException("method limit exceeded");
    }
    if (fields.size() > 65535) {
        throw new IllegalArgumentException("field limit exceeded");
    }

    //第三步, 寫入最終的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 {
        //1.寫入魔數
        dout.writeInt(0xCAFEBABE);
        //2.寫入次版本號
        dout.writeShort(CLASSFILE_MINOR_VERSION);
        //3.寫入主版本號
        dout.writeShort(CLASSFILE_MAJOR_VERSION);
        //4.寫入常量池
        cp.write(dout);
        //5.寫入訪問修飾符
        dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
        //6.寫入類索引
        dout.writeShort(cp.getClass(dotToSlash(className)));
        //7.寫入父類索引, 生成的代理類都繼承自Proxy
        dout.writeShort(cp.getClass(superclassName));
        //8.寫入接口計數值
        dout.writeShort(interfaces.length);
        //9.寫入接口集合
        for (int i = 0; i < interfaces.length; i++) {
            dout.writeShort(cp.getClass(dotToSlash(interfaces[i].getName())));
        }
        //10.寫入字段計數值
        dout.writeShort(fields.size());
        //11.寫入字段集合 
        for (FieldInfo f : fields) {
            f.write(dout);
        }
        //12.寫入方法計數值
        dout.writeShort(methods.size());
        //13.寫入方法集合
        for (MethodInfo m : methods) {
            m.write(dout);
        }
        //14.寫入屬性計數值, 代理類class文件沒有屬性因此爲0
        dout.writeShort(0);
    } catch (IOException e) {
        throw new InternalError("unexpected I/O Exception");
    }
    //轉換成二進制數組輸出
    return bout.toByteArray();
}
複製代碼

以上註釋的內容，若是小夥伴們看過字節碼格式的話，應該不陌生。這一部份內容就是去建立咱們的代理類的Class字節碼文件。並經過ByteArrayOutputStream的做用，將咱們手動生成的字節碼內容轉成byte[]，並調用defineClass0方法，將其加載到內存當中。

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

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

複製代碼

總結

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

複製代碼