go實現java虛擬機02

　　上一篇通過flag包實現了命令行參數的解析，其實就是將輸入的參數保存到一個結構體中，上一篇說過的例如java -classpath hello.jar HelloWorld這種命令，那麼HelloWorld這個類是怎麼找出來的呢？是直接在hello.jar中去找嗎？

　　還記得java的類加載機制嗎？有個叫做雙親委託機制，就比如我們自己定義一個String類爲什麼沒用呢？雖然說編譯時可以通過的，但是在運行的時候卻會報錯，如下所示，爲什麼提示String類中沒有main方法呢，明明我就寫了呀！其實是在類加載的時候，首先會把String類交給啓動類加載器加載，也就是在jdk中jre/lib目錄下去找；沒有的話就使用擴展類加載器去加載，也就是在jdk中jre/lib/ext中去加載，最後纔是我們用戶的類路徑下找，默認是當前路徑，也可以通過-classpath命令指定用戶類路徑；

　　而String類很明顯在啓動類路徑下rt.jar包中，所以加載當的是官方的String類，當然沒有main方法啦！

 

　　再回到最開始的問題，例如java -classpath hello.jar HelloWorld這種命令，HelloWorld這個類在哪裏找，現在就很清楚了，現在jdk下jre/lib中找，找不到就到jre/lib/ext中找，還找不到就在-classpath指定的路徑中找，下面就用go代碼實現一下，文件目錄如下，這次的目錄是ch02，基於上一篇的ch01實現，classpath是一個目錄，cmd.go和main.go是文件

 

 一.命令行添加jre路徑

　　爲了可以更好的指定jre路徑，我們命令行中添加一個參數-Xjre，例如ch2 -Xjre “D:\java\jdk8” java.lang.String，如果命令行中沒有指定-Xjre參數，那麼就去你計算機環境變量中獲取JAVA_HOME了，這就不多說了，所以我們要把cmd.go這裏結構體做一個修改，以及對應的解析也添加一個，不多說；

 

 二.定義類路徑接口

　　在classpath目錄下定義Entry接口，這個接口是找到制指定class文件的入口，這個接口很重要，根據-classpath後面實際上傳進去的路徑，可以判斷應該獲取哪個實例去該路徑下讀取class字節碼文件；其中有四種類型的結構體：CompositeEntry，WildcardEntry，ZipEntry和DirEntry，這四種結構體都要實現Entry接口，我們先別在意這四種是怎麼實現的，假設已經實現好了，我們直接拿來用；

package classpath

import (
    "os"
    "strings"
)

//這裏存放類路徑的分隔符，這裏是分號，因爲-classpath命令行中後面可以指定多個目錄名稱，用分號分隔
const pathListSeparator = string(os.PathListSeparator)

type Entry interface {
    //這個接口用於尋找和加載class文件
    //className是類的相對路徑，斜線分隔，以.class文件結尾，比如要讀取java.lang.Object，應該傳入java/lang/Object.class
    //返回的數據有該class文件的字節數組
    readClass(className string) ([]byte, Entry, error)

    //相當於java中的toString方法
    String() string
}

//根據參數不同創建不同類型的Entry
func newEntry(path string) Entry {
    //如果有多個類以分號的形式傳進來，就實例化CompositeEntry這個Entry
    //例如java -classpath path\to\classes;lib\a.jar;lib\b.jar;lib\c.zip ...這種路徑形式
    if strings.Contains(path, pathListSeparator) {
        return newCompositeEntry(path)
    }

    //傳進去的類全路徑path字符串是以*號結尾
    //例如java -classpath lib\*...
    if strings.HasSuffix(path, "*") {
        return newWildcardEntry(path)
    }

    //傳進去的類的全路徑名是以jar，JAR，zip，ZIP結尾的字符串
    //例如java -classpath hello.jar ...  或者   java -classpath hello.zip ...
    if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") ||
        strings.HasSuffix(path, ".zip") || strings.HasSuffix(path, ".ZIP") {
        return newZipEntry(path)
    }

    //這種就是該java文件在當前目錄下
    return newDirEntry(path)
}

 

三.實現雙親委託機制

　　上面是定義好了具體的針對不同路徑進行解析的結構體，下面我們就實現雙親委託機制就行了，其實比較容易，大概的邏輯就是：例如命令行輸入的是.\ch02.exe -Xjre "D:\java\jdk8\jre" java.lang.Object，那麼首先會判斷我們提供的jre目錄"D:\java\jdk8\jre"是否存在，不存在的話就獲取環境變量的jre，反正就是獲取jre路徑；

