Java类加载器

Posted 2020-10-27 白话灵煕

1.类加载器介绍

类加载器负责将class文件加载到内存中，并为之生成对应的java.lang.Class对象。对于任意一个类，都需要加载它的类加载器和这个类本身来确定该类在JVM中唯一性，也就是说，同一个class文件用两个不同的类加载器加载并创建两个java.lang.Class对象，即使两个对象来源自同一个class文件，它们也是不相等的，这里“相等”包括Class对象的equals()方法、isAssignableFrom()方法、isInstance()方法，也包括使用instanceof关键字做对象所属关系判定情况。

验证代码如下：

 

[java] view plain copy

 

1. public class ClassLoaderTest {  
2.     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {  
3.         // 自定义类加载器  
4.         ClassLoader myLoader = new ClassLoader() {  
5.             @Override  
6.             public Class<?> loadClass(String name) throws ClassNotFoundException {  
7.                 String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";  
8.                 InputStream is = getClass().getResourceAsStream(fileName);  
9.                 if (is == null) {  
10.                     return super.loadClass(name);  
11.                 }  
12.                 try {  
13.                     byte[] buff = new byte[is.available()];  
14.                     is.read(buff);  
15.                     return defineClass(name, buff, 0, buff.length);  
16.                 } catch (IOException e) {  
17.                     throw new ClassNotFoundException(name);  
18.                 }  
19.             }  
20.         };  
21.         // 使用自定义的类加载加载classLoaderTest.ClassLoaderTest类  
22.         Class clazz = myLoader.loadClass("classLoaderTest.ClassLoaderTest");  
23.         Object obj = clazz.newInstance();  
24.         /* 
25.          创建obj对象的类实例是由自定义类加载器加载的， 
26.          classLoaderTest.ClassLoaderTest使用的类加载器是系统类加载器，所属关系并不一致 
27.          */  
28.         System.out.println(obj instanceof classLoaderTest.ClassLoaderTest);  
29.         /* 
30.          clazz类实例是由自定义类加载器加载的， 
31.          classLoaderTest.ClassLoaderTest.class使用的类加载器是系统类加载器 
32.          */  
33.         System.out.println(clazz.getClassLoader());  
34.         System.out.println(classLoaderTest.ClassLoaderTest.class.getClassLoader());  
35.         System.out.println(clazz.equals(classLoaderTest.ClassLoaderTest.class));  
36.     }  
37. }  

输出结果：

 

[java] view plain copy

 

1. false  
2. classLoaderTest.ClassLoaderTest$1@537e7f88  
3. sun.misc.Launcher$AppClassLoader@7d05e560  
4. false  

 

2.类加载器分类

从Java虚拟机的角度来讲，只存在两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），这个类加载器是虚拟机的一部分；另一种就是所有其他的类加载器，这些类加载器都由Java语言实现，独立于虚拟机，并且全部继承自java.lang.ClassLoader。细分来看，类加载器还可以分为如下几类：

• Bootstrap ClassLoader：根类加载器
• Extension ClassLoader：扩展类加载器
• System ClassLoader：应用程序类加载器
• 用户自定义类加载器

2.1 Bootstrap ClassLoader

Bootstrap ClassLoader被称为根类加载器，它负责加载Java的核心类。根类加载器并不是java.lang.ClassLoader的子类，而是由JVM自身实现的。在Sun的JVM中，当执行java.exe命令时，使用-Xbootclasspath选择或使用-D选项指定sun.boot.class.path系统属性值可以指定加载附加的类。

通过如下程序查看根类加载器加载的类的路径：

 

 

[java] view plain copy

 

1. public class LoaderTest {  
2.     public static void main(String[] args) throws IOException {  
3.         // 获取根类加载器所加载的全部URL数组  
4.         URL[] urls = Launcher.getBootstrapClassPath().getURLs();  
5.         // 遍历、输出根类加载器加载的全部URL  
6.         System.out.println("*********根类加载器加载的全部URL*************");  
7.         for (URL url : urls) {  
8.             System.out.println(url.toExternalForm());  
9.         }  
10.     }  
11. }  

输出结果：

 

 

[java] view plain copy

 

1. *********根类加载器加载的全部URL*************  
2. file:/D:/Java/jdk1.7.0_80/jre/lib/resources.jar  
3. file:/D:/Java/jdk1.7.0_80/jre/lib/rt.jar  
4. file:/D:/Java/jdk1.7.0_80/jre/lib/sunrsasign.jar  
5. file:/D:/Java/jdk1.7.0_80/jre/lib/jsse.jar  
6. file:/D:/Java/jdk1.7.0_80/jre/lib/jce.jar  
7. file:/D:/Java/jdk1.7.0_80/jre/lib/charsets.jar  
8. file:/D:/Java/jdk1.7.0_80/jre/lib/jfr.jar  
9. file:/D:/Java/jdk1.7.0_80/jre/classes  

 

