初探JVM字节码

作者: LemonNan
原文地址: https://juejin.im/post/6885658003811827725
代码地址: https://github.com/LemonLmNan/ByteCode

字节码

概述

本篇要介绍的是能 “一次编译,到处运行的 JVM 字节码”

为什么能到处运行?

是因为在 任意平台下所编译出来的 class文件都遵循相同的字节码规范, 运行期间 不同平台的 JVM 解析相同的 class文件 能解析出特定于该平台的机器码以供使用.

本文大致介绍

1.字节码文件的结构

2.手动解析class文件的字节码, 解析出对应的信息

这里我在解析的时候, 借助到了一个 IDEA 的插件 jclasslib(不得不说, 真香) , 这个插件能极大的加快手动解析的效率, 毕竟可以校验数据的正确性.

当然, java已经提供了对应的命令供查看

javap -verbose xxx.class

class 文件结构简析

以下结构来自 Oracle 官方文档

ClassFile {
    u4             magic;                       // 魔数, class文件的固定开头, cafebabe 开头的文件jvm才会尝试去解析, 4字节
    u2             minor_version;               // 小版本, 2字节
    u2             major_version;               // 大版本 比如 1.8, 2字节
    u2             constant_pool_count;         // 常量池大小
    cp_info        constant_pool[constant_pool_count-1];    // 常量池数组
    u2             access_flags;                // 类的描述符
    u2             this_class;                  // 描述类自身的索引
    u2             super_class;                 // 父类的索引
    u2             interfaces_count;            // 接口数量
    u2             interfaces[interfaces_count];    // 接口数组
    u2             fields_count;                // 字段数量
    field_info     fields[fields_count];        // 字段数组
    u2             methods_count;               // 方法数量
    method_info    methods[methods_count];      // 方法数组
    u2             attributes_count;            // 基本信息数量
    attribute_info attributes[attributes_count];    // 基本信息数组
}

1.魔数（Magic Number）

所有的.class文件的前四个字节都是魔数，魔数的固定值为：0xCAFEBABE。魔数放在文件开头，JVM可以根据文件的开头来判断这个文件是否可能是一个.class文件，如果是，才会继续进行之后的操作。

2.版本号

魔数后面的4个字节表示将文件 编译成 class文件 的 JVM版本号, 前两个字节为 次版本号 , 后面两字节为 主版本号, 比如 1.8, 在这里是 16 进制的值, 比如我电脑上的1.8.0(通过 java -version 查看), 用该 JVM 编译出来的class文件, 在版本号这里就会显示 0000 0034.

16进制的 0034 转成十进制为 3*16^1 + 4= 52, 正好对应官网上的大版本 1.8, 加上前面的00, 表示 1.8.0 的版本号.

3.常量池（Constant Pool）

常量池整体上分为两部分: 常量池计数器以及常量池数据区, 数据区存储两类常量: 字面量和符号饮用, 字面量就是Java中的直接量, 比如 “12345” 和 12345 这一类, 符号引用比如字段、方法、类的一些描述信息.

• 常量池计数器 (count, 表示有 count 个常量)
• 常量池数据区 (count 个 cp_info 结构, 有14种类型 cp_info 结构)

14种 cp_info 类型

