手写JAVA虚拟机(三)——搜索class文件并读出内容

时间:2022-12-27 20:21:33

  查看手写JAVA虚拟机系列可以进我的博客园主页查看。

  前面我们介绍了准备工作以及命令行的编写。既然我们的任务实现命令行中的java命令,同时我们知道java命令是将class文件(字节码)转换成机器码,那么我们现在的任务就是读出这个class文件里面的内容

  正文:

  java虚拟机规范中是没有规定虚拟机该从哪里找类,也就是找class文件的,而oracle的是根据类路径,也就是classpath来搜索类的。搜索的优先级:启动类路径(bootstrap classpath)>扩展类路径(extension classpath)>用户类路径(user classpath)

  启动类路径(bootstrap classpath):默认为指定的jre\lib目录。

  扩展类路径(extension classpath):默认为指定的jre\lib\ext目录。手写JAVA虚拟机(三)——搜索class文件并读出内容

  

  看一下我们现在的工作目录结构(具体工作目录看我博客首页前面的文章)。

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  与前一章看起来还是有一些差别的,后面会一一介绍。

  类路径的设计我们我们采用组合模式。类路径由启动类路径、扩展类路径和用户类路径组成,这三个路径又由更小的路径构成。

  首先定义一个接口来表示类路径。在ch02\classpath目录下创建entry.go文件,在其中定义Entry接口:

  

package classpath

import "os"
import "strings"

//存放路径分隔符
const pathListSeparator = string (os.PathListSeparator)

//定义Entry接口
type Entry interface{
    readClass(className string)([]byte,Entry,error)//查找和加载class文件
    String() string//类似于java中toString()函数
}

//类似于java的构造函数,根据参数创建不同类型的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)
}

  由newEntry()方法可能会猜到我们对Entry接口有4个实现,分别是DirEntry、ZipEntry、CompositeEntry和WildcardEntry,因此我们在classpath文件夹下面分别建立四个go文件,如图:

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  其实这4种实现的基本逻辑都是类似的,我们以DirEntry为例详细说明(也就是entry_dir.go文件):

package classpath

import "io/ioutil"
import "path/filepath"

type DirEntry struct {
    absDir string    //存放绝对路径
}

//用path创建一个DirEntry实例并返回
func newDirEntry(path string) *DirEntry{
    //将path转换为绝对路径,如果出错则panic,无错则创建DirEntry实例并返回
    absDir,err:=filepath.Abs(path)
    if err!=nil{
        panic(err)
    }
    return &DirEntry{absDir}
}

//将指定class的内容读出
func (self *DirEntry) readClass(className string) ([]byte,Entry,error){
    //讲绝对路径和文件名拼接在一起,并使用ioutil包读取该指定文件内容,返回结果
    fileName :=filepath.Join(self.absDir,className)
    data,err:=ioutil.ReadFile(fileName)
    return data,self,err
}

func (self *DirEntry) String() string{
    return self.absDir
}

  首先引入了两个包,io/ioutil之前介绍过,类似于C的输入输出流,path/filepath用于对路径进行处理。然后定义了DirEntry这个结构体,里面只有一个absDir字段,类型为string,这个字段是用来存储绝对路径的。

  再往下是三个函数。第一个newDirEntry(path string) *DirEntry,由于go语言中没有像java那样自带构造函数,所以为了方便,对于这些结构体我们都会自己写一个“构造函数”。传入路径值path,通过filepath包的Abs方法来处理并返回一个绝对路径和err信息。java中函数只支持不返回值void和返回一个值int、boolean等,go中支持返回多个值,像这里的absDir和err。如果err为nil(即空),则返回一个包含绝对路径的DirEntry实例,err不为空,则返回错误信息,panic类似于java中的throw。

  第二个是readClass方法。先利用filepath包中的Join方法拼接绝对路径和类名,获取fileName为文件名。然后通过ioutil包中的ReadFile方法来读取fileName对应文件中的内容,返回data,self(指该DirEntry实例),err。

  第三个String方法返回绝对路径值。

  下一个实现ZipEntry(也就是entry_zip.go文件):

package classpath

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

type ZipEntry struct {
    //存放绝对路径
    absPath string
}

//创建一个ZipEntry实例
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) {
    //利用archive/zip包打开zip文件,出错则返回错误
    r, err := zip.OpenReader(self.absPath)
    if err != nil {
        return nil, nil, err
    }

    //defer保证在return前执行
    defer r.Close()
    //遍历指定路径中的File
    for _, f := range r.File {
        //如果找到与className相同的文件,读出rc(为ReadCloser接口提供读取文件内容的方法),如果出错,返回错误信息
        if f.Name == className {
            rc, err := f.Open()
            if err != nil {
                return nil, nil, err
            }
            //defer保证在return前执行,即保证关闭
            defer rc.Close()
            //通过rc读出其中内容为data,返回
            data, err := ioutil.ReadAll(rc)
            if err != nil {
                return nil, nil, err
            }
            return data, self, nil
        }
    }
    //遍历完成,没有找到对应的文件,返回class not found信息
    return nil, nil, errors.New("class not found: " + className)
}

