為了搞清楚類載入，竟然手擼JVM！

作者：小傅哥
部落格：https://bugstack.cn
Github：https://github.com/fuzhengwei/CodeGuide/wiki

沉澱、分享、成長，讓自己和他人都能有所收穫！?

一、前言

學習，不知道從哪下手？

當學習一個新知識不知道從哪下手的時候，最有效的辦法是梳理這個知識結構的脈絡資訊，彙總出一整張的思維匯出。接下來就是按照思維導圖的知識結構，一個個學習相應的知識點，並彙總記錄。

就像JVM的學習，可以說它包括了非常多的內容，也是一個龐大的知識體系。例如：類載入、載入器、生命週期、效能優化、調優引數、調優工具、優化方案、記憶體區域、虛擬機器棧、直接記憶體、記憶體溢位、元空間、垃圾回收、可達性分析、標記清除、回收過程等等。如果沒有梳理的一頭扎進去，東一榔頭西一棒子，很容易造成學習恐懼感。

如圖 24-1 是 JVM 知識框架梳理，後續我們會按照這個結構陸續講解每一塊內容。

二、面試題

謝飛機，小記！，很多知識根本就是背背背，也沒法操作，難學！

謝飛機：大哥，你問我兩個JVM問題，我看看我自己還行不！

面試官：啊？嗯！往死了問還是？

謝飛機：就就就，都行！你看著來！

面試官：啊，那 JVM 載入過程都是什麼步驟？

謝飛機：巴拉巴拉，載入、驗證、準備、解析、初始化、使用、解除安裝！

面試官：嗯，背的挺好！我懷疑你沒操作過！ 那載入的時候，JVM 規範規定從第幾位開始是解析常量池，以及資料型別是如何定義的，u1、u2、u4，是怎麼個玩意？

謝飛機：握草！算了，告訴我看啥吧！

三、類載入過程描述

JVM 類載入過程分為，載入、連結、初始化、使用和解除安裝這四個階段，在連結中又包括：驗證、準備、解析。

• 載入：Java 虛擬機器規範對 class 檔案格式進行了嚴格的規則，但對於從哪裡載入 class 檔案，卻非常自由。Java 虛擬機器實現可以從檔案系統讀取、從JAR(或ZIP)壓縮包中提取 class 檔案。除此之外也可以通過網路下載、資料庫載入，甚至是執行時直接生成的 class 檔案。
• 連結：包括了三個階段；
  • 驗證，確保被載入類的正確性，驗證位元組流是否符合 class 檔案規範，例魔數 0xCAFEBABE，以及版本號等。
  • 準備，為類的靜態變數分配記憶體並設定變數初始值等
  • 解析，解析包括解析出常量池資料和屬性表資訊，這裡會包括 ConstantPool 結構體以及 AttributeInfo 介面等。
• 初始化：類載入完成的最後一步就是初始化，目的就是為標記常量值的欄位賦值，以及執行 <clinit> 方法的過程。JVM虛擬機器通過鎖的方式確保 clinit 僅被執行一次
• 使用：程式程式碼執行使用階段。
• 解除安裝：程式程式碼退出、異常、結束等。

四、寫個程式碼載入下

JVM 之所以不好掌握，主要是因為不好實操。虛擬機器是 C++ 寫的，很多 Java 程式設計師根本就不會去讀，或者讀不懂。那麼，也就沒辦法實實在在的體會到，到底是怎麼載入的，載入的時候都幹了啥。只有看到程式碼，我才覺得自己學會了！

所以，我們這裡要手動寫一下，JVM 虛擬機器的部分程式碼，也就是類載入的過程。通過 Java 程式碼來實現 Java 虛擬機器的部分功能，讓開發 Java 程式碼的程式設計師更容易理解虛擬機器的執行過程。

1. 案例工程

interview-24
├── pom.xml
└── src
    └── main
    │    └── java
    │        └── org.itstack.interview.jvm
    │             ├── classpath
    │             │   ├── impl
    │             │   │   ├── CompositeEntry.java
    │             │   │   ├── DirEntry.java 
    │             │   │   ├── WildcardEntry.java 
    │             │   │   └── ZipEntry.java    
    │             │   ├── Classpath.java
    │             │   └── Entry.java    
    │             ├── Cmd.java
    │             └── Main.java
    └── test
         └── java
             └── org.itstack.interview.jvm.test
                 └── HelloWorld.java

