java虚拟机详解篇五（类的加载器）

java虚拟机详解篇五（类的加载器）
ClassLoader类

loadClass(String name, boolean resolve)：根据指定的二进制名称来加载类，该方法为ClassLoader的入口点，系统就是调用ClassLoader的该方法来获取指定类对应的Class对象。
findClass(String name)：根据二进制名称来查找类。

如果需要实现自定义的ClassLoader，可以通过重写以上两个方法来实现，优先推荐重写findClass(String name)方法。因为重写 findClassO方法可以避免覆盖默认类加载器的父类委托和缓冲机制两种策略 ; 如果重写 loadClassO方法，则实现逻辑更为复杂。

loadClass()方法的执行步骤如下：

1、用 findLoadedClass(String) 来检查是否己经加载类，如果已经加载则直接返回。在父类加载器上调用
2、 loadClassO方法。如果父类加载器为 null ，则使用根类加载器来加载。
3、调用 findClass(String)方法查找类。

ClassLoader 里还包含如下一些普通方法：

1、 findSystemClass(String name): 从本地文件系统装入文件。它在本地文件系统中寻找类文件，如果存在，就使用 defineClassO方法将原始字节转换成 Class 对象，以将该文件转换成类。

2、static getSystemClassLoaderO: 这是一个静态方法，用于返回系统类加载器

3、getParent（）: 获取该类加载器的父类加载器。

4、resolveClass(Class c): 链接指定的类。类加载器可以使用此方法来链接类 c 。

5、findLoadedClass(String name): 如果此 Java 虚拟机己加载了名为 name 的类，则直接返回该类对应的Class 实例，否则返回 null。该方法是 Java 类加载缓存机制的体现。

源码展示：
```
import java.io.*;
import java.lang.reflect.*;

public class CompileClassLoader extends ClassLoader
{

	private byte[] getBytes(String filename)
		throws IOException
	{
		File file = new File(filename);
		long len = file.length();
		byte[] raw = new byte[(int)len];
		try(
			FileInputStream fin = new FileInputStream(file))
		{

			int r = fin.read(raw);
			if(r != len)
			throw new IOException("无法读取全部文件"
				+ r + " != " + len);
			return raw;
		}
	}

	private boolean compile(String javaFile)
		throws IOException
	{
		System.out.println("CompileClassLoader:正在编译 "
			+ javaFile + "...");
		// 调用系统的javac命令
		Process p = Runtime.getRuntime().exec("javac " + javaFile);
		try
		{
			// 其他线程等待这个线程完成
			p.waitFor();
		}
		catch(InterruptedException ie)
		{
			System.out.println(ie);
		}

		int ret = p.exitValue();

		return ret == 0;
	}

	protected Class<?> findClass(String name)
		throws ClassNotFoundException
	{
		Class clazz = null;

		String fileStub = name.replace("." , "/");
		String javaFilename = fileStub + ".java";
		String classFilename = fileStub + ".class";
		File javaFile = new File(javaFilename);
		File classFile = new File(classFilename);

		if(javaFile.exists() && (!classFile.exists()
			|| javaFile.lastModified() > classFile.lastModified()))
		{
			try
			{

				if(!compile(javaFilename) || !classFile.exists())
				{
					throw new ClassNotFoundException(
						"ClassNotFoundExcetpion:" + javaFilename);
				}
			}
			catch (IOException ex)
			{
				ex.printStackTrace();
			}
		}

		if (classFile.exists())
		{
			try
			{

				byte[] raw = getBytes(classFilename);

				clazz = defineClass(name,raw,0,raw.length);
			}
			catch(IOException ie)
			{
				ie.printStackTrace();
			}
		}

		if(clazz == null)
		{
			throw new ClassNotFoundException(name);
		}
		return clazz;
	}

	public static void main(String[] args) throws Exception
	{

		if (args.length < 1)
		{
			System.out.println("缺少目标类，请按如下格式运行java源文件：");
			System.out.println("java CompileClassLoader ClassName");
		}

		String progClass = args[0];

		String[] progArgs = new String[args.length-1];
		System.arraycopy(args , 1 , progArgs
			, 0 , progArgs.length);
		CompileClassLoader ccl = new CompileClassLoader();

		Class<?> clazz = ccl.loadClass(progClass);

		Method main = clazz.getMethod("main" , (new String[0]).getClass());
		Object[] argsArray = {progArgs};
		main.invoke(null,argsArray);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
```
URLClassLoader类

