熊猫四川麻将赢钱规律 当前位置:首页>熊猫四川麻将赢钱规律>正文

熊猫四川麻将赢钱规律

发布时间:2018-11-22

原标题:ASM字节码框架学习之动态代理

这时候,殷落花开口说道:“小民,赵前辈说的对,洪绝即便有错,那也应该由世俗界的法律去约束他。看在我的面子上,就把他交给警察去管吧。”

kg棋牌是哪个公司游戏

王小民看了看那些繁琐的报表和文件,微微摇了摇头,而后轻声道:“琳儿小姐,中午有空吗?请你吃个饭。”
叶扬冷哼一声,森然的说道:“对于这些曰本人,就应该扔上几枚核弹将他们全部炸沉了。”

小舞是背对着高大青年出现在对方背后的,蝎子辫甩出,那高大青年还在吃惊的时候,只觉得脖子上一紧。

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

编辑:石王

发布时间:2018-11-22 00:00:00

当前文章:http://radiokey.biz/house/awg48.html

百赢棋牌2.6.3(3.4.2) 德州扑克在哪玩 棋牌游戏代理怎么做 天天电玩城旧版本 网狐荣耀316 熊猫麻将金币有什么用 熊猫四川麻将辅助软件 一木棋牌app

74884 98133 87336 98582 33751 4863237893 40994 94451

责任编辑:马邓

随机推荐