总结一下最近看的书中的知识点，以后多翻阅，都是很底层的概念

Java虚拟机规范定义了Java字节码的格式和行为，其中包括类文件结构。类文件结构中有一个重要的部分是常量池（Constant Pool），它包含了类文件中使用的所有常量信息。常量池中有多种类型的常量项，每种常量项都有其特定的结构。

先总结一下class文件解析到内存的结构，
```go
ClassFile {
    u4 magic;  // 魔数，用于标识文件格式，固定为0xCAFEBABE。
    
    u2 minor_version;  // 类文件的次版本号，与major_version一起决定了该类文件的JVM版本要求。
    u2 major_version;  // 类文件的主版本号。比如52表示Java SE 8，53表示Java SE 9。
    
    u2 constant_pool_count;  // 常量池中的项数加1。实际项数是constant_pool_count - 1。
    cp_info constant_pool[constant_pool_count - 1];  // 常量池数组，存储类文件中用到的各种常量，如类名、方法名、字符串、数字等。
    
    u2 access_flags;  // 类访问标志，用于标识类或接口的访问属性，如public、final、super、interface、abstract等。
    
    u2 this_class;  // 指向constant_pool中的索引，表示当前类的符号引用，通常是一个CONSTANT_Class_info项。
    
    u2 super_class;  // 指向constant_pool中的索引，表示当前类的父类的符号引用。如果当前类是Object类，没有父类，这个值为0。
    
    u2 interfaces_count;  // 实现的接口数。
    u2 interfaces[interfaces_count];  // 实现接口的列表，每个接口都是一个对constant_pool中CONSTANT_Class_info项的索引。
    
    u2 fields_count;  // 字段数量，即类或接口中声明的字段数（不包括从父类继承的字段）。
    field_info fields[fields_count];  // 字段信息的数组，每个field_info项表示一个字段的定义，如字段的名称、类型、修饰符、属性等。
    
    u2 methods_count;  // 方法数量，即类或接口中声明的方法数（不包括从父类继承的方法）。
    method_info methods[methods_count];  // 方法信息的数组，每个method_info项表示一个方法的定义，如方法的名称、描述符、修饰符、属性（包括字节码）等。
    
    u2 attributes_count;  // 类的附加属性数量。
    attribute_info attributes[attributes_count];  // 类文件级别的附加属性数组，比如"SourceFile"、"InnerClasses"、"EnclosingMethod"等。
}

```
`constant_pool_coun`t 是一个无符号的短整型（u2），表示常量池中常量项的数量。常量池的索引是从1开始的，因此 `constant_pool_count` 的值比常量池中实际的常量项数量多1。如果 constant_pool_count 的值是20，那么常量池中有19个常量项。

常量项的通用结构如下
```
cp_info {
    u1 tag;
    u1 info[];
}
```
- tag：标识常量项的类型，不同的常量项类型有不同的 tag 值。

- info：根据 tag 值的不同，info 数组的内容也会有所不同。

#### 常量池的作用
- 符号引用：常量池主要用于存储类、接口、字段和方法的符号引用。这些符号引用在类加载过程中会被解析为直接引用。

- 字面量：常量池还存储了字符串字面量、整数和浮点数常量等。

- 运行时常量池：在类加载过程中，Java虚拟机会将常量池中的内容加载到方法区中的运行时常量池，供程序运行时使用。

#### 常量池的解析
在类加载的解析阶段，Java虚拟机会将常量池中的符号引用替换为直接引用。这个过程包括：

- 类或接口的解析：将类或接口的符号引用解析为指向方法区中该类或接口的直接引用。

- 字段解析：将字段的符号引用解析为指向具体存储位置的直接引用。

- 方法解析：将方法的符号引用解析为指向方法代码起始位置的直接引用。

以下是17种常量项的详细结构

### 1. CONSTANT_Class_info
```java
CONSTANT_Class_info {
    u1 tag; // 值为7
    u2 name_index; // 指向常量池中 CONSTANT_Utf8_info 的索引
}
```

### 2. CONSTANT_Fieldref_info
```java
CONSTANT_Fieldref_info {
    u1 tag; // 值为9
    u2 class_index; // 指向常量池中 CONSTANT_Class_info 的索引
    u2 name_and_type_index; // 指向常量池中 CONSTANT_NameAndType_info 的索引
}
```

### 3. CONSTANT_Methodref_info
```java
CONSTANT_Methodref_info {
    u1 tag; // 值为10
    u2 class_index; // 指向常量池中 CONSTANT_Class_info 的索引
    u2 name_and_type_index; // 指向常量池中 CONSTANT_NameAndType_info 的索引
}
```