类型	tag 值	字段及大小	描述
CONSTANT_Utf8_info	1	CONSTANT_Utf8_info { u1 tag; u2 length; u1 bytes[length]; }	utf8 编码的字符串
CONSTANT_Integer_info	3	CONSTANT_Integer_info { u1 tag; u4 bytes; }	整形
CONSTANT_Float_info	4	CONSTANT_Float_info { u1 tag; u4 bytes; }	浮点型
CONSTANT_Long_info	5	CONSTANT_Long_info { u1 tag; u4 high_bytes; u4 low_bytes; }	长整型
CONSTANT_Double_info	6	CONSTANT_Double_info { u1 tag; u4 high_bytes; u4 low_bytes; }	双精度浮点型
CONSTANT_Class_info	7	CONSTANT_Class_info { u1 tag; u2 name_index; }	class
CONSTANT_String_info	8	CONSTANT_String_info { u1 tag; u2 string_index; }	字符串
CONSTANT_Fieldref_info	9	CONSTANT_Fieldref_info { u1 tag; u2 class_index; u2 name_and_type_index; }	字段的类型
CONSTANT_Methodref_info	10	CONSTANT_Methodref_info { u1 tag; u2 class_index; u2 name_and_type_index; }	方法的类型
CONSTANT_InterfaceMethodref_info	11	CONSTANT_InterfaceMethodref_info { u1 tag; u2 class_index; u2 name_and_type_index; }	接口方法
CONSTANT_NameAndType_info	12	CONSTANT_NameAndType_info { u1 tag; u2 name_index; u2 descriptor_index; }	名称和类型的
CONSTANT_MethodHandle_info	15	CONSTANT_MethodHandle_info { u1 tag; u1 reference_kind; u2 reference_index; }	方法句柄
CONSTANT_MethodType_info	16	CONSTANT_MethodType_info { u1 tag; u2 descriptor_index; }	方法类型
CONSTANT_InvokeDynamic_info	18	CONSTANT_InvokeDynamic_info { u1 tag; u2 bootstrap_method_attr_index; u2 name_and_type_index; }	invokedynamic是1.7后为jvm上的动态类型语言量身定制的, 1.8上还被用到了lambda上.

4.访问标志

在 class文件的结构里, 访问标志(Access_Flag)表示的是该类的一些访问标志, 访问标志有以下的类型可选, 如果一个类符合多个 Access_Flag 类型, 则该值是多个类型值进行逻辑与.

比如一个 public final 的类, 该类的 Access_Flag 值为 0x0001 | 0x0010 = 0x0011.

Flag Name	Value	Interpretation
ACC_PUBLIC	0x0001	public类
ACC_FINAL	0x0010	final类
ACC_SUPER	0x0020	如果设置了这个值, 则调用父类方法的时候会搜索类层次, 找到最近的一个父类方法进行调用.
ACC_INTERFACE	0x0200	interface, 接口
ACC_ABSTRACT	0x0400	abstract 类
ACC_SYNTHETIC	0x1000	synthetic, 不存在于源代码，由编译器生成
ACC_ANNOTATION	0x2000	注解类
ACC_ENUM	0x4000	枚举类

5.当前类 - this_class

访问标志后的两个字节，描述的是当前类的全限定名。这两个字节保存的值为常量池中的索引值，根据索引值就能在常量池中找到这个类的全限定名。

6.父类 - super_class

当前类名后的两个字节，描述父类的全限定名，同上，保存的也是常量池中的索引值。

7.接口信息 - interfaces_count & interfaces[interfaces_count]

父类名称后为两字节的接口计数器，描述了该类或父类实现的接口数量.

后面是 interfaces_count 个接口, 需要根据class文件的格式进行解析.

8.字段表 - fields_count & fields[fields_count]

字段表用于描述类和接口中声明的变量，包含类级别的变量以及实例变量，但是不包含方法内部声明的局部变量。字段表也分为两部分，第一部分为两个字节，描述字段个数；第二部分是每个字段的详细信息fields_info。字段表结构如下图所示：

// fields_info 结构, 表示每一个字段的结构
field_info {
    u2             access_flags;	// 字段的访问权限和属性
    u2             name_index;		// 字段名索引, 名称的常量在 constant_pool 中的索引, 在 constant_pool 中显示该字段的名称
    u2             descriptor_index;	// 这个表示字段的类型索引, 指向一个在 constant_pool 中的常量
    u2             attributes_count;	// 字段的基本属性数量
    attribute_info attributes[attributes_count];	// 字段的基本属性数组
}

fields_info 里的 access_flags 选项, 表示字段的访问权限和属性

