共计 7285 个字符，预计需要花费 19 分钟才能阅读完成。
微信公众号【Java 技术江湖】一位阿里 Java 工程师的技术小站。作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点 Docker、ELK，同时也分享技术干货和学习经验，致力于 Java 全栈开发！（关注公众号后回复”Java“即可领取 Java 基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的 Java 学习指南、Java 程序员面试指南等干货资源）
9eedaaa588bef997bef63a7160fa349134bdb78c
用 java 解析 class 文件
转自 https://juejin.im/post/589834…
前言
身为一个 java 程序员，怎么能不了解 JVM 呢，倘若想学习 JVM，那就又必须要了解 Class 文件，Class 之于虚拟机，就如鱼之于水，虚拟机因为 Class 而有了生命。《深入理解 java 虚拟机》中花了一整个章节来讲解 Class 文件，可是看完后，一直都还是迷迷糊糊，似懂非懂。正好前段时间看见一本书很不错：《自己动手写 Java 虚拟机》，作者利用 go 语言实现了一个简单的 JVM，虽然没有完整实现 JVM 的所有功能，但是对于一些对 JVM 稍感兴趣的人来说，可读性还是很高的。作者讲解的很详细，每个过程都分为了一章，其中一部分就是讲解如何解析 Class 文件。
这本书不太厚，很快就读完了，读完后，收获颇丰。但是纸上得来终觉浅，绝知此事要躬行，我便尝试着自己解析 Class 文件。go 语言虽然很优秀，但是终究不熟练，尤其是不太习惯其把类型放在变量之后的语法，还是老老实实用 java 吧。
话不多说，先贴出项目地址：github.com/HalfStackDe…
Class 文件
什么是 Class 文件？
java 之所以能够实现跨平台，便在于其编译阶段不是将代码直接编译为平台相关的机器语言，而是先编译成二进制形式的 java 字节码，放在 Class 文件之中，虚拟机再加载 Class 文件，解析出程序运行所需的内容。每个类都会被编译成一个单独的 class 文件，内部类也会作为一个独立的类，生成自己的 class。
基本结构
随便找到一个 class 文件，用 Sublime Text 打开是这样的：
是不是一脸懵逼，不过 java 虚拟机规范中给出了 class 文件的基本格式，只要按照这个格式去解析就可以了：
ClassFile {
u4 magic;
u2 minor_version;
u2 major_version;
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];}
ClassFile 中的字段类型有 u1、u2、u4, 这是什么类型呢？其实很简单，就是分别表示 1 个字节，2 个字节和 4 个字节。
开头四个字节为：magic，是用来唯一标识文件格式的，一般被称作 magic number（魔数），这样虚拟机才能识别出所加载的文件是否是 class 格式，class 文件的魔数为 cafebabe。不只是 class 文件，基本上大部分文件都有魔数，用来标识自己的格式。
接下来的部分主要是 class 文件的一些信息，如常量池、类访问标志、父类、接口信息、字段、方法等，具体的信息可参考《Java 虚拟机规范》。
class 文件的结构
从上面可以看到，class 文件确实和它的另一个名字字节码文件一样是由一个个的字节码组成的。这里要注意的是因为 class 文件是由一个个字节组成的，所以如果当一个数据大于一个字节的时候，是使用无符号大端模式进行存储的，大小端模式的区别可以参考这里。那么这些字节表示什么意思呢？JVM 是如何解析这些字节数据的呢？我们到 oracle 的官方文档上看一下他们是如何定义 class 文件的结构的：
从上面可以看到，一个 Class 文件中的每一个字节都有指定的意义，比如一开始的 4 个字节代表的是 magic number，这个值对所有的 Class 文件都一样，就是 CAFEBABE，接下来的 2 个字节是次版本号。再比如 cp_info，这是一个非常重要的字段，就是后面要着重介绍的常量池。
如果需要看每个字段的代表的意思可以看一下 Java Language and Virtual MachineSpecifications https://docs.oracle.com/javas…
上面的结构看起来可以比较抽象，那么可以看一下下面这张示意图：
现在大家应该可以想到了，实际上 class 文件中的所有的字节都代表了固定的信息，所以 JVM 只要根据 class 文件的格式就可以知道这个 class 文件中的存放了什么内容了，比如说方法的信息，字段信息等。
解析
字段类型
上面说到 ClassFile 中的字段类型有 u1、u2、u4，分别表示 1 个字节，2 个字节和 4 个字节的无符号整数。java 中 short、int、long 分别为 2、4、8 个字节的有符号整数，去掉符号位，刚好可以用来表示 u1、u2、u4。
public class U1 {
public static short read(InputStream inputStream) {byte[] bytes = new byte[1];
try {inputStream.read(bytes);
} catch (IOException e) {e.printStackTrace();
}
short value = (short) (bytes[0] & 0xFF);
return value;
}}
public class U2 {
public static int read(InputStream inputStream) {byte[] bytes = new byte[2];
try {inputStream.read(bytes);
} catch (IOException e) {e.printStackTrace();
}
int num = 0;
for (int i= 0; i < bytes.length; i++) {
num <<= 8;
num |= (bytes[i] & 0xff);
}
return num;
}}
public class U4 {
public static long read(InputStream inputStream) {byte[] bytes = new byte[4];
try {inputStream.read(bytes);
} catch (IOException e) {e.printStackTrace();
}
long num = 0;
for (int i= 0; i < bytes.length; i++) {
num <<= 8;
num |= (bytes[i] & 0xff);
}
return num;
}}
常量池
定义好字段类型后，我们就可以读取 class 文件了，首先是读取魔数之类的基本信息，这部分很简单：
FileInputStream inputStream = new FileInputStream(file);
ClassFile classFile = new ClassFile();
classFile.magic = U4.read(inputStream);
classFile.minorVersion = U2.read(inputStream);
classFile.majorVersion = U2.read(inputStream);
这部分只是热热身，接下来的大头在于常量池。解析常量池之前，我们先来解释一下常量池是什么。
常量池，顾名思义，存放常量的资源池，这里的常量指的是字面量和符号引用。字面量指的是一些字符串资源，而符号引用分为三类：类符号引用、方法符号引用和字段符号引用。通过将资源放在常量池中，其他项就可以直接定义成常量池中的索引了，避免了空间的浪费，不只是 class 文件，Android 可执行文件 dex 也是同样如此，将字符串资源等放在 DexData 中，其他项通过索引定位资源。java 虚拟机规范给出了常量池中每一项的格式：
cp_info {
u1 tag;
u1 info[]; }
上面的这个格式只是一个通用格式，常量池中真正包含的数据有 14 种格式，每种格式的 tag 值不同, 具体如下所示:
由于格式太多，文章中只挑选一部分讲解：
这里首先读取常量池的大小，初始化常量池：
// 解析常量池
int constant_pool_count = U2.read(inputStream);
ConstantPool constantPool = new ConstantPool(constant_pool_count);
constantPool.read(inputStream);
接下来再逐个读取每项内容，并存储到数组 cpInfo 中，这里需要注意的是，cpInfo[]下标从 1 开始，0 无效，且真正的常量池大小为 constant_pool_count-1。
public class ConstantPool {
public int constant_pool_count;
public ConstantInfo[] cpInfo;
public ConstantPool(int count) {
constant_pool_count = count;
cpInfo = new ConstantInfo[constant_pool_count];
}
public void read(InputStream inputStream) {for (int i = 1; i < constant_pool_count; i++) {short tag = U1.read(inputStream);
ConstantInfo constantInfo = ConstantInfo.getConstantInfo(tag);
constantInfo.read(inputStream);
cpInfo[i] = constantInfo;
if (tag == ConstantInfo.CONSTANT_Double || tag == ConstantInfo.CONSTANT_Long) {i++;}
}
}}
我们先来看看 CONSTANT_Utf8 格式，这一项里面存放的是 MUTF- 8 编码的字符串：
CONSTANT_Utf8_info {
u1 tag;
u2 length;
u1 bytes[length]; }
那么如何读取这一项呢？
public class ConstantUtf8 extends ConstantInfo {
public String value;
@Override
public void read(InputStream inputStream) {int length = U2.read(inputStream);
byte[] bytes = new byte[length];
try {inputStream.read(bytes);
} catch (IOException e) {e.printStackTrace();
}
try {value = readUtf8(bytes);
} catch (UTFDataFormatException e) {e.printStackTrace();
}
}
private String readUtf8(byte[] bytearr) throws UTFDataFormatException {//copy from java.io.DataInputStream.readUTF()
}}
很简单，首先读取这一项的字节数组长度，接着调用 readUtf8(), 将字节数组转化为 String 字符串。
再来看看 CONSTANT_Class 这一项，这一项存储的是类或者接口的符号引用：
CONSTANT_Class_info {
u1 tag;
u2 name_index;}
注意这里的 name_index 并不是直接的字符串，而是指向常量池中 cpInfo 数组的 name_index 项，且 cpInfo[name_index]一定是 CONSTANT_Utf8 格式。
public class ConstantClass extends ConstantInfo {
public int nameIndex;
@Override
public void read(InputStream inputStream) {nameIndex = U2.read(inputStream);
}}
常量池解析完毕后，就可以供后面的数据使用了，比方说 ClassFile 中的 this_class 指向的就是常量池中格式为 CONSTANT_Class 的某一项, 那么我们就可以读取出类名：
int classIndex = U2.read(inputStream);
ConstantClass clazz = (ConstantClass) constantPool.cpInfo[classIndex];
ConstantUtf8 className = (ConstantUtf8) constantPool.cpInfo[clazz.nameIndex];
classFile.className = className.value;
System.out.print(“classname:” + classFile.className + “n”);
字节码指令
解析常量池之后还需要接着解析一些类信息，如父类、接口类、字段等，但是相信大家最好奇的还是 java 指令的存储，大家都知道，我们平时写的 java 代码会被编译成 java 字节码，那么这些字节码到底存储在哪呢？别急，讲解指令之前，我们先来了解下 ClassFile 中的 method_info，其格式如下：
method_info {
u2 access_flags;
u2 name_index;
u2 descriptor_index;
u2 attributes_count;
attribute_info attributes[attributes_count];}
method_info 里主要是一些方法信息：如访问标志、方法名索引、方法描述符索引及属性数组。这里要强调的是属性数组，因为字节码指令就存储在这个属性数组里。属性有很多种，比如说异常表就是一个属性，而存储字节码指令的属性为 CODE 属性，看这名字也知道是用来存储代码的了。属性的通用格式为：
attribute_info {
u2 attribute_name_index;
u4 attribute_length;
u1 info[attribute_length];}
根据 attribute_name_index 可以从常量池中拿到属性名，再根据属性名就可以判断属性种类了。
Code 属性的具体格式为：
Code_attribute {
u2 attribute_name_index; u4 attribute_length;
u2 max_stack;
u2 max_locals;
u4 code_length;
u1 code[code_length];
u2 exception_table_length;
{
u2 start_pc;
u2 end_pc;
u2 handler_pc;
u2 catch_type;
} exception_table[exception_table_length];
u2 attributes_count;
attribute_info attributes[attributes_count];}
其中 code 数组里存储就是字节码指令，那么如何解析呢？每条指令在 code[]中都是一个字节，我们平时 javap 命令反编译看到的指令其实是助记符，只是方便阅读字节码使用的，jvm 有一张字节码与助记符的对照表，根据对照表，就可以将指令翻译为可读的助记符了。这里我也是在网上随便找了一个对照表，保存到本地 txt 文件中，并在使用时解析成 HashMap。代码很简单，就不贴了，可以参考我代码中 InstructionTable.java。
接下来我们就可以解析字节码了：
for (int j = 0; j < methodInfo.attributesCount; j++) {
if (methodInfo.attributes[j] instanceof CodeAttribute) {CodeAttribute codeAttribute = (CodeAttribute) methodInfo.attributes[j];
for (int m = 0; m < codeAttribute.codeLength; m++) {short code = codeAttribute.code[m];
System.out.print(InstructionTable.getInstruction(code) + "\n");
}
}}
运行
整个项目终于写完了，接下来就来看看效果如何，随便找一个 class 文件解析运行：
哈哈，是不是很赞！
最后再贴一下项目地址：github.com/HalfStackDe…，欢迎 Fork And Star！
总结
Class 文件看起来很复杂，其实真正解析起来，也没有那么难，关键是要自己动手试试，才能彻底理解，希望各位看完后也能觉知此事要躬行！
微信公众号【Java 技术江湖】一位阿里 Java 工程师的技术小站。（关注公众号后回复”Java“即可领取 Java 基础、进阶、项目和架构师等免费学习资料，更有数据库、分布式、微服务等热门技术学习视频，内容丰富，兼顾原理和实践，另外也将赠送作者原创的 Java 学习指南、Java 程序员面试指南等干货资源。