用Java手写jvm之模拟类加载器加载class

写在前面

本文来实验模拟类加载器加载class的过程。
1：程序

首先来定义类加载器类：

1. /**
2. * 类加载器
3. * 正常应该有bootstrap，ext，app三个类加载器，这里简单起见，只用一个来模拟了
4. */
5. public class ClassLoader {
6.     // bootstrap，ext，app 组合的classpath
7.     private Classpath classpath;
8.     // 类名->对应的Class类
9.     private Map<String, Class> classMap;
11.     public ClassLoader(Classpath classpath) {
12.         this.classpath = classpath;
13.         this.classMap = new HashMap<>();
14.     }
16.     public Class loadClass(String className) {
17.         Class clazz = classMap.get(className);
18.         if (null != clazz) return clazz;
19.         try {
20.             return loadNonArrayClass(className);
21.         } catch (Exception e) {
22.             e.printStackTrace();
23.         }
24.         return null;
25.     }
27.         private Class loadNonArrayClass(String className) throws Exception {
28.         byte[] data = this.classpath.readClass(className);
29.         if (null == data) {
30.             throw new ClassNotFoundException(className);
31.         }
32.         // 1：加载，找到字节码并生成Class对象
33.         Class clazz = defineClass(data);
34.         // 2：链接 验证：有效性 准备：静态变量空间申请  解析：符号引用转直接引用
35.         link(clazz);
36.         // 3：初始化 调用init clinit方法
37.         init(clazz);
38.         return clazz;
39.     }
41.     private void init(Class clazz) {
42.         System.out.println("todo 初始化类：" + clazz.name);
43.     }
45.     private void link(Class clazz) {
46.         verify(clazz);
47.         prepare(clazz);
48.     }
50.     private void prepare(Class clazz) {
51.         calcInstanceFieldSlotIds(clazz);
52.         calcStaticFieldSlotIds(clazz);
53.         allocAndInitStaticVars(clazz);
54.     }
55.     // ...
56. }

复制代码

方法defineClass(data)对应了加载阶段，link(clazz)对应了链接阶段（包罗验证，准备，解析），init(clazz);对应了初始化。
为了更加全面的模拟这个过程，我们还自定义了Class类，和Method类，如下：

1. public class Class {
2.     // 类访问修饰符
3.     public int accessFlags;
4.     // 类名称
5.     public String name;
6.     // 父类名称，因为Java是单继承多实现所以这里的父类只有1个
7.     public String superClassName;
8.     // 父接口名称们，因为Java是单继承多实现，所以这里的父接口是多个
9.     public String[] interfaceNames;
10.     public RunTimeConstantPool runTimeConstantPool;
11.     // 类的字段信息们
12.     public Field[] fields;
13.     // 类的方法信息们，包含有方法对应的指令码数组信息，本地变量表和操作数栈大小信息
14.     public Method[] methods;
15.     // 加载本类的类加载器
16.     public ClassLoader loader;
17.     // 父类对应的Class对象
18.     public Class superClass;
19.     public Class[] interfaces;
21.     public int instanceSlotCount;
22.     public int staticSlotCount;
23.     public Slots staticVars;
25.     // ...
26. }

复制代码

1. public class Method extends ClassMember {
2.     // 操作数栈大小
3.     public int maxStack;
4.     // 本地变量表大小
5.     public int maxLocals;
6.     // 指令码字节数组
7.     public byte[] code;
8.     // ...
9. }
11. /**
12. * 类成员对象
13. * 字段
14. * 方法
15. * 因为字段和方法有些共享的内容，比如访问修饰符，名称，所属的class等，所以定义该公共父类
16. */
17. public class ClassMember {
18.     // 字段、方法的访问修饰符
19.     public int accessFlags;
20.     // 方法，字段的名称
21.     public String name;
22.     // 方法，字段类型的描述
23.     // 如private String name [Ljava/lang/String;
24.     // 如public void (String name) {} ([Ljava/lang/String;)V
25.     public String descriptor;
26.     // 所属的类对应的Class对象
27.     public Class clazz;
29.     // ...
30. }

复制代码

核心就是这些，具体的照旧需要投入时间来看源码，来多debug，接着写测试类：