### 4. CONSTANT_InterfaceMethodref_info
```java
CONSTANT_InterfaceMethodref_info {
    u1 tag; // 值为11
    u2 class_index; // 指向常量池中 CONSTANT_Class_info 的索引
    u2 name_and_type_index; // 指向常量池中 CONSTANT_NameAndType_info 的索引
}
```

### 5. CONSTANT_String_info
```java
CONSTANT_String_info {
    u1 tag; // 值为8
    u2 string_index; // 指向常量池中 CONSTANT_Utf8_info 的索引
}
```

### 6. CONSTANT_Integer_info
```java
CONSTANT_Integer_info {
    u1 tag; // 值为3
    u4 bytes; // 整数值
}
```

### 7. CONSTANT_Float_info
```java
CONSTANT_Float_info {
    u1 tag; // 值为4
    u4 bytes; // 浮点数值
}
```

### 8. CONSTANT_Long_info
```java
CONSTANT_Long_info {
    u1 tag; // 值为5
    u4 high_bytes; // 高32位
    u4 low_bytes; // 低32位
}
```

### 9. CONSTANT_Double_info
```java
CONSTANT_Double_info {
    u1 tag; // 值为6
    u4 high_bytes; // 高32位
    u4 low_bytes; // 低32位
}
```

### 10. CONSTANT_NameAndType_info
```java
CONSTANT_NameAndType_info {
    u1 tag; // 值为12
    u2 name_index; // 指向常量池中 CONSTANT_Utf8_info 的索引
    u2 descriptor_index; // 指向常量池中 CONSTANT_Utf8_info 的索引
}
```

### 11. CONSTANT_Utf8_info
```java
CONSTANT_Utf8_info {
    u1 tag; // 值为1
    u2 length; // UTF-8编码的字符串长度
    u1 bytes[length]; // UTF-8编码的字符串
}
```

### 12. CONSTANT_MethodHandle_info
```java
CONSTANT_MethodHandle_info {
    u1 tag; // 值为15
    u1 reference_kind; // 引用类型，值在1到9之间
    u2 reference_index; // 指向常量池中相应的索引
}
```

### 13. CONSTANT_MethodType_info
```java
CONSTANT_MethodType_info {
    u1 tag; // 值为16
    u2 descriptor_index; // 指向常量池中 CONSTANT_Utf8_info 的索引
}
```

### 14. CONSTANT_Dynamic_info
```java
CONSTANT_Dynamic_info {
    u1 tag; // 值为17
    u2 bootstrap_method_attr_index; // 指向BootstrapMethods属性的索引
    u2 name_and_type_index; // 指向常量池中 CONSTANT_NameAndType_info 的索引
}
```

### 15. CONSTANT_InvokeDynamic_info
```java
CONSTANT_InvokeDynamic_info {
    u1 tag; // 值为18
    u2 bootstrap_method_attr_index; // 指向BootstrapMethods属性的索引
    u2 name_and_type_index; // 指向常量池中 CONSTANT_NameAndType_info 的索引
}
```

### 16. CONSTANT_Module_info
```java
CONSTANT_Module_info {
    u1 tag; // 值为19
    u2 name_index; // 指向常量池中 CONSTANT_Utf8_info 的索引
}
```

### 17. CONSTANT_Package_info
```java
CONSTANT_Package_info {
    u1 tag; // 值为20
    u2 name_index; // 指向常量池中 CONSTANT_Utf8_info 的索引
}
```

这些结构定义了常量池中每个常量项的格式，使得Java虚拟机能够正确解析和使用这些常量。每个常量项都有一个唯一的 `tag` 值，用于标识其类型，并跟随相应的数据结构。

常量池种不同的常量项

指令集和解释器

接下来是第四章，这章讲的主要是初步初步构建运行时数据区，在开始写代码之前，我们需要了解JVM的运行时数据区是怎样的，背过八股文的都知道，大概是下面的一样的结构

![image.png](/static/img/d155e1d7aa7d70c4b367080ddf4b466c.image.webp)

主要分为多线程共享和线程独享两个区域，Java虚拟机规范对这块很宽松，对于heap，内存可以连续也可以不连续，可以固定大小也可以动态大小，可以垃圾回收也可以不进行垃圾回收，所以heap部分我们直接套用Go本身带的垃圾回收机制和heap就可以，方法区存储类元数据，先不管，所以这节课主要考虑实现线程独享的虚拟机栈，本地方法栈和程序计数器，知道他们是怎么运作的

JVM操作的类型有两种，分别是基本类型和引用类型，基本类型我们可以和Go对应替换，引用类型我们用指针实现，对于null我们用nil替换，因为后面的章节才真正的实现Object,我们先定义一个空结构体表示他

