JAVA开发常用类库--字节码库

也许你写了无数行的代码，也许你能非常溜的使用高级语言，但是你未必了解那些高级语言的执行过程。例如大行其道的Java。

Java号称是一门“一次编译到处运行”的语言，但是我们对这句话的理解深度又有多少呢？从我们写的java文件到通过编译器编译成java字节码文件（也就是.class文件），这个过程是java编译过程；而我们的java虚拟机执行的就是字节码文件。不论该字节码文件来自何方，由哪种编译器编译，甚至是手写字节码文件，只要符合java虚拟机的规范，那么它就能够执行该字节码文件。那么本文主要讲讲java字节码文件相关知识。接下来我们通过具体的Demo来深入理解：

首先我们来写一个java源文件

上面是我们写的一个java程序，很简单，只有一个成员变量a以及一个方法testMethod() 。

接下来我们用javac命令或者ide工具将该java源文件编译成java字节码文件。

上图是编译好的字节码文件，我们可以看到一堆16进制的字节。如果你使用IDE去打开，也许看到的是已经被反编译的我们所熟悉的java代码，而这才是纯正的字节码，这也是我们今天需要讲的内容重点。

也许你会对这样一堆字节码感到头疼，不过没关系，我们慢慢试着你看懂它，或许有不一样的收获。在开始之前我们先来看一张图

这张图是一张java字节码的总览图，我们也就是按照上面的顺序来对字节码进行解读的。一共含有10部分，包含魔数，版本号，常量池等等，接下来我们按照顺序一步一步解读。

魔数

从上面的总览图中我们知道前4个字节表示的是魔数，对应我们Demo的是 0XCAFE BABE。什么是魔数？魔数是用来区分文件类型的一种标志，一般都是用文件的前几个字节来表示。比如0XCAFE BABE表示的是class文件，那么有人会问，文件类型可以通过文件名后缀来判断啊？是的，但是文件名是可以修改的（包括后缀），那么为了保证文件的安全性，讲文件类型写在文件内部来保证不被篡改。
从java的字节码文件类型我们看到，CAFE BABE翻译过来是咖啡宝贝之意，然后再看看java图标。

CAFE BABE = 咖啡。

版本号

我们识别了文件类型之后，接下来要知道版本号。版本号含主版本号和次版本号，都是各占2个字节。在此Demo种为0X0000 0033。其中前面的0000是次版本号，后面的0033是主版本号。通过进制转换得到的是次版本号为0，主版本号为51。
从oracle官方网站我们能够知道，51对应的正式jdk1.7，而其次版本为0，所以该文件的版本为1.7.0。如果需要验证，可以在用java –version命令输出版本号，或者修改编译目标版本–target重新编译，查看编译后的字节码文件版本号是否做了相应的修改。

至此，我们共了解了前8字节的含义，下面讲讲常量池相关内容。

常量池

紧接着主版本号之后的就是常量池入口。常量池是Class文件中的资源仓库，在接下来的内容中我们会发现很多地方会涉及，如Class Name，Interfaces等。常量池中主要存储2大类常量：字面量和符号引用。字面量如文本字符串，java中声明为final的常量值等等，而符号引用如类和接口的全局限定名，字段的名称和描述符，方法的名称和描述符。

为什么需要类和接口的全局限定名呢？系统引用类或者接口的时候不是通过内存地址进行操作吗？这里大家仔细想想，java虚拟机在没有将类加载到内存的时候根本都没有分配内存地址，也就不存在对内存的操作，所以java虚拟机首先需要将类加载到虚拟机中，那么这个过程设计对类的定位（需要加载A包下的B类，不能加载到别的包下面的别的类中），所以需要通过全局限定名来判别唯一性。这就是为什么叫做全局，限定的意思，也就是唯一性。

在进行具体常量池分析之前，我们先来了解一下常量池的项目类型表：

上面的表中描述了11中数据类型的结构，其实在jdk1.7之后又增加了3种（CONSTANT_MethodHandle_info,CONSTANT_MethodType_info以及CONSTANT_InvokeDynamic_info)。这样算起来一共是14种。接下来我们按照Demo的字节码进行逐一翻译。

