手写一个简单的JVM--01. 解析Class文件
java的运行过程
在运行一段 java 代码的时候需要经过编译
,验证
,加载
和运行
,具体如下图:
对于 Java 源码变成字节码的编译过程,我们暂且跳过不讨论。
想弄清楚 java 代码的运行原理,其实本质就是 java 字节码如何被 jvm 执行。
下面我们就从两个方面去认识字节码:
- 字节码是什么?
- 字节码如何被执行的?
我们先写一个简单的 java 程序:
1 |
|
对于上面的代码我们可以知道运行的结果是 3,这个结果是怎么被计算出来?
class文件的构成
用java -d .
命令把上面的代码编译成 class 文件,编译后得到 AddMain.class
文件,用文本工具打开后,结果如下图:
上面的数据是一个 16 进制的数据, 对 .class
文件暂且下一个定义,一个存储 16 进制的文件。具体这些 16 进制的内容到底是什么,需要查询具体的虚拟机规范。
class文件的基本结构
根据JVM的虚拟机规范(SE8)提供的资料,class文件
对应的结构体如下:
1 | ClassFile { |
其中u2
和u4
分别代表占用的字节,u2代表占用两个字节,u4代表占用两个字节,cp_info constant_pool[constant_pool_count-1]
代表是数组
对应的结构图如下:
{:height=”200px” width=”200px”}
在我们了解了class的结构之后,就可以开始试着解析class文件。
4. 解析过程
对于类的解析过程,如果了解类的结构,则就是工作量的事情,如果对类的结构很熟悉的同学,可以跳过本节
文件的读取
对于解析文件过程,第一步首先是读取文件,我们以 DataInputStream 的流的形式把数据读入内存中,代码如下:
1 | private DataInputStream dataInputStream; |
在上面的操作中,我们把类的文件成功的转换成流文件 DataInputStream
,我们是类文件是按照顺序读取的,所以可以定义的游标的对象 cursor
来读取,对 cursor
可以封装几个读取的方法:
1 | public void readFully(byte[] byteArr) throws IOException { |
获得魔数
Java中的魔数
是一个固定的值cafe babe
,一共占用 4 个字节,我们可以通过简单的方式把魔数取出来:
1 | byte[] byteArr=new byte[4]; |
对应16进制转字符的方法:
1 | public static String binaryToHexString(byte[] bytes) { |
打印结果为:CAFE BABE
获得jdk版本
得到简单的魔数后,我们在向后面解析 4 个字节。
从开始的类结构图上可以看出,文件的内容是:0000 0034
Jdk 的 minor_version 和 major_version 版本号是分别占用两个字节,正好是一个 UnsignedShort 的长度,我们使用readUnsignedShort
读取。
1 | minor_version = cursor.readUnsignedShort(); |
得到的结果分别是:
1 | minor_version=0, major_version=52 |
{:height=”600px” width=”600px”}
对比上面的版本号可以看出,笔者的jdk的版本是1.8
常量池
对于常量池来说,是一个数组结构的类型变量,首先我们需要读取数组的长度 constant_pool_count
,根据类的结构,可以得到对应的长度信息:
1 | constant_pool_count= cursor.readUnsignedShort(); |
很明显是0x0024
转成十进制的值为 36 。
在这里需要注意一点的是,此处的常量池的数组个数是 35,与正常的 java 的数组的使用习惯不同,此处的索引是从 1 开始。
在知道常量池的个数后,我们还需要知道常量池中的常量
到底是什么?
在JVM中常量主要分为两类,一种是字面量,如文本字符串,声明为 final 类型的常量值。 另一种是属于符号引用,如:类和接口全限定名,字段的描述等等。
根据上面的大类,我们可以查阅 Jvm 的虚拟机规范,可以看到常量池单元在虚拟机中定义基本结构如下:
1 | cp_info { |
其中tag代表类型类型,后面 info[] 项的内容 tag 由的类型所决定。 tag 对应的类型如下:
</img src=”/img/classReader/05.png” alt=”tag” style=”zoom:40%;” />
对于上面的常量的类型,我们依次看下:
解析常量池
在解析常量池之前我们可以通过javap -v
命令来查看对应的常量池:
这个图片我们先保留,作为我们后面查询的依据。
对于常量池的解析,我们先来一个简单的设计,通过上面的魔数,版本号的获取,加上我们即将要解析的常量池,我们可以简单的定义一个类结构如下(ClassParseInfo,后续还会加字段):
1 | public class ClassParseInfo { |
其中ConstantPool
是常量池,我们知道所有的常量的类型都满足cp_info
结构,所以我们可以简单定义一个基类:
1 |
|
而ConstantPool
类的结构应该为:
1 | public class ConstantPool { |
下面我们就先认识下各个常量池的类型:
CONSTANT_Class
CONSTANT_Class 结构用于表示类和接口,具体的格式如下:
1 | CONSTANT_Class_info { |
- tag代表CONSTANT_Class的tag值7
- name_index 是常量池中的一个索引
对应的解析类的代码:
1 | public class CONSTANT_Class_info extends CPInfo { |
CONSTANT_Fieldref_info, CONSTANT_Methodref_info 和 CONSTANT_InterfaceMethodref_info 结构
这三个的类型的结构基本一致:
1 | CONSTANT_Fieldref_info { |
1 | CONSTANT_Methodref_info { |
1 | CONSTANT_InterfaceMethodref_info { |
tag 分别代表三个类型的标记值,CONSTANT_Fieldref(9),CONSTANT_Methodref(10)和CONSTANT_InterfaceMethodref(11)
class_index
Class_index 代表是常量池的引用,从名字上面可以看出,常量池在此处的引用必须要是 类或者是接口的类型。
CONSTANT_Fieldref_info
结构的 class_index 项的类型既可以是 类也可以是接口。CONSTANT_Methodref_info
结构的 class_index 项的类型必须是类(不能是接口)。CONSTANT_InterfaceMethodref_info` 结构的 class_index 项的类型必须是接口 (不能是类)。
name_and_type_index
这个代表是当前常量类型的name和type类型的索引,可以通过这个索引知道当前类的索引值。
解析类的代码
1 |
|
CONSTANT_String_info
CONSTANT_String_info代表java.lang.String
类型的常量对象,格式如下:
1 | CONSTANT_String_info { |
string_index
string_index 项的值必须是对常量池的有效索引,常量池在该索引处的项必须是 CONSTANT_Utf8_info结构, 代表一个字符串
解析类的代码如下:
1 |
|
CONSTANT_Integer_info 和 CONSTANT_Float_info 结构
1 | CONSTANT_Integer_info { |
bytes
CONSTANT_Integer_info 结构的 bytes 项表示 int 常量的值.
CONSTANT_Float_info 表示 float 常量的值
对于 CONSTANT_Float_info 的表示方法比较特殊,此处不再深究,只需要记录二进制的数据。解析代码
1 |
|
1 |
|
CONSTANT_Long_info 和 CONSTANT_Double_info 结构
CONSTANT_Long_info 和 CONSTANT_Double_info 结构表示 8 字节(long 和 double)的数值常量:
1 | CONSTANT_Long_info { |
如果一个 CONSTANT_Long_info 或 CONSTANT_Double_info 结构的项在常量池中的索引为 n,则常量池中下一个有效的项的索引为 n+2,此时常量池中索引为 n+1 的项有效但必须被认为不可用 。
high_bytes 和 low_bytes
在CONSTANT_Long_info的结构中,无符号的highbyte和low_bytes共同来表示当前常量的值,具体算法为 high_bytes<<32+low_bytes
CONSTANT_Double_info的计算方法此处不做深究。
解析代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class CONSTANT_Long_info extends CPInfo {
private long longValue;
public CONSTANT_Long_info(ClassReadCursor cursor) throws IOException {
super(ConstantPoolType.CONSTANT_Long);
longValue = cursor.readLong();
}
}
public class CONSTANT_Double_info extends CPInfo {
private double douleValue;
public CONSTANT_Double_info(ClassReadCursor cursor) throws IOException {
super(ConstantPoolType.CONSTANT_Double);
this.douleValue = cursor.readDouble();
}
}
CONSTANT_NameAndType_info 结构
CONSTANT_NameAndType_info 结构用于表示字段或方法.
1 | CONSTANT_NameAndType_info { |
Name_index
代表当前方法的名称,表示特殊的方法名
或者表示一个有效的字段或方法的非限定名(Unqualified Name)。 Decriptor_index
当前方法或者字段描述的索引值。
1
2
3
4
5
6
7
8
9public class CONSTANT_NameAndType_info extends CPInfo {
private int name_inex;
private int descriptor_index;
public CONSTANT_NameAndType_info(ClassReadCursor cusor) throws IOException {
super(ConstantPoolType.CONSTANT_NameAndType);
this.name_inex = cusor.readUnsignedShort();
this.descriptor_index = cusor.readUnsignedShort();
}
}
CONSTANT_Utf8_info 结构
CONSTANT_Utf8_info 结构用于表示字符串常量的值:
1 | CONSTANT_Utf8_info { |
length
length表示当前字符串的字节长度
bytes[]
bytes[]是表示字符串值的 byte 数组,bytes[]数组中每个成员的 byte 值都不会是 0, 也不在 0xf0 至 0xff 范围内。解析代码
1
2
3
4
5
6
7
8
9
10
11
12public class CONSTANT_Utf8_info extends CPInfo {
private int length;
private String text;
public CONSTANT_Utf8_info(ClassReadCursor cusor) throws IOException {
super(ConstantPoolType.CONSTANT_Utf8);
text=cusor.readUTF();
}
public String getText() {
return text;
}
}
CONSTANT_MethodHandle_info 结构
CONSTANT_MethodHandle_info 结构用于表示方法句柄,结构如下:
1 | CONSTANT_MethodHandle_info { |
reference_kind
reference_kind 项的值必须在 1 至 9 之间(包括 1 和 9),它决定了方法句柄的类型。
方法句柄类型的值表示方法句柄的字节码行为
reference_index
reference_index 项的值必须是对常量池的有效索引:
如果 reference_kind 项的值为 1(REF_getField)、2(REF_getStatic)、3
(REF_putField)或 4(REF_putStatic),那么常量池在 reference_index 索引处的项必须是 CONSTANT_Fieldref_info(§4.4.2)结构,表示由一个字 段创建的方法句柄。
如果 reference_kind 项的值是 5(REF_invokeVirtual)、6 (REF_invokeStatic)、7(REF_invokeSpecial)或 8 (REF_newInvokeSpecial),那么常量池在 reference_index 索引处的项必须 是 CONSTANT_Methodref_info(§4.4.2)结构,表示由类的方法或构造函数 创建的方法句柄。
如果 reference_kind 项的值是 9(REF_invokeInterface),那么常量池在 reference_index 索引处的项必须是 CONSTANT_InterfaceMethodref_info (§4.4.2)结构,表示由接口方法创建的方法句柄。
如果 reference_kind 项的值是 5(REF_invokeVirtual)、6 (REF_invokeStatic)、7(REF_invokeSpecial)或 9 (REF_invokeInterface),那么方法句柄对应的方法不能为实例初始化(
) 方法或类初始化方法( )。 如果 reference_kind 项的值是 8(REF_newInvokeSpecial),那么方法句柄对应的方法必须为实例初始化(
)方法。
解析代码
1
2
3
4
5
6
7
8
9
10
11
public class CONSTANT_MethodHandle_info extends CPInfo {
private int reference_kind;
private int reference_index;
public CONSTANT_MethodHandle_info(ClassReadCursor cursor) throws IOException {
super(ConstantPoolType.CONSTANT_MethodHandle);
reference_kind=cursor.readUnsignedByte();
reference_index=cursor.readUnsignedShort();
}
}
CONSTANT_MethodType_info
CONSTANT_MethodType_info 表示方法类型,具体结构如下:
1 | CONSTANT_MethodType_info { |
descriptor_index
descriptor_index 项的值必须是对常量池的有效索引,常量池在该索引处的项必须是 CONSTANT_Utf8_info(§4.4.7)结构,表示方法的描述符解析代码:
1
2
3
4
5
6
7
8
9
10
public class CONSTANT_MethodType_info extends CPInfo
{
private int descriptor_index;
public CONSTANT_MethodType_info(ClassReadCursor cursor) throws IOException {
super(ConstantPoolType.CONSTANT_MethodType);
descriptor_index=cursor.readUnsignedShort();
}
}
CONSTANT_InvokeDynamic_info 结构
CONSTANT_InvokeDynamic_info 用于表示 invokedynamic 指令所使用到的引导方法 (Bootstrap Method)、引导方法使用到动态调用名称(Dynamic Invocation Name)、参 数和请求返回类型、以及可以选择性的附加被称为静态参数(Static Arguments)的常量序列。
1 | CONSTANT_MethodType_info { |
bootstrap_method_attr_index
bootstrap_method_attr_index 项的值必须是对当前 Class 文件中引导方法表的 bootstrap_methods[]数组的有效索引。
name_and_type_index
name_and_type_index项的值必须是对当前常量池的有效索引,常量池在该索引处的 项必须是 CONSTANT_NameAndType_info结构,表示方法名和方法描述符
解析代码:
1
2
3
4
5
6
7
8
9
10
11
12public class CONSTANT_InvokeDynamic_info extends CPInfo {
private int bootstrap_method_attr_index;
private int name_and_type_index;
public CONSTANT_InvokeDynamic_info(ClassReadCursor cursor) throws IOException {
super(ConstantPoolType.CONSTANT_InvokeDynamic);
bootstrap_method_attr_index = cursor.readUnsignedShort();
name_and_type_index = cursor.readUnsignedShort();
}
}
经过上面的解读,我们可以写常量池解析的代码了
- 根据tag进入不同的构造函数
- 有一个公共的基类cp_info
我们可以使用最简单的switch-case的形式来写:
1 |
|
访问标记
在访问限定的修饰符中,有public,private
等限定修饰词,标记和修饰符对应的关系如下:
1 |
|
我们可以简单的使用读取无符号的整型来获取对应的访问标记,我们在类ClassParseInfo加一个access_flag字段:
1 | private final int access_flag; |
1 | access_flag=cr.readUnsignedShort(); |
得到数值为0x00021
。分别与上面的类型做&
运算,得到访问的标记ACC_PUBLIC,
ACC_SUPER`
类索引和父类索引
类索引是指当前类的在常量池中对应的位置,索引对应的位置一定是CONSTANT_Class_info
父类索引是当前类父类对应的位置,如果当前类有父类,则会显示当前的类在常量池的所以。如果没有父类,也会有一个基本的父类Object
.
ClassParseInfo再加两个字段:
1 | public final int this_class; |
对应的解析代码:
1 | this_class = cursor.readUnsignedShort(); |
得到的值是4和5。我们根据索引查到对应的值为两个CONSTANT_Class_info
数据:
1 | { |
查看28,29对应的数据,分别为org/rz/AddMain
和java/lang/Object
:
接口的数量和接口
demo中的接口的数量为0,所以我们不用获取interface.
字段
每个字段(Field)都由 field_info 结构所定义,在同一个 Class 文件中,不会有两个字 段同时具有相同的字段名和描述符。
field_info 结构格式如下:
1 | field_info { |
access_flags
access_flags 项的值是用于定义字段被访问权限和基础属性的掩码标志。
具体的类型如下:
| 标记名 | 值 | 说明 |
| ——————-| ———| —————————————————-|
| ACC_PUBLIC | 0x0001 | public,表示字段可以从任何包访问。 |
| ACC_PRIVATE | 0x0002 | private,表示字段仅能该类自身调用。 |
| ACC_PROTECTED | 0x0004 | protected,表示字段可以被子类调用。 |
| ACC_STATIC | 0x0008 | static,表示静态字段。 |
| ACC_FINAL | 0x0010 | final,表示字段定义后值无法修改 |
| ACC_VOLATILE | 0x0040 | volatile,表示字段是易变的。 |
| ACC_TRANSIENT | 0x0080 | transient,表示字段不会被序列化。 |
| ACC_SYNTHETIC | 0x1000 | 表示字段由编译器自动产生。 |
| ACC_ENUM | 0x4000 | enum,表示字段为枚举类型。 |name_index
name_index 项的值必须是对常量池的一个有效索引。常量池在该索引处的项必须是 CONSTANT_Utf8_info结构,表示一个有效的字段的非全限定名。- descriptor_index
descriptor_index 项的值必须是对常量池的一个有效索引。常量池在该索引处的项必 须是 CONSTANT_Utf8_info结构,表示一个有效的字段的描述符。 - attributes_count
attributes_count 的项的值表示当前字段的附加属性的数量。 - attributes[]
attributes 表的每一个成员的值必须是 attribute结构(后续会单独讨论)
方法
所有方法(Method),包括实例初始化方法和类初始化方法在内,都由 method_info 结构所定义。在一个 Class 文件中,不会有两个方法同时具有相同的方法名和描述符。
method_info 结构格式如下:
1 | method_info { |
access_flags
access_flags 项的值是用于定义当前方法的访问权限和基本属性的掩码标志.具体标记如下:
| 标记名 | 值 | 说明 |
| ————————| ———| ———————————————————|
| ACC_PUBLIC | 0x0001 | public,方法可以从包外访问 |
| ACC_PRIVATE | 0x0002 | private,方法只能本类中访问 |
| ACC_PROTECTED | 0x0004 | protected,方法在自身和子类可以访问 |
| ACC_STATIC | 0x0008 | static,静态方法 |
| ACC_FINAL | 0x0010 | final,方法不能被重写(覆盖) |
| ACC_SYNCHRONIZED | 0x0020 | synchronized,方法由管程同步 |
| ACC_BRIDGE | 0x0040 | bridge,方法由编译器产生 |
| ACC_VARARGS | 0x0080 | 表示方法带有变长参数 |
| ACC_NATIVE | 0x0100 | native,方法引用非 java 语言的本地方法 |
| ACC_ABSTRACT | 0x0400 | abstract,方法没有具体实现 |
| ACC_STRICT | 0x0800 | strictfp,方法使用 FP-strict 浮点格式 |
| ACC_SYNTHETIC | 0x1000 | 方法在源文件中不出现,由编译器产生 |
name_index
name_index 项的值必须是对常量池的一个有效索引。常量池在该索引处的项必须是 CONSTANT_Utf8_info结构,它要么表示初始化方法的名字(或 ),要么表示一个方法的有效的非全限定名 descriptor_index
descriptor_index 项的值必须是对常量池的一个有效索引。常量池在该索引处的项必 须是 CONSTANT_Utf8_info结构,表示一个有效的方法的描述符attributes_count
表示附加属性的数量attributes[]
与字段附加属性一致。
属性
属性在 Class 文件格式中的 ClassFile结构、field_info结构,method_info结构和 Code_attribute结构都有使用,所有属性的通用格式如下:
1 | attribute_info { |
其中attribute_name_index代表当前属性在常量池中的索引,我们获得对应的名称后,可以匹配到对应类型的属性。属性的类型主要有:
1 | public class AttributeType { |
上面的这么多类型,我们只需要挑几个比较常用的重点说下,至于完整的可以参考JVM规范。
ConstantValue 属性
ConstantValue 属性表示一个常量字段的值。 具体的数据结构如下:
1 | ConstantValue_attribute { |
attribute_name_index
attribute_name_index 项的值,必须是一个对常量池的有效索引。
attribute_length
ConstantValue_attribute 结构的 attribute_length 项的值固定为 2。constantvalue_index
constantvalue_index 项的值的索引。常量池在该索引处 的项给出该属性表示的常量值。constantvalue_index的类型一共分为下面几种:| 字段类型 | 项类型 |
| —————————————-| ————————|
| long | CONSTANT_Long |
| float | CONSTANT_Float |
| double | CONSTANT_Double |
| int,short,char,byte,boolean | CONSTANT_Integer |
| String | CONSTANT_String |对应的解析代码如下:
1
2
3
4
5
6
7
8public class ConstantValue_attribute extends Attribute {
private int constantvalue_index;
private int constantvalue;
public ConstantValue_attribute(ClassReadCursor cursor, int attribute_index) throws IOException {
super(ConstantValue, attribute_index, cursor.readInt());
constantvalue_index = cursor.readUnsignedShort();
}
}
Code属性
Code 属性是一个变长属性,位于 method_info结构的属性表,记录的方法的字节码指令及相关辅助信息。code的结构如下:
1 | Code_attribute { |
code 中有几个需要注意的属性如下:
- max_stack
max_stack 项的值给出了当前方法的操作数栈在运行执行的任何时间点的最大深度 max_locals
max_locals 项的值给出了分配在当前方法引用的局部变量表中的局部变量个数,包括 调用此方法时用于传递参数的局部变量。
long 和 double 型的局部变量的最大索引是 max_locals-2,其它类型的局部变量的 最大索引是 max_locals-1.max_stack和max_locals在编译期就已经能够确定了。
attribute_info
attribute_info是code属性的属性。可以出现在 Code 属性的属性表中的成员只能是 LineNumberTable,LocalVariableTable,LocalVariableTypeTable和StackMapTable
解析代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public class Code_attribute extends Attribute {
private int max_stack;
private int max_locals;
private int code_length;
private int exception_table_length;
private int attributes_count;
private byte[] code;
private byte[] paraCode;
private Opcode[] opcodeArr;
private ExceptionTable[] exceptionTables;
private Attribute[] attributes;
public Code_attribute(ClassReadCursor cursor, int attrTag) throws Exception {
super(AttributeType.Code, attrTag, cursor.readInt());
max_stack = cursor.readUnsignedShort();
max_locals = cursor.readUnsignedShort();
code_length = cursor.readInt();
if (code_length > 0) {
code = new byte[code_length];
cursor.readFully(code);
opcodeArr = new Opcode[code_length];
paraCode=new byte[code_length];
}
int index=0;
int paraIndex=0;
for (int i = 0; i < code_length; i++) {
byte bCode = code[i];
Opcode opcode = Opcode.valueOf(Byte.toUnsignedInt(bCode));
opcodeArr[index++] = opcode;
if(opcode.operandCount>0){
for (int j = 0; j < opcode.operandCount; j++) {
paraCode[paraIndex++]=code[i+j+1];
}
}
i += opcode.operandCount;
}
exception_table_length = cursor.readUnsignedShort();
if (exception_table_length > 0) {
exceptionTables = new ExceptionTable[exception_table_length];
for (int i = 0; i < exception_table_length; i++) {
int start_pc = cursor.readUnsignedShort();
int end_pc = cursor.readUnsignedShort();
int handler_pc = cursor.readUnsignedShort();
int catch_type = cursor.readUnsignedShort();
this.exceptionTables[i] = new ExceptionTable(start_pc, end_pc, handler_pc, catch_type);
}
}
attributes_count = cursor.readUnsignedShort();
if (attributes_count > 0) {
attributes = new Attribute[attributes_count];
for (int i = 0; i < attributes_count; i++) {
Attribute attribute = AttributeFactory.create(cursor);
attributes[i] = attribute;
}
}
}
}code属性解析完成后是一个16进制的数字,这时候就需要对应的指令来映射出对应的代码。 例如:
0x03-->iconst_0
,很多指令后面还会跟上几位参数
,如if_icmpeq
,后面的两位都是参数。
StackMapTable
StackMapTable属性主要用于字节码的验证,是类型检测器(Type Checker)会检查和处理目标方法的局部变量和操作数栈所需要的类型。 对于我们运行字节码作用不大,我们知道能正常解析出属性即可,对应的数据结构如下:
1 | StackMapTable_attribute { |
其中比较复杂的stack_map_frame这个还有很多数据接口,此处不一一列举,后面直接贴出解析代码:
1 |
|
Exceptions 属性
Exceptions 属性指出了一个方法需要检查的可能抛出的异常。一个 method_info 结构中最多只能有一个 Exceptions 属性。
Exceptions 属性格式如下:
1 | Exceptions_attribute { |
attribute_length
attribute_length 项的值给出了当前属性的长度,不包括开始的 6 个字节。
number_of_exceptions
number_of_exceptions 项的值给出了 exception_index_table[]数组中成员的数量。
exception_index_table[]
exception_index_table[]数组的每个成员的值都必须是对常量池的有效索引。常量 池在这些索引处的成员必须都是 CONSTANT_Class_info结构,表示这个 方法声明要抛出的异常的类的类型。
一个方法如果要抛出异常,必须至少满足下列三个条件中的一个:
- 要抛出的是 RuntimeException 或其子类的实例。
- 要抛出的是 Error 或其子类的实例。
- 要抛出的是在 exception_index_table[]数组中申明的异常类或其子类的实例。 这些要求没有在 Java 虚拟机中进行强制检查,它们只在编译时进行强制检查
SourceFile属性
SourceFile属性表示当前类的源码路径,具体结构如下:
1 | SourceFile_attribute { |
在上面的Javap命令中有体现:SourceFile: "AddMain.java"
,此处不再赘述。具体解析的代码如下:
1 |
|
LineNumberTable属性
LineNumberTable 属性是可选变长属性,位于 Code结构的属性表。它被调试器用于确定源文件中行号表示的内容在 Java 虚拟机的 code[]数组中对应的部分。
在 Code 属性 的属性表中,LineNumberTable 属性可以按照任意顺序出现,此外,多个 LineNumberTable 属性可以共同表示一个行号在源文件中表示的内容,即 LineNumberTable 属性不需要与源文件 的行一一对应。
1 | LineNumberTable_attribute { |
line_number_table[]
line_number_table[]数组的每个成员都表明源文件中行号的变化在 code[]数组中 都会有对应的标记点。line_number_table 的每个成员都具有如下两项:
start_pc
start_pc 项的值必须是 code[]数组的一个索引,code[]数组在该索引处的字符 表示源文件中新的行的起点。start_pc 项的值必须小于当前 LineNumberTable 属性所在的 Code 属性的 code_length 项的值。
line_number
line_number 项的值必须与源文件的行数相匹配。
LocalVariableTable属性
被调试器用于确定方法在执行过程中局部变量的信息。具体的结构如下:
1 | LocalVariableTable_attribute { |
local_variable_type_table[]数组的每一个成员表示一个局部变量的值在 code[] 数组中的偏移量范围
local_variable_type_table[]
local_variable_table[]数组的每一个成员表示一个局部变量的值在 code[] 数组中的偏移量范围。它同时也是用于从当前帧的局部变量表找出所需的局部变量的索引
具体的解析代码如下:
1 |
|
对于上面的字段,方法和属性的解析,我们对ClassParseInfo再增加几个字段,变成:
1 | public final String magic; |
JVM的运行
Java字节码的文件我们已经解析完了,首先看下我们解析出来方法的指令:
1 | 0 "iconst_1" |
对比下javap指令生成的数据:
通过上面的操作,我们实现了对class文件的解析,并得到了常量池和JVM的相关指令。
手写一个简单的JVM--01. 解析Class文件