JVM：类加载子系统

一、类加载子系统概述

类加载子系统由多个类加载器组成，它们负责从文件系统或者网络中读取二进制形式的字节码（.class）文件，并将其加载进 JVM。字节码文件中关于类的定义、类中属性的定义、类中方法的定义以及类中方法的字节码等信息，会存储在方法区（Java 8 以后，元空间是方法区的一种实现方式 ）的类信息部分。类的静态变量存储在方法区（Java 8 后位于堆中 ），字节码中的常量池（包括字符串常量、数字常量、类名、方法名、属性名等符号引用 ）会被加载到方法区的运行时常量池部分

二、类的加载过程

1. 加载：根据双亲委派机制和类的全限定名（类名 + 包名），合适的类加载器会将类的二进制形式的 .class 文件加载进 JVM。类的定义、类中属性的定义、类中方法的定义以及类中方法的字节码等信息会放在方法区（JDK 8 及以后为元空间）的类信息部分；在 JDK 7 及以前，类的静态变量放在方法区的静态变量部分，而 JDK 8 及以后，静态变量存储在堆中；字节码的常量池里的数据会被放在方法区的运行时常量池。并且在堆中生成这个类的 Class 对象，作为该类在 JVM 中的访问入口

2. 验证：验证这个字节码文件是否合法，此阶段会从文件格式、元数据、字节码、符号引用等多方面进行检查，确保字节码符合 JVM 规范且不会危害 JVM 安全

3. 准备：为类的静态变量分配内存并设置默认初始值。例如，int 类型的静态变量默认初始值为 0，boolean 类型为 false 等。若静态变量被 final 修饰，在准备阶段就会被初始化为指定的值

4. 解析：把运行时常量池中的符号引用转换为直接引用。例如，将方法名、类名等符号引用指向方法的字节码、类的实际内存地址等实际引用，使 JVM 能准确找到并调用相关的类、方法和字段

5. 初始化：会执行类的 <clinit>() 方法，这个方法由类的静态变量赋值语句和静态代码块合并而成，按照在源代码中的定义顺序执行。父类的 <clinit>() 方法会先执行。并且在多线程状态下，<clinit>() 方法是会加锁的，若多个线程都尝试调用该方法，同一时刻只有一个线程能够执行该方法，以保证类的初始化过程是线程安全的

三、类加载器分类

1. 引导类加载器（Bootstrap ClassLoader）：由 C/C++ 编写，通过本地的 C/C++ 方法进行初始化。它负责加载 Java 的核心类库，比如java.lang、java.util等基础包中的类，这些类是 JVM 运行的基础
2. 扩展类加载器（Extension ClassLoader）：由 Java 语言编写，它是由sun.misc.Launcher$extClassLoader实现。它是在 JVM 启动过程中，由引导类加载器加载sun.misc.Launcher类时，该类创建了扩展类加载器实例。扩展类加载器主要从java.ext.dirs系统属性指定的目录，或者 JDK 安装目录的jre/lib/ext子目录下加载类库
3. 应用程序类加载器（AppClassLoader）：同样由 Java 语言编写，由sun.misc.Launcher$AppClassLoader实现。它也是由sun.misc.Launcher创建。它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库，通常我们自己编写的类默认由它加载
4. 用户自定义类加载器：开发人员可以通过继承java.lang.ClassLoader类来实现自定义类加载器，以满足如加载加密的类文件、从特定数据源加载类等特殊需求。在 JDK 1.2 之后，建议将自定义加载逻辑写在findClass()方法中，若需求不太复杂，也可继承URLClassLoader来简化编写

四、ClassLoader 使用说明

（1）ClassLoader 类

是抽象类，其他类加载器（除引导类加载器）都继承自它，包含getParent()、loadClass()等方法，用于获取父加载器、加载类等操作

（2）获取 ClassLoader 途径