0x0015：由于常量池的数量不固定（n+2），所以需要在常量池的入口处放置一项u2类型的数据代表常量池数量。因此该16进制是21，表示有20项常量，索引范围为1~20。明明是21，为何是20呢？因为Class文件格式规定，设计者就讲第0项保留出来了，以备后患。从这里我们知道接下来我们需要翻译出20项常量。
Constant #1 （一共有20个常量，这是第一个，以此类推…）
0x0a-：从常量类型表中我们发现，第一个数据均是u1类型的tag，16进制的0a是十进制的10，对应表中的MethodRef_info。
0x-00 04-：Class_info索引项#4
0x-00 11-：NameAndType索引项#17
Constant #2
0x-09: FieldRef_info
0x0003 :Class_info索引项#3
0x0012：NameAndType索引项#18
Constant #3
0x07-: Class_info
0x-00 13-: 全局限定名常量索引为#19
Constant #4
0x-07 :Class_info
0x0014:全局限定名常量索引为#20
Constant #5
0x01:Utf-8_info
0x-00 01-:字符串长度为1（选择接下来的一个字节长度转义）
0x-61:”a”(十六进制转ASCII字符)
Constant #6
0x01:Utf-8_info
0x-00 01：字符串长度为1
0x-49:”I”
Constant #7
0x01:Utf-8_info
0x-00 06:字符串长度为6
0x-3c 696e 6974 3e-:”“
Constant #8
0x01 :UTF-8_info
0x0003:字符串长度为3
0x2829 56:”()V”
Constant #9
0x-01:Utf-8_info
0x0004：字符串长度为4
0x436f 6465:”Code”
Constant #10
0x01:Utf-8_info
0x00 0f:字符串长度为15
0x4c 696e 654e 756d 6265 7254 6162 6c65:”LineNumberTable”
Constant #11
ox01: Utf-8_info
0x00 12字符串长度为18
0x-4c 6f63 616c 5661 7269 6162 6c65 5461 626c 65:”LocalVariableTable”
Constant #12
0x01:Utf-8_info
0x0004 字符串长度为4
0x7468 6973 :”this”
Constant #13
0x01:Utf-8_info
0x0f:字符串长度为15
0x4c 636f 6d2f 6465 6d6f 2f44 656d 6f3b:”Lcom/demo/Demo;”
Constant #14
0x01:Utf-8_info
0x00 0a:字符串长度为10
ox74 6573 744d 6574 686f 64:”testMethod”
Constant #15
0x01:Utf-8_info
0x000a:字符串长度为10
0x536f 7572 6365 4669 6c65 :”SourceFile”
Constant #16
0x01:Utf-8_info
0x0009:字符串长度为9
0x-44 656d 6f2e 6a61 7661 :”Demo.java”
Constant #17
0x0c :NameAndType_info
0x0007:字段或者名字名称常量项索引#7
0x0008:字段或者方法描述符常量索引#8
Constant #18
0x0c:NameAndType_info
0x0005:字段或者名字名称常量项索引#5
0x0006:字段或者方法描述符常量索引#6
Constant #19
0x01:Utf-8_info
0x00 0d:字符串长度为13
0x63 6f6d 2f64 656d 6f2f 4465 6d6f:”com/demo/Demo”
Constant #20
0x01:Utf-8_info
0x00 10 :字符串长度为16
0x6a 6176 612f 6c61 6e67 2f4f 626a 6563 74 :”java/lang/Object”
到这里为止我们解析了所有的常量。接下来是解析访问标志位。

Access_Flag 访问标志

访问标志信息包括该Class文件是类还是接口，是否被定义成public，是否是abstract，如果是类，是否被声明成final。通过上面的源代码，我们知道该文件是类并且是public。

0x 00 21：是0x0020和0x0001的并集。其中0x0020这个标志值涉及到了字节码指令，后期会有专题对字节码指令进行讲解。

类索引

类索引用于确定类的全限定名
0x00 03 表示引用第3个常量，同时第3个常量引用第19个常量，查找得”com/demo/Demo”。#3.#19

父类索引

0x00 04 同理：#4.#20(java/lang/Object)

接口索引

通过java_byte.jpeg图我们知道，这个接口有2+n个字节，前两个字节表示的是接口数量，后面跟着就是接口的表。我们这个类没有任何接口，所以应该是0000。果不其然，查找字节码文件得到的就是0000。

字段表集合

字段表用于描述类和接口中声明的变量。这里的字段包含了类级别变量以及实例变量，但是不包括方法内部声明的局部变量。
同样，接下来就是2+n个字段属性。我们只有一个属性a，按道理应该是0001。查找文件果不其然是0001。
那么接下来我们要针对这样的字段进行解析。附上字段表结构图

0x00 02 ：访问标志为private（自行搜索字段访问标志）
0x00 05 : 字段名称索引为#5，对应的是”a”
0x 00 06 :描述符索引为#6，对应的是”I”
0x 00 00 :属性表数量为0，因此没有属性表。
tips:一些不太重要的表（字段，方法访问标志表）可以自行搜索，这里就不贴出来了，防止篇幅过大。