Java为ClassLoader提供了一个URLClassLoader实现类，该类也是系统类加载器和扩展类加载器的父类（此处是父类，而不是父类加载器，这里是类与类之间的继承关系），URLClassLoader功能比较强大，它既可以从本地文件系统获取二进制文件来加载类，也可以从远程主机获取二进制文件来加载类。
应用程序中可以直接使用URLClassLoader来加载类，URLClassLoader类提供了如下两个构造器：

URLClassLoader(URL[] urls)：使用默认的父类加载器创建一个ClassLoader对象，该对象将从urls所指定的系列路径来查询、并加载类。

URLClassLoader(URL[] urls, ClassLoader parent)：使用指定的父类加载器创建一个ClassLoader对象，其他功能前一个构造器相同。

类加载器

java虚拟机的类加载器一共有三种，分别是启动类加载器（引导类加载器（根类加载器）：Bootstrap ClassLoader），扩展类加载器（Extension ClassLoader），应用程序类加载器（系统类加载器 AppClassLoader）。还有就是在java程序中，我们可以自行定义一个类加载器，这个类加载器被划分为自定义类加载器。如图：

实例代码：
```
import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;

public class ClassLoaderTest {
    public static void main(String[] args) {
        // 获取系统类加载器
        ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器："+systemLoader); // sun.misc.Launcher$AppClassLoader@18b4aac2

        // 获取系统类加载器的上层，扩展类加载器
        ClassLoader parent = systemLoader.getParent();
        System.out.println(parent); // sun.misc.Launcher$ExtClassLoader@61bbe9ba

        Enumeration<URL> eml = null;
        try {
            eml = systemLoader.getResources("");
        } catch (IOException e) {
            e.printStackTrace();
        }
        while(eml.hasMoreElements()){
            System.out.println(eml.nextElement()); // 代码路径/java/AnnotationAndReflection/target/classes/
        }
        //获取系统类加载器的父类加载器，得到扩展类加载器
        ClassLoader extensionLader = systemLoader.getParent();
        System.out.println( " 扩展类加载器 : " + extensionLader);// sun.misc.Launcher$ExtClassLoader@61bbe9ba
        System.out.println(" 扩展类加载器的加载路径: "
                + System.getProperty (" java.ext.dirs " ));
        System.out.println("扩展类加载器的 parent: "
                + extensionLader . getParent());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
```
结果： 系统类加载器的加载路径是程序运行的当前路径，扩展类加载器的加载路径是 null，扩展类加载器的父加载器是 null，并不是根类加载器。这是因为根类加载器并没有继承 ClassLoader 抽象类，所以扩展类加载器的getParent()方法返回 null 。但实际上，扩展类加载器的父类加载器是根类加载器，只是根类加载器并不是 Java 实现的，而且由于程序通常无须访问根类加载器，因此访问扩展类加载器的父类加载器时返回 null 。

启动类加载器
- 这个类加载器使用C/C++实现的，内嵌在jvm的内部（一般的类加载器访问不到）
- 它用来加载java的核心类库，（比如JAVA_HOME/jre/lib/resources.jar或者是sun.boot.class.path路径下的内容）用于提供jvm需要的类
- 不继承自java.lang.ClassLoader，没有父类加载器。（它最大）
- 加载扩展类加载器和应用程序类加载器，并且为他们指定父类加载器。
- 为了安全考虑，BootstrapClassLoader只是会加载sun、javax、java等开头的类。
- 启动类加载器是无法被Java程序直接引用的。
扩展类加载器
- java 语言编写的，由sun.misc.Launcher$ExtClassLoader实现。
- 派生于ClassLoader类
- 父类加载器为启动类加载器
- 从java.ext.dirs系统属性所指定的目录中加载类库，或者是从jdk安装的目录jre/lib/ext子目录的（扩展类库）下加载类库，如果用户创建jar文件放在此目录下也会自动有扩展类加载器加载。
应用程序类加载器
- java 语言编写，由sun.misc.Launcher$AppClassLoader实现
- 派生于ClassLoader类
- 父类加载器为扩展类加载器
- 它负责加载环境变量classpath或是系统属性，java.class.path路径下的类库。
- 该类是程序中默认的类加载器。java的应用的类都是由该加载完成。
- 通过ClassLoader.getSystemClassLoader()可以获取该类加载器。
- 开发者可以直接使用该类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
自定义类的加载器