```go
package rtda

type Object struct {}
```
接下来我们就用`*Object`来表示一个引用，具体的对应关系参照下面的表

![image.png](/static/img/6e1c3067f4fe35351d9c6f1ae690e8bf.image.webp)

要实现线程独享变量，没有现成怎么行呢？我们定义一个对象表示线程，他应该有

![image.png](/static/img/0e23a4292d4a5f59c52ad98b4c29095b.image.webp)

这三个东西，我们先不管本地方法栈，先实现虚拟机栈和程序计数器

```go
type Thread struct {
	pc    int 
	stack *Stack
}

func NewThread() *Thread {
	return &Thread{
		stack: newStack(1024), // 创建一个新的栈，初始容量为1024
	}
}

func (self *Thread) PC() int {
	return self.pc // 返回当前线程的程序计数器（PC）
}

func (self *Thread) SetPC(pc int) {
	self.pc = pc // 设置当前线程的程序计数器（PC）
}

func (self *Thread) PushFrame(frame *Frame) {
	self.stack.push(frame) // 将一个栈帧压入当前线程的栈中
}

func (self *Thread) PopFrame() *Frame {
	return self.stack.pop() // 从当前线程的栈中弹出一个栈帧
}

func (self *Thread) CurrentFrame() *Frame {
	return self.stack.top() // 返回当前线程的栈顶栈帧
}
```
接下来就是虚拟机栈的实现了，Java虚拟机栈分为一个个栈帧，每一个栈帧有四个部分组成，如图

![image.png](/static/img/5ebcd963767fc6d8c80b7ce11c7ebc94.image.webp)

先定义Stack，Java虚拟机规范对虚拟机栈没有太多约束，既可以是固定大小也可以自动扩容，如果是固定大小，爆栈后抛出StackOverFlowError异常，如果是动态扩容，当申请不到内存是应该抛出OutOfMemoryError,我们可以直接用链表来实现Stack里面的栈帧,一个栈帧链表，Stack里面包含链表头结点引用和允许的最大深度maxsize,接下来定义Stack
```go
type Stack struct {
	maxSize uint // 栈的最大容量
	size    uint // 当前栈的大小
	_top    *Frame // 栈顶的栈帧，栈是作为链表实现的
}

func newStack(maxSize uint) *Stack {
	return &Stack{
		maxSize: maxSize, // 初始化栈的最大容量
	}
}

func (self *Stack) push(frame *Frame) {
	if self.size >= self.maxSize {
		panic("java.lang.StackOverflowError") // 如果栈已满，抛出StackOverflowError异常
	}

	if self._top != nil {
		frame.lower = self._top // 将新栈帧的lower指针指向当前栈顶栈帧
	}

	self._top = frame // 将新栈帧设置为栈顶
	self.size++ // 栈的大小加1
}


func (self *Stack) pop() *Frame {
	if self._top == nil {
		panic("jvm stack is empty!") // 如果栈为空，抛出异常
	}

	top := self._top // 获取当前栈顶栈帧
	self._top = top.lower // 将栈顶指针指向下一个栈帧
	top.lower = nil // 将弹出栈帧的lower指针置空
	self.size-- // 栈的大小减1

	return top // 返回弹出的栈帧
}


func (self *Stack) top() *Frame {
	if self._top == nil {
		panic("jvm stack is empty!") // 如果栈为空，抛出异常
	}

	return self._top // 返回当前栈顶栈帧
}


```
现在还没有真正实现异常，先这样暂停执行

接下来就是定义栈帧，按照之前说的，只要先实现局部变量表和操作数栈
```go

type Frame struct {
	lower        *Frame // 栈是作为链表实现的，指向下一个栈帧
	localVars    LocalVars // 局部变量表
	operandStack *OperandStack // 操作数栈
}


func NewFrame(maxLocals, maxStack uint) *Frame {
	return &Frame{
		localVars:    newLocalVars(maxLocals), // 初始化局部变量表，容量为maxLocals
		operandStack: newOperandStack(maxStack), // 初始化操作数栈，容量为maxStack
	}
}


func (self *Frame) LocalVars() LocalVars {
	return self.localVars // 返回局部变量表
}

func (self *Frame) OperandStack() *OperandStack {
	return self.operandStack // 返回操作数栈
}

```

接下来就是局部变量表定义了，局部变量表示按索引访问的，所以我们可以用数组实现，且局部变量表分为一个个Solt,一个Solt是32位，可以存储一个int或者引用，两个Solt可以存储一个long或者double，接下来定义
```go
package rtda

type Slot struct {
	num int32
	ref *Object
}
```
我们用这个结构来表示一个Solt,接下来就可以定义局部变量表了，再定义一些操作方法

