ASM字节码框架学习之动态代理

想了解JDK动态代理和CGLIB的实现原理和细节的同学，看过来， 本文将向你们展示如何从零开始构建构建一个动态代理对象。

ASM字节码操纵框架，可以直接以二进制的形式来来修改已经存在的类或者创建新的类。ASM封装了操作字节码的大部分细节，并提供了非常方便的接口来对字节码进行操作。ASM框架是全功能的，使用ASM字节码框架，可以方便地对类增加成员，修改方法，创建新的类等。关于ASM的学习，可以参考：Learn ASM CoreApi。作为学习ASM框架的第一篇总结，本文的主要内容是使用ASM框架实现一个简单的JDK动态代理和CGLIB代理。

设定代理类和被代理类

被代理类

被代理类非常简单。

public interface CalculatorInterface {
    int add(int i, int j);
    int sub(int i, int j);
}

public class Calculator implements CalculatorInterface {
    public int add(int i, int j) {
        return i + j;
    }

    public int sub(int i, int j) {
        return i - j;
    }
}

代理类目标代码原型

CGLIB版本的代理类如下，直接从Calculator继承。如果是JDK版本的，则改为实现CalculatorInterface即可。

这里简化了，对要拦截的方法的个数写死了(m1,m2)，实际在生成字节码的时候并没有写死。

这一份代码，就是我要用字节码方式生成的代码。

public class CalculatorProxy extends Calculator {
    private InvocationHandler handler;
    private Object target
    private Method m1;
    private Method m2;

    public CalculatorProxy(Object o, InvocationHandler h, Method targetMethod1, Method targetMethod2) {
        super();
        target = o;
        handler = h;
        m1 = targetMethod1;
        m2 = targetMethod2;
    }

    @Override
    public int add(final int i, final int j) {
        try {
            return (int)handler.invoke(this, m1, new Object[] {i, j});
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }
}

代理工厂

代理工厂类似JDK的Proxy对象，只需要向代理工厂对象提供被代理对象和一个InvocationHandler即可使用CGLIB的方式来生成代理类，如果要使用JDK的方式来生成代理对象，则需要再额外提供一下待实现接口。使用newProxy方法得到代理对象。

public class AopProxy {
    public AopProxy(Object target, InvocationHandler handler) {
        ...
    }
    public AopProxy(Object target, InvocationHandler handler, Class<?>[] interfaces) {
        ...
    }
    public Object newProxy() throws Exception{
    }
}

生成代理类

基本指令

使用ASM生成一个类最复杂的地方在于方法体的生成，相当于直接写字节码。生成上文的目标类需要用到如下指令：

这个表格说的指令参数，并不是真正的JVM指令的参数，而是使用ASM框架生成相应字节码时需要传递的参数

指令名称	指令参数说明	指令含义	操作数栈
ILOAD	index: unsigned byte	从局部变量表中加载下标为index的int到操作数栈	无参数出栈，结果入栈
ALOAD	index: unsigned byte	将栈顶的引用写入到局部变量表中下标为index的引用	无参数出栈，结果入栈
ASTORE	index: unsigned byte	从局部变量表中加载下标为index的引用到操作数栈	objectRef 引用 出栈
INVOKESPECIAL	owner: string 类名 name: string 方法名 desc:方法签名 itf:boolean 是否是接口（false）	调用构造器，私有方法，或显示调用父类的方法，静态绑定	objectRef:实例对象 出栈 arg1:第一个参数 出栈 arg... 有返回的话入栈
INVOKEVIRTUAL	owner: string 类名 name: string 方法名 desc:方法签名 itf:boolean 是否是接口（false）	根据对象类型多态调用，动态绑定	objectRef:实例对象 出栈 arg1:第一个参数 出栈 arg... 有返回的话入栈
INVOKEINTERFACE	owner: string 类名 name: string 方法名 desc:方法签名 itf:boolean 是否是接口（true）	根据对象类型多态调用，动态绑定	objectRef:实例对象 出栈 arg1:第一个参数 出栈 arg... 有返回的话入栈
NEW	name: string	构造一个类型为name的对象，分配内存，并完成成员初始化，但是并不调用构造方法	无参数出栈，结果入栈
PUTFIELD	owner: string 类名 name: string 成员名 desc: string 成员类型描述	设置一个field值	objectRef 实例对象 出栈 value 成员的值 出栈
GETFIELD	owner: string 类名 name: string 成员名 desc: string 成员类型描述	读取一个field值	objectRef 实例对象 出栈 value 成员的值 入栈
ANEWARRAY	type: string 类型名称	新建引用类型为type的数组	count：int 数组长度 出栈 arrayref：数组引用 入栈
DUP	无参	复制栈顶的数据	value 栈顶的值 出栈 value 栈顶的值 入栈两次
AASTORE	无参	将引用存入数组指定位置	arrayRef 数组引用 出栈 index 下标 出栈 value 引用 出栈

INVOKEVIRTUAL 和 INVOKEINTERFACE的区别见：链接。如果调用一个方法的时候，能够确定这个方法在方法表中的位置，就调用INVOKEVIRTUAL，如果不能，就调用INVOKEINTERFACE。具体一点来说：如果一个变量的静态类型是接口，就使用INVOKEINTERFACE，如果是类，就使用INVOKEVIRTUAL。

方法调用基本知识

• 调用一个方法之前，需要确保方法需要的参数都已经加载到操作数栈中。如果是实例方法，需要将隐含的this也加载到栈中。
• 参数入栈的顺序和参数声明的顺序一致。实际弹出参数时，和声明顺序相反。（后进先出）。

关键代码生成

获取要代理的方法

比较简单，兼容了基于接口和基于类的代理两种场景

private List<Method> getProxyMethods() {
    List<Method> methods = new LinkedList<>();
    List<Class<?>> superClassList = interfaceList;
    if (superClassList.isEmpty()) {  //如果没有指定接口，就代理父类的所有公有方法
        superClassList = Collections.singletonList(targetClass);
    }
    for (final Class<?> aClass : superClassList) {
        methods.addAll(filterObjectMethods(aClass.getMethods())); //将来自Object的方法过滤掉
    }
    return methods;
}

写入类描述

ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);  //COMPUTE_FRAMES能够帮我们省去很多麻烦
cw.visit(Opcodes.V1_8,                  //字节码版本
        Opcodes.ACC_PUBLIC,            //类是public的
        convertClassName(className),  //类名
        null,                          //类的签名
        getSuperClassName(),          //父类
        getInterfaceNames());          //要实现的接口