Flag Name	Value	Interpretation
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	synthetic, 不存在于源代码，由编译器生成
ACC_ENUM	0x4000	enum

ext

在java中获取字段的类型, 可以通过以下的代码获取

// test1 是类 ByteCodeDemo 中的一个字段, 
// 注意使用这个的时候, 要有get 和 set 方法, 否则会抛异常:
// Exception in thread "main" java.beans.IntrospectionException: Method not found: isTest1(read)/ Method not found: setTest1(write), 源码里面默认的话是用 is+字段名首字母大写 和 get+字段名首字母大写 去判断 read 方法
// 这个是 ByteCodeDemo 类里的一个字段 test1
private String test1 = "12345";
// 下面是获取字段类型代码
PropertyDescriptor descriptor = new PropertyDescriptor("test1", ByteCodeDemo.class);
Class clazz = descriptor.getPropertyType();
// 输出 "class java.lang.String"
System.out.println(clazz);

9.方法表 - methods_count & methods[methods_count]

字段表结束后为方法表，方法表也是由两部分组成，第一部分为两个字节描述方法的个数；第二部分为每个方法的详细信息。方法的详细信息较为复杂，包括方法的访问标志、方法名、方法的描述符以及方法的属性，如下图所示：

// 描述方法的结构
method_info {
    u2             access_flags;	// 方法的访问标志
    u2             name_index;		// 方法名称的索引
    u2             descriptor_index;	// 方法类型的索引
    u2             attributes_count;	// attribute 数量
    attribute_info attributes[attributes_count];	// attribute 数组 
}

方法的访问标志 access_flags

Flag Name	Value	Interpretation
ACC_PUBLIC	0x0001	public
ACC_PRIVATE	0x0002	private
ACC_PROTECTED	0x0004	protected
ACC_STATIC	0x0008	static
ACC_FINAL	0x0010	final
ACC_SYNCHRONIZED	0x0020	synchronized, 使用 monitor 监视器实现
ACC_BRIDGE	0x0040	桥接方法
ACC_VARARGS	0x0080	方法是否接受不定参数
ACC_NATIVE	0x0100	native, 使用其它语言实现的方法
ACC_ABSTRACT	0x0400	abstract, 抽象方法
ACC_STRICT	0x0800	浮点模式, JDk 1.1以及之前版本的编译器是 非FP-strict模式
ACC_SYNTHETIC	0x1000	源代码不存在, 由编译器生成

10.基本属性表 - attributes_count & attributes[attributes_count]

字节码的最后一部分，存放了在该class文件中类或接口所定义属性的基本信息。

解析

上面说了一大堆, 接下来开始尝试解析一个class文件, 这里解析class 是根据 class 文件下的数据结构一路解下来, 并 没有什么特殊的技巧 .

这里的话是要是字节的读取, 在这里我主要用到了两个类: ByteInfo 和 Utils (这两个类是后来才放进 common 包里的, 之前只是单纯的放外面)

最终成果图

下面是java代码解析出来的数据.

插件

右边是一个 IDEA 中一个 jclasslib 的插件, 这里就不介绍怎么安装了.

这个插件的很大一个作用是 方便校验自己解析的是否正确.

流程里的一个🌰

下面是代码里大致的流程, 最后的可读字节数是为了查看校验是否解析完了.

从 analy 这里看流程还算是比较清楚的, 一个结构一个结构的解析, 跟 oracle 官方的结构能一一对上.

首先是魔数 magic, 它在class 文件的开头, 占用 4个字节, 而用16进制来表现的话, 它的值就是 “ca fe ba be”, 16进制两位表示一个字节, 下面是魔数的一个解析, 用 JDK的Integer转成16进制的字符串. Integer.toHexString(bytes[i] & 0xFF)

    /**
     * 魔数
     * @throws Throwable
     */
    void magic()throws Throwable{
        String magicString = ByteInfo.readHexString(4);
        if(!"cafebabe".equals(magicString)){
            throw new ClassFormatError("magic");
        }
        this.magic = magicString;
    }

