谈谈字节码增强(一)之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;
    }
}

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

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

真正调用的InvocationHandlerinvoker就是调用了我们自己定义的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动态代理,实质是通过运行期生成字节码文件的方式,基于实现被代理对象的接口实现代理的功能,所以如果要对非实现接口的类做代理,实质是做不到的。如果要做到,则需要看下面的博客了。

你可能感兴趣的:(谈谈字节码增强(一)之java动态代理)