1. /**
2. * -Xthejrepath     D:\programs\javas\java1.8/jre -Xthetargetclazz     D:\test\itstack-demo-jvm-master\tryy-too-simulate-classload-load-clazz\target\test-classes\org\itstack\demo\test\HelloWorld
3. */
4. public class Main {
6.     public static void main(String[] args) {
7.         Cmd cmd = Cmd.parse(args);
8.         if (!cmd.ok || cmd.helpFlag) {
9.             System.out.println("Usage: <main class> [-options] class [args...]");
10.             return;
11.         }
12.         if (cmd.versionFlag) {
13.             //注意案例测试都是基于1.8，另外jdk1.9以后使用模块化没有rt.jar
14.             System.out.println("java version "1.8.0"");
15.             return;
16.         }
17.         startJVM(cmd);
18.     }
20.     private static void startJVM(Cmd cmd) {
21.         // 创建classpath
22.         Classpath cp = new Classpath(cmd.thejrepath, cmd.classpath);
23. //        System.out.printf("classpath：%s class：%s args：%s\n", cp, cmd.getMainClass(), cmd.getAppArgs());
24.         System.out.printf("classpath：%s parsed class：%s \n", cp, cmd.thetargetclazz);
25.         //获取className
26. //        String className = cmd.getMainClass().replace(".", "/");
27.         try {
28. //            byte[] classData = cp.readClass(className);
29.             /*byte[] classData = cp.readClass(cmd.thetargetclazz.replace(".", "/"));
30.             System.out.println(Arrays.toString(classData));
31.             System.out.println("classData：");
32.             for (byte b : classData) {
33.                 //16进制输出
34.                 System.out.print(String.format("%02x", b & 0xff) + " ");
35.             }*/
36.             // 创建类加载器准备加载类
37.             /**
38.              * 加载3个阶段
39.              * 1：加载
40.              *      找到字节码，并将其存储到原元空间（<=7方法区），然后该类，该类父类，父接口也加载并在堆中生成对应的Class对象
41.              * 2：链接
42.              *      验证：验证文件内容的合法性，如是否cafebabe打头，结构是否符合定义
43.              *      准备：主要是给静态变量申请内存空间，以及赋初始值，如int，short这种则给默认值0
44.              *      解析：符号引用（指向类或者方法的一个字符串）转换为直接引用（jvm的内存地址）
45.              * 3：初始化
46.              *      执行<init>,<clinit>方法,完成静态变量的赋值
47.              */
48.             ClassLoader classLoader = new ClassLoader(cp);
49.             String clazzName = cmd.thetargetclazz.replace(".", "/");
50.             Class mainClass = classLoader.loadClass(clazzName);
51.             Method mainMethod = mainClass.getMainMethod();
52.             new Interpreter(mainMethod);
55.             /*// 创建className对应的ClassFile对象
56.             ClassFile classFile = loadClass(clazzName, cp);
57.             MemberInfo mainMethod = getMainMethod(classFile);
58.             if (null == mainMethod) {
59.                 System.out.println("Main method not found in class " + cmd.classpath);
60.                 return;
61.             }
62.             // 核心重点代码：通过解释器来执行main方法
63.             new Interpreter(mainMethod);*/
64.         } catch (Exception e) {
65.             System.out.println("Could not find or load main class " + cmd.getMainClass());
66.             e.printStackTrace();
67.         }
68.     }
70.     /**
71.      * 获取main函数，这里我们要模拟是执行器执行main函数的过程，当然其他方法也是一样的！！！
72.      * @param classFile
73.      * @return
74.      */
75.     private static MemberInfo getMainMethod(ClassFile classFile) {
76.         if (null == classFile) return null;
77.         MemberInfo[] methods = classFile.methods();
78.         for (MemberInfo m : methods) {
79.             if ("main".equals(m.name()) && "([Ljava/lang/String;)V".equals(m.descriptor())) {
80.                 return m;
81.             }
82.         }
83.         return null;
84.     }
86.     /**
87.      * 生成class文件对象
88.      * @param clazzName
89.      * @param cp
90.      * @return
91.      */
92.     private static ClassFile loadClass(String clazzName, Classpath cp) {
93.         try {
94.             // 获取类class对应的byte数组
95.             byte[] classData = cp.readClass(clazzName);
96.             return new ClassFile(classData);
97.         } catch (Exception e) {
98.             System.out.println("无法加载到类： " + clazzName);
99.             return null;
100.         }
101.     }
103. }

复制代码

定义需要加载的类，加载之后会解析该类main函数的指令码并使用自定义的解释器来实行代码：

1. package org.itstack.demo.test;
3. /**
4. * -Xjre D:\programs\javas\java1.8/jre D:\test\itstack-demo-jvm-master\try-too-simulate-interpreter\target\test-classes\org\itstack\demo\test\HelloWorld
5. */
6. public class HelloWorld {
7.    
8.     public static void main(String[] args) {
9.         int sum = 0;
10.         for (int i = 1; i <= 100; i++) {
11.             sum += i;
12.         }
13.         System.out.println(sum);
14.     }
15. }

复制代码

配置program argument-Xthejrepath D:\programs\javas\java1.8/jre -Xthetargetclazz D:\test\itstack-demo-jvm-master\tryy-too-simulate-classload-load-clazz\target\test-classes\org\itstack\demo\test\HelloWorld:

运行:

写在后面

参考文章列表

第23讲 | 请介绍类加载过程，什么是双亲委派模型？ 。
用Java手写jvm之模拟解释器实行指令码 。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。