以上，工程結構就是按照 JVM 虛擬機器規範，使用 Java 程式碼實現 JVM 中載入 class 檔案部分內容。當然這部分還不包括解析，因為解析部分的程式碼非常龐大，我們先從把 .class 檔案載入讀取開始瞭解。

2. 程式碼講解

2.1 定義類路徑介面(Entry)

public interface Entry {

    byte[] readClass(String className) throws IOException;
    
    static Entry create(String path) {
        //File.pathSeparator；路徑分隔符(win\linux)
        if (path.contains(File.pathSeparator)) {
            return new CompositeEntry(path);
        }
        if (path.endsWith("*")) {
            return new WildcardEntry(path);
        }
        if (path.endsWith(".jar") || path.endsWith(".JAR") ||
                path.endsWith(".zip") || path.endsWith(".ZIP")) {
            return new ZipEntry(path);
        }
        return new DirEntry(path);
    }
}

• 介面中提供了介面方法 readClass 和靜態方法 create(String path)。
• jdk1.8 是可以在介面中編寫靜態方法的，在設計上屬於補全了抽象類的類似功能。這個靜態方法主要是按照不同的路徑地址型別，提供不同的解析方法。包括：CompositeEntry、WildcardEntry、ZipEntry、DirEntry，這四種。接下來分別看每一種的具體實現

2.2 目錄形式路徑(DirEntry)

public class DirEntry implements Entry {

    private Path absolutePath;

    public DirEntry(String path){
        //獲取絕對路徑
        this.absolutePath = Paths.get(path).toAbsolutePath();
    }

    @Override
    public byte[] readClass(String className) throws IOException {
        return Files.readAllBytes(absolutePath.resolve(className));
    }

    @Override
    public String toString() {
        return this.absolutePath.toString();
    }
}

• 目錄形式的通過讀取絕對路徑下的檔案，通過 Files.readAllBytes 方式獲取位元組碼。

2.3 壓縮包形式路徑(ZipEntry)

public class ZipEntry implements Entry {

    private Path absolutePath;

    public ZipEntry(String path) {
        //獲取絕對路徑
        this.absolutePath = Paths.get(path).toAbsolutePath();
    }

    @Override
    public byte[] readClass(String className) throws IOException {
        try (FileSystem zipFs = FileSystems.newFileSystem(absolutePath, null)) {
            return Files.readAllBytes(zipFs.getPath(className));
        }
    }

    @Override
    public String toString() {
        return this.absolutePath.toString();
    }

}

• 其實壓縮包形式與目錄形式，只有在檔案讀取上有包裝差別而已。FileSystems.newFileSystem

2.4 混合形式路徑(CompositeEntry)

public class CompositeEntry implements Entry {

    private final List<Entry> entryList = new ArrayList<>();

    public CompositeEntry(String pathList) {
        String[] paths = pathList.split(File.pathSeparator);
        for (String path : paths) {
            entryList.add(Entry.create(path));
        }
    }

    @Override
    public byte[] readClass(String className) throws IOException {
        for (Entry entry : entryList) {
            try {
                return entry.readClass(className);
            } catch (Exception ignored) {
                //ignored
            }
        }
        throw new IOException("class not found " + className);
    }


    @Override
    public String toString() {
        String[] strs = new String[entryList.size()];
        for (int i = 0; i < entryList.size(); i++) {
            strs[i] = entryList.get(i).toString();
        }
        return String.join(File.pathSeparator, strs);
    }
    
}

• File.pathSeparator，是一個分隔符屬性，win/linux 有不同的型別，所以使用這個方法進行分割路徑。
• 分割後的路徑裝到 List 集合中，這個過程屬於拆分路徑。

2.5 萬用字元型別路徑(WildcardEntry)

public class WildcardEntry extends CompositeEntry {

    public WildcardEntry(String path) {
        super(toPathList(path));
    }

    private static String toPathList(String wildcardPath) {
        String baseDir = wildcardPath.replace("*", ""); // remove *
        try {
            return Files.walk(Paths.get(baseDir))
                    .filter(Files::isRegularFile)
                    .map(Path::toString)
                    .filter(p -> p.endsWith(".jar") || p.endsWith(".JAR"))
                    .collect(Collectors.joining(File.pathSeparator));
        } catch (IOException e) {
            return "";
        }
    }

}

• 這個類屬於混合形式路徑處理類的子類，唯一提供的方法就是把類路徑解析出來。

2.6 類路徑解析(Classpath)

