正文

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

IP云
IP云V管理员/31 阅读
07/25
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

想了解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框架生成相应字节码时需要传递的参数

指令名称指令参数说明指令含义操作数栈
ILOADindex: unsigned byte从局部变量表中加载下标为index的int到操作数栈无参数出栈，结果入栈
ALOADindex: unsigned byte将栈顶的引用写入到局部变量表中下标为index的引用无参数出栈，结果入栈
ASTOREindex: unsigned byte从局部变量表中加载下标为index的引用到操作数栈objectRef 引用 出栈
INVOKESPECIALowner: string 类名
name: string 方法名
desc:方法签名
itf:boolean 是否是接口（false）		调用构造器，私有方法，或显示调用父类的方法，静态绑定objectRef:实例对象 出栈
arg1:第一个参数 出栈
arg...
有返回的话入栈
INVOKEVIRTUALowner: string 类名
name: string 方法名
desc:方法签名
itf:boolean 是否是接口（false）		根据对象类型多态调用，动态绑定objectRef:实例对象 出栈
arg1:第一个参数 出栈
arg...
有返回的话入栈
INVOKEINTERFACEowner: string 类名
name: string 方法名
desc:方法签名
itf:boolean 是否是接口（true）		根据对象类型多态调用，动态绑定objectRef:实例对象 出栈
arg1:第一个参数 出栈
arg...
有返回的话入栈
NEWname: string构造一个类型为name的对象，分配内存，并完成成员初始化，但是并不调用构造方法无参数出栈，结果入栈
PUTFIELDowner: string 类名
name: string 成员名
desc: string 成员类型描述		设置一个field值objectRef 实例对象 出栈
value 成员的值 出栈
GETFIELDowner: string 类名
name: string 成员名
desc: string 成员类型描述		读取一个field值objectRef 实例对象 出栈
value 成员的值 入栈
ANEWARRAYtype: 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虚拟机指令集