写入域

生成如下几个域：target，handler，以及和要拦截的方法个数对应的Method域m1,m2...

public void writeFields(ClassWriter cw, List<Method> methods) {
    int i = 1;
    //为每一个要代理的方法，生成一个Method类型的成员，用于后面保存目标对象的方法
    for (final Method method : methods) {
        cw.visitField(Opcodes.ACC_PRIVATE, "m" + i++, "Ljava/lang/reflect/Method;", null, null).visitEnd();
    }
    //生成一个handler成员，保存回调接口
    cw.visitField(Opcodes.ACC_PRIVATE, "handler",
                  convertClassNameToDesc(InvocationHandler.class.getCanonicalName()),
                  null, null).visitEnd();

    //生成一个target成员，保存被代理对象
    cw.visitField(Opcodes.ACC_PRIVATE, "target",
                  convertClassNameToDesc(Object.class.getCanonicalName()),
                  null, null).visitEnd();
}

写构造方法

1 生成方法签名并调用父类构造方法

MethodVisitor mv =
    cw.visitMethod(Opcodes.ACC_PUBLIC,
                  "<init>",
                  "(Ljava/lang/Object;Ljava/lang/reflect/InvocationHandler;[Ljava/lang/reflect/Method;)V",
                  null, null);
mv.visitVarInsn(Opcodes.ALOAD, 0);  //调用构造方法需要传入隐式参数this
mv.visitMethodInsn(Opcodes.INVOKESPECIAL, convertClassName(superClass.getCanonicalName()), "<init>", "()V",
                  false);

2 初始化target和handler

从局部变量表中加载数据并赋值到各field种即可，构造函数的入参为：target,handler,method[]，因此target和handler在局部变量表中的位置是1和2. 使用javap -v -p -l classfile 可以查看相关信息。

//初始化targe
mv.visitVarInsn(Opcodes.ALOAD, 0); //this
mv.visitVarInsn(Opcodes.ALOAD, 1); //局部变量target
mv.visitFieldInsn(Opcodes.PUTFIELD, convertClassName(className), "target",
                  convertClassNameToDesc(Object.class.getCanonicalName()));
//初始化handler
mv.visitVarInsn(Opcodes.ALOAD, 0);//this
mv.visitVarInsn(Opcodes.ALOAD, 2);//局部变量handler
mv.visitFieldInsn(Opcodes.PUTFIELD, convertClassName(className), "handler",
                  convertClassNameToDesc(InvocationHandler.class.getCanonicalName()));

