谈谈字节码增强(一)之java动态代理

最近看到很多人在分享动态代理的实现，想到上次在公司分享过一次字节码增强方面的技术，这里随便写写，做个总结。

什么叫做字节码增强技术？

个人理解，是在Java字节码生成之后，运行期对其进行修改，增强其功能，这种方式相当于对应用程序的二进制文件进行修改。Java字节码增强主要是为了减少冗余代码，提高性能等。

何为运行期？

请关注https://www.jianshu.com/p/bcb00756b1eb

有哪些与字节码相关的技术?

• 动态代理 java自身使用的动态代理
• CGLIB
• javassist
• asm

接下来，具体看看为什么说这些都与字节码增强有关。

---

动态代理

• 实质是动态生成字节码与反射机制结合。
• 运行期根据不同的入参生成不同的字节码文件，继承于Proxy对象，实现传入对象的实现接口。

举个例子：

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

这是一个简单的例子，实现了invocationHandler接口,该代理类只做了一件事情，凡是被该类代理的对象，在调用之和之后都会输出两行日志在console，其他什么都没做。

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

定义接口和实现类，并对该类做代理，执行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 ...

为什么会出现两行日志，到底程序在执行的过程中做了些什么？
其实在调用过程中，真正执行的对象不是HelloWorldImpl，而是生成了一个proxy对象，这个helloWorldInteface对象实质是通过字节码增强技术产生的一个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对象，实质是实现了HelloWorldInteface接口，在调用sayHello()方法时，实质是调用了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;
    }
}

能看到，实质调用的是父类InvocationHandler的invoker方法，invocationHandler是什么时候初始化的?不由的想到了我们自己定义的LogProxy，logProxy对象本身就是invocationHandler的实现类，且在获取代理对象的时候，初始化了proxy对象并返回了。

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

真正调用的InvocationHandler的invoker就是调用了我们自己定义的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;
}

总结：

java动态代理，实质是通过运行期生成字节码文件的方式，基于实现被代理对象的接口实现代理的功能，所以如果要对非实现接口的类做代理，实质是做不到的。如果要做到，则需要看下面的博客了。