首页 > 嗟来之食 > 手写JAVA虚拟机(三)——搜索class文件并读出内容
2018
06-06

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

  查看手写JAVA虚拟机系列可以进我的博客园主页查看。
  前面我们介绍了准备工作以及命令行的编写。既然我们的任务实现命令行中的java命令,同时我们知道java命令是将class文件(字节码)转换成机器码,那么我们现在的任务就是读出这个class文件里面的内容。
  正文:
  java虚拟机规范中是没有规定虚拟机该从哪里找类,也就是找class文件的,而oracle的是根据类路径,也就是classpath来搜索类的。搜索的优先级:启动类路径(bootstrap classpath)>扩展类路径(extension classpath)>用户类路径(user classpath)。
  启动类路径(bootstrap classpath):默认为指定的jre\lib目录。
  扩展类路径(extension classpath):默认为指定的jre\lib\ext目录。
  
  看一下我们现在的工作目录结构(具体工作目录看我博客首页前面的文章)。
  
  
  与前一章看起来还是有一些差别的,后面会一一介绍。
  类路径的设计我们我们采用组合模式。类路径由启动类路径、扩展类路径和用户类路径组成,这三个路径又由更小的路径构成。
  首先定义一个接口来表示类路径。在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文件,如图:
  
  其实这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:
  
  表示go程序编译成功。会在工作空间的bin下出现ch02.exe,在bin目录下打开命令行,输入ch02 -Xjre "" java.lang.Object:
  
  由于我们没有输入-Xjre路径,这样会自动找到我们环境变量JAVA_HOME目录,用其中的jre来解析Object类并显示。
  我们得到了输入,现在我们要证明这个就是我们要的输出。这里解析的是Object类,我们要找到这个类的class文件。在我们在JAVA_HOME环境变量里面找jre/lib,目录下面有一个rt.jar,如图:
  
  解压这个jar(有可能解压不了,那就复制到其他盘解压),解压之后打开:
  
  可以在lang下面找到Object.class,正好对应我们上面命令行里面输入的java.lang.Object。用记事本或者sublime打开这个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();
}
}
}

  运行结果如图:
  对比红框中的内容发现我们通过命令行导出的class内容是正确的。
  至此整个搜索class文件并读出文件的内容就完成了。

最后编辑:
作者:
这个作者貌似有点懒,什么都没有留下。

留下一个回复