啟動類路徑、擴充套件類路徑、使用者類路徑，熟悉嗎？是不經常看到這幾句話，那麼時候怎麼實現的呢？

有了上面我們做的一些基礎類的工作，接下來就是類解析的實際呼叫過程。程式碼如下：

public class Classpath {

    private Entry bootstrapClasspath;  //啟動類路徑
    private Entry extensionClasspath;  //擴充套件類路徑
    private Entry userClasspath;       //使用者類路徑

    public Classpath(String jreOption, String cpOption) {
        //啟動類&擴充套件類 "C:\Program Files\Java\jdk1.8.0_161\jre"
        bootstrapAndExtensionClasspath(jreOption);
        //使用者類 F:\..\org\itstack\demo\test\HelloWorld
        parseUserClasspath(cpOption);
    }

    private void bootstrapAndExtensionClasspath(String jreOption) {
        
        String jreDir = getJreDir(jreOption);

        //..jre/lib/*
        String jreLibPath = Paths.get(jreDir, "lib") + File.separator + "*";
        bootstrapClasspath = new WildcardEntry(jreLibPath);

        //..jre/lib/ext/*
        String jreExtPath = Paths.get(jreDir, "lib", "ext") + File.separator + "*";
        extensionClasspath = new WildcardEntry(jreExtPath);

    }

    private static String getJreDir(String jreOption) {
        if (jreOption != null && Files.exists(Paths.get(jreOption))) {
            return jreOption;
        }
        if (Files.exists(Paths.get("./jre"))) {
            return "./jre";
        }
        String jh = System.getenv("JAVA_HOME");
        if (jh != null) {
            return Paths.get(jh, "jre").toString();
        }
        throw new RuntimeException("Can not find JRE folder!");
    }

    private void parseUserClasspath(String cpOption) {
        if (cpOption == null) {
            cpOption = ".";
        }
        userClasspath = Entry.create(cpOption);
    }

    public byte[] readClass(String className) throws Exception {
        className = className + ".class";

        //[readClass]啟動類路徑
        try {
            return bootstrapClasspath.readClass(className);
        } catch (Exception ignored) {
            //ignored
        }

        //[readClass]擴充套件類路徑
        try {
            return extensionClasspath.readClass(className);
        } catch (Exception ignored) {
            //ignored
        }

        //[readClass]使用者類路徑
        return userClasspath.readClass(className);
    }

}

• 啟動類路徑，bootstrapClasspath.readClass(className);
• 擴充套件類路徑，extensionClasspath.readClass(className);
• 使用者類路徑，userClasspath.readClass(className);
• 這回就看到它們具體在哪使用了吧！有了具體的程式碼也就方便理解了

2.7 載入類測試驗證

private static void startJVM(Cmd cmd) {
    Classpath cp = new Classpath(cmd.jre, cmd.classpath);
    System.out.printf("classpath：%s class：%s args：%s\n", cp, cmd.getMainClass(), cmd.getAppArgs());
    //獲取className
    String className = cmd.getMainClass().replace(".", "/");
    try {
        byte[] classData = cp.readClass(className);
        System.out.println(Arrays.toString(classData));
    } catch (Exception e) {
        System.out.println("Could not find or load main class " + cmd.getMainClass());
        e.printStackTrace();
    }
}

這段就是使用 Classpath 類進行類路徑載入，這裡我們測試載入 java.lang.String 類。你可以載入其他的類，或者自己寫的類

• 配置IDEA，program arguments 引數：-Xjre "C:\Program Files\Java\jdk1.8.0_161\jre" java.lang.String
• 另外這裡讀取出的 class 檔案資訊，列印的是 byte 型別資訊。

測試結果

[-54, -2, -70, -66, 0, 0, 0, 52, 2, 28, 3, 0, 0, -40, 0, 3, 0, 0, -37, -1, 3, 0, 0, -33, -1, 3, 0, 1, 0, 0, 8, 0, 15, 8, 0, 61, 8, 0, 85, 8, 0, 88, 8, 0, 89, 8, 0, 112, 8, 0, -81, 8, 0, -75, 8, 0, -47, 8, 0, -45, 1, 0, 0, 1, 0, 3, 40, 41, 73, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 3, 40, 41, 86, 1, 0, 3, 40, 41, 90, 1, 0, 4, 40, 41, 91, ...]

這塊部分擷取的程式執行列印結果，就是讀取的 class 檔案資訊，只不過暫時還不能看出什麼。接下來我們再把它翻譯過來！

五、解析位元組碼檔案