方法

我们只有一个方法testMethod，按照道理应该前2个字节是0001。通过查找发现是0x00 02。这是什么原因，这代表着有2个方法呢？且继续看……

上图是一张方法表结构图，按照这个图我们分析下面的字节码：

第1个方法：

0x00 01：访问标志 ACC_PUBLIC，表明该方法是public。（可自行搜索方法访问标志表）
0x00 07：方法名索引为#7，对应的是”“
0x00 08：方法描述符索引为#8，对应的是”()V”
0x00 01：属性表数量为1(一个属性表)
那么这里涉及到了属性表。什么是属性表呢？可以这么理解，它是为了描述一些专有信息的，上面的方法带有一张属性表。所有属性表的结构如下图：
一个u2的属性名称索引，一个u2的属性长度加上属性长度的info。
虚拟机规范预定义的属性有很多，比如Code，LineNumberTable，LocalVariableTable，SourceFile等等，这个网上可以搜索到。

按照上面的表结构解析得到下面信息：
0x0009:名称索引为#9(“Code”)。
0x000 00038：属性长度为56字节。
那么接下来解析一个Code属性表，按照下图解析

前面6个字节（名称索引2字节+属性长度4字节）已经解析过了，所以接下来就是解析剩下的56-6=50字节即可。
0x00 02 ：max_stack=2
0x00 01 : max_locals=1
0x00 0000 0a : code_length=10
0x2a b700 012a 04b5 0002 b1 : 这是code代码，可以通过虚拟机字节码指令进行查找。
2a=aload_0(将第一个引用变量推送到栈顶)
b7=invokespecial(调用父类构造方法)
00=什么都不做
01 =将null推送到栈顶
2a=同上
04=iconst_1 将int型1推送到栈顶
b5=putfield 为指定的类的实例变量赋值
00= 同上
02=iconst_m1 将int型-1推送栈顶
b1=return 从当前方法返回void
整理，去除无动作指令得到下面
0 : aload_0
1 : invokespecial
4 : aload_0
5 : iconst_1
6 : putfield
9 : return
关于虚拟机字节码指令这块内容，后期会继续深入下去…… 目前只需要了解即可。接下来顺着Code属性表继续解析下去:
0x00 00 : exception_table_length=0
0x00 02 : attributes_count=2(Code属性表内部还含有2个属性表)
0x00 0a: 第一个属性表是”LineNumberTable”

0x00 0000 0a : “属性长度为10”
0x00 02 ：line_number_table_length=2
line_number_table是一个数量为line_number_table_length，类型为line_number_info的集合，line_number_info表包括了start_pc和line_number两个u2类型的数据项，前者是字节码行号，后者是Java源码行号
0x00 00 : start_pc =0
0x00 03 : end_pc =3
0x00 04 : start_pc=4
0x00 04 : end_pc=4

0x00 0b 第二个属性表是：”LocalVariableTable”

local_variable_table.png
local_variable_info.png
0x00 0000 0c：属性长度为12
0x00 01 : local_variable_table_length=1
然后按照local_variable_info表结构进行解析：
0x00 00 : start_pc=0
0x00 0a：length=10
0x000c : name_index=”this”
0x000d : descriptor_index #13 (“Lcom/demo/Demo”)
0000 index=0
//——-到这里第一个方法就解析完成了——-//
Method（)–1个属性Code表-2个属性表（LineNumberTable ，LocalVariableTable）接下来解析第二个方法

第2个方法：

0x00 04：”protected”
0x00 0e: #14（”testMethod”）
0x00 08 : “()V”
0x0001 ： 属性数量=1
0x0009 ：”Code”
0x0000 002b 属性长度为43
解析一个Code表
0000 :max_stack =0
0001 : max_local =1
0000 0001 : code_length =1
0xb1 : return(该方法返回void)
0x0000 异常表长度=0
0x0002 属性表长度为2
//第一个属性表
0x000a : #10，LineNumberTable
0x0000 0006 : 属性长度为6
0x0001 : line_number_length = 1
0x0000 : start_pc =0
0x0008 : end_pc =8
//第二个属性表
0x000b : #11 ，LocalVariableTable
0x0000 000c : 属性长度为12
0x0001 : local_variable_table_length =1
0x0000 :start_pc = 0
0x0001: length = 1
0x000c : name_index =#12 “this”
0x000d : 描述索引#13 “Lcom/demo/Demo;”
0000 index=0

