java動態代理底層探究

平常面試的時候,有人回問你Spring,你會說什麼AOP什麼的,然後他會越來越往深問,其實說到AOP那麼動態代理是繞不開的,那麼今天我們一起來看看這個動態代理是什麼個一回事先貼一張圖:

上面便是動態代理的結束以及它的實現方式,以及區別(我確實很懶....)but 上面的也挺通俗易懂,只要你不是初學者

-----------------------------------------華麗的分割線--------------------------------------------------------

接下來當然要繼續貼圖啦:

這張圖便是動態代理大概的實現流程,我們看到.只有javaProxy是直接修改字節碼的,其他的都是基於ASM來操作字節碼ASM我也不太懂,然後那個javassist也是用來操作ASM的,是島國一位工程師寫的,據說dubbo就是用的這項技術.

我們看到無論是何種方式它都是基於對class字節碼的修改來進行代理的.

好的這只是一個大概的瞭解那麼我們來寫代碼感受感受:

整體需求就是一個普通的Service接口,

讓後一個普通的實現類,ServiceImpl 

最後我們來個測試的小方法:來看看動態代理的實現:

public class ProjexTest {
    public static void main(String[] args) {
        final  serviceImpl impl =new serviceImpl();
        UserServce  servce = (UserServce)Proxy.newProxyInstance(ProjexTest.class.getClassLoader(), new Class[]{UserServce.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("代理執行前");
                try {
                    return method.invoke(impl, args);
                } finally {
                    System.out.println("代理執行後");
                }
            }
        });
        servce.get();
    }

我們還是很奇怪上面到底是什麼東東?用我表達不好語言解釋一下:

首先,我們new 了一個newProxyInstance()然後我們在InvocationHandler()裏面的invoke方法來實現它的動態代理.

還是貼圖方便一點這樣我們便實現了一個簡單的代理類

這裏的我們get()方法就相當於客戶端,掉的是userservice接口的方法,委託類就是serviceimpl 代理類就是我們傳的userservice.class,這樣通過接口屏蔽的底層的實現細節,這樣透明化嘍.

對啊是如何做到代理目標對象的呢?這個好說我們通過代理類來分析一下:

@Test
public void buildProcyClass() throws IOException {
    byte[] bytes = ProxyGenerator.generateProxyClass("UserService$proxy", new Class[]{
            UserServce.class
    });
    String filename = String.format("%s/target/UserService$proxy.class", System.getProperty("user.dir"));
    File file = new File(filename);
    FileOutputStream outputStream = new FileOutputStream(file);
    outputStream.write(bytes);
    outputStream.flush();
    outputStream.close();
}

這樣我就把它代理的類輸出出來了:

public final class UserService$proxy extends Proxy implements UserServce {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public UserService$proxy(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 String get() throws  {
        try {
            return (String)super.h.invoke(this, m3, (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", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.yqun.springboot.service.UserServce").getMethod("get");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

這個就是輸出來的類,我們可以看到代理過來的類:

return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); 裏面的參數就對應着:

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 上問中這個invoke裏面要的參數,

其實這樣我們可以清楚的看到,代理類回事怎麼一回事

我們看看他是怎麼生成的:追 類 可以通過了嗎看到它就是生成一個動態代理對對象

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

/*獲取查詢遍歷已經構建好的class類也就是我們接口的代理類
 * Look up or generate the designated proxy class.
 */
Class<?> cl = getProxyClass0(loader, intfs);

// If the proxy class defined by the given loader implementing //點進去首先會通過從load緩存裏面取
// the given interfaces exists, this will simply return the cached copy;//如果有對它從字節碼進行構建
// otherwise, it will create the proxy class via the ProxyClassFactory//沒有的話去創建一個新的
return proxyClassCache.get(loader, interfaces);

我們看到如果它沒有的話回去ProxyClassFactory類裏面去實現那麼我們就看看裏面的方法,

 -->ProxyClassFactory.apply 就是裝配自動代理的過程 動態代理所用的接口
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
//存儲所有動態代理所對應的接口
            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*驗證接口 也就是說ClassLoader 對應的接口是否已經存在是否是同一個
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.

                 */

也就是說對代理的類是不service的實現類

當然裏面還有許多亂七八糟的方法,但是我只看懂了這個.這裏他會對字節碼重組也就是修改class文件,相當於吧代碼編譯成字節碼

在往深就是類加載器的方法了,這個便是對字節碼的重新裝載 也就是ClassLoad裏面的

@Deprecated
protected final Class<?> defineClass(byte[] b, int off, int len)
    throws ClassFormatError
{
    return defineClass(null, b, off, len, null);
}

的方法

總結兩張圖結尾:

最後一張圖特別重要,也就是寫了這麼長時間的總計吧算是...