JVM 在把 class 檔案載入完成後，接下來就進入連結的過程，這個過程包括了內容的校驗、準備和解析，其實就是把 byte 型別 class 翻譯過來，做相應的操作。

整個這個過程內容相對較多，這裡只做部分邏輯的實現和講解。如果讀者感興趣可以閱讀小傅哥的《用Java實現JVM》專欄。

1. 提取部分位元組碼

//取部分位元組碼：java.lang.String
private static byte[] classData = {
        -54, -2, -70, -66, 0, 0, 0, 52, 2, 26, 3, 0, 0, -40, 0, 3, 0, 0, -37, -1, 3, 0, 0, -33, -1, 3, 0, 1, 0, 0, 8, 0,
        59, 8, 0, 83, 8, 0, 86, 8, 0, 87, 8, 0, 110, 8, 0, -83, 8, 0, -77, 8, 0, -49, 8, 0, -47, 1, 0, 3, 40, 41, 73, 1,
        0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 1, 0, 20, 40, 41,
        76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 3, 40, 41, 86, 1, 0, 3,
        40, 41, 90, 1, 0, 4, 40, 41, 91, 66, 1, 0, 4, 40, 41, 91, 67, 1, 0, 4, 40, 67, 41, 67, 1, 0, 21, 40, 68, 41, 76,
        106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 4, 40, 73, 41, 67, 1, 0, 4};

• java.lang.String 解析出來的位元組碼內容較多，當然包括的內容也多，比如魔數、版本、類、常量、方法等等。所以我們這裡只擷取部分進行進行解析。

2. 解析魔數並校驗

很多檔案格式都會規定滿足該格式的檔案必須以某幾個固定位元組開頭，這幾個位元組主要起到標識作用，叫作魔數(magic number)。

例如；

• PDF檔案以4位元組“%PDF”(0x25、0x50、0x44、0x46)開頭，
• ZIP檔案以2位元組“PK”(0x50、0x4B)開頭
• class檔案以4位元組“0xCAFEBABE”開頭

private static void readAndCheckMagic() {
    System.out.println("\r\n------------ 校驗魔數 ------------");
    //從class位元組碼中讀取前四位
    byte[] magic_byte = new byte[4];
    System.arraycopy(classData, 0, magic_byte, 0, 4);
    
    //將4位byte位元組轉成16進位制字串
    String magic_hex_str = new BigInteger(1, magic_byte).toString(16);
    System.out.println("magic_hex_str：" + magic_hex_str);
    
    //byte_magic_str 是16進位制的字串，cafebabe，因為java中沒有無符號整型，所以如果想要無符號只能放到更高位中
    long magic_unsigned_int32 = Long.parseLong(magic_hex_str, 16);
    System.out.println("magic_unsigned_int32：" + magic_unsigned_int32);
    
    //魔數比對，一種通過字串比對，另外一種使用假設的無符號16進位制比較。如果使用無符號比較需要將0xCAFEBABE & 0x0FFFFFFFFL與運算
    System.out.println("0xCAFEBABE & 0x0FFFFFFFFL：" + (0xCAFEBABE & 0x0FFFFFFFFL));
    
    if (magic_unsigned_int32 == (0xCAFEBABE & 0x0FFFFFFFFL)) {
        System.out.println("class位元組碼魔數無符號16進位制數值一致校驗通過");
    } else {
        System.out.println("class位元組碼魔數無符號16進位制數值一致校驗拒絕");
    }
}

• 讀取位元組碼中的前四位，-54, -2, -70, -66，將這四位轉換為16進位制。
• 因為 java 中是沒有無符號整型的，所以只能用更高位存放。
• 解析後就是魔數的對比，看是否與 CAFEBABE 一致。

測試結果

------------ 校驗魔數 ------------
magic_hex_str：cafebabe
magic_unsigned_int32：3405691582
0xCAFEBABE & 0x0FFFFFFFFL：3405691582
class位元組碼魔數無符號16進位制數值一致校驗通過

3. 解析版本號資訊

剛才我們已經讀取了4位魔數資訊，接下來再讀取2位，是版本資訊。

魔數之後是class檔案的次版本號和主版本號，都是u2型別。假設某class檔案的主版本號是M，次版本號是m，那麼完整的版本號可以表示成“M.m”的形式。次版本號只在J2SE 1.2之前用過，從1.2開始基本上就沒有什麼用了(都是0)。主版本號在J2SE 1.2之前是45，從1.2開始，每次有大版本的Java版本釋出，都會加1｛45、46、47、48、49、50、51、52｝