2.2 Extension ClassLoader

Extension ClassLoader是扩展类加载器，它负责加载JRE的扩展目录中JAR包的类，或者被java.ext.dirs系统变量所指定的路径中的所有类库，开发者可以直接使用扩展类加载器。

2.3 Application ClassLoader

Application ClassLoader是应用程序类加载器，由sun.misc.Launcher$AppClassLoader实现，可以通过ClassLoader.getSystemClassLoader()方法获取，因此也被称为系统类加载器。它负责加载用户类路径(ClassPath)上指定的类库，开发者可以直接使用这个类加载器，如果应用程序没有自定义类加载器，一般情况下这个就是程序中默认的类加载器。

2.4 自定义类加载器器

为了实现类加载的个性化定制，我们可以通过扩展java.lang.ClassLoader类来实现自定义类加载器，详细的实现随后描述。

我们的应用程序一般都是由这几种类加载器相互配合进行加载的，类加载器之间的关系如图：

类加载器之间的关系并非是类继承性质的父子关系，而是一种组合关系。

3.类加载器加载类的步骤

类加载器在加载一个类时会先把加载的请求委托给父加载器加载，如果父类加载器仍有父加载器（只有根加载器没有父加载器），则再次委托给其父加载器，最后所有的加载请求都会传送给根类加载器，只有当父类加载器中无法完成对委托的类的加载时，该类才会被子加载器加载。这样的加载方式显著的好处就是：在一个运行的JVM中，所有的类都不会被不同的类加载器，某个类在各个加载器环境中看到的都是同一个Class对象。
另外，当一个类加载器负责加载某个Class时，该Class所引用的其他Class也会被该类加载器载入，除非显式使用另外一个类加载器加载。
JVM的类加载有一种缓存机制，如果一个类已经被加载过，那么在程序中再次用到这个类时，会直接从缓存中获取该类，只有在缓存中不存在该类时，类加载器才会读取该类的二进制数据并创建该类的Class对象。这也很好地解释了为什么修改了Java代码之后需要重启JVM修改才能生效。不过，现在已经有技术能够做到修改Java代码后不重启JVM仍可生效。

4.创建自定义的类加载器

在日常的程序开发中，出于某种需要，我们可能要自定义一些类加载器。通常推荐扩展ClassLoader类并重写findClass方法来实现自定义类加载器。
接下来我们自定义实现一个可以直接加载源代码的加载类，实现的原理很简单，把对源码的编译放在类加载器中执行：

 

[java] view plain copy

 

