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字节码框架学习之动态代理

小结

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

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

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

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

上一篇:15. 星际争霸之php设计模式--策略模式


下一篇:修改OpenCart系统配置