```go
import "math"

type LocalVars []Slot // 局部变量表，是一个Slot切片的别名

func newLocalVars(maxLocals uint) LocalVars {
	if maxLocals > 0 {
		return make([]Slot, maxLocals) // 创建一个长度为maxLocals的Slot切片
	}
	return nil // 如果maxLocals为0，返回nil
}

func (self LocalVars) SetInt(index uint, val int32) {
	self[index].num = val // 将int32值存储在局部变量表的指定索引位置
}

func (self LocalVars) GetInt(index uint) int32 {
	return self[index].num // 从局部变量表的指定索引位置获取int32值
}

func (self LocalVars) SetFloat(index uint, val float32) {
	bits := math.Float32bits(val) // 将float32值转换为uint32位表示
	self[index].num = int32(bits) // 将uint32位表示存储在局部变量表的指定索引位置
}

func (self LocalVars) GetFloat(index uint) float32 {
	bits := uint32(self[index].num) // 从局部变量表的指定索引位置获取int32值并转换为uint32位表示
	return math.Float32frombits(bits) // 将uint32位表示转换为float32值
}

// long consumes two slots
func (self LocalVars) SetLong(index uint, val int64) {
	self[index].num = int32(val) // 将int64值的低32位存储在局部变量表的指定索引位置
	self[index+1].num = int32(val >> 32) // 将int64值的高32位存储在局部变量表的下一个索引位置
}

func (self LocalVars) GetLong(index uint) int64 {
	low := uint32(self[index].num) // 从局部变量表的指定索引位置获取低32位
	high := uint32(self[index+1].num) // 从局部变量表的下一个索引位置获取高32位
	return int64(high)<<32 | int64(low) // 将高32位和低32位组合成int64值
}


// double consumes two slots
func (self LocalVars) SetDouble(index uint, val float64) {
	bits := math.Float64bits(val) // 将float64值转换为uint64位表示
	self.SetLong(index, int64(bits)) // 将uint64位表示存储在局部变量表的指定索引位置和下一个索引位置
}

func (self LocalVars) GetDouble(index uint) float64 {
	bits := uint64(self.GetLong(index)) // 从局部变量表的指定索引位置和下一个索引位置获取int64值并转换为uint64位表示
	return math.Float64frombits(bits) // 将uint64位表示转换为float64值
}

func (self LocalVars) SetRef(index uint, ref *Object) {
	self[index].ref = ref // 将引用存储在局部变量表的指定索引位置
}

func (self LocalVars) GetRef(index uint) *Object {
	return self[index].ref // 从局部变量表的指定索引位置获取引用
}

```

接下来就是操作数栈，操作数栈跟局部变量表一样，也是用Solt表示，栈顶是size，在实现一些栈方法
```go
import "math"

type OperandStack struct {
	size  uint // 当前操作数栈的大小
	slots []Slot // 操作数栈的槽位
}

func newOperandStack(maxStack uint) *OperandStack {
	if maxStack > 0 {
		return &OperandStack{
			slots: make([]Slot, maxStack), // 创建一个长度为maxStack的Slot切片
		}
	}
	return nil // 如果maxStack为0，返回nil
}

func (self *OperandStack) PushInt(val int32) {
	self.slots[self.size].num = val // 将int32值存储在操作数栈的当前位置
	self.size++ // 操作数栈的大小加1
}

func (self *OperandStack) PopInt() int32 {
	self.size-- // 操作数栈的大小减1
	return self.slots[self.size].num // 从操作数栈的当前位置获取int32值
}

func (self *OperandStack) PushFloat(val float32) {
	bits := math.Float32bits(val) // 将float32值转换为uint32位表示
	self.slots[self.size].num = int32(bits) // 将uint32位表示存储在操作数栈的当前位置
	self.size++ // 操作数栈的大小加1
}

func (self *OperandStack) PopFloat() float32 {
	self.size-- // 操作数栈的大小减1
	bits := uint32(self.slots[self.size].num) // 从操作数栈的当前位置获取int32值并转换为uint32位表示
	return math.Float32frombits(bits) // 将uint32位表示转换为float32值
}

// long consumes two slots
func (self *OperandStack) PushLong(val int64) {
	self.slots[self.size].num = int32(val) // 将int64值的低32位存储在操作数栈的当前位置
	self.slots[self.size+1].num = int32(val >> 32) // 将int64值的高32位存储在操作数栈的下一个位置
	self.size += 2 // 操作数栈的大小加2
}

func (self *OperandStack) PopLong() int64 {
	self.size -= 2 // 操作数栈的大小减2
	low := uint32(self.slots[self.size].num) // 从操作数栈的当前位置获取低32位
	high := uint32(self.slots[self.size+1].num) // 从操作数栈的下一个位置获取高32位
	return int64(high)<<32 | int64(low) // 将高32位和低32位组合成int64值
}

// double consumes two slots
func (self *OperandStack) PushDouble(val float64) {
	bits := math.Float64bits(val) // 将float64值转换为uint64位表示
	self.PushLong(int64(bits)) // 将uint64位表示存储在操作数栈的当前位置和下一个位置
}

func (self *OperandStack) PopDouble() float64 {
	bits := uint64(self.PopLong()) // 从操作数栈的当前位置和下一个位置获取int64值并转换为uint64位表示
	return math.Float64frombits(bits) // 将uint64位表示转换为float64值
}

func (self *OperandStack) PushRef(ref *Object) {
	self.slots[self.size].ref = ref // 将引用存储在操作数栈的当前位置
	self.size++ // 操作数栈的大小加1
}


func (self *OperandStack) PopRef() *Object {
	self.size-- // 操作数栈的大小减1
	ref := self.slots[self.size].ref // 从操作数栈的当前位置获取引用
	self.slots[self.size].ref = nil // 将操作数栈的当前位置的引用置空
	return ref // 返回引用
}

```
其他的方法没什么好说的最后PopRef的时候记得把ref置为nil，这样对象才会被Go Runtime给回收。大概的代码和逻辑已经说完了，接下来试试