private static void readAndCheckVersion() {
    System.out.println("\r\n------------ 校驗版本號 ------------");
    //從class位元組碼第4位開始讀取，讀取2位
    byte[] minor_byte = new byte[2];
    System.arraycopy(classData, 4, minor_byte, 0, 2);
    
    //將2位byte位元組轉成16進位制字串
    String minor_hex_str = new BigInteger(1, minor_byte).toString(16);
    System.out.println("minor_hex_str：" + minor_hex_str);
    
    //minor_unsigned_int32 轉成無符號16進位制
    int minor_unsigned_int32 = Integer.parseInt(minor_hex_str, 16);
    System.out.println("minor_unsigned_int32：" + minor_unsigned_int32);
    
    //從class位元組碼第6位開始讀取，讀取2位
    byte[] major_byte = new byte[2];
    System.arraycopy(classData, 6, major_byte, 0, 2);
    
    //將2位byte位元組轉成16進位制字串
    String major_hex_str = new BigInteger(1, major_byte).toString(16);
    System.out.println("major_hex_str：" + major_hex_str);
    
    //major_unsigned_int32 轉成無符號16進位制
    int major_unsigned_int32 = Integer.parseInt(major_hex_str, 16);
    System.out.println("major_unsigned_int32：" + major_unsigned_int32);
    System.out.println("版本號：" + major_unsigned_int32 + "." + minor_unsigned_int32);
}

• 這裡有一個小技巧，class 檔案解析出來是一整片的內容，JVM 需要按照虛擬機器規範，一段一段的解析出所有的資訊。
• 同樣這裡我們需要把2位byte轉換為16進位制資訊，並繼續從第6位繼續讀取2位資訊。組合出來的才是版本資訊。

測試結果

------------ 校驗版本號 ------------
minor_hex_str：0
minor_unsigned_int32：0
major_hex_str：34
major_unsigned_int32：52
版本號：52.0

4. 解析全部內容對照

按照 JVM 的載入過程，其實遠不止魔數和版本號資訊，還有很多其他內容，這裡我們可以把測試結果展示出來，方便大家有一個學習結果的比對印象。

