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

冷不防 2022-01-26 03:45 297阅读 0赞

（点击上方公众号，可快速关注）

> 来源：**一点水的坚持**  
> https://www.jianshu.com/p/0f64779cdcea

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

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

> 个人理解，是在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);

#### 总结： ####

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

> #### 【欢迎投稿】 ####
> 
> 如果大家有原创好文投稿，请直接给公号发送留言。
> 
> ① 留言格式：  
> 【投稿】+《文章标题》+ 文章链接  
> 示例：  
> 【投稿】《手写SpringMVC-实战篇》：https://blog.csdn.net/chyanwu68/article/details/81150924
> 
> ② 附上您的个人简介~|

--------------------

**分享朋友圈、点赞就是对全栈工程师成长记公众号最大的支持！**

![format_png][]

[format_png]: /images/20220126/4706c6cd37594045a4f0645aed86b289.png