版本号和常量池里的常量数量, 常量池存放在 ConstantPool 中, 里面用一个map存储, index 作为 key, 下面是解析代码.

    /**
     * 版本
     * @throws Throwable
     */
    void version()throws Throwable{
        int minorVersion = ByteInfo.readInt(2);
        this.minor_version = minorVersion;

        int majorVersion = ByteInfo.readInt(2);
        this.major_version = majorVersion;
    }

    /**
     * 常量池里常量的数量
     * @throws Throwable
     */
    void constantPoolCount()throws Throwable{
        int cp_count = ByteInfo.readInt(2);
        this.constant_pool_count = cp_count;
	      // 实际上是 n-1 个常量
        ConstantPool.init((cp_count - 1) << 1);
    }

		// 常量池常量, 部分解析见下图
		public ConstantPoolEntry(int cp_index){
        this.cp_index = cp_index;
        map.put("index", cp_index);
    }

部分常量的解析

Method

Attributes

所有 Attributes 的通用字段

根据常量池里的值, 解析成不同的Attributes

其中的一个 LineNumberTable_attribute

代码太多不在这里一一列举了, 想看看作者朴实无华的代码可以到下面这个地址去 clone 代码.

代码地址: https://github.com/LemonLmNan/ByteCode

注意事项

常量池

这里有一个地方要注意, 常量池里的常量数量如果是 120, 则实际上只有 120 - 1 = 119 个常量.

从 oracle 给的 class 文件的结构也可以看出:

   u2             constant_pool_count;         // 常量池大小
   cp_info        constant_pool[constant_pool_count-1];    // 常量池数组

关于数值的解析

分析到这里, 其实大家应该都比较清楚了, 解析class 实际上是对 byte 的一个操作, ByteInfo 里面可以读取3种大小的 byte[] , byte[1], byte[2], byte[4], 这三种分别对应 u1, u2, u4, 因为在本次的代码里, u1和u2的使用 int 表示, u4的使用 long来表示(但是由于某些原因, 读取到long值后又强转为了 int 处理).
这里需要注意的是, Double 和 Long 这两个数值的解析, 跟一般的不太一样(其实也差不多), 在解析完数值之后, 因为这两个常量占用常量池里两个常量, 也就是一个 Double/Long 需要占用2个常量, 具体看下面的代码截图.

解析double

解析完后, double和long需要做额外的处理, 这里为了处理方便, 添加了一个空的常量进常量池.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ArCHqoJa-1603192998073)(https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7c4a6e1fa38344ffb4a4f78fe83f7151~tplv-k3u1fbpfcp-watermark.image)]
但实际上, 官方文档自己也说了这是一个糟糕的决定.

oracle的官方文档说明:

All 8-byte constants take up two entries in the constant_pool table of the class file. If a CONSTANT_Long_info or CONSTANT_Double_info structure is the item in the constant_pool table at index n, then the next usable item in the pool is located at index n+2. The constant_pool index n+1 must be valid but is considered unusable.

大概意思就是比如第 n个是double, 读取了数据后, 下一个可用的是第 n+2 个常量, 第 n+1 个默认不可用

最后

本项目目前仅用于class字节码的入门, 如果有什么好的建议或者意见欢迎大家提出来.

今天这篇到这里就结束了, 感谢观看.

参考

oracle官方: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.putstatic

美团点评: https://tech.meituan.com/2019/09/05/java-bytecode-enhancement.html

做人做事都非常细的老傅: https://bugstack.cn/itstack-demo-jvm/2019/05/03/%E7%94%A8Java%E5%AE%9E%E7%8E%B0JVM%E7%AC%AC%E4%B8%89%E7%AB%A0-%E8%A7%A3%E6%9E%90class%E6%96%87%E4%BB%B6.html