最近看到很多人在分享動態(tài)代理的實現(xiàn)，想到上次在公司分享過一次字節(jié)碼增強方面的技術(shù)，這里隨便寫寫，做個總結(jié)。

什么叫做字節(jié)碼增強技術(shù)？

個人理解，是在Java字節(jié)碼生成之后，運行期對其進行修改，增強其功能，這種方式相當(dāng)于對應(yīng)用程序的二進制文件進行修改。Java字節(jié)碼增強主要是為了減少冗余代碼，提高性能等。

何為運行期？

請關(guān)注http://www.itdecent.cn/p/bcb00756b1eb

有哪些與字節(jié)碼相關(guān)的技術(shù)?

• 動態(tài)代理 java自身使用的動態(tài)代理
• CGLIB
• javassist
• asm

接下來，具體看看為什么說這些都與字節(jié)碼增強有關(guān)。

動態(tài)代理

• 實質(zhì)是動態(tài)生成字節(jié)碼與反射機制結(jié)合。
• 運行期根據(jù)不同的入?yún)⑸刹煌淖止?jié)碼文件，繼承于Proxy對象，實現(xiàn)傳入對象的實現(xiàn)接口。

舉個例子：

public class LogProxy implements InvocationHandler{

    private Object object;

    public Object getProxyObject(Object o){
        object=o;
        try{
            return Proxy.newProxyInstance(this.getClass().getClassLoader(),o.getClass().getInterfaces(),this);
        }catch (IllegalArgumentException e){
            throw new RuntimeException(e);
        }

    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before invoke ...");
        Object result= method.invoke(object,args);
        System.out.println("after invoke ...");
        return result;
    }
}

這是一個簡單的例子，實現(xiàn)了invocationHandler接口,該代理類只做了一件事情，凡是被該類代理的對象，在調(diào)用之和之后都會輸出兩行日志在console，其他什么都沒做。

public interface HelloWorldInteface {
    public void sayHello();
}
public class HelloWorldImpl implements HelloWorldInteface{
    public void sayHello() {
        System.out.println("hello world");
    }
}

定義接口和實現(xiàn)類，并對該類做代理，執(zhí)行sayHello方法

public class Main {

    public static void main(String[] args) {
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        HelloWorldInteface helloWorldInteface = (HelloWorldInteface) logProxy.getProxyObject(new HelloWorldImpl());
        helloWorldInteface.sayHello();
        dateUtils.getCurrentDate();
    }
}

我們能看到日志如下：

before invoke ...
hello world
after invoke ...

為什么會出現(xiàn)兩行日志，到底程序在執(zhí)行的過程中做了些什么？
其實在調(diào)用過程中，真正執(zhí)行的對象不是HelloWorldImpl，而是生成了一個proxy對象，這個helloWorldInteface對象實質(zhì)是通過字節(jié)碼增強技術(shù)產(chǎn)生的一個proxy對象，具體如下：

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

    public $Proxy1(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 void sayHello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } 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);
        }
    }

    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")});
            m3 = Class.forName("com.github.jettyrun.monitor.client.jdkproxy.HelloWorldInteface").getMethod("sayHello", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", 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());
        }
    }
}

我們能看到，生成的這個proxy對象，實質(zhì)是實現(xiàn)了HelloWorldInteface接口，在調(diào)用sayHello()方法時，實質(zhì)是調(diào)用了invocationHandler.invoke方法。

 public final void sayHello() throws  {
        try {
            //proxy的h方法。
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

public class Proxy implements java.io.Serializable {
   protected InvocationHandler h;
   public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h){
            return cons.newInstance(new Object[]{h});
   }
   protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }
}

能看到，實質(zhì)調(diào)用的是父類InvocationHandler的invoker方法，invocationHandler是什么時候初始化的?不由的想到了我們自己定義的LogProxy，logProxy對象本身就是invocationHandler的實現(xiàn)類，且在獲取代理對象的時候，初始化了proxy對象并返回了。

Proxy.newProxyInstance(this.getClass().getClassLoader(),o.getClass().getInterfaces(),this);

真正調(diào)用的InvocationHandler的invoker就是調(diào)用了我們自己定義的invoke方法。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("before invoke ...");
    Object result= method.invoke(object,args);
    System.out.println("after invoke ...");
    return result;
}

總結(jié)：

java動態(tài)代理，實質(zhì)是通過運行期生成字節(jié)碼文件的方式，基于實現(xiàn)被代理對象的接口實現(xiàn)代理的功能，所以如果要對非實現(xiàn)接口的類做代理，實質(zhì)是做不到的。如果要做到，則需要看下面的博客了。