func (self *ZipEntry) String() string {
    return self.absPath
}

  这个实现稍微复杂一点。先引入4个包,然后声明ZipEntry结构体。再往后依次是三个方法,构造方法,readClass方法,String方法。构造方法和String方法与上面DirEntry类似,下面说一下这里的readClass方法。

  首先使用archive/zip包来打开这个绝对路径,出错则返回。这里有一个defer r.close(),这个defer类似于java里面的finally,保证在return前执行,也就是说即使这里出现err需要return,也会先执行r.close()再return。如果没有err则继续,for循环遍历这个zip下的file,如果找到文件名与给定的文件名相同的,就打开这个文件,打开之后利用ioutil包中的ReadAll读取其中的内容,返回data。如果出错,则进行相应的处理。

  下面直接给出entry_composite.go和entry_wildcard.go代码:

package classpath

import "errors"
import "strings"

type CompositeEntry []Entry

//创建一个CompositeEntry实例
func newCompositeEntry(pathList string) CompositeEntry {
    compositeEntry := []Entry{}
    //将传入的pathList按分隔符分成小路径
    for _, path := range strings.Split(pathList, pathListSeparator) {
        entry := newEntry(path)
        compositeEntry = append(compositeEntry, entry)
    }
    return compositeEntry
}

//遍历并调用每个子路径的readClass方法,读取class数据并返回
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,再拼接返回
func (self CompositeEntry) String() string {
    strs := make([]string, len(self))
    for i, entry := range self {
        strs[i] = entry.String()
    }

    return strings.Join(strs, pathListSeparator)
}
package classpath

import "os"
import "path/filepath"
import "strings"

//类似CompositeEntry,不定义新的类型

//创建一个WildcardEntry实例
func newWildcardEntry(path string) CompositeEntry {
    //删除末尾*
    baseDir := path[:len(path)-1]
    compositeEntry := []Entry{}
    //根据后缀名选出jar文件,并跳过子目录
    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
    }
    //遍历baseDir创建ZipEntry
    filepath.Walk(baseDir, walkFn)

    return compositeEntry
}

  这样我们的接口和4个实现就介绍完了,这仅仅是找到了文件并打开了文件,我们还需要用jre“翻译”这些内容,jre在哪呢?对,就是在我们一开始说的classpath中,现在就是要设计classpath结构

  前面说了classpath有三个路径:启动类路径(bootstrap classpath)>扩展类路径(extension classpath)>用户类路径(user classpath)。

  在classpath文件夹下新建一个classpath.go文件:

package classpath

import "os"
import "path/filepath"

type Classpath struct {
    bootClasspath Entry    //启动类路径,默认为jre/lib目录
    extClasspath Entry//扩展类路径,默认为jre/lib/ext
    userClasspath Entry//用户类路径
}

//解析启动类路径和扩展类路径
func Parse(jreOption, cpOption string) *Classpath {
    cp := &Classpath{}
    cp.parseBootAndExtClasspath(jreOption)//找启动类路径和扩展类路径
    cp.parseUserClasspath(cpOption)//找用户类路径
    return cp
}


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)
}

//找jre目录
func getJreDir(jreOption string) string {
    //找用户输入的路径jre
    if jreOption != "" && exists(jreOption) {
        return jreOption
    }
    //找当前目录下jre
    if exists("./jre") {
        return "./jre"
    }
    //找JAVA_HOME中jre
    if jh := os.Getenv("JAVA_HOME"); jh != "" {
        return filepath.Join(jh, "jre")
    }
    //都找不到,返回panic
    panic("Can not find jre folder!")
}

//判断目录是否存在
func exists(path string) bool {
    if _, err := os.Stat(path); err != nil {
        if os.IsNotExist(err) {
            return false
        }
    }
    return true
}

//用户未输入-classpath/-cp参数,默认使用当前目录作为用户类路径
func (self *Classpath) parseUserClasspath(cpOption string) {
    if cpOption == "" {
        cpOption = "."
    }
    self.userClasspath = newEntry(cpOption)
}

//依次从启动类路径、扩展类路径和用户类路径中搜索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)
}

