使用ASM字节码框架实现动态代理

时间  2019-12-02
标签 使用 asm 字节 框架 实现 动态 代理 繁體版
原文   原文链接

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

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

设定代理类和被代理类

被代理类

被代理类很是简单。web

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方法获得代理对象。oracle

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。jvm

方法调用基本知识

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

关键代码生成

获取要代理的方法

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

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虚拟机指令集

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程