3、動態代理

定義

動態代理類的源碼是在程序運行期間由JVM根據反射等機制動態的生成，所以不存在代理類的字節碼文件。
代理類和委託類的關係是在程序運行時確定。

實現方式

在java的動態代理機制中，有兩個重要的類或接口
一個是 InvocationHandler(Interface)、另一個則是 Proxy(Class)，這一個類和接口是實現我們動態代理所必須用到的。

每一個動態代理類都必須要實現InvocationHandler這個接口，並且每個代理類的實例都關聯到了一個handler，當我們通過代理對象調用一個方法的時候，這個方法的調用就會被轉發爲由InvocationHandler這個接口的 invoke 方法來進行調用。

java.lang.reflect.InvocationHandler#invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
//proxy:代理類對象
//method:調用的方法
//args:傳入方法的參數

可以看出，現在還不知道代理類對象是什麼，這用到了另一個類:java.lang.reflect.Proxy
Proxy類的作用就是用來動態創建一個代理對象的類，它提供了許多的方法，但是我們用的最多的就是 newProxyInstance 這個方法

//返回 動態的代理對象
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException

loader: 加載代理對象的ClassLoader
interfaces:一個Interface對象的數組，代理類實現的這些接口列表
h:關聯到的InvocationHandler對象

demo

package proxy;

import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Main {
    //定義兩個subject以及realSubject
    interface UserManager {
        void query();
    }
    static class UserManagerImpl implements UserManager {
        @Override
        public void query() {
            System.out.println("query user");
        }
    }
    interface InfManager {
        void del();
        void add();
    }
    static class InfManagerImpl implements InfManager {
        @Override
        public void add() {
            System.out.println("query add");
        }
        @Override
        public void del() {
            System.out.println("query del");
        }
    }
    //實現InvocationHandler接口
    static class MyProxy implements InvocationHandler {
        Object realSubject;
        //引入實現類
        Object getProxy(Object obj) {
            this.realSubject = obj;
            return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
        }

        //複寫invoke方法,進行AOP，完成轉發
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //filter();
            //pre();
            //通過反射，把proxy的代理類 轉交給 實現類上
            Object res = method.invoke(realSubject, args);
            //after();
            return res;
        }
    }

    public static void main(String[] args) {
        MyProxy myProxy = new MyProxy();
        Object proxy = myProxy.getProxy(new UserManagerImpl());
        System.out.println(proxy + " " + proxy.getClass());
        ((UserManager)proxy).query();

        proxy = myProxy.getProxy(new InfManagerImpl());
        System.out.println(proxy + " " + proxy.getClass());
        ((InfManager)proxy).del();
        ((InfManager)proxy).add();
    }

輸出:

proxy.Main$UserManagerImpl@30f39991 class proxy.$Proxy0
query user
proxy.Main$InfManagerImpl@f6f4d33 class proxy.$Proxy1
query del
query add

動態代理優點：

可以看出
1.上面只有一個proxy類，卻代理了多個服務UserManager以及InfManager，而靜態代理需要n個proxy類
2.通過invoke方法，在所有被代理的類的某些函數調用時觸發，一口氣完成所有對應代理的AOP
(靜態代理需要在每個代理上進行AOP)

調用原理

從上面代碼看，有幾個問題需要思考一下
1.proxy的class文件是如何生成的
2.proxy的class文件內容是什麼
3.proxy類對象是怎麼生成的
4.invoke方法是如何觸發的

1.proxy的class文件是如何生成的

java.lang.reflect.Proxy#newProxyInstance

 

進入java.lang.reflect.WeakCache#get

//之前利用緩存，設置了supplier（實際是Factory類型）
V value = supplier.get();

進入java.lang.reflect.WeakCache.Factory#get

//valueFactory是ProxyClassFactory類型
value = Objects.requireNonNull(valueFactory.apply(key, parameter));

進入java.lang.reflect.Proxy.ProxyClassFactory#apply

/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);

這裏面就是得到class文件byte內容的邏輯

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        //動態生成代理類的字節碼,非常複雜
        final byte[] var4 = var3.generateClassFile();
        //根據配置，判斷class文件是否存儲在本地
        if(saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if(var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);
                            Files.createDirectories(var3, new FileAttribute[0]);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class", new String[0]);
                        }

                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }
        //返回代理類的字節碼 
        return var4;
    }

