JVM-01.JVM类加载机制

思维导图：点击查看思维导图.
类加载的过程：
加载： 在硬盘上通过IO读取字节码文件，使用类时才会进行加载。在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口
验证： 验证格式是否正确、是否符合Java语言规范等
准备： 给类的静态变量分配内存，并赋默认值（非指定的值）
解析： 将符号引用替换为直接引用（内存地址）的过程。
该阶段会把一些静态方法（符号引用）替换为数据所在内存的指针或句柄等（直接引用）：即静态链接过程（类加载期间完成），动态链接程序运行期间将符号引用替换为直接引用
初始化： 对类的静态变量初始化为指定的值，执行静态代码块
使用
卸载： 执行了 System.exit() 方法，程序正常执行结束，执行过程遇到异常或错误而异常终止，操作系统错误导致 JVM 进程终止
程序正常执行结束

类加载器（实质是类）
引导类加载器BootStrapClassLoader：加载支撑 JVM 运行的位于 JRE 的 lib 目录下的核心类库（ C++生成对象）
扩展类加载器ExtClassLoader：加载支撑JVM运行的位于lib目录下的ext 扩展目录中的 jar 包
应用程序加载器AppClassLoader：加载 ClassPath 路径下的类包，主要加载我们自己编写的类
自定义加载器：加载用户自定义路径下的类

双亲委派模型
向上委派：实际是查找缓存，是否加载类该类，有则直接返回，没有继续向上
向下查找：委派到顶层后，缓存中没有，查找加载路径，有则加载返回，没有则继续向下查找
在这里插入图片描述

public abstract class ClassLoader {// // The parent class loader for delegationprivate final ClassLoader parent;......
}

AppClassLoader 的 parent 属性是 ExtClassLoader
ExtClassLoader 的 parent 属性是 BootStrapClassLoader
MyClassLoader 的 parent 属性默认是 AppClassLoader

//调用自定义ClassLoader先给parent赋值，parent由默认构造方法进行赋值
// ClassLoader的默认构造方法
protected ClassLoader() {this(checkCreateClassLoader(), getSystemClassLoader());
}
/**
getSystemClassLoader->initSystemClassLoader方法中将parent赋值为
默认的AppClassLoader
sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
scl = l.getClassLoader();
**/

下面是双亲委托模型源码：

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);if (c == null) {long t0 = System.nanoTime();try {//当前加载器的父加载器不为空则委托父加载器加载该类if (parent != null) {c = parent.loadClass(name, false);} else { //当前加载器父加载器为空则委托引导类加载器加载该类c = findBootstrapClassOrNull(name);}} 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();//都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类c = findClass(name);// this is the defining class loader; record the statssun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}// 不会执行if (resolve) {resolveClass(c);}return c;}
}

双亲委派模型源码解析

检查指定名称的类是否被加载过，如果加载过直接返回
该类没有被加载过，判断是否有父加载器，如果有则由父加载器加载（调用 parent.loadClass(name,false)），或者直接调用 bootStrapClassLoader 来加载
如果父加载器和 bootStrapClassLoader 加载器都没有找到指定的类，则调用当前类加载器的 findClass() 方法来加载

设置双亲委派机制的好处：
沙箱安全机制：自己写的 java.lang.String.class 类不会被加载，这样便可以防止核心 API 库被随意篡改
避免类的重复加载：当父亲已经加载了该类时，就没有必要子 ClassLoader 再加载一次，保证被加载类的唯一性

package java.lang;
// 自定义Math类
public class Math {public static void main(String[] args) {System.out.println("My Math Class");}
}

自定义的 java.lang 包下面的 Math 方法中运行时返回的是 JDK 的自己的类，不是我们自定义的类，类中没有 Main 方法。
在这里插入图片描述
自定义类加载器
实现自定义类加载器只需要继承 ClassLoader 类并重写 findClass() 方法即可，下面是一个简单的自定义类加载器：

/*** 自定义类加载器*/
public class MyClassLoaderTest{static class MyClassLoader extends ClassLoader {// 类路径private String classPath;public MyClassLoader(String classPath) {this.classPath = classPath;}// 重写ClassLoader的findClass方法，ClassLoader类的findClass为空实现protected Class<?> findClass(String name) throws ClassNotFoundException {try {byte[] data = loadByte(name);//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组return defineClass(name, data, 0, data.length);} catch (Exception e) {e.printStackTrace();throw new ClassNotFoundException();}}// 读取字节码文件为字节数组private byte[] loadByte(String name) throws Exception {name = name.replaceAll("\\.", "/");FileInputStream fileInputStream = new FileInputStream(classPath + File.separator + name + ".class");int length = fileInputStream.available(); // 返回与之关联文件的字节数byte[] data = new byte[length];// 将字节码文件写入data并返回fileInputStream.read(data);fileInputStream.close();return data;}}// 测试public static void main(String[] args) throws Exception{// 初始化自定义类加载器，会先初始化parent属性ClassLoader设置为AppClassLoaderMyClassLoader classLoader = new MyClassLoader("E:/test");// E盘创建文件 E:test/p01/jvm/TestClass.classClass clazz = classLoader.loadClass("p01.jvm.TestClass");// 调用加载类中的方法Object obj = clazz.newInstance();Method method = clazz.getDeclaredMethod("printMethod", null);method.invoke(obj, null);// 该项目下的p01.jvm.TestClass文件需要删除，否则会出现调用的是AppClassLoaderSystem.out.println(clazz.getClassLoader().getClass().getName());}
}

打破双亲委派机制
1.在自定义加载器中重写 loadClass() 方法
2.JAVA SPI 机制（Service Provider Interface）

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
{synchronized (getClassLoadingLock(name)) {// First, check if the class has already been loadedClass<?> c = findLoadedClass(name);if (c == null) {long t1 = System.nanoTime();if (!name.startsWith("p01.jvm")) {c = this.getParent().loadClass(name);}else {c = findClass(name);}sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}if (resolve) {resolveClass(c);}return c;}
}

public static void main(String[] args) throws Exception {// 初始化自定义类加载器，会先初始化parent属性ClassLoader设置为AppClassLoaderMyClassLoader classLoader = new MyClassLoader("E:/test");// E盘创建文件 E:test/p01/jvm/TestClass.classClass clazz = classLoader.loadClass("p01.jvm.TestClass");// 调用加载类中的方法Object obj = clazz.newInstance();Method method = clazz.getDeclaredMethod("printMethod", null);method.invoke(obj, null);// 该项目下的p01.jvm.TestClass文件需要删除，否则会出现调用的是AppClassLoaderSystem.out.println(clazz.getClassLoader().getClass().getName());// 非指定路径，使用JVM的引导类加载器Class clazz1 = classLoader.loadClass("java.lang.String");Object obj1 = clazz1.newInstance();Method method1 = clazz1.getDeclaredMethod("isEmpty", null);method1.invoke(obj1, null);System.out.println(clazz1.getClassLoader());
}
// 重新new一个MyClassLoader 
// classLoader = new MyClassLoader("E:/test2");
// Class clazz = classLoader.loadClass("p01.jvm.TestClass");
// 可以加载相同名称的类（与Tocat类似，可以实现加载不同版本的包中的相同类）/** 
执行结果：
--------------------------------------------
我加载了该类！ --> 加载了E盘的class文件
p01.jvm.MyClassLoaderTest$MyClassLoader --> 自定义加载器
true  --> 调用的是rt.jar包下的String.class
null   --> 引导类加载器
**/