3 初始化method域

构造函数的第三个参数时Method数组，需要将这些值依次保存到多个method域中。

//初始化mi
int i = 1;
for (final Method method : methods) {
    mv.visitVarInsn(Opcodes.ALOAD, 0);  //加载this，为putfield指令做准备
    mv.visitVarInsn(Opcodes.ALOAD, 3); // 加载入参method数组
    mv.visitLdcInsn(i - 1); //将i-1作为常量载入，这个常量和上面的method数组是AALoad质量的操作数，表示要加载数组中某个位置的值
    mv.visitInsn(Opcodes.AALOAD); //aaload指令消耗了上面的两个操作数，并将结果放入到操作数栈顶，这个结果和this将被putfield使用
    mv.visitFieldInsn(Opcodes.PUTFIELD, convertClassName(className), "m" + i,
                      convertClassNameToDesc(Method.class.getCanonicalName()));
    i++;
}

4 完成构造函数

mv.visitInsn(Opcodes.RETURN);  //写入return指令
mv.visitMaxs(1, 1); //计算栈和局部变量的大小，传入的参数会被忽略，因为ClassWriter被设置了COMPUTE_FRAMES，操作数栈大小，局部变量表大小，还有StackMapFrame都会在此时被重新计算。
mv.visitEnd();

写入要代理的方法

写方法构造一个类最复杂的地方，需要非常小心地处理操作数栈，否则很容易出各种奇怪的问题。

private void writeMethods(ClassWriter cw, List<Method> methods) {
    int i = 1;
    for (Method x : methods) {
        writeMethod(cw, x, i++);  //写入方法，i表示是第几个方法，用来和method域对应
    }
}

private void writeMethod(ClassWriter cw, Method method, int i) {
大招都在这里了
}

写入方法描述

String name = method.getName();  //方法名称
String desc = DescHelper.getDesc(method); //方法描述，包含形参列表和返回值类型
Class<?>[] exceptionTypes = method.getExceptionTypes();
List<String> exceptionDescList = new LinkedList<>();
for (final Class<?> exceptionType : exceptionTypes) {
    exceptionDescList.add(DescHelper.getDesc(exceptionType)); //异常声明
}
MethodVisitor mv =
    cw.visitMethod(Opcodes.ACC_PUBLIC, name, desc, null,
                  exceptionDescList.toArray(new String[exceptionDescList.size()])); //写入方法签名
mv.visitCode();

写入方法体

方法体核心代码其实就一句话：

public int add(int i, int j) {
    return (Integer)this.handler.invoke(this, this.m1, new Object[]{i,j});
    ...
}

调用invoke方法，invoke方法需要的参数含handler自己的this引用在内，总共有四个：this,proxy,method,args。这四个参数需要先计算好并放依次入操作数栈之后，才能调用invoke方法。接下来就按照准备这几个参数的顺序来说明怎么生成字节码。

准备参数：this

域handler的引用，其实就是handler.invoke方法需要的this指针。

mv.visitVarInsn(Opcodes.ALOAD, 0);  //加载this参数
mv.visitFieldInsn(Opcodes.GETFIELD,
                  convertClassName(className), //指定field的owner
                  "handler", //指定field的名称
                  convertClassNameToDesc(invocationHandlerClassName)); //指定field的描述

GETFIELD执行完之后，handler的引用会被放到操作数栈顶。此时，invoke方法第一个参数：this准备就绪。

准备参数：proxy

handler.invoke 需要的proxy参数，是指代理对象的引用。有于handler.invoke是在代理对象中执行的代码，因此代理对象就是当前方法的this指针。

mv.visitVarInsn(Opcodes.ALOAD, 0);  //加载this指针。此时，invoke方法的第二个参数：proxy准备就绪。

准备参数：method

生成类的代码是通用的，并不清楚当前是在生成哪一个代理方法，因此需要使用哪个method域取决于入参i。

mv.visitVarInsn(Opcodes.ALOAD, 0);  //加载this，为GETFIELD指令准备操作数栈
mv.visitFieldInsn(Opcodes.GETFIELD,
                  convertClassName(className),  //域的owner
                  "m" + i,  //域的名称
                  convertClassNameToDesc(Method.class.getCanonicalName())); //域的描述

GETFIELD指令执行完成之后，响应的method域就进入操作数栈。此时invoke方法的第三个参数：method准备就绪。

准备参数args

args参数是一个数组，当前上下文int add(i,j)中并不存在，需要手动构造出来。

代码：new Object[]{i,j} 的生成步骤如下：

