Java类加载机制详解（附代码示例）
文章目录
Java类加载机制详解（附代码示例）什么是类加载？服务端处理请求的流程特殊情况说明总结类加载过程通常分为以下几个步骤：
何时类加载？类加载流程1、加载阶段示例：使用classLoader加载类
2、链接阶段a.验证 (Verification)b. 准备 (Preparation)c.解析(Resolution)
3、初始化阶段示例：类初始化顺序
类加载器的委派模型示例：自定义类加载器
类卸载示例：类卸载
类加载的注意事项代码示例汇总示例1：使用 Class.forName加载类并触发初始化实例2：反射加载类并创建实例实例3：自定义类加载器加载类
结论
在Java编程语言中，类加载机制是Java虚拟机 ( JVM ) 实现其跨平台特性和动态特性的核心部分，理解类加载的概念、时机以及流程，对于开发高效、健壮的 Java 应用程序至关重要。
本文将深入探讨什么是类加载、类加载的时机、类加载的具体流程，并通过代码示例加深理解。
什么是类加载？
类加载 (ClassLoading) 是指 JVM 将类的二进制数据（.class文件)从不同的来源（如文件系统、网络等）读取到内存中，并将其转换为 JVM 可以理解和执行的内部数据结构的过程。这个过程不仅包括将类的字节码加载到内存，还涉及对类的链接和初始化。
类加载器的工作机制 Java 使用类加载器（Class Loader）来加载类的字节码。当一个类首次被引用时（例如，通过new关键字创建实例、调用静态方法或访问静态字段），类加载器会将该类的字节码加载到 JVM 中。类加载的唯一性 对于同一个类加载器而言，一个类只会被加载一次。后续对该类的引用会直接使用已加载的类定义，不会重复加载。类的卸载条件 类的卸载（即从 JVM 中移除）非常罕见，需要满足以下条件：
该类的所有实例都已被垃圾回收。加载该类的类加载器已被垃圾回收。该类的Class对象没有被任何地方引用。 在 Java 服务端中，类的加载机制使得一个类在程序运行期间通常只会被加载一次，而不是每次处理请求时都重新加载。以下是详细的解释：
服务端处理请求的流程
当浏览器发送请求到 Java 服务端时，典型的处理流程如下：
服务器（如 Tomcat、Jetty）接收请求并分配一个线程处理。线程调用对应的 Servlet 或 Controller 处理请求。处理请求的过程中可能会创建类的实例，但类本身已经在应用启动时或首次使用时被加载。
特殊情况说明
热部署场景：某些开发工具（如 JRebel）或框架（如 Spring Boot DevTools）支持类的热替换，允许在不重启应用的情况下重新加载修改后的类。但这属于特殊机制，并非默认行为。自定义类加载器：如果应用使用自定义类加载器动态加载类，可能会导致同一个类被不同的类加载器多次加载，但这种情况在普通 Web 应用中很少见。
总结
在标准的 Java Web 应用中，浏览器每次发送请求不会触发类的重新加载。类加载是一次性操作，发生在应用启动或首次使用该类时。这一机制确保了性能和内存使用的高效性。
类加载过程通常分为以下几个步骤：
加载(Loading)：将类的二进制数据读入内存。
链接 (Linking):
验证(Verification)：确保字节码符合Java语言规范，没有安全问题。准备（Preparation)：为类变量分配内存并设置默认初始值。解析(Resolution)：将符号引|用转化为直接引用。 初始化(Initialization)：执行类构造器
何时类加载？
类加载的时机通常由JVM根据需要决定，遵循懒加载（Lazy Loading)的原则，即在真正需要使用某个 类时才加载该类。具体来说，以下情况会触发类的加载：
创建类的实例：通过new关键字或反射机制创建对象时。访问类的静态成员：读取或修改类的静态字段，或调用静态方法时。使用子类：当子类加载时，父类也会被加载。反射: 通过Class.forName()等反射方法加载类。初始化类：调用 java.lang.reflect包中的某些方法可能发类的初始化。JVM自身的需求：如启动时加载一些核心类。
❗❗❗需要注意的是，类加载与类的初始化是两个不同的过程。类加载是将类的信息加载到 JVM中，而类的初始化则是执行类构造器以初始化类变量。
类加载流程
类加载流程涉及多个步骤和组件，主要包括以下几个阶段：
1、加载阶段
在加载阶段，类加载器(Class Loader) 负责查找并加载类的二进制数据。Java中主要有以下几种类加载器:
引导类加载器 (Bootstrap ClassLoader)：负责加载 JVM核心类库，如 java.lang.*等。扩展类加载器 (Extension ClassLoader)：加载 JRE扩展目录（jre/lib/ext）中的类。应用类加载器 (Application ClassLoader)：加载应用程序 classpath路径下的类。用户自定义类加载器：开发者可以根据需要创建自定义类加载器，以加载特定来源的类。
示例：使用classLoader加载类
package cn.js;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 21:12
* @Version 1.0
*/
public class ClassLoaderExample {
public static void main(String[] args) {
try {
//获取系统类加载器
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
//加载指定类
Class cls = classLoader.loadClass("com.example.Myclass");
System.out.println("类加载器：" + cls.getClassLoader());
System.out.println("类名:" + cls.getName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
2、链接阶段
链接阶段将加载的类准备好以供JVM使用，分为以下三个子阶段：
a.验证 (Verification)
验证的目的是确保被加载类的字节码符合JVM规范，防止恶意代码破坏系统。验证过程包括：
文件格式验证：检查类文件的魔数、版本等基本结构。元数据验证：检查类的内部结构，如字段、方法的描述符。字节码验证：确保字节码指令的合法性和正确性。符号引用验证：确保类中的符号引用能被正确解析。
b. 准备 (Preparation)
准备阶段主要为类的静态变量分配内存，并设置其初始值（默认值）。这包括：
为类变量（static字段）分配内存空间。将静态变量初始化为默认值（如整型为 0，引用类型为 null）。确定类的初始内存布局。
c.解析(Resolution)
解析阶段将类中的符号引用转换为直接引用，包括：
类或接口的解析: 将符号引用转为 java.lang.Class对象的引用。字段的解析：将符号引用转为具体字段的内存地址。方法的解析：将符号引用转为具体方法的内存地址。
3、初始化阶段
初始化阶段是类加载过程的最后一步，主要任务是执行类构造器
执行静态变量的初始化赋值。执行静态代码块。
示例：类初始化顺序
package cn.js;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 21:17
* @Version 1.0
*/
public class InitializationExample {
static int a=5;
static {
a=10;
System.out.println("静态的代码块执行，a= "+a);
}
public static void main(String[] args) {
System.out.println("主方法执行，a= "+a);
}
}
输出：
静态的代码块执行，a= 10
主方法执行，a= 10
在上述示例中，类加载时首先初始化静态变量 a为5，然后执行静态代码块将a的值改为10，最后在主方法中打印出a的值。
类加载器的委派模型
Java采用了双亲委派模型来组织类加载器的层次结构。具体来说，当一个类加载器接收到类加载请求时，它会首先将请求委派给父类加载器处理，只有在父类加载器无法完成加载时，子类加载器才会尝试自己加载。这种机制确保了Java核心类库的安全性和一致性，避免了类的重复加载和命名冲突。
示例：自定义类加载器
以下示例展示了如何创建一个自定义类加载器，并加载一个自定义类。
package cn.js;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 21:20
* @Version 1.0
*/
public class CustomClassLoader extends ClassLoader {
private String classPath;
public CustomClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class findClass(String name) throws ClassNotFoundException {
byte[] data = loadClassData(name);
if (data == null) {
throw new ClassNotFoundException("Cannot find class: " + name);
}
return defineClass(name, data, 0, data.length);
}
private byte[] loadClassData(String name) {
String filename = classPath + File.separator + name.replace(".", File.separator) + ".class";
try (FileInputStream fis = new FileInputStream(filename)) {
byte[] buffer = new byte[fis.available()];
fis.read(buffer);
return buffer;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
}
使用自定义类加载器加载类
package cn.js;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 21:30
* @Version 1.0
*/
public class CustomClassLoaderTest {
public static void main(String[] args) {
String classPath = "path/to/classes";//替换为实际路径
CustomClassLoader customLoader = new CustomClassLoader(classPath);
try {
Class cls = customLoader.loadClass("com.example.Myclass");
Object obj = cls.newInstance();
System.out.println("类加载器:" + cls.getClassLoader());
System.out.println("对象:" + obj.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}
在上述示例中，自定义类加载器customClassLoader加载位于指定路径 path/to/classes下的com.example.MyClass类。通过这种方式，可以实现从非标准位置加载类，例如从网络或加密存储中加载类。
类卸载
当一个类不再被任何引用使用，并且其类加载器也可以被垃圾回收时，JVM 会将该类卸载，释放内存。类卸载的触发条件较为严格，通常在应用程序需要动态加载和卸载类时才会涉及。
示例：类卸载
package cn.js;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 21:35
* @Version 1.0
*/
public class ClassUnloadExample {
public static void main(String[] args) throws Exception {
CustomClassLoader loader = new CustomClassLoader("path/to/classes");
Class cls = loader.loadClass("com.example.Myclass");
Object obj = cls.newInstance();
System.out.println("类加载器:" + cls.getClassLoader());
// 使类加载器和类无引用
loader = null;
cls = null;
obj = null;
//建议进行垃圾回收
System.gc();
// 等待一段时间以确保GC完成
Thread.sleep(1000);
System.out.println("尝试重新加载类");
// 重新创建类加载器并加载类
CustomClassLoader newLoader = new CustomClassLoader("path/to/classes");
Class newCls = newLoader.loadClass("com.example.Myclass");
System.out.println("新类加载器：" + newCls.getClassLoader());
}
}
❗❗❗注意：类卸载是由 JVM 自动管理的，开发者无法强制卸载某个类。上述示例通过消除类和类加载器的引用，并建议进行垃圾回收，从而尝试触发类卸载。
类加载的注意事项
类加载器的隔离性：不同的类加载器之间相互隔离，同名的类可以由不同的类加载器加载，从而在 JVM 中共存。热加载与动态加载：Java允许在运行时动态加载类，这对于开发插件系统和动态模块化应用非常有用。安全性：类加载机制结合Java的安全管理器，确保加载的类不会执行非法操作，保护系统安全。避免类的重复加载：通过双亲委派模型，可以有效避免类的重复加载和命名冲突。
代码示例汇总
示例1：使用 Class.forName加载类并触发初始化
package cn.js;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 21:42
* @Version 1.0
*/
public class ForNameExample {
static {
System.out.println("ForNameExample 类初始化");
}
public static void staticMethod() {
System.out.println("调用静态方法");
}
public static void main(String[] args) {
try {
// 仅加载类，不初始化
Class cls1 = Class.forName("cn.js.ForNameExample", false,
ForNameExample.class.getClassLoader());
System.out.println("类已加载但未初始化");
//加载并初始化类
Class cls2 = Class.forName("cn.js.ForNameExample");
System.out.println("类已加载并初始化");
//调用静态方法
ForNameExample.staticMethod();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
输出
ForNameExample 类初始化
类已加载但未初始化
类已加载并初始化
调用静态方法
实例2：反射加载类并创建实例
package cn.js;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 21:58
* @Version 1.0
*/
public class ReflectionExample {
static {
System.out.println("ReflectionExample 类初始化");
}
public ReflectionExample() {
System.out.println("ReflectionExample 构造方法");
}
public void sayHello() {
System.out.println("Hello from ReflectionExample!");
}
public static void main(String[] args) {
try {
// 通过反射加载类
Class cls = Class.forName("cn.js.ReflectionExample");
// 创建实例
Object obj = cls.newInstance();
//调用方法
cls.getMethod("sayHello").invoke(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出
ReflectionExample 类初始化
ReflectionExample 构造方法
Hello from ReflectionExample!
实例3：自定义类加载器加载类
package cn.js;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* Description:
*
* @Author Js
* @Create 2025-03-17 22:02
* @Version 1.0
*/
public class MyClassLoader extends ClassLoader {
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class findClass(String name) throws ClassNotFoundException {
byte[] data = loadClassData(name);
if (data == null) {
throw new ClassNotFoundException("cannot find class: " + name);
}
return defineClass(name, data, 0, data.length);
}
private byte[] loadClassData(String name) {
String fileName = classPath + File.separator + name.replace(".",
File.separator) + ".class";
try (FileInputStream fis = new FileInputStream(fileName)) {
byte[] buffer = new byte[fis.available()];
fis.read(buffer);
return buffer;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
}
package cn.js;
public class CustomLoaderTest {
public static void main(String[] args) {
String classPath = "path/to/classes";// 普换为实际路径
MyClassLoader loader = new MyClassLoader(classPath);
try {
Class cls = loader.loadClass("com.exanple.Myclass");
Object obj = cls.newInstance();
System.out.println("类加载器:" + cls.getClassLoader());
System.out.println("对象:" + obj.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}
结论
类加载是Java虚拟机运行的基础，通过类加载机制，java实现了其平台无关性和动态特性。理解类加载的过程、时机以及加载器的工作原理，有助于开发者编写高效、安全的java应用程序，尤其是在复杂系统和大型项目中，合理利用类加载机制可以显著提升系统的灵活性和可维护性。
通过本文的介绍和代码示例，希望各位同僚对 java 的类加载机制有了更深入的理解，并能够在实际开发中灵活应用这一机制，充分发挥Java语言的优势。
魔兽世界9.0：挖不到核心精良？别急，手把手带你玩转考古学114推送皮肤科段晓涵医师科普：白头发越来越多难道是这些原因？