写在前面
完成类加载器加载class的三阶段，加载，解析，初始化中的加载😀😀😀
源码 。
jvm想要运行class，是根据类全限定名称来从特定的位置基于类加载器来查找的，分别如下：
启动类加载器负责加载jre/lib目录
扩展类加载器负责加载jre/ext/lib目录
应用加载器负责加载应用程序classpath
不管是哪种类加载器，都要完成找到class查找这个工作。
具体类加载器的工作流程可以分为如下3个步骤：
1：加载
根据类的全限定名称（包+类名称），定位并且读取字节码
2：链接（验证，准备，解析）
验证字节码是否合法，给静态变量申请内存，符号引用（一个串）转直接引用（一个内存地址）
3：初始化
执行初始化代码，如{}代码块，以及给静态变量赋值
本部分要来模拟的就是这里的1：加载。
1：程序
因为分别要从如下三个目录来查找class：
1：jre/lib
2：jre/ext/lib
3：应用classpath
不管是那个目录，用户在指定class所在位置时都可能使用不同的形式，可能如下：
1：一个目录，如d:\test\
2：一个jar，zip等，如d:\test\aa.jar,d:\test\aa.zip
3：通配符形式，如d:\test\*
4：也可能是以上三种的组合形式
为了抽象不同的文件形式，我们先来定义如下文件入口形式的接口：
public interface Entry {
byte[] readClass(String className) throws IOException;
static Entry create(String path) {
//File.pathSeparator；路径分隔符(win\linux)
if (path.contains(File.pathSeparator)) {
return new CompositeEntry(path);
}
if (path.endsWith("*")) {
return new WildcardEntry(path);
}
if (path.endsWith(".jar") || path.endsWith(".JAR") ||
path.endsWith(".zip") || path.endsWith(".ZIP")) {
return new ZipEntry(path);
}
return new DirEntry(path);
}
}
其中抽象方法readClass用来完成读取字节码的工作，也就是本文要做的内容，静态方法create用来根据给定的路径生成对应的Entry对象，这里根据路径形式的不同我们需要定义Entry不同的子类，分别是目录形式的子类DirectoryEntry：
package com.dahuyou.find.clazz.entry.impl;
import com.dahuyou.find.clazz.entry.Entry;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
/**
* 目录形式的entry 如 d:\test
*/
public class DirectoryEntry implements Entry {
private Path absolutePath;
public DirectoryEntry(String path) {
//获取绝对路径
this.absolutePath = Paths.get(path).toAbsolutePath();
}
@Override
public byte[] readClass(String className) throws IOException {
return Files.readAllBytes(absolutePath.resolve(className));
}
@Override
public String toString() {
return this.absolutePath.toString();
}
}
jar和zip形式的entry：
package com.dahuyou.find.clazz.entry.impl;
import com.dahuyou.find.clazz.entry.Entry;
import java.io.IOException;
import java.nio.file.*;
/**
* jar,zip形式的entry
*/
public class JarOrZipEntry implements Entry {
private Path absolutePath;
public JarOrZipEntry(String path) {
//获取绝对路径
this.absolutePath = Paths.get(path).toAbsolutePath();
}
@Override
public byte[] readClass(String className) throws IOException {
try (FileSystem zipFs = FileSystems.newFileSystem(absolutePath, null)) {
return Files.readAllBytes(zipFs.getPath(className));
}
}
@Override
public String toString() {
return this.absolutePath.toString();
}
}
这里因为通配符形式的路径其实是组合形式的一种特殊写法，如d:\test\目录下有a.jar,b.jar,则组合形式就是d:\test\a.jar,d:\test\b.jar，而通配符形式就是d:\test\*，通配符形式是可以转换为组合形式的，只不过多了一个转换的工作而已，所以这里，我们单独定义组合形式子类，然后再继承组合形式定义通配符形式。
则，组合形式子类如下：
package com.dahuyou.find.clazz.entry.impl;
import com.dahuyou.find.clazz.entry.Entry;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* 一组路径的组合形式entry
*/
public class CompositeEntry implements Entry {
private final List<Entry> entryList = new ArrayList<>();
public CompositeEntry(String pathList) {
String[] paths = pathList.split(File.pathSeparator);
for (String path : paths) {
entryList.add(Entry.create(path));
}
}
@Override
public byte[] readClass(String className) throws IOException {
for (Entry entry : entryList) {
try {
return entry.readClass(className);
} catch (Exception ignored) {
//ignored
}
}
throw new IOException("class not found " + className);
}
@Override
public String toString() {
String[] strs = new String[entryList.size()];
for (int i = 0; i < entryList.size(); i++) {
strs[i] = entryList.get(i).toString();
}
return String.join(File.pathSeparator, strs);
}
}
通配符entry如下：
package com.dahuyou.find.clazz.entry.impl;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Collectors;
/**
* 通配符entry，继承CompositeEntry，只需要将通配符转换为一组路径，就转换为组合entry了，
* 所以这里直接继承组合entry，妙啊！！！
*/
public class WildcardEntry extends CompositeEntry {
public WildcardEntry(String path) {
super(toPathList(path));
}
private static String toPathList(String wildcardPath) {
String baseDir = wildcardPath.replace("*", ""); // remove *
try {
return Files.walk(Paths.get(baseDir))
.filter(Files::isRegularFile)
.map(Path::toString)
.filter(p -> p.endsWith(".jar") || p.endsWith(".JAR"))
.collect(Collectors.joining(File.pathSeparator));
} catch (IOException e) {
return "";
}
}
}
UML图：
又因为类最终其实是从classpath下查找的，所以我们还需要定义一个类来代表classpath，使用各种entry来完成具体查找class的工作：
package com.dahuyou.find.clazz.classpath;
import com.dahuyou.find.clazz.classpath.entry.Entry;
import com.dahuyou.find.clazz.classpath.entry.impl.WildcardEntry;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
/**
* classpath类（jre entry+jre ext entry+应用entry）
*/
public class Classpath {
// jre路径的entry（jvm中启动类加载器使用）
private Entry bootstrapClasspath;
// jre扩展路径entry（jvm中扩展类加载器使用）
private Entry extensionClasspath;
// 应用class路径entry（jvm中app类加载器使用）
private Entry userClasspath;
public Classpath(String jreOption, String cpOption) {
//启动类(D:\programs\javas\java1.8\jre\lib)&扩展类(D:\programs\javas\java1.8\jre\lib\ext)
bootstrapAndExtensionClasspath(jreOption);
//用户类 d:\test\target\classes
parseUserClasspath(cpOption);
}
private void bootstrapAndExtensionClasspath(String jreOption) {
String jreDir = getJreDir(jreOption);
//..jre/lib/* jre核心类库初始化
String jreLibPath = Paths.get(jreDir, "lib") + File.separator + "*";
bootstrapClasspath = new WildcardEntry(jreLibPath);
//..jre/lib/ext/* jre ext初始化
String jreExtPath = Paths.get(jreDir, "lib", "ext") + File.separator + "*";
extensionClasspath = new WildcardEntry(jreExtPath);
}
private static String getJreDir(String jreOption) {
// 用户直接设置了jre目录 D:\programs\javas\java1.8\jre
if (jreOption != null && Files.exists(Paths.get(jreOption))) {
return jreOption;
}
if (Files.exists(Paths.get("./jre"))) {
return "./jre";
}
String jh = System.getenv("JAVA_HOME");
if (jh != null) {
return Paths.get(jh, "jre").toString();
}
throw new RuntimeException("Can not find JRE folder!");
}
private void parseUserClasspath(String cpOption) {
if (cpOption == null) {
cpOption = ".";
}
userClasspath = Entry.create(cpOption);
}
public byte[] readClass(String className) throws Exception {
className = className + ".class";
// 先使用jre 的entry加载（对应jvm先通过启动类加载器加载）
try {
return bootstrapClasspath.readClass(className);
} catch (Exception ignored) {
//ignored
}
// jre的entry加载不到，使用ext对应的entry加载（对应jvm 启动类加载器加载不到，使用ext类加载器加载）
try {
return extensionClasspath.readClass(className);
} catch (Exception ignored) {
//ignored
}
// 最后通过用户类 entry加载（对应jvm最后猜使用app应用类加载器）
return userClasspath.readClass(className);
}
}
总结以上代码就是，为了对应不同形式的class，即不同入口形式的class，定义了entry接口，并根据不同的入口形式定义了对应的entry实现，然后定义了classpath类，该类分别针对jre，jre ext,用户类，定义了对应的entry，这样的当需要查找某个class时，就可以按照顺序分别从jre entry->jre ext entry->用户entry来查找了，可参考如下图：
接着我们还需要定义接收命令行参数的类，这个如果你看过前面的文章就比较熟悉了，这里贴下源码：
package com.dahuyou.find.clazz.cmd;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import java.util.List;
public class Cmd {
@Parameter(names = {"-?", "-help"}, description = "print help message", order = 3, help = true)
boolean helpFlag = false;
@Parameter(names = "-version", description = "print version and exit", order = 2)
boolean versionFlag = false;
@Parameter(names = {"-cp", "-classpath"}, description = "classpath", order = 1)
String classpath;
@Parameter(names = "-Xthejrepath", description = "path to jre", order = 4)
String thejrepath;
// 要查找的目标类
@Parameter(names = "-Xthetargetclazz", description = "path to jre", order = 4)
public String thetargetclazz;
@Parameter(description = "main class and args")
List<String> mainClassAndArgs;
boolean ok;
String getMainClass() {
return mainClassAndArgs != null && !mainClassAndArgs.isEmpty()
? mainClassAndArgs.get(0)
: null;
}
List<String> getAppArgs() {
return mainClassAndArgs != null && mainClassAndArgs.size() > 1
? mainClassAndArgs.subList(1, mainClassAndArgs.size())
: null;
}
static Cmd parse(String[] argv) {
Cmd args = new Cmd();
JCommander cmd = JCommander.newBuilder().addObject(args).build();
cmd.parse(argv);
args.ok = true;
return args;
}
}
通过-Xthejrepath来指定jre路径，当然也可以不指定，程序也会读取JAVA_HOME环境变量配置。-Xthetargetclazz指定要查找的目标类。
定义主函数类：
package com.dahuyou.find.clazz;
import com.dahuyou.find.clazz.classpath.Classpath;
import com.dahuyou.find.clazz.cmd.Cmd;
import java.util.Arrays;
/**
* program arguments：-Xthejrepath D:\programs\javas\java1.8/jre -Xthetargetclazz D:\test\itstack-demo-jvm-master\find-class-from-classpath\target\test-classes\com\dahuyou\find\clazz\test\ShowMeByteCode
*/
public class Main {
public static void main(String[] args) {
Cmd cmd = Cmd.parse(args);
if (!cmd.ok || cmd.helpFlag) {
System.out.println("Usage: <main class> [-options] class [args...]");
return;
}
if (cmd.versionFlag) {
//注意案例测试都是基于1.8，另外jdk1.9以后使用模块化没有rt.jar
System.out.println("java version \"1.8.0\"");
return;
}
startJVM(cmd);
}
private static void startJVM(Cmd cmd) {
// 创建classpath
Classpath cp = new Classpath(cmd.thejrepath, cmd.classpath);
System.out.printf("classpath：%s class：%s args：%s\n", cp, cmd.getMainClass(), cmd.getAppArgs());
//获取className
// String className = cmd.getMainClass().replace(".", "/");
try {
// byte[] classData = cp.readClass(className);
byte[] classData = cp.readClass(cmd.thetargetclazz.replace(".", "/"));
System.out.println(Arrays.toString(classData));
System.out.println("classData：");
for (byte b : classData) {
//16进制输出
System.out.print(String.format("%02x", b & 0xff) + " ");
}
} catch (Exception e) {
System.out.println("Could not find or load main class " + cmd.getMainClass());
e.printStackTrace();
}
}
}
为了测试，我们来定义一个要查找的类：
package com.dahuyou.find.clazz.test;
public class ShowMeByteCode {
public static void main(String[] args) {
}
}
运行，首先配置参数：
-Xthejrepath
D:\programs\javas\java1.8/jre
-Xthetargetclazz
D:\test\itstack-demo-jvm-master\find-class-from-classpath\target\test-classes\com\dahuyou\find\clazz\test\ShowMeByteCode
-Xthejrepath设置jre的路径，-Xthetargetclazz设置要查找的目标class，运行如下：
classpath：com.dahuyou.find.clazz.classpath.Classpath@bebdb06 class：null args：null
[-54, -2, -70, -66, 0, 0, 0, 52, 0, 20, 10, 0, 3, 0, 17, 7, 0, 18, 7, 0, 19, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0, 18, 76, 111, 99, 97, 108, 86, 97, 114, 105, 97, 98, 108, 101, 84, 97, 98, 108, 101, 1, 0, 4, 116, 104, 105, 115, 1, 0, 44, 76, 99, 111, 109, 47, 100, 97, 104, 117, 121, 111, 117, 47, 102, 105, 110, 100, 47, 99, 108, 97, 122, 122, 47, 116, 101, 115, 116, 47, 83, 104, 111, 119, 77, 101, 66, 121, 116, 101, 67, 111, 100, 101, 59, 1, 0, 4, 109, 97, 105, 110, 1, 0, 22, 40, 91, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 86, 1, 0, 4, 97, 114, 103, 115, 1, 0, 19, 91, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, 0, 19, 83, 104, 111, 119, 77, 101, 66, 121, 116, 101, 67, 111, 100, 101, 46, 106, 97, 118, 97, 12, 0, 4, 0, 5, 1, 0, 42, 99, 111, 109, 47, 100, 97, 104, 117, 121, 111, 117, 47, 102, 105, 110, 100, 47, 99, 108, 97, 122, 122, 47, 116, 101, 115, 116, 47, 83, 104, 111, 119, 77, 101, 66, 121, 116, 101, 67, 111, 100, 101, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, 2, 0, 3, 0, 0, 0, 0, 0, 2, 0, 1, 0, 4, 0, 5, 0, 1, 0, 6, 0, 0, 0, 47, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0, 2, 0, 7, 0, 0, 0, 6, 0, 1, 0, 0, 0, 3, 0, 8, 0, 0, 0, 12, 0, 1, 0, 0, 0, 5, 0, 9, 0, 10, 0, 0, 0, 9, 0, 11, 0, 12, 0, 1, 0, 6, 0, 0, 0, 43, 0, 0, 0, 1, 0, 0, 0, 1, -79, 0, 0, 0, 2, 0, 7, 0, 0, 0, 6, 0, 1, 0, 0, 0, 6, 0, 8, 0, 0, 0, 12, 0, 1, 0, 0, 0, 1, 0, 13, 0, 14, 0, 0, 0, 1, 0, 15, 0, 0, 0, 2, 0, 16]
classData：
ca fe ba be 00 00 00 34 00 14 0a 00 03 00 11 07 00 12 07 00 13 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01 00 04 74 68 69 73 01 00 2c 4c 63 6f 6d 2f 64 61 68 75 79 6f 75 2f 66 69 6e 64 2f 63 6c 61 7a 7a 2f 74 65 73 74 2f 53 68 6f 77 4d 65 42 79 74 65 43 6f 64 65 3b 01 00 04 6d 61 69 6e 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 01 00 0a 53 6f 75 72 63 65 46 69 6c 65 01 00 13 53 68 6f 77 4d 65 42 79 74 65 43 6f 64 65 2e 6a 61 76 61 0c 00 04 00 05 01 00 2a 63 6f 6d 2f 64 61 68 75 79 6f 75 2f 66 69 6e 64 2f 63 6c 61 7a 7a 2f 74 65 73 74 2f 53 68 6f 77 4d 65 42 79 74 65 43 6f 64 65 01 00 10 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 00 21 00 02 00 03 00 00 00 00 00 02 00 01 00 04 00 05 00 01 00 06 00 00 00 2f 00 01 00 01 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 07 00 00 00 06 00 01 00 00 00 03 00 08 00 00 00 0c 00 01 00 00 00 05 00 09 00 0a 00 00 00 09 00 0b 00 0c 00 01 00 06 00 00 00 2b 00 00 00 01 00 00 00 01 b1 00 00 00 02 00 07 00 00 00 06 00 01 00 00 00 06 00 08 00 00 00 0c 00 01 00 00 00 01 00 0d 00 0e 00 00 00 01 00 0f 00 00 00 02 00 10
Process finished with exit code 0
可以使用sublime等工具打开class，查看十六进制字节码对比程序输出结果：
写在后面
参考文章列表
【Java 基础篇】Java类加载器详解 。
jvm之启动参数 。
