Java ASM学习(2)

1.编译后的方法区，其中存储的代码都是一些字节码指令

2.Java虚拟机执行模型：

java代码是在一个线程内部执行，每一个线程都有本身的执行栈，栈由帧组成，每一个帧表示一个方法的调用，每调用一个方法，都将将新的帧压入执行栈，方法返回时(不论是整成return仍是异常返回)，该方法对应的帧都将出栈，即按照先进后出的规则。

执行栈与操做数栈不同，操做数栈包含在执行栈中。每一帧包括局部变量和操做数栈两部分，操做数栈中包括字节码指令用来当操做数的值。好比a.equals(b)将建立一帧，此时该帧将有一个空栈，而且a和b做为局部变量

字节码指令：

由标识该指令的操做码和固定数目的参数组成，操做码指定要进行哪一类操做，参数指定具体精确行为。指令分为两类，一类在局部变量和操做数栈之间传值，一类从操做数栈弹出值计算后再压入

例如：

ILOAD,LLOAD,FLOAD,DLOAD,ALOAD读取一个局部变量，并将其值压入操做数栈中，其对应的参数是其读取的局部变量索引i(由于局部变量就是经过索引来进行随机访问的)，LLOAD和DLOAD加载时须要两个槽(slot),由于局部变量部分和操做数占部分的每一个槽(slot)均可以保存除了long和double以外的java值(long和double须要两个槽)。

ILOAD:加载boolean、char、byte、short、int局部变量
LLOAD:加载long
FLOAD:加载float
DLOAD:加载double
ALOAD:加载对象和数组引用

对应的ISTORE,LSTORE,FSTORE,DSTORE,ASTORE从操做数栈弹出值并将其存储在指定的索引i所表明的局部变量中，因此这些操做指令是和java数据类型密切相关的。存取值和数据类型也相关，好比使用ISTORE 1 ALOAD 1,此时从操做数栈弹出一个int值存入索引1处的局部变量中，再将该值转为对象类型进行转换读取是非法的。可是对于一个局部变量位置，咱们能够在运行过程当中改变其类型，好比ISTORE 1 ALOAD 1非法，可是ATORE 1 ALOAD1就合法了。具体的字节码指令见ASM指南附A.1

经过一个例子来进行学习，好比如下方法：

package asm;

public class bean {
    private int f;

    public bean() {
    }

    public void setF(int f) {
        this.f = f;
    }

    public int getF() {
        return this.f;
    }
}

直接经过字节码文件查看其class文件结构，其字段就一个int类型的f，访问修饰符为private

setf方法的字节码指令以下

 其局部变量表以下，因此有两个值一个就是当前对象this和成员变量f，分别对应下标0和1

 这里要设计到几个字节码指令：

GETFIELD owner name desc：读取一个字段的值并将其值压入操做数栈中
PUTFIELD owner name desc：从操做数弹出值存在name所表明的字段中
owner：类的全限定名
GETSTATIC owner name desc和PUTSTATIC owner name desc相似，只是为静态变量

aload 0，读取局部变量this，也就是局部变量表下标为0处的this对象(其在调用这个方法的时候就已经初始化存储在局部变量表中)，而后将其压入操做数栈。

iload 1，读取局部变量f，下标为1(建立帧期间已经初始化，也就是入口参数int f)，压入操做数栈中

putfield #2 <asm/bean.f> 也就是弹出压入的两个值，赋值给asm/bean.f，也就是将入口的int f的值赋给this.f

return 即该方法执行完成，那么该帧从执行栈从弹出

getf对应的字节码指令以下所示：

aload 0，即从局部变量表拿到this放入操做数栈

getfield #2 <asm/bean.f> 即从操做数栈中拿出this，并将this.f的值压入操做数栈

ireturn 返回f的值get方法的调用者，xreturn，x即返回变量对应的修饰符

bean构造方法，字节码指令以下：

aload 0: 从局部变量表拿到this，压入操做数栈

这里要设计方法的调用相关的字节码指令：

INVOKEVIRTUAL owner name desc：
调用owner所表示的类的name方法
desc用来描述一个方法的参数类型和返回类型
INVOKESTATIC：调用静态方法
INVOKESPECIAL: 调用私有方法和构造器
INVOKEINTERFACE: 接口中定义的方法

invokespecial #1 <java/lang/Object.<init>>: 调用object对象的init方法，即super()调用，最后return返回，若是是对于如下代码：

package asm;

public class bean {
    private int f;

    public void setFf(int f) {
        if(f>0){
        this.f = f;}
        else {
            throw new IllegalArgumentException();
        }
    }

    public int getF() {
        return f;
    }

}

此时setf的字节码指令以下：

iload  1，从局部表量表中拿出入口参数 int f，压入操做数栈

ifile 9：此时弹出操做数栈中的int f和0进行比较

a.若是小于等于0(这里将大于判断转为小于等于的判断)，则到第12条指令 

new #2 ：新建一个异常对象并压入操做数栈

dup：重复压入该值一次

invokespecial #4  : 弹出操做栈中两个对象值其中之一，并调用其构造函数实例化该对象

athrow：弹出操做数栈中剩下的值(另外一个异常对象)，并将其做为异常抛出

b.若是大于0，则依次执行

aload0 从局部变量表拿出this对象放入操做数栈中

iload1 拿出入口int f的值压入栈中

putfiled #2 <asm/bean.f>：将int f的值赋给this.f