在java程序开发的过程中，类的加载基本上都是由上述三类加载器加载完成，在必要的时候可以自己定义类加载器。
自定义类加载器可以实现一下几种常见的功能：

1、执行代码前自动验证数字签名
2、根据用户提供的密码解密代码，从而实现代码混淆器来避免反编译*.class文件
3、根据用户需求来动态地加载类
4、根据应用需求把其他数据以字节码的形式加载到应用中。

自定义类加载器好处：

1、隔离加载类
2、修改类加载的方式
3、扩展加载源
4、防止源码泄露

 类加载器的数据来源

类的加载器加载的数据来源有以下几种：
```
1、从本地文件系统加载 class 文件，这是绝大部分示例程序的类加载方式 。
2、从 JAR 包加载 class 文件，jvm可以从 JAR 文件中 直接加载该 class 文件 。
3、通过网络加载class文件
4、把一个java的源文件动态编译并执行加载
5、从专有的数据库中提取class文件，比较少见。
6、从加密文件中获取，这是典型的防止class文件被反编译的措施。
7、由其他文件生成，典型的场景：jsp应用。
1
2
3
4
5
6
7
```
类加载器加载class的步骤
1. 检测此 Class 是否载入过(即在缓存区中是否有此 Class ) ，如果有则直接进入第 8 步，否则接着执行第 2 步。
2. 如果父类加载器不存在( 如果没有父类加载器，则要么 parent 一定是根类加载器，要么本身就是根类加载器) ，则跳到第 4 步执行 :如果父类加载器存在，则接着执行第 3 步。
3. 请求使用父类加载器去载入目标类，如果成功载入则跳到第 8 步，否则接着执行第 5 步。
4. 请求使用根类加载器来载入目标类，如果成功载入则跳到第 8 步，否则跳到第 7 步。
5. 当前类加载器尝试寻找 Class 文件 ( 从与此 ClassLoader 相关的类路径中寻找)，如果找到则执行第 6 步，如果找不到则跳到第 7 步。
6. 从文件中载入 Class ，成功载入后跳到第 8 步。
7. 抛出 ClassNotFoundException 异常。
8. 返回对应的 java .lang.Class 对象。
其中，第 5 、6 步允许重写 ClassLoader的 findClassO方法来实现自己的载入策略，甚至重写 loadClass()方法来实现自己的载入过程。

文章参考
- java全栈知识体系
- http://www.cnblogs.com/ityouknow/p/5603287.html
- http://blog.csdn.net/ns_code/article/details/17881581
- https://segmentfault.com/a/1190000005608960
- http://www.importnew.com/18548.html
- http://zyjustin9.iteye.com/blog/2092131
- http://www.codeceo.com/article/java-class-loader-learn.html
相关阅读:
SpringBoot项目集成Redis+JWT实现系统登录token校验
 Golang | Leetcode Golang题解之第147题对链表进行插入排序
 【Python】定义函数求解一元二次方程
 基于抗冠状病毒优化（ACVO）算法求解单目标优化问题附matlab代码
 如何将数据库迁移到 Amazon Aurora
机器学习笔记——欠拟合、过拟合
 计算机视觉与深度学习 | 惯性/视觉/激光雷达SLAM技术综述
 buuctf misc [UTCTF2020]docx
在Linux上安装RStudio工具并实现本地远程访问【内网穿透】
在ubuntu下远程链接仓库gitte/github
原文地址：https://blog.csdn.net/m0_46198325/article/details/126376465

ClassLoader类

URLClassLoader类

类加载器

启动类加载器

扩展类加载器

应用程序类加载器

自定义类的加载器

类加载器的数据来源

类加载器加载class的步骤

文章参考