修改main文件
```go
package main

import (
	"fmt"
	"jvm/rtda"
)

func main() {
	cmd := parseCmd() // 解析命令行参数

	if cmd.versionFlag {
		fmt.Println("version 0.0.1") // 如果指定了版本标志，打印版本信息
	} else if cmd.helpFlag || cmd.class == "" {
		printUsage() // 如果指定了帮助标志或未指定类名，打印使用说明
	} else {
		startJVM(cmd) // 启动JVM
	}
}
func startJVM(cmd *Cmd) {
	frame := rtda.NewFrame(100, 100)
	testLocalVars(frame.LocalVars())
	testOperandStack(frame.OperandStack())
}

func testLocalVars(vars rtda.LocalVars) {
	vars.SetInt(0, 100)
	vars.SetInt(1, -100)
	vars.SetLong(2, 2997924580)
	vars.SetLong(4, -2997924580)
	vars.SetFloat(6, 3.1415926)
	vars.SetDouble(7, 2.71828182845)
	vars.SetRef(9, nil)
	println(vars.GetInt(0))
	println(vars.GetInt(1))
	println(vars.GetLong(2))
	println(vars.GetLong(4))
	println(vars.GetFloat(6))
	println(vars.GetDouble(7))
	println(vars.GetRef(9))
}

func testOperandStack(ops *rtda.OperandStack) {
	ops.PushInt(100)
	ops.PushInt(-100)
	ops.PushLong(2997924580)
	ops.PushLong(-2997924580)
	ops.PushFloat(3.1415926)
	ops.PushDouble(2.71828182845)
	ops.PushRef(nil)
	println(ops.PopRef())
	println(ops.PopDouble())
	println(ops.PopFloat())
	println(ops.PopLong())
	println(ops.PopLong())
	println(ops.PopInt())
	println(ops.PopInt())
}

```
运行试试

![image.png](/static/img/5cdac1bd954ad378ea8e34a1e5b60cfd.image.webp)

现在还只是实现了基本结构，后续将继续完善并真正派上用场

运行时数据区构建

class文件解析

这节课需要了解的部分是类加载

```java
public class Main
{
	public static void main(String[] args) {
		System.out.println("Hello World");
	}
}


```
上面是一个最简单的Java程序，一个Hello World!，试想如果我们有一个执行字节码的Java虚拟机，我们能直接加载这个类运行吗？

答案是不行，为什么呢？因为这个程序还用到了String类和System这两个类，如果直接加载Main肯定会报找不到xxx,我们需要知道的就是JVM是怎么找到这些类的。

主流的JVM把所有类分为三个路径
- bootstrap classpath
- extension classpath
- user classpath

背过八股文的应该都有所耳闻，分别是启动类路径，扩展类路径和用户类路径，启动类一般在jre/lib，扩展类一般在jre/lib/ext

接下来我们要做的就是增加一个指定JRE路径的参数-Xjre，修改上节课部分代码

