引子：对于之前分析的Mini JVM的实现原理，这里再加几篇关于源码的分析，目的是为了可以更形象的展现之前所说的内容，同时在分析源码的同时如果有同学有更好的实现的方法也可以提出来一起交流。
1. 解析常量池
在之前的文章中已经提到过，常量池是整个class文件中十分重要的一部分，其存在的意思主要是可以减少class中的重复数据，使class文件可以更加的小。同时执行引擎在执行的时候也会引用到常量池中的内容。所以常量池的解析对于整个JVM来说是很关键的一步。
首先再来看一下常量池在class存在的形式
嗯，没错，都是一些二进制数值，所以解析常量池的工作其实就是将这个数值根据规则转成java中的一个一个的类。
1.1 常量池类结构图
之前常量池的文章中介绍过, 常量池就是由一个个的常量项组成的, 因此可以得出以下的类结构图
这个结构应该很容易就可以想到，下面来看一下代码是如何实现的。
1.2 代码实现
解析常量池：传入的参数就是class文件的字节码数组
private int _parseConstantPool(byte[] contents) {
// 由class文件的结构规范可知, 常量吃的长度在class文件的第8个字节到第10(不包括)个字节记节
// 所以这里的CONSTANT_POOL_LENGTH_START和CONSTANT_POOL_LENGTH_END分别是8和10
Integer constantPoolLength = byte2Int(Arrays.copyOfRange(contents, CONSTANT_POOL_LENGTH_START, CONSTANT_POOL_LENGTH_END));
// 常量池长度数据之后紧接着就是常量池的具体内容, 所以pos的值就是10
int pos = CONSTANT_POOL_START;
List<AbstractConstant> abstractConstant = new ArrayList<>();
ConstantPool pool = new ConstantPool(abstractConstant);
// 因为常量池中常量项的序号是从1开始的, 所以遍历的时候需要是常量项长度-1
// 同时保留的第0项用于表示不引用任何的常量项, 因此这里一开始就创建一个NullConstant
abstractConstant.add(new NullConstant());
for (int i = 0; i < constantPoolLength - 1; i++) {
byte tag = contents[pos];
pos = pos + 1;
// 根据tag的值来判断接下来的常量项是到底是什么类型
// 不同的常量项的具体数据内容不同, 需要进行单独的解析
// 解析完每一个常量项都需要更新pos的值, 其一直指向下一个常量项的tag位置
// 每一个常量项的数据格式定义可以参考oracle jvm规范
switch (tag) {
case CONSTANT_UTF8: {
int length = byte2Int(Arrays.copyOfRange(contents, pos, pos + 2));
byte[] content = Arrays.copyOfRange(contents, pos + 2, pos + 2 + length);
UTF8Constant utf8Constant = new UTF8Constant(pool, tag, length, content);
abstractConstant.add(utf8Constant);
pos += (2 + length);
break;
}
case CONSTANT_INTEGER: {
// TODO: 17/6/6 后序添加
break;
}
case CONSTANT_FLOAT: {
// TODO: 17/6/6 后序添加
break;
}
case CONSTANT_LONG: {
// TODO: 17/6/6 后序添加
break;
}
case CONSTANT_DOUBLE: {
// TODO: 17/6/6 后序添加
break;
}
case CONSTANT_CLASS: {
int nameIndex = byte2Int(Arrays.copyOfRange(contents, pos, pos + 2));
ClassConstant classConstant = new ClassConstant(pool, tag, nameIndex);
abstractConstant.add(classConstant);
pos += 2;
break;
}
case CONSTANT_STRING: {
Integer stringIndex = byte2Int(Arrays.copyOfRange(contents, pos, pos + 2));
StringConstant stringConstant = new StringConstant(pool, tag, stringIndex);
abstractConstant.add(stringConstant);
pos += 2;
break;
}
case CONSTANT_FIELD_REF: {
Integer classIndex = byte2Int(Arrays.copyOfRange(contents, pos, pos + 2));
Integer nameAndTypeIndex = byte2Int(Arrays.copyOfRange(contents, pos + 2, pos + 4));
FieldRefConstant fieldRefConstant = new FieldRefConstant(pool, tag, classIndex, nameAndTypeIndex);
abstractConstant.add(fieldRefConstant);
pos += 4;
break;
}
case CONSTANT_METHOD_REF: {
Integer classIndex = byte2Int(Arrays.copyOfRange(contents, pos, pos + 2));
Integer nameAndTypeIndex = byte2Int(Arrays.copyOfRange(contents, pos + 2, pos + 4));
MethodRefConstant methodRefConstant = new MethodRefConstant(pool, tag, classIndex, nameAndTypeIndex);
abstractConstant.add(methodRefConstant);
pos += 4;
break;
}
case CONSTANT_INTERFACE_METHOD_REF: {
// TODO: 17/6/6 后序添加
break;
}
case CONSTANT_NAME_AND_TYPE: {
Integer nameIndex = byte2Int(Arrays.copyOfRange(contents, pos, pos + 2));
Integer descriptorIndex = byte2Int(Arrays.copyOfRange(contents, pos + 2, pos + 4));
NameAndTypeConstant nameAndTypeConstant = new NameAndTypeConstant(pool, tag, nameIndex, descriptorIndex);
abstractConstant.add(nameAndTypeConstant);
pos += 4;
break;
}
case CONSTANT_METHOD_HANDLE: {
// TODO: 17/6/6 后序添加
break;
}
case CONSTANT_METHOD_TYPE: {
// TODO: 17/6/6 后序添加
break;
}
case CONSTANT_INVOKE_DYNAMIC: {
// TODO: 17/6/6 后序添加
break;
}
default:
throw new RuntimeException("class文件常量池结构不正确");
}
}
classFile.setConstantPool(pool);
return pos;
}2. 解析访问标志
由之前的class文件的结构可知，常量池之后紧跟着的就是类的访问标志，也就是那些private、 abstract之类的东西。class文件中使用2个字节来表示这些内容，具体的说是用16bit来表示这些内容，因为这两个字节的每一位都是有意义的，当某一位的值为1时就表示有某个修饰符。所以解析访问标志实际上就是判断每一位是否是1。
代码如下：
class修饰符的枚举定义：
public enum ClassAccessFlag {
// 每一个对于类合法的修饰符都会在这里进行定义, code代表的就是该修饰符具体所在的bit
ACC_PUBLIC(0X0001, "PUBLIC"),
ACC_FINAL(0x0010, "FINAL"),
ACC_SUPER(0x0020, "SUPER"),
ACC_ABSTRACT(0x0400, "ABSTRACT"),
ACC_SYNTHETIC(0x1000, "SYNTHETIC"),
ACC_ANNOTATION(0x2000, "ANNOTATION"),
ACC_ENUM(0x4000, "ENUM");
private int code;
private String name;
ClassAccessFlag(int code, String name) {
this.code = code;
this.name = name;
}
public int getCode() {
return code;
}
public String getName() {
return name;
}
}解析class的修饰符
/**
* 解析Class的修饰符
*/
private int _parseClassAccessFlag(byte[] contents, int accessFlagStart) {
int accessFlag = byte2Int(Arrays.copyOfRange(contents, accessFlagStart, accessFlagStart + 2));
// 由上面的分析可以知道, 只要将正在解析的类的修饰符的值与上面定义的枚举进行位运算就可以知道该类有哪些修饰符
// 写到这里突然发现这个过程可以不用一个一个if进行判断而是可以通过一个循环进行实现, 所以写文章的好处之一就是有的时候会灵光一现, 想到其他的更好的实现方法
List<ClassAccessFlag> classAccessFlags = new ArrayList<>();
if ((accessFlag & ACC_PUBLIC.getCode()) != 0) {
classAccessFlags.add(ACC_PUBLIC);
}
if ((accessFlag & ACC_FINAL.getCode()) != 0) {
classAccessFlags.add(ACC_FINAL);
}
if ((accessFlag & ACC_SUPER.getCode()) != 0) {
classAccessFlags.add(ACC_SUPER);
}
if ((accessFlag & ACC_ABSTRACT.getCode()) != 0) {
classAccessFlags.add(ACC_ABSTRACT);
}
if ((accessFlag & ACC_SYNTHETIC.getCode()) != 0) {
classAccessFlags.add(ACC_SYNTHETIC);
}
if ((accessFlag & ACC_ENUM.getCode()) != 0) {
classAccessFlags.add(ACC_ENUM);
}
classFile.setAccessFlag(classAccessFlags);
return accessFlagStart + 2;
}3. 解析类的索引
解析类的索引可以说是很简单的了，其实就是找到该类和其父类在常量池中的索引项，也就是找到该类和其父类在常量池中的索引。这些内容在常量项中本身就存在，这里仅仅是引用一下，但是jvm规范单独将这部分数据提取出来表示我想是为了之后获取类的信息可以更加的方便，而不用再到常量池中一个个的找。毕竟类的信息对于解析一个类是时常要用到的。
解析类的索引：
/**
* 解析Class和其父类在常量池中的索引
*/
private int _parseClassIndex(byte[] contents, int classIndexStart) {
int thisClassIndex = byte2Int(Arrays.copyOfRange(contents, classIndexStart, classIndexStart + 2));
int superClassIndex = byte2Int(Arrays.copyOfRange(contents, classIndexStart + 2, classIndexStart + 4));
ClassIndex classIndex = new ClassIndex(thisClassIndex, superClassIndex);
classFile.setClassIndex(classIndex);
return classIndexStart + 4;
}这段代码没什么好解释的，可以说是简单的到不能再简单了，thisClassIndex和superClassIndex的值一定是常量池的某个常量项的索引值（如果这个class是合法的）。
其实在解析完class index后紧跟的是interface index，也就是这个类实现的接口的索引，但是我的这个mini jvm要解析的类没有实现接口，所以这个就不剖析了。但是其实现的方式和解析class index实际上是一样的。
4. 总结
整个mini jvm的代码实现还不是很完整，即使是已经实现的功能也还有很多可以优化的地方，之后的计划是一遍完善功能一遍继续解析mini jvm的代码，后面解析方法和字段的代码也是很关键的，还有最后的执行引擎的实现是整个mini jvm的核心。最后如果有必要再对一些Miscellaneous的实现进行解析一下。
433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