1. 通过当前类获取 ClassLoader：
   1. 在 Java 中，每个类都有一个 getClassLoader() 方法（java.lang.Class 类的方法），可以用来获取加载该类的类加载器。对于系统类（由引导类加载器加载），此方法会返回 null

      public class ClassLoaderExample {public static void main(String[] args) {// 获取当前类 ClassLoaderExample 的类加载器ClassLoader classLoader = ClassLoaderExample.class.getClassLoader();System.out.println("通过当前类获取的 ClassLoader: " + classLoader);}
      }

   2. 在上述代码中，ClassLoaderExample.class.getClassLoader() 调用获取了加载 ClassLoaderExample 类的类加载器，通常情况下，如果是自己编写的类，会是应用程序类加载器（AppClassLoader）
2. 通过当前线程上下文获取 ClassLoader：
   1. 线程上下文类加载器（Thread Context ClassLoader）可以在运行时动态地改变类加载器。可以通过 Thread 类的 getContextClassLoader() 方法来获取

      public class ClassLoaderExample {public static void main(String[] args) {Thread currentThread = Thread.currentThread();ClassLoader contextClassLoader = currentThread.getContextClassLoader();System.out.println("通过当前线程上下文获取的 ClassLoader: " + contextClassLoader);}
      }

   2. 在默认情况下，主线程的上下文类加载器是应用程序类加载器。如果在某些框架（如 Spring）中，可能会被设置为自定义的类加载器，以实现特定的类加载需求
3. 通过系统获取 ClassLoader：
   1. 可以通过 ClassLoader 类的静态方法 getSystemClassLoader() 来获取系统类加载器，在 Java 中，系统类加载器一般就是应用程序类加载器（AppClassLoader）

      public class ClassLoaderExample {public static void main(String[] args) {ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();System.out.println("通过系统获取的 ClassLoader: " + systemClassLoader);}
      }

   2. 运行这段代码，会输出应用程序类加载器的相关信息，它负责加载应用程序的类路径（classpath）下的类

五、双亲委派机制

1. 双亲委派机制的工作原理是：当一个类加载器收到加载类的请求时，它会先将该请求向上委派给其父类加载器，也就是按照用户自定义类加载器→应用程序类加载器→扩展类加载器→引导类加载器的顺序，直至到达引导类加载器。引导类加载器会首先尝试加载该类，如果它无法完成加载，就把任务交还给扩展类加载器尝试加载；若扩展类加载器也无法完成，再交给应用程序类加载器；若应用程序类加载器还是不行，最后由用户自定义类加载器来尝试加载
2. 其好处是可以保护核心 API，防止被篡改。例如，即便自定义了一个 String 类，当加载请求经过层层委派到引导类加载器时，它会加载 Java 基础类库中的 String 类，加载过程随即终止，自定义的 String 类不会被加载

六、其他相关知识

（1）字节码文件

源代码经编译生成字节码指令，这些字节码指令以二进制形式存储在.class文件里

1. 字节码文件的存储形式：.class 文件是一种二进制文件，它包含了一系列的字节码指令和其他元数据信息。这些信息以二进制形式编码，这样可以高效地存储和传输。字节码文件中的每个字节都有特定的含义，例如，某些字节表示操作码（如 getstatic、invokevirtual 等指令），而其他字节可能表示操作数或常量池索引等。由于字节码文件是二进制的，人类无法直接阅读和理解，所以需要使用反编译工具将其转换为人类可读的形式，比如使用 javap 工具或其他反编译软件
2. 类加载器加载的字节码文件：类加载器在加载字节码文件时，处理的确实是二进制形式的数据。类加载器的主要职责之一就是从文件系统、网络或其他来源获取 .class 文件的二进制数据，并将其加载到 JVM 中。例如，当使用应用程序类加载器加载一个自定义类时，它会根据类的全限定名找到对应的 .class 文件，然后读取该文件的二进制内容。之后，类加载器会将这些二进制数据转换为 JVM 内部的数据结构，存储在方法区中
3. JVM 里的字节码：JVM 在运行过程中处理的字节码本质上也是二进制形式的。在类加载过程中，字节码被加载到 JVM 的方法区，以二进制形式存储。当 JVM 执行字节码时，解释器或 JIT 编译器会读取这些二进制的字节码指令，并将其转换为机器码或直接执行。例如，解释器会逐行读取二进制的字节码指令，根据指令的含义进行相应的操作，如操作数栈的压栈和出栈、方法调用等

（2）线程上下文类加载器

线程上下文类加载器（Thread Context ClassLoader）是 Java 里很实用的机制，打破了双亲委派模型的限制，让线程在运行时能使用指定的类加载器来加载类

6.2.1Java SPI 机制示例

Java SPI（Service Provider Interface）是一种服务发现机制，核心思想是将接口和实现分离，在 META - INF/services 目录下定义服务提供者的配置文件。通常，启动类和服务提供者的实现类可能由不同的类加载器加载，这时就需要使用线程上下文类加载器

1. 定义服务接口

   // 定义一个简单的服务接口
   public interface MyService {void doSomething();
   }

2. 实现服务接口

   // 实现服务接口
   public class MyServiceImpl implements MyService {@Overridepublic void doSomething() {System.out.println("MyServiceImpl is doing something.");}
   }

3. 创建服务配置文件：在 src/main/resources/META - INF/services 目录下创建一个名为 com.example.MyService 的文件（com.example 是 MyService 接口所在的包名），文件内容为服务实现类的全限定名：

   com.example.MyServiceImpl

4. 使用线程上下文类加载器加载服务

   import java.util.ServiceLoader;public class SPIDemo {public static void main(String[] args) {// 获取当前线程的上下文类加载器ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();// 使用 ServiceLoader 加载服务ServiceLoader<MyService> serviceLoader = ServiceLoader.load(MyService.class, contextClassLoader);for (MyService service : serviceLoader) {service.doSomething();}}
   }

   在这个例子中，ServiceLoader.load 方法使用线程上下文类加载器来加载 MyService 接口的实现类。由于服务提供者配置文件和实现类可能不在默认的类加载路径下，使用线程上下文类加载器可以确保正确加载这些类

6.2.2自定义类加载器示例

在某些情况下，你可能需要自定义类加载器来加载特定位置的类。这时可以通过线程上下文类加载器来使用自定义类加载器

1. 自定义类加载器

   import java.io.File;
   import java.io.FileInputStream;
   import java.io.IOException;public class CustomClassLoader extends ClassLoader {private String classPath;public CustomClassLoader(String classPath) {this.classPath = classPath;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {try {byte[] classData = getClassData(name);if (classData != null) {return defineClass(name, classData, 0, classData.length);}} catch (IOException e) {e.printStackTrace();}return super.findClass(name);}private byte[] getClassData(String className) throws IOException {String path = classPath + File.separatorChar + className.replace('.', File.separatorChar) + ".class";try (FileInputStream fis = new FileInputStream(path)) {byte[] buffer = new byte[fis.available()];fis.read(buffer);return buffer;}}
   }

2. 使用自定义类加载器作为线程上下文类加载器

   public class CustomClassLoaderDemo {public static void main(String[] args) throws Exception {// 创建自定义类加载器CustomClassLoader customClassLoader = new CustomClassLoader("/path/to/classes");// 设置当前线程的上下文类加载器为自定义类加载器Thread.currentThread().setContextClassLoader(customClassLoader);// 使用线程上下文类加载器加载类Class<?> clazz = customClassLoader.loadClass("com.example.MyClass");Object instance = clazz.getDeclaredConstructor().newInstance();// 假设 MyClass 有一个 doSomething 方法clazz.getMethod("doSomething").invoke(instance);}
   }

   在这个例子中，我们创建了一个自定义类加载器 CustomClassLoader，并将其设置为当前线程的上下文类加载器。然后使用该类加载器加载指定的类并创建实例，调用其方法

（3）类的同一性判断

1. 要判断两个类是否为同一个类，需要满足两个条件：（1）它们的全限定名（类名 + 包名）必须相同；（2）加载它们的类加载器实例必须相同
2. 在双亲委派模型下，像 java.lang.String 这类 Java 基础类库中的类，会由引导类加载器负责加载。即使你自定义了一个 java.lang.String 类，当加载请求传递到引导类加载器时，它会优先加载 Java 基础类库中的 java.lang.String 类，自定义的 java.lang.String 类通常不会被加载，这保障了核心类库的安全性和唯一性
3. 不过，通过线程上下文类加载器，确实可以打破双亲委派机制的限制。你可以指定应用程序类加载器或者自定义类加载器来加载自定义的 java.lang.String 类。这样一来，JVM 中可能会存在全限定名相同但由不同类加载器加载的两个类。由于类加载器不同，这两个类在 JVM 中会被视为不同的类
4. 在 JVM 里，类的唯一性是由全限定名和加载它的类加载器共同确定的。只有当全限定名和类加载器都相同时，JVM 才会认为这两个类是同一个类。例如，在使用反射创建对象或进行类型比较时，这一规则就会发挥作用。如果两个类的全限定名相同但类加载器不同，对它们进行类型比较时会得到 false 的结果

（4）自定义类加载器

在 Java 中，自定义类加载器一般通过继承java.lang.ClassLoader类来实现，在 JDK 1.2 之后，通常推荐重写findClass方法而非loadClass方法，这样能避免破坏双亲委派机制。如果需求不复杂，还可以继承URLClassLoader类来简化编写。下面详细介绍这两种方式：

6.4.1继承ClassLoader类并重写findClass方法

// TestClass.java
public class TestClass {public void sayHello() {System.out.println("Hello from TestClass!");}
}

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;// 自定义类加载器，继承自 ClassLoader
public class CustomClassLoader extends ClassLoader {// 类文件所在的路径private String classPath;// 构造函数，接收类文件所在路径public CustomClassLoader(String classPath) {this.classPath = classPath;}// 重写 findClass 方法，用于查找并加载类@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {// 从指定路径加载类的字节数据byte[] classData = loadClassData(name);if (classData == null) {// 如果未找到类数据，抛出类未找到异常throw new ClassNotFoundException();}// 使用 defineClass 方法将字节数据转换为 Class 对象return defineClass(name, classData, 0, classData.length);}// 从文件系统中读取类的字节数据private byte[] loadClassData(String name) {// 构建类文件的完整路径String filePath = classPath + File.separatorChar + name.replace('.', File.separatorChar) + ".class";try (FileInputStream fis = new FileInputStream(filePath)) {// 创建字节数组，大小为文件的长度byte[] buffer = new byte[fis.available()];// 从文件输入流中读取数据到字节数组fis.read(buffer);return buffer;} catch (IOException e) {// 处理读取文件时的异常e.printStackTrace();return null;}}
}    

public class CustomClassLoaderTest {public static void main(String[] args) throws Exception {// 创建自定义类加载器实例，指定类文件所在路径CustomClassLoader customClassLoader = new CustomClassLoader("/path/to/classes");// 使用自定义类加载器加载 TestClassClass<?> clazz = customClassLoader.loadClass("TestClass");// 创建 TestClass 的实例Object instance = clazz.getDeclaredConstructor().newInstance();// 调用 TestClass 的 sayHello 方法clazz.getMethod("sayHello").invoke(instance);}
}    

6.4.2继承URLClassLoader类

import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;public class SimpleCustomClassLoader extends URLClassLoader {public SimpleCustomClassLoader(URL[] urls) {super(urls);}// 可以根据需要重写其他方法，若只是简单加载类，继承URLClassLoader即可满足基本需求
}

代码说明：SimpleCustomClassLoader继承了URLClassLoader类，通过构造函数传入包含类文件路径的URL数组。URLClassLoader已经实现了基本的类加载逻辑，包括从指定的URL中查找和加载类。如果只是需要从特定的URL路径加载类，继承URLClassLoader并传入正确的URL数组就可以满足需求，无需重写太多方法，简化了自定义类加载器的编写过程

（5）自定义类加载器实现热部署

1. 自定义类加载器
   1. 首先，需要创建一个自定义类加载器，通常继承自 ClassLoader 类。自定义类加载器的主要作用是负责从指定的位置（如文件系统、网络等）加载类的字节码文件，并将其转换为 Class 对象
   2. 在自定义类加载器中，一般需要重写 findClass 方法，该方法用于查找并加载类的字节码。当调用 loadClass 方法时，会根据双亲委派机制先尝试让父类加载器加载类，如果父类加载器无法加载，才会调用自定义类加载器的 findClass 方法

      import java.io.File;
      import java.io.FileInputStream;
      import java.io.IOException;public class CustomClassLoader extends ClassLoader {private String classPath;public CustomClassLoader(String classPath) {this.classPath = classPath;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {byte[] classData = loadClassData(name);if (classData == null) {throw new ClassNotFoundException();}return defineClass(name, classData, 0, classData.length);}private byte[] loadClassData(String name) {String filePath = classPath + File.separatorChar + name.replace('.', File.separatorChar) + ".class";try (FileInputStream fis = new FileInputStream(filePath)) {byte[] buffer = new byte[fis.available()];fis.read(buffer);return buffer;} catch (IOException e) {e.printStackTrace();return null;}}
      }

      当监测到 MyServiceImpl 类文件更新后，使用新的 CustomClassLoader 实例来加载新的 MyServiceImpl 类：

      // 假设类文件在这个路径
      String classPath = "/path/to/classes"; 
      CustomClassLoader newClassLoader = new CustomClassLoader(classPath);
      Class<?> newClass = newClassLoader.loadClass("com.example.MyServiceImpl");

2. 监测类文件的变化
   1. 为了实现热部署，需要实时监测类文件的变化。可以通过定时任务或者文件系统的监听机制来实现
   2. 定时任务：每隔一段时间（如几秒）检查类文件的修改时间，如果发现修改时间有变化，说明类文件已经被更新
   3. 文件系统监听：利用操作系统提供的文件系统监听功能，当类文件发生变化时，会触发相应的事件，通知程序进行处理
3. 加载新的类文件
   1. 当监测到类文件发生变化时，需要使用自定义类加载器加载新的类文件。由于 Java 的类加载机制中，同一个类加载器只能加载同一个类一次，所以为了加载新的类定义，需要创建一个新的自定义类加载器实例
   2. 新的类加载器会重新从文件系统中读取类的字节码文件，并通过 defineClass 方法将字节码转换为 Class 对象
4. 替换旧的类实例
   1. ​​​​​​​加载新的类文件后，需要将旧的类实例替换为新的类实例。这可以通过反射机制来实现
   2. 首先，使用新的类加载器加载新的类，然后通过反射创建新的类实例

      Object newInstance = newClass.getDeclaredConstructor().newInstance();

   3. 接着，将新的类实例替换掉旧的类实例，这样在后续的程序执行中，就会使用新的类定义（假设在某个服务管理类中持有 MyService 实例：）

      public class ServiceManager {private static MyService service;public static void setService(MyService newService) {service = newService;}public static MyService getService() {return service;}
      }

      在创建新实例后，把新实例设置到 ServiceManager 中：

      // 假设 MyService 是接口，MyServiceImpl 实现了该接口
      MyService newServiceInstance = (MyService) newInstance;
      ServiceManager.setService(newServiceInstance);

      经过上述步骤，后续程序中调用 ServiceManager.getService() 获取到的就是新的 MyServiceImpl 实例，会使用新的类定义。例如：

      MyService service = ServiceManager.getService();
      service.doSomething(); // 调用新类的方法

5. 注意事项
   1. ​​​​​​​类加载器的隔离：为了避免类加载冲突，每个新的类加载器应该有自己独立的命名空间。不同版本的类由不同的类加载器加载，它们在 JVM 中被视为不同的类
   2. 资源管理：在替换类实例时，需要确保旧的类实例被正确地释放，避免内存泄漏
   3. 线程安全：热部署过程中可能会涉及到多线程环境，需要确保线程安全，避免出现并发问题

（6）类加载器引用

1. 类加载器引用的保存位置：当一个类被类加载器加载到 JVM 中时，JVM 会在方法区为这个类创建一个 Class 对象，这个 Class 对象会持有加载它的类加载器的引用。引导类加载器是用本地代码实现的，它没有对应的 Java 对象，所以不存在保存引用到方法区的情况；扩展类加载器、应用程序类加载器和自定义类加载器在加载类时，对应的类的 Class 对象会记录加载它的类加载器
2. 通过类加载器区分全类名相同的类：在 Java 中，类的唯一性由全限定名（包名 + 类名）和加载它的类加载器共同确定。即使两个类的全限定名相同，但如果它们是由不同的类加载器加载的，那么在 JVM 中它们就是不同的类。例如，当有两个全类名相同的类来自不同的文件路径时，可以使用自定义类加载器分别加载它们，加载后的这两个类在 JVM 中是不同的，不能相互替代
3. 类型转换与类加载器的关系：只有当两个类是由同一个类加载器加载时，才会进一步判断它们是否具有父子关系以确定是否可以进行类型转换。例如，将一个由类加载器 A 加载的 MyClass 对象尝试转换为另一个由类加载器 B 加载的 MyClass 对象，会抛出 ClassCastException 异常

（7）类的五种主动使用方式

1. 实例化对象时：当使用new关键字创建一个类的实例，比如MyClass myObject = new MyClass(); ，如果MyClass还没有被加载到 JVM 中，就会触发类加载过程，将类的字节码文件加载到内存，并生成对应的Class对象
2. 访问类的静态成员时：包括访问类的静态变量，如int value = MyClass.staticVariable; ，或者调用类的静态方法，如MyClass.staticMethod(); 。如果此时类尚未被加载，就会触发类加载。但如果访问的是被final修饰且在编译期已确定值（如public static final int NUM = 10; ）的静态常量，不会触发类加载，因为这些常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类。不过，如果静态常量的值是通过方法调用等动态方式确定的（如public static final int VALUE = getValue(); ，其中getValue()是方法），则会触发类加载
3. 使用反射机制时：当通过反射访问类，例如Class<?> clazz = Class.forName("com.example.MyClass"); 或者使用反射创建实例、调用方法等操作时，如果类还没有被加载，就会触发类加载
4. 初始化子类时：当初始化一个子类时，如果其父类还没有被加载和初始化，那么会先触发父类的加载和初始化
5. JVM 启动时：虚拟机启动时，会加载一组特定的类，这些类是 JVM 启动过程中所必需的，比如包含main方法的主类。JVM 会首先加载并初始化这个主类，作为程序执行的起点