```go
flag.Usage = printUsage
	flag.BoolVar(&cmd.helpFlag, "help", false, "print help message")
	flag.BoolVar(&cmd.helpFlag, "?", false, "print help message")
	flag.BoolVar(&cmd.versionFlag, "version", false, "print version and exit")
	flag.StringVar(&cmd.cpOption, "classpath", "", "classpath")
	flag.StringVar(&cmd.cpOption, "cp", "", "classpath")
	flag.StringVar(&cmd.XjreOption, "Xjre", "", "path to jre")
	flag.Parse()
....

type Cmd struct {
	helpFlag    bool
	versionFlag bool
	cpOption    string
	XjreOption  string
	class       string
	args        []string
}
```
主要是加了个参数指定Jre路径，然后按照刚刚我们的思路写代码，总共有三个预选的类路径抽象出来是下面这样
```go
// 定义Classpath结构体，用于管理启动类路径、扩展类路径和用户类路径
type Classpath struct {
    // 启动类路径，用于存放Java核心库
    bootClasspath Entry
    // 扩展类路径，用于存放Java扩展库
    extClasspath  Entry
    // 用户类路径，用于存放用户自定义的类和资源
    userClasspath Entry
}
```
Entry是代表类路径里面每一个项，打开jre\lib,

![image.png](/static/img/b5fc0a786dc6a43fa2d04c9195a80bbd.image.webp)

类库是一个个jar包组织的，所以我们肯定要有一个zip/jar的实现ZipEntry，其他实现分别是DirEntry,代表一个目录项处理，CompositeEntry，处理多路径，WildcardEntry，处理某个路径下所有jar包（模糊匹配）

看一下Entry

```go

// 定义路径列表分隔符，根据操作系统不同，可能是冒号（Linux/Unix）或分号（Windows）
const pathListSeparator = string(os.PathListSeparator)

// 定义Entry接口，包含两个方法：readClass用于读取类文件，String用于返回Entry的字符串表示
type Entry interface {
	readClass(className string) ([]byte, Entry, error)
	String() string
}

// 根据路径参数选择构建对应的Entry实现
func newEntry(path string) Entry {
	// 如果路径包含路径列表分隔符，表示是多路径参数，例如 xxx;xxx;xxx;
	if strings.Contains(path, pathListSeparator) {
		return newCompositeEntry(path)
	}

	// 如果路径以通配符 "*" 结尾，表示要处理该目录下的所有文件，例如 /jre/*
	if strings.HasSuffix(path, "*") {
		return newWildcardEntry(path)
	}

	// 如果路径以 ".jar" 或 ".JAR" 或 ".zip" 或 ".ZIP" 结尾，表示要处理Jar包或Zip包
	if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") ||
		strings.HasSuffix(path, ".zip") || strings.HasSuffix(path, ".ZIP") {
		return newZipEntry(path)
	}

	// 如果以上条件都不满足，表示是单个目录路径
	return newDirEntry(path)
}

```

