Java虛擬機器之搜尋class檔案
Java命令
Java虛擬機器的工作是執行Java應用程式。和其他型別的應用程式一樣，Java應用程式也需要一個入口點，這個入口點就是我們熟知的main()方法。如果一個類包含main()方法，這個類就可以用來啟動Java應用程式，我們把這個類叫作主類。最簡單的Java程式是隻有一個main()方法的類，如著名的HelloWorld程式。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, world!");
}
}
那麼Java虛擬機器如何知道我們要從哪個類啟動應用程式呢？對此，Java虛擬機器規範沒有明確規定。也就是說，是由虛擬機器實現自行決定的。比如Oracle的Java虛擬機器實現是通過java命令來啟動的，主類名由命令列引數指定。java命令有如下4種形式：
java [-options] class [args] java [-options] -jar jarfile [args] javaw [-options] class [args] javaw [-options] -jar jarfile [args]
可以向java命令傳遞三組引數：選項、主類名（或者JAR檔名）。
和main()方法引數。選項由減號“-”開頭。通常，第一個非選項引數給出主類的完全限定名（fully qualified class name）。但是如果使用者提供了–jar選項，則第一個非選項引數表示JAR檔名，java命令必須從這個JAR檔案中尋找主類。javaw命令和java命令幾乎一樣，唯一的差別在於，javaw命令不顯示命令列視窗，因此特別適合用於啟動GUI（圖形使用者介面）應用程式。
選項可以分為兩類：標準選項和非標準選項。標準選項比較穩定，不會輕易變動。非標準選項以-X開頭。非標準選項中有一部分是高階選項，以-XX開頭。表1-1列出了java命令常用的選項及其用途。
| 選項 | 用途 |
| -version | 輸出版本資訊，然後退出 |
| -?/-help | 輸出幫助資訊，然後退出 |
| -cp/-classpath | 指定使用者類路徑 |
| -Dproperty=value | 設定Java系統屬性 |
| -Xms<size> | 設定初始堆空間大小 |
| -Xmx<size> | 設定最大堆空間大小 |
| -Xss<size> | 設定執行緒棧空間大小 |
編寫命令列工具
我們將以Go語言來闡述Java虛擬機器，先定義一個結構體來表示命令列選項和引數。在ch01目錄下建立cmd.go檔案，用你喜歡的文字編輯器開啟它，然後在其中定義Cmd結構體，程式碼如下：
package main
import "flag"
import "fmt"
import "os"
type Cmd struct {
helpFlag bool
versionFlag bool
cpOption string
class string
args []string
}
在Java語言中，API一般以類庫的形式提供。在Go語言中，API則是以包（package）的形式提供。包可以向用戶提供常量、變數、結構體以及函式等。Java內建了豐富的類庫，Go也同樣內建了功能強大的包，如：fmt、os和flag包。
os包定義了一個Args變數，其中存放傳遞給命令列的全部引數。如果直接處理os.Args變數，需要寫很多程式碼。還好Go語言內建了flag包，這個包可以幫助我們處理命令列選項。有了flag包，我們的工作就簡單了很多。繼續編輯cmd.go檔案，在其中定義parseCmd()函式 ，程式碼如下：
func parseCmd() *Cmd {
cmd := &Cmd{}
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.Parse()
args := flag.Args()
if len(args) > 0 {
cmd.class = args[0]
cmd.args = args[1:]
}
return cmd
}
首先設定flag.Usage變數，把printUsage()函式賦值給它；然後呼叫flag包提供的各種Var()函式設定需要解析的選項；接著呼叫Parse()函式解析選項。如果Parse()函式解析失敗，它就呼叫printUsage()函式把命令的用法列印到控制檯。printUsage()函式的程式碼如下：
func printUsage() {
fmt.Printf("Usage: %s [-options] class [args...]\n", os.Args[0])
}
如果解析成功，呼叫flag.Args()函式可以捕獲其他沒有被解析的引數。其中第一個引數就是主類名，剩下的是要傳遞給主類的引數。這樣，用了不到40行程式碼，我們的命令列工具就編寫完了。下面來測試它。
在ch01目錄下建立main.go檔案，然後輸入下面的程式碼：
package main
import "fmt"
func main() {
cmd := parseCmd()
if cmd.versionFlag {
fmt.Println("version 0.0.1")
} else if cmd.helpFlag || cmd.class == "" {
printUsage()
} else {
startJVM(cmd)
}
}
func startJVM(cmd *Cmd) {
fmt.Printf("classpath:%s class:%s args:%v\n",
cmd.cpOption, cmd.class, cmd.args)
}
注意，與cmd.go檔案一樣，main.go檔案的包名也是main。在Go語言中，main是一個特殊的包，這個包所在的目錄（可以叫作任何名字）會被編譯為可執行檔案。Go程式的入口也是main()函式，但是不接收任何引數，也不能有返回值。main()函式先呼叫ParseCommand()函式解析命令列引數，如果一切正常，則呼叫startJVM()函式啟動Java虛擬機器。如果解析出現錯誤，或者使用者輸入了-help選項，則呼叫PrintUsage()函式打印出幫助資訊。如果使用者輸入了-version選項，則輸出版本資訊。
開啟命令列視窗，執行下面的命令：
go install jvmgo\ch01
開啟命令列視窗，執行命令go install jvmgo\ch01命令執行完畢後，如果沒有看到任何輸出就證明編譯成功了，此時在{GOPATH}\bin目錄下會出現ch01.exe檔案。現在，可以用各種引數進行測試：
D:\go_space\bin>ch01.exe
Usage: ch01.exe [-options] class [args...]
D:\go_space\bin>ch01.exe -version
version 0.0.1
D:\go_space\bin>ch01.exe -help
Usage: ch01.exe [-options] class [args...]
D:\go_space\bin>ch01.exe -version
version 0.0.1
D:\go_space\bin>ch01.exe -cp foo/bar MyApp arg1 arg2
classpath:foo/bar class:MyApp args:[arg1 arg2]
類路徑
之前我們曾經介紹過HelloWorld類，載入HelloWorld類之前，首先要載入它的超類，也就是java.lang.Object。在呼叫main()方法之前，因為虛擬機器需要準備好引數陣列，所以需要載入java.lang.String和java.lang.String[]類。把字串列印到控制檯還需要載入java.lang.System類，等等。那麼，Java虛擬機器從哪裡尋找這些類呢？
Java虛擬機器規範並沒有規定虛擬機器應該從哪裡尋找類，因此不同的虛擬機器實現可以採用不同的方法。Oracle的Java虛擬機器實現根據類路徑（class path）來搜尋類。按照搜尋的先後順序，類路徑可以分為以下3個部分：
- 啟動類路徑（bootstrap classpath）
- 擴充套件類路徑（extension classpath）
- 使用者類路徑（user classpath）
啟動類路徑預設對應jre\lib目錄，Java標準庫（大部分在rt.jar裡）位於該路徑。擴充套件類路徑預設對應jre\lib\ext目錄，使用Java擴充套件機制的類位於這個路徑。我們自己實現的類，以及第三方類庫則位於使用者類路徑。可以通過-Xbootclasspath選項修改啟動類路徑，不過通常並不需要這樣做。
使用者類路徑的預設值是當前目錄，也就是“.”。可以設定CLASSPATH環境變數來修改使用者類路徑，但是這樣做不夠靈活，所以不推薦使用。更好的辦法是給java命令傳遞-classpath（或簡寫為-cp）選項。-classpath/-cp選項的優先順序更高，可以覆蓋CLASSPATH環境變數設定。-classpath/-cp選項既可以指定目錄，也可以指定JAR檔案或者ZIP檔案，如下：
java -cp path\to\classes ... java -cp path\to\lib1.jar ... java -cp path\to\lib2.zip ...
還可以同時指定多個目錄或檔案，用分隔符分開即可。分隔符因作業系統而異。在Windows系統下是分號，在類UNIX（包括Linux、Mac OS X等）系統下是冒號。例如在Windows下：
java -cp path\to\classes;lib\a.jar;lib\b.jar;lib\c.zip ...
從Java 6開始，還可以使用萬用字元（*）指定某個目錄下的所有JAR檔案，格式如下：
java -cp classes;lib\* ...
把ch01目錄複製一份，然後改名為ch02。因為要建立的原始檔都在classpath包中，所以在ch02目錄中建立一個classpath子目錄。現在目錄結構看起來應該是這樣：
${GOPATH}\src
|-jvmgo
|-ch01
|-ch02
|-classpath
|-cmd.go
|-main.go
我們的Java虛擬機器將使用JDK的啟動類路徑來尋找和載入Java標準庫中的類，因此需要某種方式指定jre目錄的位置。命令列選項是個不錯的選擇，所以增加一個非標準選項-Xjre。開啟ch02\cmd.go，修改Cmd結構體，新增XjreOption欄位，程式碼如下：
type Cmd struct {
helpFlag bool
versionFlag bool
cpOption string
XjreOption string
class string
args []string
}
parseCmd()函式也要相應修改，程式碼如下：
func parseCmd() *Cmd {
cmd := &Cmd{}
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()
args := flag.Args()
if len(args) > 0 {
cmd.class = args[0]
cmd.args = args[1:]
}
return cmd
}
實現類路徑
可以把類路徑想象成一個大的整體，它由啟動類路徑、擴充套件類路徑和使用者類路徑三個小路徑構成。三個小路徑又分別由更小的路徑構成，這很像組合模式（composite pattern）。
Entry介面
先定義一個介面來表示類路徑項。在ch02\classpath目錄下建立entry.go檔案，在其中定義Entry介面，程式碼如下：
package classpath
import "os"
import "strings"
const pathListSeparator = string(os.PathListSeparator)
type Entry interface {
readClass(className string) ([]byte, Entry, error)
String() string
}
func newEntry(path string) Entry {……}
常量pathListSeparator是string型別，存放路徑分隔符，後面會用到。Entry介面中有兩個方法。readClass()方法負責尋找和載入class檔案；String()方法的作用相當於Java中的toString()，用於返回變數的字串表示。
readClass()方法的引數是class檔案的相對路徑，路徑之間用斜線（/）分隔，檔名有.class字尾。比如要讀取java.lang.Object類，傳入的引數應該是java/lang/Object.class。返回值是讀取到的位元組資料、最終定位到class檔案的Entry，以及錯誤資訊。Go的函式或方法允許返回多個值，按照慣例，可以使用最後一個返回值作為錯誤資訊。
newEntry()函式根據引數建立不同型別的Entry例項，程式碼如下：
func newEntry(path string) Entry {
if strings.Contains(path, pathListSeparator) {
return newCompositeEntry(path)
}
if strings.HasSuffix(path, "*") {
return newWildcardEntry(path)
}
if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") ||
strings.HasSuffix(path, ".zip") || strings.HasSuffix(path, ".ZIP") {
return newZipEntry(path)
}
return newDirEntry(path)
}
Entry介面有4個實現，分別是DirEntry、ZipEntry、CompositeEntry和WildcardEntry。下面分別介紹每一種實現。
DirEntry
在4種實現中，DirEntry相對簡單一些，表示目錄形式的類路徑。在ch02\classpath目錄下建立entry_dir.go檔案，在其中定義DirEntry結構體，程式碼如下：
package classpath
import "io/ioutil"
import "path/filepath"
type DirEntry struct {
absDir string
}
func newDirEntry(path string) *DirEntry {……}
func (self *DirEntry) readClass(className string) ([]byte, Entry, error) {……}
func (self *DirEntry) String() string {……}
DirEntry只有一個欄位，用於存放目錄的絕對路徑。和Java語言不同，Go結構體不需要顯示實現介面，只要方法匹配即可。Go沒有專門的建構函式，可以使用new開頭的函式來建立結構體例項，並把這類函式稱為建構函式。newDirEntry()函式的程式碼如下：
func newDirEntry(path string) *DirEntry {
absDir, err := filepath.Abs(path)
if err != nil {
panic(err)
}
return &DirEntry{absDir}
}
newDirEntry()先把引數轉換成絕對路徑，如果轉換過程出現錯誤，則呼叫panic()函式終止程式執行，否則建立DirEntry例項並返回。
下面介紹readClass()方法：
func (self *DirEntry) readClass(className string) ([]byte, Entry, error) {
fileName := filepath.Join(self.absDir, className)
data, err := ioutil.ReadFile(fileName)
return data, self, err
}
readClass()先把目錄和class檔名拼成一個完整的路徑，然後呼叫ioutil包提供的ReadFile()函式讀取class檔案內容，最後返回。String()方法很簡單，直接返回目錄，程式碼如下：
func (self *DirEntry) String() string {
return self.absDir
}
ZipEntry
ZipEntry表示ZIP或JAR檔案形式的類路徑。在ch02\classpath目錄下建立entry_zip.go檔案，在其中定義ZipEntry結構體，程式碼如下：
package classpath
import "archive/zip"
import "errors"
import "io/ioutil"
import "path/filepath"
type ZipEntry struct {
absPath string
}
func newZipEntry(path string) *ZipEntry {……}
func (self *ZipEntry) readClass(className string) ([]byte, Entry, error) {……}
func (self *ZipEntry) String() string {……}
absPath欄位存放ZIP或JAR檔案的絕對路徑。建構函式和String()與DirEntry大同小異，程式碼如下：
func newZipEntry(path string) *ZipEntry {
absPath, err := filepath.Abs(path)
if err != nil {
panic(err)
}
return &ZipEntry{absPath}
}
下面重點介紹如何從ZIP檔案中提取class檔案，程式碼如下：
func (self *ZipEntry) readClass(className string) ([]byte, Entry, error) {
r, err := zip.OpenReader(self.absPath)
if err != nil {
return nil, nil, err
}
defer r.Close()
for _, f := range r.File {
if f.Name == className {
rc, err := f.Open()
if err != nil {
return nil, nil, err
}
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)
}
CompositeEntry
在ch02\classpath目錄下建立entry_composite.go檔案，在其中定義CompositeEntry結構體，程式碼如下：
package classpath
import "errors"
import "strings"
type CompositeEntry []Entry
func newCompositeEntry(pathList string) CompositeEntry {……}
func (self CompositeEntry) readClass(className string) ([]byte, Entry, error) {……}
func (self CompositeEntry) String() string {……}
如前所述，CompositeEntry由更小的Entry組成，正好可以表示成[]Entry。在Go語言中，陣列屬於比較低層的資料結構，很少直接使用。大部分情況下，使用更便利的slice型別。建構函式把引數（路徑列表）按分隔符分成小路徑，然後把每個小路徑都轉換成具體的Entry例項，程式碼如下：
func newCompositeEntry(pathList string) CompositeEntry {
compositeEntry := []Entry{}
for _, path := range strings.Split(pathList, pathListSeparator) {
entry := newEntry(path)
compositeEntry = append(compositeEntry, entry)
}
return compositeEntry
}
相信讀者已經想到readClass()方法的程式碼了：依次呼叫每一個子路徑的readClass()方法，如果成功讀取到class資料，返回資料即可；如果收到錯誤資訊，則繼續；如果遍歷完所有的子路徑還沒有找到class檔案，則返回錯誤。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)
}
String()方法也不復雜。呼叫每一個子路徑的String()方法，然後把得到的字串用路徑分隔符拼接起來即可，程式碼如下：
func (self CompositeEntry) String() string {
strs := make([]string, len(self))
for i, entry := range self {
strs[i] = entry.String()
}
return strings.Join(strs, pathListSeparator)
}
WildcardEntry
WildcardEntry實際上也是CompositeEntry，所以就不再定義新的型別了。在ch02\classpath目錄下建立entry_wildcard.go檔案，在其中定義newWildcardEntry()函式，程式碼如下：
package classpath
import "os"
import "path/filepath"
import "strings"
func newWildcardEntry(path string) CompositeEntry {
baseDir := path[:len(path)-1] // remove *
compositeEntry := []Entry{}
walkFn := func(path string, info os.FileInfo, err error) error {……}
filepath.Walk(baseDir, walkFn)
return compositeEntry
}
首先把路徑末尾的星號去掉，得到baseDir，然後呼叫filepath包的Walk()函式遍歷baseDir建立ZipEntry。Walk()函式的第二個引數也是一個函式，walkFn變數的定義如下：
walkFn := func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() && path != baseDir {
return filepath.SkipDir
}
if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") {
jarEntry := newZipEntry(path)
compositeEntry = append(compositeEntry, jarEntry)
}
return nil
}
在walkFn中，根據字尾名選出JAR檔案，並且返回SkipDir跳過子目錄（萬用字元類路徑不能遞迴匹配子目錄下的JAR檔案）。
Classpath
Entry介面和4個實現介紹完了，接下來實現Classpath結構體。還是在ch02\classpath目錄下建立classpath.go檔案，把下面的程式碼輸入進去。
package classpath
import "os"
import "path/filepath"
type Classpath struct {
bootClasspath Entry
extClasspath Entry
userClasspath Entry
}
func Parse(jreOption, cpOption string) *Classpath {……}
func (self *Classpath) ReadClass(className string) ([]byte, Entry, error) {……}
func (self *Classpath) String() string {……}
Classpath結構體有三個欄位，分別存放三種類路徑。Parse()函式使用-Xjre選項解析啟動類路徑和擴充套件類路徑，使用-classpath/-cp選項解析使用者類路徑，程式碼如下：
func Parse(jreOption, cpOption string) *Classpath {
cp := &Classpath{}
cp.parseBootAndExtClasspath(jreOption)
cp.parseUserClasspath(cpOption)
return cp
}
parseBootAndExtClasspath()方法的程式碼如下：
func (self *Classpath) parseBootAndExtClasspath(jreOption string) {
jreDir := getJreDir(jreOption)
// jre/lib/*
jreLibPath := filepath.Join(jreDir, "lib", "*")
self.bootClasspath = newWildcardEntry(jreLibPath)
// jre/lib/ext/*
jreExtPath := filepath.Join(jreDir, "lib", "ext", "*")
self.extClasspath = newWildcardEntry(jreExtPath)
}
優先使用使用者輸入的-Xjre選項作為jre目錄。如果沒有輸入該選項，則在當前目錄下尋找jre目錄。如果找不到，嘗試使用JAVA_HOME環境變數。getJreDir()函式的程式碼如下：
func getJreDir(jreOption string) string {
if jreOption != "" && exists(jreOption) {
return jreOption
}
if exists("./jre") {
return "./jre"
}
if jh := os.Getenv("JAVA_HOME"); jh != "" {
return filepath.Join(jh, "jre")
}
panic("Can not find jre folder!")
}
exists()函式用於判斷目錄是否存在，程式碼如下：
func exists(path string) bool {
if _, err := os.Stat(path); err != nil {
if os.IsNotExist(err) {
return false
}
}
return true
}
parseUserClasspath()方法的程式碼相對簡單一些，如下：
func (self *Classpath) parseUserClasspath(cpOption string) {
if cpOption == "" {
cpOption = "."
}
self.userClasspath = newEntry(cpOption)
}
如果使用者沒有提供-classpath/-cp選項，則使用當前目錄作為使用者類路徑。ReadClass()方法依次從啟動類路徑、擴充套件類路徑和使用者類路徑中搜索class檔案，程式碼如下：
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)
}
注意，傳遞給ReadClass()方法的類名不包含“.class”字尾。最後，String()方法返回使用者類路徑的字串表示，程式碼如下：
func (self *Classpath) String() string {
return self.userClasspath.String()
}
現在，我們來測試一下ch02的程式碼，開啟ch02/main.go檔案，新增兩條import語句，程式碼如下：
package main
import "fmt"
import "strings"
import "jvmgo/ch02/classpath"
func main() {……}
func startJVM(cmd *Cmd) {……}
main()函式不用變，重寫startJVM()函式，程式碼如下：
func startJVM(cmd *Cmd) {
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)
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)
}
startJVM()先打印出命令列引數，然後讀取主類資料，並列印到控制檯，雖然還是無法真正啟動Java虛擬機器。開啟命令列視窗，執行下面的命令編譯程式碼：
D:\go_space\src>go install jvmgo\ch02
編譯成功後，在{GOPATH}\bin目錄下出現ch02.exe檔案。執行ch02.exe，指定好-Xjre選項和類名，就可以把class檔案的內容打印出來：
D:\go_space\bin>ch02.exe -Xjre "D:\JDK\jdk1.8.0_77\jre" java.lang.Object classpath:D:\go_space\bin class:java.lang.Object args:[] class data:[202 254 186……2 0 77]