//到这里为止，方法解析都完成了，回过头看看顶部解析顺序图，我们接下来就要解析Attributes了。

Attribute

0x0001 ：同样的，表示有1个Attributes了。
0x000f : #15(“SourceFile”)
0x0000 0002 attribute_length=2
0x0010 : sourcefile_index = #16(“Demo.java”)
SourceFile属性用来记录生成该Class文件的源码文件名称。

另话

其实，我们写了这么多确实很麻烦，不过这种过程自己体验一遍的所获所得还是不同的。现在，使用java自带的反编译器来解析字节码文件。
javap -verbose Demo //不用带后缀.class

总结

到此为止，讲解完成了class文件的解析，这样以后我们也能看懂字节码文件了。了解class文件的结构对后面进一步了解虚拟机执行引擎非常重要，所以这是基础并重要的一步。

作者：小腊月
链接：https://www.jianshu.com/p/252f381a6bc4
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

---

以上是java字节码的介绍
属于JVM底层的知识

接下来介绍的是java操作字节库的类库有哪些及相关操作

字节码操作

1.Java动态性的两种常见实现方式：

字节码操作
反射

2.运行时操作字节码可以实现如下功能：

动态生成新的类
动态改变某个类的结构(添加/删除/修改 新的属性/方法)

3.优势：

比反射开销小，性能高
Javaasist性能高于反射，低于ASM

常见的字节码操作类库

1.BCEL

Byte Code Engineering Library(BCEL)，这是Apache Software Foundation的Jakarta项目的一部分。BCEL是Java classworking 广泛使用的一种框架，它可以让您深入jvm汇编语言进行类库操作的细节。BCEL与javassist有不同的处理字节码方法，BCEL在实际的jvm指令层次上进行操作(BCEL拥有丰富的jvm指令集支持) 而javassist所强调的是源代码级别的工作。

2.ASM

是一个轻量级Java字节码操作框架，直接涉及到JVM底层的操作和指令
高性能，高质量

3.CGLB(code generation library)

生成类库，基于ASM实现

4.javassist

是一个开源的分析，编辑和创建Java字节码的类库。性能较ASM差，跟cglib差不多，但是使用简单。很多开源框架都在使用它。
主页： http://www.csg.ci.i.u-tokyo.ac.jp/~chiba/javassist/

javassist库的API详解

javassist的最外层的API和java的反射包中的API及其类似

它主要有CtClass, CtMethod,CtField几个类组成，用于执行和JDK反射API中java.lang.Class, java.lang,reflect.Method,java.lang.reflect.Method.Field相同的操作

创建一个类

public class JavassistTest {  
    public static void main(String[] args) throws Exception {  
        ClassPool pool = ClassPool.getDefault();  
        CtClass cc = pool.makeClass("bean.User");  

        //创建属性  
        CtField field01 = CtField.make("private int id;",cc);  
        CtField field02 = CtField.make("private String name;", cc);  
        cc.addField(field01);  
        cc.addField(field02);  

        //创建方法  
        CtMethod method01 = CtMethod.make("public String getName(){return name;}", cc);  
        CtMethod method02 = CtMethod.make("public void setName(String name){this.name = name;}", cc);  
        cc.addMethod(method01);  
        cc.addMethod(method02);  

        //添加有参构造器  
        CtConstructor constructor = new CtConstructor(new CtClass[]{CtClass.intType,pool.get("java.lang.String")},cc);  
        constructor.setBody("{this.id=id;this.name=name;}");  
        cc.addConstructor(constructor);  
        //无参构造器  
        CtConstructor cons = new CtConstructor(null,cc);  
        cons.setBody("{}");  
        cc.addConstructor(cons);  

        cc.writeFile("E:/workspace/TestCompiler/src");  
    }  

} 

方法操作

修改已有的方法体（插入代码到已有方法体）
新增方法
删除方法

$0 $1 $2 $0代表是this, $1代表方法参数的第一个参数，$2代表方法参数的第二个参数，以此类推，$N代表方法参数的第N个
$args The type of $args is OBject[]. $args(0)对应的是$1，不是$0
$$ 一个方法调用的深度
$r 方法返回值的类型
$_ 方法返回值。(修改方法体时不支持)
addCatch() 方法中加入try catch块 $e代表 异常对象
$class this的类型(Class)。也就是$0的类型
$sig 方法参数的类型(Class)数组，数组的顺序。

构造方法操作

getConstructors()

注解操作

public @interface Author{
String name();
int year();
}

@Author(name="over",year=2012)
public class Point{int x,int y;}