classpath：org.itstack.demo.jvm.classpath.Classpath@4bf558aa class：java.lang.String args：null
version: 52.0
constants count：540
access flags：0x31
this class：java/lang/String
super class：java/lang/Object
interfaces：[java/io/Serializable, java/lang/Comparable, java/lang/CharSequence]
fields count：5
value 		 [C
hash 		 I
serialVersionUID 		 J
serialPersistentFields 		 [Ljava/io/ObjectStreamField;
CASE_INSENSITIVE_ORDER 		 Ljava/util/Comparator;
methods count: 94
<init> 		 ()V
<init> 		 (Ljava/lang/String;)V
<init> 		 ([C)V
<init> 		 ([CII)V
<init> 		 ([III)V
<init> 		 ([BIII)V
<init> 		 ([BI)V
checkBounds 		 ([BII)V
<init> 		 ([BIILjava/lang/String;)V
<init> 		 ([BIILjava/nio/charset/Charset;)V
<init> 		 ([BLjava/lang/String;)V
<init> 		 ([BLjava/nio/charset/Charset;)V
<init> 		 ([BII)V
<init> 		 ([B)V
<init> 		 (Ljava/lang/StringBuffer;)V
<init> 		 (Ljava/lang/StringBuilder;)V
<init> 		 ([CZ)V
length 		 ()I
isEmpty 		 ()Z
charAt 		 (I)C
codePointAt 		 (I)I
codePointBefore 		 (I)I
codePointCount 		 (II)I
offsetByCodePoints 		 (II)I
getChars 		 ([CI)V
getChars 		 (II[CI)V
getBytes 		 (II[BI)V
getBytes 		 (Ljava/lang/String;)[B
getBytes 		 (Ljava/nio/charset/Charset;)[B
getBytes 		 ()[B
equals 		 (Ljava/lang/Object;)Z
contentEquals 		 (Ljava/lang/StringBuffer;)Z
nonSyncContentEquals 		 (Ljava/lang/AbstractStringBuilder;)Z
contentEquals 		 (Ljava/lang/CharSequence;)Z
equalsIgnoreCase 		 (Ljava/lang/String;)Z
compareTo 		 (Ljava/lang/String;)I
compareToIgnoreCase 		 (Ljava/lang/String;)I
regionMatches 		 (ILjava/lang/String;II)Z
regionMatches 		 (ZILjava/lang/String;II)Z
startsWith 		 (Ljava/lang/String;I)Z
startsWith 		 (Ljava/lang/String;)Z
endsWith 		 (Ljava/lang/String;)Z
hashCode 		 ()I
indexOf 		 (I)I
indexOf 		 (II)I
indexOfSupplementary 		 (II)I
lastIndexOf 		 (I)I
lastIndexOf 		 (II)I
lastIndexOfSupplementary 		 (II)I
indexOf 		 (Ljava/lang/String;)I
indexOf 		 (Ljava/lang/String;I)I
indexOf 		 ([CIILjava/lang/String;I)I
indexOf 		 ([CII[CIII)I
lastIndexOf 		 (Ljava/lang/String;)I
lastIndexOf 		 (Ljava/lang/String;I)I
lastIndexOf 		 ([CIILjava/lang/String;I)I
lastIndexOf 		 ([CII[CIII)I
substring 		 (I)Ljava/lang/String;
substring 		 (II)Ljava/lang/String;
subSequence 		 (II)Ljava/lang/CharSequence;
concat 		 (Ljava/lang/String;)Ljava/lang/String;
replace 		 (CC)Ljava/lang/String;
matches 		 (Ljava/lang/String;)Z
contains 		 (Ljava/lang/CharSequence;)Z
replaceFirst 		 (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
replaceAll 		 (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
replace 		 (Ljava/lang/CharSequence;Ljava/lang/CharSequence;)Ljava/lang/String;
split 		 (Ljava/lang/String;I)[Ljava/lang/String;
split 		 (Ljava/lang/String;)[Ljava/lang/String;
join 		 (Ljava/lang/CharSequence;[Ljava/lang/CharSequence;)Ljava/lang/String;
join 		 (Ljava/lang/CharSequence;Ljava/lang/Iterable;)Ljava/lang/String;
toLowerCase 		 (Ljava/util/Locale;)Ljava/lang/String;
toLowerCase 		 ()Ljava/lang/String;
toUpperCase 		 (Ljava/util/Locale;)Ljava/lang/String;
toUpperCase 		 ()Ljava/lang/String;
trim 		 ()Ljava/lang/String;
toString 		 ()Ljava/lang/String;
toCharArray 		 ()[C
format 		 (Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
format 		 (Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
valueOf 		 (Ljava/lang/Object;)Ljava/lang/String;
valueOf 		 ([C)Ljava/lang/String;
valueOf 		 ([CII)Ljava/lang/String;
copyValueOf 		 ([CII)Ljava/lang/String;
copyValueOf 		 ([C)Ljava/lang/String;
valueOf 		 (Z)Ljava/lang/String;
valueOf 		 (C)Ljava/lang/String;
valueOf 		 (I)Ljava/lang/String;
valueOf 		 (J)Ljava/lang/String;
valueOf 		 (F)Ljava/lang/String;
valueOf 		 (D)Ljava/lang/String;
intern 		 ()Ljava/lang/String;
compareTo 		 (Ljava/lang/Object;)I
<clinit> 		 ()V

Process finished with exit code 0

• 如果大家對這部分驗證、準備、解析，的實現過程感興趣，可以參照這部分用Java實現的JVM原始碼：https://github.com/fuzhengwei/itstack-demo-jvm

六、總結

• 學習 JVM 最大的問題是不好實踐，所以本文以案例實操的方式，學習 JVM 的載入解析過程。也讓更多的對 JVM 感興趣的研發，能更好的接觸到 JVM 並深入的學習。
• 有了以上這段程式碼，大家可以參照 JVM 虛擬機器規範，在除錯Java版本的JVM，這樣就可以非常容易理解整個JVM的載入過程，都做了什麼。
• 如果大家需要文章中一些原圖 xmind 或者原始碼，可以新增作者小傅哥(fustack)，或者關注公眾號：bugstack蟲洞棧進行獲取。好了，本章節就扯到這，後續還有很多努力，持續原創，感謝大家的支援！

七、系列推薦

• ReentrantLock之公平鎖講解和實現
• 除了JDK、CGLIB，還有3種類代理方式？面試又卡住！
• 面試官，ThreadLocal 你要這麼問，我就掛了！
• 手寫執行緒池，對照學習ThreadPoolExecutor執行緒池實現原理！
• 一次程式碼評審，差點過不了試用期！