接下来看几个实现，DirEntry
```go
// 定义DirEntry结构体，用于表示目录条目，包含一个字段absDir表示目录的绝对路径
type DirEntry struct {
    absDir string
}

// 创建一个新的DirEntry实例，将传入的路径转换为绝对路径
func newDirEntry(path string) *DirEntry {
    // 将传入的路径转换为绝对路径
    absDir, err := filepath.Abs(path)
    // 如果转换过程中发生错误，抛出异常
    if err != nil {
        panic(err)
    }
    // 返回一个新的DirEntry实例，包含转换后的绝对路径
    return &DirEntry{absDir}
}

// 读取指定类名的类文件，返回类数据、DirEntry实例和错误信息
func (self *DirEntry) readClass(className string) ([]byte, Entry, error) {
    // 拼接目录绝对路径和类名，得到类的绝对路径
    fileName := filepath.Join(self.absDir, className)
    // 读取类文件的内容
    data, err := ioutil.ReadFile(fileName)
    // 返回类数据、DirEntry实例和错误信息
    return data, self, err
}

// 返回DirEntry的字符串表示，即目录的绝对路径
func (self *DirEntry) String() string {
    return self.absDir
}
```
ZipEntry
```go
// 定义ZipEntry结构体，用于表示ZIP或JAR文件条目，包含一个字段absPath表示文件的绝对路径
type ZipEntry struct {
    absPath string
}

// 创建一个新的ZipEntry实例，将传入的路径转换为绝对路径
func newZipEntry(path string) *ZipEntry {
    // 将传入的路径转换为绝对路径
    absPath, err := filepath.Abs(path)
    // 如果转换过程中发生错误，抛出异常
    if err != nil {
        panic(err)
    }
    // 返回一个新的ZipEntry实例，包含转换后的绝对路径
    return &ZipEntry{absPath}
}

// 读取指定类名的类文件，返回类数据、ZipEntry实例和错误信息
func (self *ZipEntry) readClass(className string) ([]byte, Entry, error) {
    // 打开ZIP或JAR文件
    r, err := zip.OpenReader(self.absPath)
    // 如果打开文件过程中发生错误，返回nil和错误信息
    if err != nil {
        return nil, nil, err
    }

    // 确保在函数返回前关闭ZIP或JAR文件
    defer r.Close()
    // 遍历ZIP或JAR文件中的所有文件
    for _, f := range r.File {
        // 如果找到与类名匹配的文件
        if f.Name == className {
            // 打开该文件
            rc, err := f.Open()
            // 如果打开文件过程中发生错误，返回nil和错误信息
            if err != nil {
                return nil, nil, err
            }

            // 确保在函数返回前关闭文件
            defer rc.Close()
            // 读取文件内容
            data, err := ioutil.ReadAll(rc)
            // 如果读取文件过程中发生错误，返回nil和错误信息
            if err != nil {
                return nil, nil, err
            }

            // 返回类数据、ZipEntry实例和nil错误信息
            return data, self, nil
        }
    }

    // 如果没有找到匹配的类文件，返回nil和错误信息
    return nil, nil, errors.New("class not found: " + className)
}

// 返回ZipEntry的字符串表示，即ZIP或JAR文件的绝对路径
func (self *ZipEntry) String() string {
    return self.absPath
}

```
CompositeEntry
```go
// 定义CompositeEntry类型，它是一个Entry接口的切片，用于表示多个Entry的组合
type CompositeEntry []Entry

// 创建一个新的CompositeEntry实例，根据路径列表创建多个Entry并添加到切片中
func newCompositeEntry(pathList string) CompositeEntry {
    // 创建一个空的Entry切片
    compositeEntry := []Entry{}

    // 将路径列表按路径分隔符分割成多个路径
    for _, path := range strings.Split(pathList, pathListSeparator) {
        // 为每个路径创建一个Entry
        entry := newEntry(path)
        // 将创建的Entry添加到切片中
        compositeEntry = append(compositeEntry, entry)
    }

    // 返回包含多个Entry的CompositeEntry实例
    return compositeEntry
}

// 读取指定类名的类文件，遍历所有Entry，尝试读取类文件，如果成功则返回类数据
func (self CompositeEntry) readClass(className string) ([]byte, Entry, error) {
    // 遍历CompositeEntry中的所有Entry
    for _, entry := range self {
        // 尝试读取类文件
        data, from, err := entry.readClass(className)
        // 如果读取成功，返回类数据、Entry实例和nil错误信息
        if err == nil {
            return data, from, nil
        }
    }

    // 如果没有找到类文件，返回nil和错误信息
    return nil, nil, errors.New("class not found: " + className)
}

// 返回CompositeEntry的字符串表示，将所有Entry的字符串表示用路径分隔符连接起来
func (self CompositeEntry) String() string {
    // 创建一个字符串切片，长度与CompositeEntry中的Entry数量相同
    strs := make([]string, len(self))

    // 遍历CompositeEntry中的所有Entry，将其字符串表示添加到字符串切片中
    for i, entry := range self {
        strs[i] = entry.String()
    }

    // 将字符串切片中的所有字符串用路径分隔符连接起来，返回结果
    return strings.Join(strs, pathListSeparator)
}

```
WildcardEntry，由于这个和上面的思路都差不多，直接套用重写new方法
```go
// 创建一个新的WildcardEntry实例，处理指定目录下的所有JAR文件
func newWildcardEntry(path string) CompositeEntry {
    // 去掉路径末尾的通配符 "*"，得到基础目录
    baseDir := path[:len(path)-1]
    // 创建一个空的Entry切片，用于存储所有JAR文件的Entry
    compositeEntry := []Entry{}

    // 定义walkFn函数，用于处理遍历到的每个文件或目录
    walkFn := func(path string, info os.FileInfo, err error) error {
        // 如果遍历过程中发生错误，返回错误
        if err != nil {
            return err
        }
        // 如果遍历到的是目录且不是基础目录，跳过该目录
        if info.IsDir() && path != baseDir {
            return filepath.SkipDir
        }
        // 如果遍历到的文件是JAR文件（以 ".jar" 或 ".JAR" 结尾）
        if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") {
            // 为该JAR文件创建一个ZipEntry
            jarEntry := newZipEntry(path)
            // 将创建的ZipEntry添加到切片中
            compositeEntry = append(compositeEntry, jarEntry)
        }
        // 返回nil表示继续遍历
        return nil
    }

    // 使用filepath.Walk函数遍历基础目录及其所有子目录，对每个文件或目录调用walkFn函数
    filepath.Walk(baseDir, walkFn)

    // 返回包含所有JAR文件Entry的CompositeEntry实例
    return compositeEntry
}
```