　　然後就是獲取jre下的lib/*和lib/ext/*，將這兩個目錄分別實例化兩個Entry實例（其實每一種Entry實例就是對每一種不同路徑下的文件進行io流讀取），分別對應着啓動類路徑和擴展類路徑；最後就是判斷有沒有提供-classpath參數，沒有提供的話就默認當前目錄下所有文件對於這用戶類路徑

package classpath

import (
    "os"
    "path/filepath"
)

//三種類路徑對應的Entry
type Classpath struct {
    //啓動類路徑
    bootClasspath Entry
    //擴展類路徑
    extClasspath Entry
    //用戶自定義的類路徑
    userClasspath Entry
}

//jreOption這個參數用於讀取啓動類和擴展類
//cpOption這個參數用於解析用戶類
//命令行輸入      .\ch02.exe -Xjre "D:\java\jdk8\jre" java.lang.Object
func Parse(jreOption string, cpOption string) *Classpath {
    cp := &Classpath{}
    //解析啓動類路徑和擴展類路徑
    cp.parseBootAndClasspath(jreOption)
    cp.parseUserClasspath(cpOption)
    return cp
}

//拼接啓動類和擴展類的的路徑，然後實例化對應的Entry
func (this *Classpath) parseBootAndClasspath(jreOption string) {
    //這裏就是判斷這個jre路徑是否存在，不存在就在環境變量中獲取JAVA_HOMR變量+jre
    //總之就是想盡辦法獲取jdk下的jre文件夾全路徑
    jreDir := getJreDir(jreOption)

    //由於找到了jdk下的jre文件夾，那麼下一步就是找到啓動類和擴展類所在的目錄
    //拼接路徑：jre/lib/*
    jreLibPath := filepath.Join(jreDir, "lib", "*")
    this.bootClasspath = newWildcardEntry(jreLibPath)

    //拼接路徑：jre/lib/ext/*
    jreExtPath := filepath.Join(jreDir, "lib", "ext", "*")
    this.extClasspath = newWildcardEntry(jreExtPath)
}

//這個函數就是獲取正確的jre文件夾，注意jreOption是絕對路徑哦
func getJreDir(jreOption string) string {
    //傳進來的文件路徑存在的話，那就返回
    if jreOption != "" && exists(jreOption) {
        return jreOption
    }
    //傳進來的路徑不存在，那麼判斷當前路徑下是否有jre文件夾
    if exists("./jre") {
        return "./jre"
    }
    //當前路徑不存在，當前路徑下也沒有jre文件夾，那麼就直接獲取jdk下的jre全路徑
    if jh := os.Getenv("JAVA_HOME"); jh != "" {
        return filepath.Join(jh, "jre")
    }
    //都沒有的話就拋出沒有這個文件夾
    panic("can not find jre folder ")

}

//判斷一個目錄是否存在，存在的話就返回true，不存在就返回false
func exists(jreOption string) bool {
    if _, err := os.Stat(jreOption); err != nil {
        if os.IsNotExist(err) {
            return false
        }
    }
    return true
}

//加載用戶類，如果-classpath的參數爲空，那麼就默認當前路徑爲用戶類所在的路徑
func (this *Classpath) parseUserClasspath(cpOption string) {
    if cpOption == "" {
        cpOption = "."
    }
    this.userClasspath = newEntry(cpOption)
}

//此方法可以看到實現了雙親委託機制
//在jdk中遍歷啓動類，擴展類和用戶定義的類,這個ReadClass是個公開方法，在其他包中可以調用
func (this *Classpath) ReadClass(className string) ([]byte, Entry, error) {
    className = className + ".class"
    if data, entry, err := this.bootClasspath.readClass(className); err == nil {
        return data, entry, err
    }
    if data, entry, err := this.extClasspath.readClass(className); err == nil {
        return data, entry, err
    }
    return this.userClasspath.readClass(className)
}

func (this *Classpath) String() string {
    return this.userClasspath.String()
}

 

四.修改main.go文件

　　之前這裏startJVM函數就是隨便打印了一行數據，現在我們就可以調用上面的Parse方法，根據命令行傳入的jre和類，根據雙親委託機制在jre(注意，這裏指定的jre路徑不存在的話就會獲取環境變量中的jre)中找指定的類，加載該類的class字節碼文件到內存中，然後給打印出來；

package main

import (
    "firstGoPrj0114/jvmgo/ch02/classpath"
    "fmt"
    "strings"
)

//命令行輸入      .\ch02.exe -Xjre "D:\java\jdk8\jre" java.lang.Object

func main() {
    cmd := parseCmd()
    if cmd.versionFlag {
        fmt.Println("version 1.0.0")
    } else if cmd.helpFlag || cmd.class == "" {
        printUsage()
    } else {
        startJVM(cmd)
    }

}

//主要是修改這個函數
func startJVM(cmd *Cmd) {
    //傳入jdk中的jre全路徑和類名，就會去裏面lib中去找或者lib/ext中去找對應的類
    //命令行輸入      .\ch02.exe -Xjre "D:\java\jdk8\jre" java.lang.Object
    cp := classpath.Parse(cmd.XjreOption, cmd.cpOption)
    fmt.Printf("classpath:%v class:%v args:%v\n", cp, cmd.class, cmd.args)
    //將全類名中的.轉爲/,以目錄的形式去讀取class文件，例如上面的java.lang.Object就變成了java/lang/Object
    className := strings.Replace(cmd.class, ".", "/", -1)
    //去讀取指定類的時候，會有一個順序，首先去啓動需要的類中嘗試去加載，然後再到擴展類目錄下去加載，最後就是到用戶定義的目錄加載
    //其中用戶定義的目錄，可以有很多中方式，可以指定是.zip方式,也可以是.jar方式
    classData, _, err := cp.ReadClass(className)
    if err != nil {
        fmt.Printf("Could not find or load mian class %s\n", cmd.class)
        return
    }
    fmt.Printf("class data:%v\n", classData)

}

 

 

5.Entry接口的實現類

　　爲什麼這個放到最後再說呢？因爲這個我感覺不是最核心的吧，把前面基本的邏輯弄清楚了，然後就是對幾種不同路徑的文件進行查找然後讀取；

　　前面說過，我們傳進去的-classpath後面的參數可以有很多種，例如：

//對應DirEntry
java -classpath path\to\service HelloWorld
//對應WildcardEntry
java -classpath path\to\* HelloWorld
//對應ZipEntry
java -classpath path\to\lib2.zip HelloWorld
java -classpath path\to\hello.jar HelloWorld
//由於可以有多個路徑，對應CompositeEntry
java -classpath path\to\classes\*;lib\a.jar;lib\b.jar;lib\c.zip HelloWorld

 

 

　　5.1 DirEntry

　　這個是最容易的，該結構體中只是存了一個絕對路徑

package classpath

import (
    "io/ioutil"
    "path/filepath"
)

//結構體相當於類，newDirEntry相當於構造方法，下面的readClass和String就是實現接口的方法
type DirEntry struct {
    //這裏用於存放絕對路徑
    absString string
}

//返回一個DirEntry實例
func newDirEntry(path string) *DirEntry {
    //將參數轉爲絕對路徑,如果是在命令行中使用，那麼就會非常精確到當前文件父文件+當前文件
    //如果是在編輯器中使用，那麼在這裏就是當前只會到當前項目路徑+文件路徑
    absDir, err := filepath.Abs(path)
    if err != nil {
        panic(err) //終止程序運行
    }
    return &DirEntry{absString: absDir}

}

//DirEntry實現了Entry的readClass方法，拼接class字節碼文件的絕對路徑，然後用ioUtil包中提供的ReadFile函數去讀取
func (self *DirEntry) readClass(className string) ([]byte, Entry, error) {
    fileName := filepath.Join(self.absString, className)
    data, err := ioutil.ReadFile(fileName)
    return data, self, err
}

//也實現了Entry的String方法
func (self *DirEntry) String() string {
    return self.absString
}

 

 

　　5.2 ZipEntry

　　這個比較容易，因爲zip壓縮包中可以有多個文件，所以只是遍歷，比較文件名就行了

package classpath

import (
    "archive/zip"
    "errors"
    "io/ioutil"
    "path/filepath"
)

//裏面也是存了一個絕對路徑
type ZipEntry struct {
    absPath string
}

//構造函數
func newZipEntry(path string) *ZipEntry {
    abs, err := filepath.Abs(path)
    if err != nil {
        panic(err)
    }
    return &ZipEntry{absPath: abs}
}

//從zip包中解析class文件，這裏比較關鍵
func (self *ZipEntry) readClass(className string) ([]byte, Entry, error) {
    //go中專門有個zip包讀取zip類型的文件
    reader, err := zip.OpenReader(self.absPath)
    if err != nil {
        return nil, nil, err
    }
    //這個關鍵字後面的方法是在當前readClass方法執行完之後就會執行
    defer reader.Close()
    //遍歷zip包中的文件名有沒有和命令行中提供的一樣
    for _, f := range reader.File {
        if f.Name == className {
            rc, err := f.Open()
            if err != nil {
                return nil, nil, err
            }
            //defer關鍵字是用於關閉已打開的文件
            defer rc.Close()
            data, err := ioutil.ReadAll(rc)
            if err != nil {
                return nil, nil, err
            }
            return data, self, nil
        }
    }
    return nil, nil, errors.New("class not found:" + className)

}

//實現接口的String方法
func (self *ZipEntry) String() string {
    return self.absPath
}

 

 

　　5.3 CompositeEntry

　　注意，這是對應多個路徑的情況啊！

package classpath

import (
    "errors"
    "strings"
)

//注意，這是一個[]Entry類型哦，因爲這種Entry可以對應的命令行中是多個路徑的
//多個路徑是用分號分隔的，於是我們就用分號分割成多個路徑，每一個都可以實例化一個Entry
//我們把實例化的Entry都放到這個切片中存着
type CompositeEntry []Entry

func newCompositeEntry(pathList string) CompositeEntry {
    compositeEntry := []Entry{}
    for _, path := range strings.Split(pathList, pathListSeparator) {
        entry := newEntry(path)
        compositeEntry = append(compositeEntry, entry)
    }
    return compositeEntry

}
//由於有多個Entry，我們就遍歷一下，調用每一個Entry的readClass方法
func (self CompositeEntry) readClass(className string) ([]byte, Entry, error) {
    for _, entry := range self {
        data, from, err := entry.readClass(className)
        if err == nil {
            return data, from, nil
        }
    }
    return nil, nil, errors.New("class not found: " + className)

}
func (self CompositeEntry) String() string {
    strs := make([]string, len(self))
    for i, entry := range self {
        strs[i] = entry.String()
    }
    return strings.Join(strs, pathListSeparator)
}

 

 

　　5.4 WildcardEntry

　　這種對應的是帶有通配符*的路徑，其實這種也是一種CompositeEntry；

package classpath

import (
    "os"
    "path/filepath"
    "strings"
)

func newWildcardEntry(path string) CompositeEntry {
    //移除路徑最後的*
    baseDir := path[:len(path)-1] // remove *
    //其實這種Entry就是CompositeEntry
    compositeEntry := CompositeEntry{}
    //一個函數，下面就是把函數作爲參數傳遞，這種用法還不是很熟悉，不過我感覺就是跟jdk8中傳Lambda
    //可以作爲參數是一樣的吧
    walkFn := func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        //跳過子目錄，說明帶有通配符*下的子目錄中的jar包是不能被搜索到的
        if info.IsDir() && path != baseDir {
            return filepath.SkipDir
        }
        //如果是jar包文件，就實例化ZipEntry，然後添加到compositeEntry裏面去
        if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") {
            jarEntry := newZipEntry(path)
            compositeEntry = append(compositeEntry, jarEntry)
        }
        return nil
    }
    //這個函數就是遍歷baseDir中所有文件
    filepath.Walk(baseDir, walkFn)
    return compositeEntry
}

 

 

六.測試

　　其實這樣就差不多了，根據命令行中輸入的命令，利用雙親委託機制，在指定的jre(或者環境變量的jre)中找指定的類，沒有的話就在用戶當前目錄中找，找到字節碼文件之後就讀取該文件，最終目錄如下：

 

 

　　就比如我們要輸出jdk8中的Object類的字節碼文件，我們首先要根據上一篇我們說的方式進行go install一下，就會在workspace下的bin目錄下有個ch02.exe可執行文件，也可以不指定-Xjre參數，都可以得到相同的結果；

 

 

 

 

　　也可以測試前面自己壓縮成的jar包，注意，指定jar包的全路徑啊！

 

 

　　至於上面那些數字什麼，這就是字節碼文件，每一個字節碼文件的格式都是幾乎一樣的，就是魔數，次版本號，主版本號，線程池大小，線程池等等組成，很容易的！下一篇再說怎麼解析這個字節碼文件。。。