马上注册，结交更多好友，享用更多功能^_^
您需要 登录 才可以下载或查看，没有账号？立即注册
x
本帖最后由 零度非安全 于 2017-2-18 09:56 编辑
前言：
身为一个 Java 程序员，怎么能不了解 JVM 呢，倘若想学习 JVM，那就又必须要了解 Class 文件，Class 之于虚拟机，就
如鱼之于水，虚拟机因为 Class 而有了生命。《深入理解 java 虚拟机》中花了一整个章节来讲解 Class 文件，可是看完
后，一直都还是迷迷糊糊，似懂非懂。正好前段时间看见一本书很不错：《自己动手写 Java 虚拟机》，作者利用 go 语言
实现了一个简单的 JVM，虽然没有完整实现 JVM 的所有功能，但是对于一些对 JVM 稍感兴趣的人来说，可读性还是很高
的。作者讲解的很详细，每个过程都分为了一章，其中一部分就是讲解如何解析 Class 文件。
这本书不太厚，很快就读完了，读完后，收获颇丰。但是纸上得来终觉浅，绝知此事要躬行，我便尝试着自己解析 Class 文
件。go 语言虽然很优秀，但是终究不熟练，尤其是不太习惯其把类型放在变量之后的语法，还是老老实实用 java 吧。
话不多说，先贴出项目地址：https://github.com/HalfStackDeveloper/ClassReader
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];
}
开头四个字节为：magic，是用来唯一标识文件格式的，一般被称作 magic number（魔数），这样虚拟机才能识别出所
加载的文件是否是 class 格式，class 文件的魔数为 cafebabe。不只是 class 文件，基本上大部分文件都有魔数，用来标识
自己的格式。
接下来的部分主要是 class 文件的一些信息，如常量池、类访问标志、父类、接口信息、字段、方法等，具体的信息可参考
《Java虚拟机规范》。
解析
字段类型
上面说到 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[];
}
由于格式太多，文章中只挑选一部分讲解：
这里首先读取常量池的大小，初始化常量池：//解析常量池
int constant_pool_count = U2.read(inputStream);
ConstantPool constantPool = new ConstantPool(constant_pool_count);
constantPool.read(inputStream);
量池大小为 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_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()
}
}
再来看看 CONSTANT_Class 这一项，这一项存储的是类或者接口的符号引用：CONSTANT_Class_info {
u1 tag;
u2 name_index;
}
dex] 一定是 CONSTANT_Utf8 格式。public class ConstantClass extends ConstantInfo {
public int nameIndex;
@Override
public void read(InputStream inputStream) {
nameIndex = U2.read(inputStream);
}
}
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];
}
组，因为字节码指令就存储在这个属性数组里。属性有很多种，比如说异常表就是一个属性，而存储字节码指令的属性
为 CODE 属性，看这名字也知道是用来存储代码的了。属性的通用格式为：attribute_info {
u2 attribute_name_index;
u4 attribute_length;
u1 info[attribute_length];
}
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];
}
译看到的指令其实是助记符，只是方便阅读字节码使用的，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项目：
https://github.com/HalfStackDeveloper/ClassReader，欢迎 Fork And Star！
总结
Class 文件看起来很复杂，其实真正解析起来，也没有那么难，关键是要自己动手试试，才能彻底理解，希望各位看完后也
能觉知此事要躬行！
参考：
1. 周志明《java虚拟机规范（JavaSE7）》
2. 张秀宏《自己动手写Java虚拟机》
3. 周志明《深入理解Java虚拟机（第2版）》
| 
( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)
狗仔卡
发表于 2017-2-17 22:37:58
置顶卡
千斤顶
显身卡
楼主
