参考文章：https://javasec.org/javase/ClassLoader/
关于类的加载机制，结果javasec和自己的理解来记录的一篇文章！！！
概念的学习
首先得知道的两点：
第一点：
Java是一个依赖于JVM(Java虚拟机)实现的跨平台的开发语言
第二点：类实例化的工作流程：
1、Java程序在运行前需要先编译成class文件（字节码），这个class文件其实就是我们的javac生成的！
2、Java类初始化的时候会调用ClassLoader对象（这里的ClassLoader其实也是一个类）加载类字节码（也就是class文件）
3、ClassLoader会调用JVM的native方法(defineClass0/1/2)来定义一个java.lang.Class实例。
现在知道了两个概念：
1、JAVA的运行依赖于JAVA虚拟机
2、类的初始化需要ClassLoader对象
3、想要生成对应的类实例就需要ClassLoader去加载对应类的字节码（也就是class文件）
注意：这里说的类实例，并不是如Unsafe unsafe = new Unsafe()这里面生成的unsafe实例，此unsafe实例跟这里的类实例不同的，为什么？
就比如这一句话：ClassLoader.getSystemClassLoader().loadClass("java.lang.String");，看着意思就是一个ClassLoader类中的getSystemClassLoader方法返回了一个对象然后调用该对象的loadClass方法加载了一个名为java.lang.String类，那么这里其实就知道了主要加载类的方法就是loadClass
可以观察下该loadClass返回的是什么，如下，那么也就知道了这是一个名叫Class类型的对象，那么也就是返回的是一个Class类型的对象，那么也就证实了上面说的，unsafe实例跟这里的类实例不同！
ClassLoader的介绍
观察如下一张图：
1、可以看到ClassLoader是位于JVM里面的
2、所有的类的实例化都需要经过ClassLoader
总结：上面的图中可以看到一切的Java类都必须经过JVM加载后才能运行，而ClassLoader的主要作用就是Java类的加载！
底层小知识：
1、在JVM类加载器中最顶层的是Bootstrap ClassLoader(引导类加载器)、Extension ClassLoader(扩展类加载器)、App ClassLoader(系统类加载器)，App ClassLoader是默认的类加载器，如果类加载时我们不指定类加载器的情况下，默认会使用App ClassLoader加载类，ClassLoader.getSystemClassLoader()返回的系统类加载器就是AppClassLoader
然后继续说，上面说了ClassLoader对象并不是只有一种，现在知道的有如上三种，其他的就是我们重写的ClassLoader类了
Java自带的三个类加载器：
Bootstrap Classloder
Extention ClassLoader
App ClassLoader
上一级称为下一级的父加载器（怎么理解，也就是Extention ClassLoader是App ClassLoader的父加载器），加载的先后顺序依次是：Bootstrap ClassLoader => Extention ClassLoader => App ClassLoader
图中可以知道：检查类加载和加载类生成的时候顺序是相反的，如图中所示，当一个类加载器查找class和resource的时候，首先判断这个class是不是已经加载成功；如果没有的话它并不是自己进行查找，而是先委托给父加载器，然后递归委托，直到Bootstrap ClassLoader加载器；如果Bootstrap classloader找到了，直接加载并且返回class和resource；如果没有找到，则一级一级返回，最后才是自己（这里的自己正常的肯定就是App ClassLoader，要不然就是你的自定义的类加载器）去查找加载。
需要知道的：某些时候我们获取一个类的类加载器时候可能会返回一个null值，如：java.io.File.class.getClassLoader()将返回一个null对象，因为java.io.File类在JVM初始化的时候会被Bootstrap ClassLoader(引导类加载器)加载(该类加载器实现于JVM层，采用C++编写)，我们在尝试获取被Bootstrap ClassLoader类加载器所加载的类的ClassLoader时候都会返回null
ClassLoader类的方法
ClassLoader最重要的如下5个方法：
1. loadClass (加载指定的Java类)
2. findClass (查找指定的Java类)
3. findLoadedClass (查找JVM已经加载过的类)
4. defineClass (定义一个Java类)
5. resolveClass (链接指定的Java类)
第一个方法，loadClass，一开始在开头也稍微介绍了下，该方法的作用是加载指定的Java类，跟一下这个方法
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
这里调用了一个loadClass，两个参数的方法，继续跟
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name); //这里先进行判断要加载的类名对应的类实例是否已经加载过了，这里findLoadedClass的作用其实就是 如果该类实例已经加载过了，那么它后续的操作就会直接返回
if (c == null) { //如果为空，那么也就是没有加载
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false); // 如果实例化ClassLoader的时候传入了父类加载器(new ClassLoader(你传入的父类加载器))就使用父类加载器加载TestHelloWorld类，否则使用JVM的Bootstrap ClassLoader加载。
} else {
c = findBootstrapClassOrNull(name); // 否则使用JVM的Bootstrap ClassLoader加载
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) { // 这里的就是根本找不到类
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name); // 这里就是上面的都找不到 然后就会调用自身的findClass方法去加载指定的类，其实这里体现的就是你的自定义加载器了，也就是说如果没有自定义加载器重写findClass方法，那肯定也是没有找到的，这里如果找到了就默认返回一个java.lang.Class类对象，也就是对应类型的class实例
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
自定义的类加载器
上面说了，如果都找不到就会用到我们的自定义加载器，同样的上面的类加载器也确实符合双亲委派模式
那么如何实现类加载器？只需要重写findClass方法就行！
这里先说下如何将字节码文件转换为byte数组，然后在java中通过defineClass来自己进行实例化，这里用的Y4er哥先知上的文章的代码，代码如下：
public class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException {
byte[] bs = getBytesByFile("C:\Users\secAdmin\Desktop\All\javaApp4\servlet2\src\main\java\com\anbai\sec\cmd\CommandExecution.class");
for (int i = 0; i < bs.length; i++) {
System.out.print(bs[i]+", ");
}
}
public static byte[] getBytesByFile(String pathStr) {
File file = new File(pathStr);
try {
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
byte[] data = bos.toByteArray();
bos.close();
return data;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
继续回来将如何实现自定义类的加载器，这里用到的还是javasec中的TestHelloWorld类作为要实例化的对象：
package com.java.classloader;
import java.lang.reflect.Method;
public class TestClassLoader extends ClassLoader {
// TestHelloWorld类名
public static String TEST_CLASS_NAME = "com.java.classloader.TestHelloWorld";
// TestHelloWorld类字节码
public static byte[] TEST_CLASS_BYTES = new byte[]{
-54, -2, -70, -66, 0, 0, 0, 51, 0, 17, 10, 0, 4, 0, 13, 8, 0, 14, 7, 0, 15, 7, 0,
16, 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, 5, 104, 101, 108, 108, 111, 1, 0, 20, 40, 41, 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, 84, 101, 115, 116, 72, 101, 108, 108, 111, 87, 111,
114, 108, 100, 46, 106, 97, 118, 97, 12, 0, 5, 0, 6, 1, 0, 12, 72, 101, 108, 108, 111,
32, 87, 111, 114, 108, 100, 126, 1, 0, 40, 99, 111, 109, 47, 97, 110, 98, 97, 105, 47,
115, 101, 99, 47, 99, 108, 97, 115, 115, 108, 111, 97, 100, 101, 114, 47, 84, 101, 115,
116, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 1, 0, 16, 106, 97, 118, 97, 47, 108,
97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, 3, 0, 4, 0, 0, 0, 0, 0, 2, 0, 1,
0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0,
1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 7, 0, 1, 0, 9, 0, 10, 0, 1, 0, 7, 0, 0, 0, 27, 0, 1,
0, 1, 0, 0, 0, 3, 18, 2, -80, 0, 0, 0, 1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 10, 0, 1, 0, 11,
0, 0, 0, 2, 0, 12
};
@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
// 只处理TestHelloWorld类
if (name.equals(TEST_CLASS_NAME)) {
// 调用JVM的native方法定义TestHelloWorld类
return defineClass(TEST_CLASS_NAME, TEST_CLASS_BYTES, 0, TEST_CLASS_BYTES.length);
}
return super.findClass(name);
}
public static void main(String[] args) {
// 创建自定义的类加载器
TestClassLoader loader = new TestClassLoader();
try {
// 使用自定义的类加载器加载TestHelloWorld类
Class testClass = loader.loadClass(TEST_CLASS_NAME);
// 反射创建TestHelloWorld类，等价于 TestHelloWorld t = new TestHelloWorld();
Object testInstance = testClass.newInstance();
// 反射获取hello方法
Method method = testInstance.getClass().getMethod("hello");
// 反射调用hello方法,等价于 String str = t.hello();
String str = (String) method.invoke(testInstance);
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
}
}
}