接下来就看看具体的加载逻辑，从命令行开始看
```go
// 启动JVM函数，接受一个Cmd结构体指针作为参数
func startJVM(cmd *Cmd) {
    // 解析JRE选项和类路径选项，得到类路径加载对象
    cp := classpath.Parse(cmd.XjreOption, cmd.cpOption)
    // 打印类路径、主类名和命令行参数
    fmt.Printf("classpath:%v class:%v args:%v\n", cp, cmd.class, cmd.args)

    // 将主类名中的包名分隔符 "." 替换为文件路径分隔符 "/"，转换为绝对路径形式
    className := strings.Replace(cmd.class, ".", "/", -1)
    // 调用类路径加载对象的ReadClass方法，读取主类数据
    classData, _, err := cp.ReadClass(className)
    // 如果读取过程中发生错误，打印错误信息并返回
    if err != nil {
        fmt.Printf("Could not find or load main class %s\n", cmd.class)
        return
    }

    // 打印读取到的类数据
    fmt.Printf("class data:%v\n", classData)
}

```

我们先看看classpath.Parse
```go
// 解析JRE选项和类路径选项，返回一个Classpath结构体指针
func Parse(jreOption, cpOption string) *Classpath {
    // 创建一个Classpath结构体实例
    cp := &Classpath{}
    // 解析启动和扩展类路径，获取对应的加载对象
    cp.parseBootAndExtClasspath(jreOption)
    // 解析用户类路径，获取对应的加载对象
    cp.parseUserClasspath(cpOption)
    // 返回解析后的Classpath结构体指针
    return cp
}

// 解析启动和扩展类路径，设置Classpath结构体的bootClasspath和extClasspath字段
func (self *Classpath) parseBootAndExtClasspath(jreOption string) {
    // 获取JRE目录路径
    jreDir := getJreDir(jreOption)

    // 拼接JRE目录下的lib/*路径，表示启动类路径
    jreLibPath := filepath.Join(jreDir, "lib", "*")
    // 创建一个WildcardEntry实例，表示启动类路径
    self.bootClasspath = newWildcardEntry(jreLibPath)

    // 拼接JRE目录下的lib/ext/*路径，表示扩展类路径
    jreExtPath := filepath.Join(jreDir, "lib", "ext", "*")
    // 创建一个WildcardEntry实例，表示扩展类路径
    self.extClasspath = newWildcardEntry(jreExtPath)
}

// 获取JRE目录路径，优先使用jreOption，其次是当前目录下的jre目录，最后是JAVA_HOME环境变量
func getJreDir(jreOption string) string {
    // 如果jreOption不为空且路径存在，返回jreOption
    if jreOption != "" && exists(jreOption) {
        return jreOption
    }
    // 如果当前目录下的jre目录存在，返回该路径
    if exists("./jre") {
        return "./jre"
    }
    // 如果JAVA_HOME环境变量存在，返回JAVA_HOME下的jre目录路径
    if jh := os.Getenv("JAVA_HOME"); jh != "" {
        return filepath.Join(jh, "jre")
    }
    // 如果以上路径都不存在，抛出异常
    panic("Can not find jre folder!")
}

// 检查指定路径是否存在
func exists(path string) bool {
    // 获取路径的文件信息，如果发生错误
    if _, err := os.Stat(path); err != nil {
        // 如果错误表示路径不存在，返回false
        if os.IsNotExist(err) {
            return false
        }
    }
    // 路径存在，返回true
    return true
}
```

代码很简单易懂，就是根据给出的路径创建对应的类路径项加载对象

然后是ReadClass方法
```go

func (self *Classpath) ReadClass(className string) ([]byte, Entry, error) {
	className = className + ".class" // 拿到类名
	if data, entry, err := self.bootClasspath.readClass(className); err == nil {  // 现在启动类路径加载
		return data, entry, err
	}
	if data, entry, err := self.extClasspath.readClass(className); err == nil {  // 扩展类路径加载
		return data, entry, err
	}
	return self.userClasspath.readClass(className)   // 用户类路径
}

```
也很简单，这个顺序应该很熟悉了，很多八股都会将Java的类加载机制，双亲委托加载什么的，顺序不能乱，接下来就是一层层加载下去直到找到对应的class

当然我们这里只是加载到内存，还没做什么，包括解析什么的

第二章讲解到此