1. import java.io.File;  
2. import java.io.FileInputStream;  
3. import java.io.IOException;  
4. import java.lang.reflect.Method;  
5.   
6. /** 
7.  * author:xszhaobo 
8.  * <p/> 
9.  * date:2016/5/7 
10.  * <p/> 
11.  * package_name:JVMTest.myclassloader 
12.  * <p/> 
13.  * project: _darksiderg 
14.  */  
15. public class CompileClassLoader extends ClassLoader {  
16.   
17.     public static void main(String[] args) throws Exception {  
18.         if (args.length < 1) {  
19.             System.out.println("缺少目标类：");  
20.             System.out.println("java CompileClassLoader ClassName");  
21.         }  
22.         // 第一个参数指定需要运行的类名  
23.         String progClass = args[0];  
24.         // 其他的一些参数  
25.         String[] progArgs = new String[args.length - 1];  
26.         System.arraycopy(args,1,progArgs,0,progArgs.length);  
27.         // 指定类加载器  
28.         CompileClassLoader loader = new CompileClassLoader();  
29.         Class clazz = loader.loadClass(progClass);  
30.         // main指方法名称   
31.         // new String[0]).getClass()表示main的形参类型对应Class  
32.         Method main = clazz.getMethod("main",(new String[0]).getClass());  
33.         Object[] argsArray = {progArgs};  
34.         // 第一个参数表示需要调用的方法所属的对象，如果调用静态方法，那么可以设置为null  
35.         // 第二个以及以后的参数表示该方法传入的参数  
36.         main.invoke(null,argsArray);  
37.      }  
38.   
39.     @Override  
40.     protected Class<?> findClass(String name) throws ClassNotFoundException {  
41.         System.out.println("加载类：" + name + ".java");  
42.         Class clazz = null;  
43.         String fileStub = name.replaceAll("\\.", "/");  
44.         String javaFileName = fileStub + ".java";  
45.         String classFileName = fileStub + ".class";  
46.         File javaFile = new File(javaFileName);  
47.         File classFile = new File(classFileName);  
48.         // java源文件存在而class文件不存在，或者java源文件修改时间晚于class文件  
49.         if (javaFile.exists() && (!classFile.exists()  
50.                 || javaFile.lastModified() > classFile.lastModified())) {  
51.             try {  
52.                 if (!compile(javaFileName) || !classFile.exists()) {  
53.                     throw new ClassNotFoundException("ClassNotFoundException:" + javaFileName);  
54.                 }  
55.             } catch (IOException e) {  
56.                 e.printStackTrace();  
57.             }  
58.   
59.             if (classFile.exists()) {  
60.                 try {  
61.                     byte[] raw = getBytes(classFileName);  
62.                     clazz = this.defineClass(name,raw,0,raw.length);  
63.                 } catch (IOException e) {  
64.                     e.printStackTrace();  
65.                 }  
66.             }  
67.         }  
68.         if (clazz == null) {  
69.             throw new ClassNotFoundException(name);  
70.         }  
71.         return clazz;  
72.     }  
73.   
74.     private boolean compile(String javaFile) throws IOException {  
75.         System.out.println("CompileClassLoader编译" + javaFile + "...");  
76.         Process p = Runtime.getRuntime().exec("javac -encoding utf-8 " + javaFile);  
77.         try {  
78.             p.waitFor();  
79.         } catch (InterruptedException e) {  
80.             e.printStackTrace();  
81.         }  
82.         int ret = p.exitValue();  
83.         return ret == 0;  
84.     }  
85.   
86.     private byte[] getBytes(String fileName) throws IOException {  
87.         File file = new File(fileName);  
88.         long length = file.length();  
89.         byte[] bytes = new byte[(int) length];  
90.         // 使用Java 7的特性：具有资源管理的try语句  
91.         try (FileInputStream fis = new FileInputStream(file)) {  
92.             int readLen = fis.read(bytes);  
93.             if (readLen != length) {  
94.                 throw new IOException("无法读文件的全部内容：" + fileName);  
95.             }  
96.             return bytes;  
97.         }  
98.   
99.         // Java 7之前的版本使用这种资源管理方式  
100.         /*try { 
101.             int readLen = fis.read(bytes); 
102.             if (readLen != length) { 
103.                 throw new IOException("无法读文件的全部内容：" + fileName); 
104.             } 
105.             return bytes; 
106.         } finally { 
107.             fis.close(); 
108.         }*/  
109.     }  
110. }  

编译该类：
javac -encoding utf-8 -Xlint:unchecked CompileClassLoader.java

 

 

指令的含义
javac是编译命令；
-encoding utf-8指定编码是utf-8；
-Xlint:unchecked指由于CompileClassLoader.java使用了未经检查或不安全的操作，需要指定-Xlint:unchecked编译；
CompileClassLoader.java指需要编译的文件。

在相同的文件夹下面随便写一个测试主类：

 

[java] view plain copy

 

1. /** 
2.  * author:xszhaobo 
3.  * <p/> 
4.  * date:2016/5/9 
5.  * <p/> 
6.  * package_name:JVMTest.myclassloader 
7.  * <p/> 
8.  * project: _darksiderg 
9.  */  
10. public class HelloTest {  
11.     public static void main(String[] args) {  
12.             System.out.println("参数 ：" + args[0]);  
13.     }  
14. }  

此时在命令行中使用CompileClassLoader作为类加载器直接使用java命令运行源代码：
java CompileClassLoader HelloTest 这是一个参数
首次加载时输出结果：

[java] view plain copy

 

1. CompileClassLoader编译HelloTest.java...  
2. 参数：这是一个参数  

可以看出这是此时先编译了HelloTest.java文件，然后运行该类中的main方法。
但是这里有一个问题，如果此时修改HelloTest.java源代码，重新执行如下命令：
java CompileClassLoader HelloTest 这是一个参数
输出的结果：

[java] view plain copy

 

1. 参数：这是一个参数  

此时的输出已经不包含“CompileClassLoader编译HelloTest.java...”这一句，说明这一次并没有重新编译源代码，该问题的原因尚未找到，如果你知道答案，不妨告诉我。
还需要注意的地方：
1.执行命令时所处的目录应当是java源文件所在的目录；
2.源代码中类的定义不要指定包，如果你指定了包，在编译源代码和指定加载器时需要做进一步处理。