goto 20: 到第20条字节码指令

return ： 返回

感受和汇编有点像，不过比汇编更容易理解，主要仍是方法内的一些操做，能看懂基本的字节码指令，复杂的再去查doc，据说面试有时候会问i++和++i的区别：

package asm;

public class testplus {

    public void plusf(){
        int i=0;
        System.out.println(i++);
    }
       public void pluse(){
        int i=0 ;
        System.out.println(++i);
       }
}

编译后：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package asm;

public class testplus {
    public testplus() {
    }
　　//i++
    public void plusf() {
        int i = 0;
        byte var10001 = i;
        int var2 = i + 1;
        System.out.println(var10001);
    }
　　//++i
    public void pluse() {
        int i = 0;
        int i = i + 1;
        System.out.println(i);
    }
}

首先从生成的class来看，i++编译后居然用字节存储了i的值，而后i自增1，输出的为字节类型i即0，因此i++，最终输出为0，++i，直接是i自增1，而后输出i，因此最终输出为1，因此for循环用i++，而不用++i

从字节码指令来看：

i++

iconst 0：首先操做数栈中压入常量0

istore 1：而后弹出常量0放入局部变量表索引1处，此时局部变量表处1处从i变为0,操做数栈空

getstatic #2 ：即拿到java.lang.System.out，即取静态变量System.out压入栈中，此时栈中1元素

 

#2在常量池中为第二个，关于该字段的引用说明以下，out对应的描述符即为Ljava/io/PrintStream; 那么类类型的描述符就是L+类的全限定名+；

 

iload 1：从局部变量表1处取值，压住操做数栈，即将0压入操做数栈

iinc 1 by 1：给局部变量1处的值+1，此时1处即从0变为1

invokevirtual：调用java.io.PrintStream.println,此时须要的值是从操做数栈中取的，然而此时操做数栈顶弹出的数值为0，因此输出为0

++i

 

iconst 0：首先操做数栈中压入常量0

istore 1：而后弹出常量0放入局部变量表索引1处，此时局部变量表处1处从i变为0,操做数栈空

getstatic #2 ：即拿到java.lang.System.out，即取静态变量System.out压入栈中，此时栈中1元素

iinc 1 by 1：将局部变量表1处的值加1，即从0变为1

iload 1：加载局部变量表1处的值，压入操做数栈中，即将1压入栈中

invokevirtual：调用java.io.PrintStream.println,此时须要的值是从操做数栈中取的，然而此时操做数栈顶弹出的数值为1，因此输出为1

因此i++和++i的区别从字节码指令上来看就是局部变量表自增和压入操做数栈的顺序不同，i++是先压栈，后局部变量表自增，++i是先局部变量表自增，后压入操做数栈，这样就彻底搞懂了2333~

因此再分析一个巩固巩固：

package asm;

public class testplus {

       public void pluse(){
        int i=0 ;
        int p = 2 + i++ - ++i;
        System.out.println(i);
        System.out.println(p);
       }

    public static void main(String[] args) {
        testplus t = new testplus();
        t.pluse();
    }
}

main方法：

new #4 <asm/testplus>：new一个对象压入栈中

dup：赋值一个栈顶的对象再压入操做数栈，关于为何要压入两个重复的值缘由：

首先字节码指令操做数值时基于栈实现的，那么对于同一个值从栈中操做时一定要弹出，那么若是对一个数同时操做两次，那么就要两次压栈。涉及到new一个对象操做时，java虚拟机自动dup，在new一个对象之后，栈中放入的是该对象在堆中的地址，好比声明如下两个

class1 a = new class1();
a.pp()

一般在调用对象调用其类中方法前确定要调用其init实例化，那么init要用一次操做数栈中的地址，此时弹出一次地址参与方法调用，后面只须要再将该栈中的地址放入局部变量表，该地址的对象已经完成了实例化操做，那么后面每次调用只须要从局部变量表从取到该对象的地址，便可任意调用其类中的方法。

invokespecial #5 ：这里调用testplus的init方法，因此从栈中弹出一个testplus的地址

astore 1：将实例化之后的该testplus对象地址放入局部变量表1处

aload 1：取局部变量表1处的对象地址压入栈中

invokevirtual #6：调用testplus的pluse方法

return ：返回

pluse方法：

 

iconst 0：压入常量0

istore 1：弹出0存入局部变量表1处 (完成int i=0)

iconst 2：将2压入栈中

iload 1：取出局部变量表1处的值0压入栈中

iinc 1 by 1：局部变量表1处的值加1，即从0变为1

iadd ：将栈中的两个值相加，即 stack[0] + stack[1] = 2 + 0 =2

iinc 1 by 1: 局部变量表1处的值加1，即从1变为2

iload 1：去局部变量表1处的值压入栈中，即栈顶为2

isub ：将栈中两个元素相减，即stack[0] - stack[1] =  2 - 2 =0

istore 2:弹出栈中的惟一一个元素2，存入局部变量表2处，此时栈空

getstatic # 2 ：拿到Syetem.out，压入栈中

iload 1：取出局部表量表1处的值压入栈中，即栈顶为2

invokevirtual  #3 ： 弹出栈中两个元素，调用System.out的println方法，即stack[0].print(stack[1])，即输出2

同理压入System.out,而后iload 2，取出局部变量表2处的0压入栈中，输出0

最终输出结果也是2和0