2.proxy的class文件內容是什麼

可以自定義存儲硬盤位置
調用sun.misc.ProxyGenerator#generateProxyClass(java.lang.String, java.lang.Class<?>[])函數即可

public static void showProxyClass() {
        String path = "./$Proxy0.class";
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0",
                InfManagerImpl.class.getInterfaces());
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

打開$Proxy0文件如下

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Main.InfManager;

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

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

    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 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 void add() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void del() throws  {
        try {
            super.h.invoke(this, m4, (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", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("proxy.Main$InfManager").getMethod("add", new Class[0]);
            m4 = Class.forName("proxy.Main$InfManager").getMethod("del", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

3.proxy類對象是怎麼生成的

java.lang.reflect.Proxy#newProxyInstance中
生成了代理對象的字節碼文件後,根據構造函數生成對象

//生成字節碼，獲取類文件
Class<?> cl = getProxyClass0(loader, intfs);
//省略
//反射，根據構造函數，生成對象，構造參數爲InvocationHandler h
return cons.newInstance(new Object[]{h});

對應的構造函數爲

protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }

4.invoke方法是如何觸發的

可以看到在生成的$Proxy0文件中，代理類實現了委託類的方法

public final void add() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

其中，h就是在生成代理對象時傳入的InvocationHandler
也就是說 代理對象觸發add方法時，調用InvocationHandler的m3方法

m3方法是什麼，在下面有

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

m3就是InfManager的add方法
然後看我們自定義的實現proxy.Main.MyProxy#invoke

        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //filter();
            //pre();
            //通過反射，把proxy的代理類 轉交給 實現類上
            Object res = method.invoke(realSubject, args);
            //after();
            return res;
        }

也就是說代理類調用add方法
實際是利用父類Proxy類的InvocationHandler屬性，傳入add這個method
在自定義的InvocationHandler中，再利用反射，利用實現類完成add操作
完成了代理類 到 實現類的調用

缺點

由Proxy創建的動態代理 不支持 對 實現類的代理
動態代理類都 extend Proxy類，implements了代理的interface。
由於java不能多繼承，這裏已經繼承了Proxy類了，不能再繼承其他的類.
所以JDK的動態代理不支持對實現類的代理，只支持接口的代理。

動態代理不支持對實現類的代理

所以之前生成的class文件是

public final class $Proxy0 extends Proxy implements InfManager

思考

1.Proxy生成的動態代理類只能implements接口，不能extend實現類
這樣是動態代理的缺點

2.需要給代理類提供InvocationHandler的實現類類，實現invoke方法。
該invoke方法就是調用被代理接口的所有方法時需要調用的
通過反射讓對應的實現類完成響應操作。

3.動態代理是如何生成class文件(以及自定義保存到某路徑)，代理對象以及如何調用
生成字節碼文件是在sun.misc.ProxyGenerator#generateProxyClass(java.lang.String, java.lang.Class<?>[], int)
不過這個class文件我打開顯示是

public static byte[] generateProxyClass(java.lang.String s, java.lang.Class<?>[] classes, int i) { /* compiled code */ }

確定的是jdk動態代理 和 asm沒有關係

4.動態代理實現demo步驟

1.定義interface和impl
2.實現InvocationHandler類，在構造函數(或者某函數)傳入實現類的對象，在invoke方法裏進行AOP，利用反射將調用從代理類轉發給實現類

5.有些文章說

Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));

直接進入了
java.lang.reflect.Proxy.ProxyClassFactory#apply
生成class文件
這個是錯的，subKeyFactory是KeyFactory類型的

問題

爲什麼一定要繼承Proxy類
目的主要是需要一個類似於InvocationHandler的成員變量，完成從代理轉發給實現類
如果動態代理的class文件直接有InvocationHandler變量不就行了麼，不繼承Proxy類用Proxy的InvocationHandler
代理類的super.h.invoke變成this.h.invoke不就行了???

refer

實現，以及api介紹,與靜態代理的比較
http://www.importnew.com/20732.html
http://layznet.iteye.com/blog/1182924
http://www.cnblogs.com/fingerboy/p/5335328.html
http://blog.csdn.net/hejingyuan6/article/details/36203505
https://my.oschina.net/hosee/blog/656945

轉摘於：
鏈接：https://www.jianshu.com/p/0e06cf43a3c2