//返回用户路径的字符串表示
func (self *Classpath) String() string {
    return self.userClasspath.String()
}

  先是定义了一个Classpath结构体,该结构体中有三个字段,分别对应启动类路径(bootstrap classpath)、扩展类路径(extension classpath)、用户类路径(user classpath)。然后是方法,主要的方法有三个,Parse、ReadClass、String。

  Parse函数使用-Xjre选项解析启动类路径和扩展类路径,用-classpath/-cp选项解析用户类路径。getJreDir方法,在这里我们定义优先使用-Xjre作为jre目录,然后是当前目录下找jre,如果都没有才去我们的环境变量JAVA_HOME里面找。exists()用于判断目录是否存在。

  ReadClass方法就是依次从启动类路径、扩展类路径和用户类路径中搜索class文件。String返回用户路径字符串。

 

  工具完成,来修改一下main函数(即main.go文件),标红的地方为与上一章不同的地方:

package main

import "fmt"
import "strings"
import "jvmgo/ch02/classpath"

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

func stratJVM(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)
}

  红色的部分:首先是Parse解析-Xjre和-cp,然后打印出命令行参数。className为从命令行获取的类名,通过ReadClass方法读取出里面的内容classData,如果无err则打印出classData。

  附上还需要的cmd.go,这个与上一章的代码相同:

package main

import "flag"
import "fmt"
import "os"

type Cmd struct{
    helpFlag     bool
    versionFlag     bool
    cpOption     string
    XjreOption string
    class     string
    args     []string
}

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
    
}

func printUsage() {
    fmt.Printf("Usage:%s[-options] class [args...]\n",os.Args[0])
}

  到这里,搜索class文件并读出内容就完成了,现在来测试一下。

  打开一个命令行,输入go install jvmgo\ch02

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  表示go程序编译成功。会在工作空间的bin下出现ch02.exe,在bin目录下打开命令行,输入ch02 -Xjre "" java.lang.Object

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  由于我们没有输入-Xjre路径,这样会自动找到我们环境变量JAVA_HOME目录,用其中的jre来解析Object类并显示。

  我们得到了输入,现在我们要证明这个就是我们要的输出。这里解析的是Object类,我们要找到这个类的class文件。在我们在JAVA_HOME环境变量里面找jre/lib,目录下面有一个rt.jar,如图:

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  解压这个jar(有可能解压不了,那就复制到其他盘解压),解压之后打开:

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  可以在lang下面找到Object.class,正好对应我们上面命令行里面输入的java.lang.Object。用记事本或者sublime打开这个class:

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  可是这个跟我们打印出来的也不一样啊:

  手写JAVA虚拟机(三)——搜索class文件并读出内容

  因为我们解析出来的是10进制,而直接打开的class里面是16进制,因此我们需要转换一下。这里给出一个我写的java转换程序,将打开的class文件的内容复制到D:\yff.txt,然后运行:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;



public class Test {
    public static String txt2String(File file){
        StringBuilder result = new StringBuilder();
        try{
            BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
            String s = null;
            while((s = br.readLine())!=null){//使用readLine方法,一次读一行
                result.append(System.lineSeparator()+s);
            }
            br.close();    
        }catch(Exception e){
            e.printStackTrace();
        }
        return result.toString();
    }
    public static int hixTo(StringBuffer sb){
        int sum=0;
        if(sb.charAt(0)>=48&&sb.charAt(0)<=57){
            sum+=(sb.charAt(0)-48)*16;
        }else{
            sum+=((sb.charAt(0)-96)+9)*16;
        }
        if(sb.charAt(1)>=48&&sb.charAt(1)<=57){
            sum+=(sb.charAt(1)-48);
        }else{
            sum+=((sb.charAt(1)-96)+9);
        }
        return sum;
    }
    public static void main(String[] arts){
        File file = new File("D:\\yff.txt");
        String str=txt2String(file);
        StringBuffer sbBefore=new StringBuffer(str);
        StringBuffer sbAfter=new StringBuffer();
        for(int i=0;i<sbBefore.length();i++){
            if((sbBefore.charAt(i)>=48&&sbBefore.charAt(i)<=57)||(sbBefore.charAt(i)>=97&&sbBefore.charAt(i)<=122)){
                //System.out.print(sbBefore.charAt(i));
                sbAfter.append(sbBefore.charAt(i));
            }
        }
        System.out.println(sbAfter);
        System.out.println();
        for(int i=0;i<sbAfter.length();i=i+2){
            System.out.print(hixTo(new StringBuffer(""+sbAfter.charAt(i)+sbAfter.charAt(i+1)))+" ");
            if(i!=0&&i%100==0)
                System.out.println();
        }
    }
}

  运行结果如图:手写JAVA虚拟机(三)——搜索class文件并读出内容

  对比红框中的内容发现我们通过命令行导出的class内容是正确的

  至此整个搜索class文件并读出文件的内容就完成了。