CtClass cc=ClassPool.getDefault().get("Point");
Object[] all = cc.getAnnotations();
Author a =(Author)all[0];
String name = a.name();
int year = a.year();
System.out.println(name+":"+year);

局限性

JDK5.0新语法不支持(包括泛型，枚举)，不支持注解修改，但可以通过底层的javassist类来解决，具体参考：javassist,bytecode.annotation
不支持数组的初始化，如String[]{“a”,”b”},除非只有数组的容量为1
不支持内部类和匿名类
不支持continue和break 表达式
对于继承关系，有些不支持 。例如

class A{}
class B extends A{}
Class C extends B{}

查资料： javassist与反射的性能比较

public class Demo01 {  
    //获取类的简单信息  
    public static void test01() throws Exception{  
        ClassPool pool = ClassPool.getDefault();  
        CtClass cc = pool.get("bean.User");  

        //得到字节码  
        byte[] bytes = cc.toBytecode();  
        System.out.println(Arrays.toString(bytes));  

        System.out.println(cc.getName());//获取类名  
        System.out.println(cc.getSimpleName());//获取简要类名  
        System.out.println(cc.getSuperclass());//获取父类  
        System.out.println(cc.getInterfaces());//获取接口  
        System.out.println(cc.getMethods());//获取  
    }  

    //新生成一个方法  
    public static void test02() throws Exception{  
        ClassPool pool = ClassPool.getDefault();  
        CtClass cc = pool.get("bean.User");  

        //第一种  
        //CtMethod cm = CtMethod.make("public String getName(){return name;}", cc);  
        //第二种  
        //参数：返回值类型，方法名，参数，对象  
        CtMethod cm = new CtMethod(CtClass.intType,"add",new CtClass[]{CtClass.intType,CtClass.intType},cc);  
        cm.setModifiers(Modifier.PUBLIC);//访问范围  
        cm.setBody("{return $1+$2;}");  

        //cc.removeMethod(m) 删除一个方法  
        cc.addMethod(cm);  
        //通过反射调用方法  
        Class clazz = cc.toClass();  
        Object obj = clazz.newInstance();//通过调用无参构造器，生成新的对象  
        Method m = clazz.getDeclaredMethod("add", int.class,int.class);  
        Object result = m.invoke(obj, 2,3);  
        System.out.println(result);  
    }  

    //修改已有的方法  
    public static void test03() throws Exception{  
        ClassPool pool  = ClassPool.getDefault();  
        CtClass cc = pool.get("bean.User");  

        CtMethod cm = cc.getDeclaredMethod("hello",new CtClass[]{pool.get("java.lang.String")});  
        cm.insertBefore("System.out.println(\"调用前\");");//调用前  
        cm.insertAt(29, "System.out.println(\"29\");");//行号  
        cm.insertAfter("System.out.println(\"调用后\");");//调用后  

        //通过反射调用方法  
        Class clazz = cc.toClass();  
        Object obj = clazz.newInstance();  
        Method m = clazz.getDeclaredMethod("hello", String.class);  
        Object result = m.invoke(obj, "张三");  
        System.out.println(result);       
    }  

    //修改已有属性  
    public static void test04() throws Exception{  
        ClassPool pool  = ClassPool.getDefault();  
        CtClass cc = pool.get("bean.User");  

        //属性  
        CtField cf = new CtField(CtClass.intType,"age",cc);  
        cf.setModifiers(Modifier.PRIVATE);  
        cc.addField(cf);  
        //增加响应的get set方法  
        cc.addMethod(CtNewMethod.getter("getAge",cf));  
        cc.addMethod(CtNewMethod.setter("setAge",cf));  

        //访问属性  
        Class clazz = cc.toClass();  
        Object obj = clazz.newInstance();         
        Field field = clazz.getDeclaredField("age");  
        System.out.println(field);  
        Method m = clazz.getDeclaredMethod("setAge", int.class);  
        m.invoke(obj, 16);  
        Method m2 = clazz.getDeclaredMethod("getAge", null);  
        Object resutl = m2.invoke(obj,null);          
        System.out.println(resutl);  
    }  

    //操作构造方法  
    public static void test05() throws Exception{  
        ClassPool pool = ClassPool.getDefault();  
        CtClass cc = pool.get("bean.User");  

        CtConstructor[] cons = cc.getConstructors();  
        for(CtConstructor con:cons){  
            System.out.println(con);  
        }  
    }  
    public static void main(String[] args) throws Exception {  
        //test01();  
        //test02();  
        //test03();  
        //test04();  
        test05();  
    }  

}