1 调用new指令

int parameterCount = method.getParameterCount();
mv.visitLdcInsn(parameterCount);  //将数组大小作为常量加载的操作数栈中
mv.visitTypeInsn(Opcodes.ANEWARRAY, convertClassName(Object.class.getCanonicalName()));  //生成数组，栈顶的int参数出栈，数组引用入栈

执行完ANEWARRAY指令之后，数组的引用Arrayref位于栈顶。

2 填入数组值

由于数组元素是Object，对于基本类型需要装箱，装箱之后再加入到数组中

int paramIndex = 0;
for (final Class<?> paramClass : method.getParameterTypes()) {
    mv.visitInsn(Opcodes.DUP); //备份一下栈顶的Arrayref，aastore指令会消耗掉这个参数，aastore指令的第一个操作数
    mv.visitLdcInsn(paramIndex); //aastore 的第二个操作数，数组下标
    mv.visitVarInsn(Opcodes.ILOAD, paramIndex + 1);  //载入局部变量 ，第一次载入i，第二次载入j
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, convertClassName(Integer.class.getCanonicalName())
        , "valueOf", "(I)Ljava/lang/Integer;", false); //装箱，valueOf会消耗到栈顶元素并返回一个Integer对象入栈
    mv.visitInsn(Opcodes.AASTORE);  //装箱操作生成aastore指令的第三个参数 ，数组元素值，之后，就可以进行指令调用了。这个指令会导致操作数栈出栈三次。
    paramIndex++;
}

AASTORE执行完之前，入栈三个操作数，执行完之后，三个操作数出栈，操作数栈不变，Arrayref依然位于栈顶。此时handler.invoke的方法就全部准备就绪了。

调用invoke方法

mv.visitMethodInsn(Opcodes.INVOKEINTERFACE,
                  invocationHandlerClassName,
                  INVOKE, INVOKE_DESC, true);

INVOKEINTERFACE按照invoke方法的参数列表，依次将需要的参数出栈。执行完之后，将结果入栈。根据invoke方法的签名，结果Object类型，是一个引用。

unbox

add方法的返回值是int，invoke方法的返回值是Object，需要unbox才能返回。

mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Integer"); //类型检查
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Integer", "intValue", "()I", false); //调用intValue方法，object引用出栈，结果入栈。
mv.visitInsn(Opcodes.IRETURN);  //返回栈顶的整数

异常处理

由于InvocationHandler的invoke方法抛出Throwable异常，需要捕获，因此，实际生成的add方法，还需要捕获异常。

private void writeMethod(ClassWriter cw, Method method, int i) {
    ...
    mv.visitCode();
    Label begin = new Label(); //方法入口加一个labe
    mv.visitLabel(begin);
  ...
    Label end = new Label();  //方法出口加一个label
    mv.visitLabel(end);
//加入try catch，并指明捕获的异常类型
    mv.visitTryCatchBlock(begin, end, end, convertClassName(Throwable.class.getCanonicalName()));
    mv.visitVarInsn(Opcodes.ASTORE, 3); //将异常存入到局部变量
//构造UndeclaredThrowableException对象
    mv.visitTypeInsn(Opcodes.NEW, convertClassName(UndeclaredThrowableException.class.getCanonicalName()));
//准备UndeclaredThrowableException构造方法的参数
    mv.visitInsn(Opcodes.DUP);  //准备UndeclaredThrowableException构造器的this参数
    mv.visitVarInsn(Opcodes.ALOAD, 3);//准备UndeclaredThrowableException构造器的undeclaredThrowable参数
    mv.visitMethodInsn(Opcodes.INVOKESPECIAL,
                      convertClassName(UndeclaredThrowableException.class.getCanonicalName()),
                      "<init>",
                      "(Ljava/lang/Throwable;)V", false);
    mv.visitInsn(Opcodes.ATHROW);  抛出UndeclaredThrowableException对象
    mv.visitMaxs(1, 1);
    mv.visitEnd();
}

至此，动态代理类就生成完了。生成的动态代理类如下：

小结

使用ASM字节码框架生成代码，可以先自己用Java代码写出目标代码，然后转成字节码来查看。也可以使用ASMifer工具来生成ASM代码。

java jdk.internal.org.objectweb.asm.util.ASMifier classfilename

ASMifier很好用，但是它生成的ASM代码，是针对一个给定的类的硬编码，不一定符合业务逻辑，但是非常值得参考。

另外，对于JVM字节码指令有不清楚的地方，可以参考文档：JVM虚拟机指令集