$2.5、动态代理字节码层面的剖析

动态代理我们都使用过，很多场景下是对被代理类的方法进行增强，那么它反映在字节码中是什么样的呢？

先实现一个动态代理，实现InvocationHandler和代理的接口类如下：

public interface Subject {

    void test();
}

实现的类：

public class RealSubject implements Subject {
    @Override
    public void test() {
        System.out.println("real subject invoke");
    }
}

我们的代理类如下

public class DynamicSubject implements InvocationHandler {

    private Object obj;

    public DynamicSubject(Subject obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("call before:" + method);
        //真正执行的方法
        method.invoke(this.obj, args);
        //真正方法代理结束
        System.out.println("call after" + method);
        return null;
    }
}

上面已经实现了对RealSubject的代理，生成客户端进行调用

    public static void main(String[] args) {
        //需要被代理的类
        RealSubject realSubject = new RealSubject();
        Class<? extends RealSubject> aClass = realSubject.getClass();

        DynamicSubject ds = new DynamicSubject(realSubject);

        Subject o = (Subject) Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), ds);
        System.out.println(o.getClass());
        o.test();
    }
}

下面进入重点，我们看输出结果

产生的Subject对象真正的类型是com.sun.proxy.$Proxy0

那这个对象是怎么产生的呢？ 而且调用这个对象的类，怎么进跑到invocationHandler里面去了呢。。。查看Proxy.newPrxoyInstance方式入口查看

上述第二张图先生成Proxy0类对应的字节码数组，然后产生Class对象，通过class对象拿到构造函数，创建真实的实例，其中实现了InvocationHandler的类作为参数传递到了产生Prxoxy0的对象中。

那我们能不能看到代理对象对应的类长啥样呢。。。，我们看下面代码：

我们将属性修改一下，获取System.getproperties().put()方法设置true进去，就可以生成本地字节码文件了，反编译的实体类为

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import com.example.demo.dynamic.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

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

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void test() 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);
        } 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"));
            m3 = Class.forName("com.example.demo.dynamic.Subject").getMethod("test");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

这下就跟前面的对象和H参数对应起来了，Client端调用的tets方法，其实就是调用h.invoke(this,test,null)方法，那么自然就调用到了我们实现了InvocationHYandler接口类中的方法

总结：动态代理的对象产生出来时，把我们代理类的实例作为参数传递进去，后续Proxy0方法调用，其实就是对应代理类Handler中实际的方法。以此达到增加的目的。

pS:我们看Prxoxy0源码得知，动态代理类还将Object中的hashCode,equals，toString方法给复写下来了，意思就是将这三个方法也默认给代理了，具体实现就看实现了InvocationHandler接口的类没有进行重写操作。

以上就是动态代理在字节码层面的实现，具体看到是如何调用我们自己的方法的，一切都是Proxy类和H参数的功能。