深入理解 Java 类加载机制与双亲委派模型

一、Java 类加载机制概述

1.1 什么是类加载？

1.2 类加载的生命周期

加载 → 验证 → 准备 → 解析 → 初始化 → 使用 → 卸载

1. 加载（Loading）：通过类的全限定名（如java.lang.String），获取定义此类的二进制字节流，将字节流转换为方法区的运行时数据结构，最后在内存中生成一个代表该类的java.lang.Class对象（作为方法区数据的访问入口）。
2. 验证（Verification）：确保加载的字节流符合 JVM 规范，无安全风险（比如文件格式验证、元数据验证、字节码验证、符号引用验证）。
3. 准备（Preparation）：为类的静态变量分配内存，并设置默认初始值（比如int默认 0，boolean默认 false），注意：此时不赋值为代码中指定的值。
4. 解析（Resolution）：将常量池中的符号引用替换为直接引用（比如把类名、方法名替换为内存地址）。
5. 初始化（Initialization）：执行类构造器<clinit>()方法，为静态变量赋值、执行静态代码块（这是类加载的最后一步，也是真正执行代码的阶段）。

注意：只有遇到new 对象、访问静态变量 / 方法、反射、子类初始化、主类启动这 5 种情况时，才会触发类的初始化。

二、类加载器（ClassLoader）

2.1 JVM 内置类加载器分类

1. 启动类加载器（Bootstrap ClassLoader）
   • 最顶层加载器，由 C++ 实现，无父类；
   • 负责加载JRE 核心类库：$JAVA_HOME/jre/lib下的rt.jar、resources.jar等（比如 String、Integer、ArrayList 都由它加载）。
2. 扩展类加载器（Extension ClassLoader）
   • 由 Java 实现（sun.misc.Launcher$ExtClassLoader）；
   • 父加载器为启动类加载器；
   • 负责加载JRE 扩展类：$JAVA_HOME/jre/lib/ext目录下的所有 jar 包。
3. 应用程序类加载器（Application ClassLoader）
   • 也叫系统类加载器（sun.misc.Launcher$AppClassLoader）；
   • 父加载器为扩展类加载器；
   • 负责加载项目 classpath 下的所有类（我们自己写的业务类、第三方 jar 包都由它加载）。

2.2 自定义类加载器

三、双亲委派模型（核心重点）

3.1 什么是双亲委派模型？

3.2 双亲委派模型工作流程

1. 应用程序类加载器收到加载请求，不加载，委派给父类（扩展类加载器）；
2. 扩展类加载器收到请求，不加载，委派给父类（启动类加载器）；
3. 启动类加载器检查自己的加载路径（jre/lib），找不到com.demo.Test，无法加载，返回给扩展类加载器；
4. 扩展类加载器检查自己的路径（jre/lib/ext），也找不到，返回给应用程序类加载器；
5. 应用程序类加载器在 classpath 下找到该类，完成加载。

1. 一路委派到启动类加载器；
2. 启动类加载器在rt.jar中找到 String 类，直接加载；
3. 子类加载器不会再重复加载。

3.3 双亲委派模型的核心优势

1. 避免类重复加载：保证一个类在 JVM 中只被加载一次（全限定名 + 类加载器唯一确定一个类）；
2. 保护 Java 核心 API 安全（沙箱安全机制）：防止核心类被恶意替换 / 篡改。

   比如：自定义java.lang.String类，按照双亲委派，会被启动类加载器优先加载 JDK 自带的 String，自定义类永远无法覆盖核心类，避免安全漏洞。

3. 层级清晰，分工明确：不同加载器负责不同范围的类，便于管理和维护。

3.4 双亲委派模型的源码解析（Java 核心实现）

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 1. 检查类是否已经被加载过
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            try {
                // 2. 如果有父加载器，优先委派给父加载器加载
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    // 3. 没有父加载器，调用启动类加载器
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父加载器无法加载，抛出异常
            }
            // 4. 父加载器都没加载到，自己调用findClass加载
            if (c == null) {
                c = findClass(name);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

四、打破双亲委派模型

4.1 为什么要打破？

• SPI（服务提供者接口）：JDBC、JNDI 等核心 API 由启动类加载器加载，但它需要调用第三方实现类（由应用类加载器加载），启动类加载器无法加载子类加载器的类，必须打破双亲委派；
• 热部署：Tomcat、Spring Boot DevTools 需要重复加载类，打破模型实现热更；
• 模块化隔离：不同模块使用独立类加载器，避免类冲突。

4.2 如何打破双亲委派？

public class BreakParentClassLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 自定义加载逻辑：不委派给父类加载器
        try {
            // 1. 自己读取class字节码（省略文件读取逻辑）
            byte[] data = getClassBytes(name);
            // 2. 定义Class对象
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            // 加载失败，调用父类加载（兼容核心类）
            return super.loadClass(name);
        }
    }

    // 读取class文件字节码
    private byte[] getClassBytes(String name) throws Exception {
        // 省略具体实现
        return new byte[0];
    }
}

4.3 经典打破案例：Tomcat 类加载机制

• 每个 Web 应用对应一个独立的WebAppClassLoader；
• 加载类时，先自己加载，不委派给父类；
• 只有加载 JDK 核心类时，才向上委派；
• 彻底打破双亲委派，实现应用间类隔离。

五、常见面试题（必看）

1. 什么是双亲委派模型？

   答：类加载请求向上委派给父类，父类无法加载时子类才加载，保证核心类安全、避免重复加载。
2. 双亲委派模型的好处？

   答：防止类重复加载、保护 Java 核心 API 不被篡改、层级清晰。
3. 如何打破双亲委派模型？

   答：重写ClassLoader的loadClass()方法，跳过父类委派逻辑。
4. 为什么自定义 java.lang.String 无法生效？

   答：双亲委派模型会让启动类加载器优先加载 JDK 自带的 String，自定义类不会被加载。
5. Tomcat 为什么打破双亲委派？

   答：实现 Web 应用之间的类隔离，不同应用可使用不同版本的依赖包。

六、总结

1. 类加载生命周期：加载→验证→准备→解析→初始化→使用→卸载；
2. JVM 三类加载器：启动类、扩展类、应用程序类加载器；
3. 双亲委派模型：向上委托，向下加载，核心是安全 + 不重复加载；
4. 打破双亲委派：重写loadClass()，适用于 SPI、热部署、隔离场景。