上一篇通過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這里結構體做一個修改，以及對應的決議也添加一個，不多說；
cmd.go
package main import ( "flag" "fmt" "os" ) //這個結構體用保存命令列輸入的引數，例如：.\ch02.exe -Xjre "D:\java\jdk8\jre" java.lang.Object type Cmd struct { helpFlag bool versionFlag bool cpOption string XjreOption string class string args []string } //命令列輸入 .\ch02.exe -Xjre "D:\java\jdk8\jre" java.lang.Object func parseCmd() *Cmd { cmd := &Cmd{} //這里的意思就是如果決議失敗的話，就呼叫printUsage函式 flag.Usage = printUsage //下面這些在控制臺中表示的是-xxx，要匹配上，沒有匹配上就報錯 //匹配上了的話，在-xxx后面的都是【表情】屬于引數，其中第一個表示的是類名，后面的都是其他的引數 flag.BoolVar(&cmd.helpFlag, "help", false, "print help message") flag.BoolVar(&cmd.versionFlag, "version", false, "print version and exit") flag.StringVar(&cmd.cpOption, "classpath", "", "classpath") //決議jre類路徑 flag.StringVar(&cmd.XjreOption, "Xjre", "", "path to jre") flag.Parse() args := flag.Args() //決議成功的話，那就繼續獲取后面的引數 if len(args) > 0 { cmd.class = args[0] cmd.args = args[1:] } return cmd } //這里傳進去的引數，決議錯誤的話就顯示第一個引數的提示資訊 func printUsage() { fmt.Printf("Usage:%s [-options] class [args]\n", os.Args[0]) }View Code
二.定義類路徑介面
在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包的全路徑啊！
至于上面那些數字什么，這就是位元組碼檔案，每一個位元組碼檔案的格式都是幾乎一樣的，就是魔數，次版本號，主版本號，執行緒池大小，執行緒池等等組成，很容易的！下一篇再說怎么決議這個位元組碼檔案，，，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/38568.html
標籤：Go
下一篇：Go切片