在 Java 的世界里，类加载器（ClassLoader）扮演着至关重要的角色。本文将详细解析 JVM 类加载机制，从类加载的各个阶段、类加载器的类型及其设计目的，到动态加载和双亲委派机制，力求帮助读者全面理解这一关键概念。

前文回顾

在上篇文章中，我们详细讨论了 JVM 的整体运行原理。我们从 .java 文件编译成 .class 字节码文件开始，经过类加载器加载类到 JVM，最终由 JVM 执行这些类中的代码。今天，我们将重点放在 JVM 的类加载过程，深入了解类加载机制，以便在面试中能清晰地解释这些核心概念。

JVM 在什么情况下会加载一个类？

类加载的过程虽然复杂，但从实用角度出发，我们主要把握其核心工作原理即可。一个类从加载到使用，一般会经历以下过程：

类加载时机

JVM 会在代码中用到某个类时加载它。举个例子：

java

public class MainApp {
    public static void main(String[] args) {
        System.out.println("Hello, JVM Class Loader!");
        Helper helper = new Helper();
        helper.doSomething();
    }
}

class Helper {
    public void doSomething() {
        System.out.println("Helper is doing something.");
    }
}

在 JVM 启动后，MainApp 类会首先被加载到内存，然后开始执行 main() 方法。当代码运行到 Helper 类时，Helper 类也会被加载到内存中。

从实用角度出发，来看看验证、准备和初始化的过程

从实用角度出发，验证、准备和初始化的过程如下：

验证阶段

验证阶段确保 .class 文件内容符合 JVM 规范。例如，如果 .class 文件被篡改，JVM 将无法执行其中的字节码。

准备阶段

准备阶段为类的变量分配内存，并设置初始值。以 Helper 类为例：

java

public class Helper {
    static int counter = 10;
}

在准备阶段，counter 变量会被分配内存并初始化为 0。

初始化阶段

初始化阶段执行类的初始化代码。继续以 Helper 类为例：

java

public class Helper {
    static int counter = 10;

    static {
        counter = Configuration.getInt("helper.counter");
    }
}

在初始化阶段，counter 变量会被设置为 Configuration.getInt("helper.counter") 返回的值。

核心阶段：初始化

初始化阶段的核心是执行类的静态初始化代码和静态代码块。例如：

java

public class DataManager {
    static Map dataMap;

    static {
        dataMap = loadDataFromDisk();
    }

    private static Map loadDataFromDisk() {
        // 模拟从磁盘加载数据
        Map data = new HashMap<>();
        data.put("key1", "value1");
        data.put("key2", "value2");
        return data;
    }
}

在初始化阶段，loadDataFromDisk() 方法会被调用，dataMap 被初始化为从磁盘加载的数据。

类初始化的规则

类初始化的时机包括以下几种情况：

1. 创建类的实例时（new 操作符）。
2. 访问类的静态变量或静态方法时。
3. 反射调用类的方法时。
4. 初始化一个类时，如果其父类还未初始化，则先初始化父类。

类加载器和双亲委派机制

类加载器是实现类加载过程的核心。Java 中的类加载器包括：

1. 启动类加载器（Bootstrap ClassLoader）：加载 JVM 核心类库，如 java.lang.* 包中的类。
2. 扩展类加载器（Extension ClassLoader）：加载 lib/ext 目录中的类。
3. 应用程序类加载器（Application ClassLoader）：加载应用程序的类路径（classpath）中的类。
4. 自定义类加载器：开发者可以根据需要自定义类加载器。

双亲委派机制

双亲委派机制是指类加载器在加载类时，会先委托父类加载器加载，如果父类加载器找不到该类，才由子加载器尝试加载。其目的是避免重复加载和保证核心类库的安全性。

例如：

java

public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class findClass(String name) throws ClassNotFoundException {
        byte[] classData = getClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] getClassData(String name) {
        // 自定义类数据加载逻辑
        return null;
    }
}

各种类加载器的设计目的

启动类加载器（Bootstrap ClassLoader）

设计目的

启动类加载器是 JVM 自身的一部分，用于加载 Java 核心库中的类。这些核心库包括 Java 的基础类库（如 java.lang.* 包中的类）。启动类加载器是用本地代码实现的，通常是用 C++ 编写。

设计原理

• 加载核心类库：启动类加载器主要负责加载 JVM 运行所需的核心类库，通常位于 JRE 安装目录的 lib 目录下的 rt.jar 文件中。
• 安全性：通过启动类加载器加载核心类库，可以确保这些类库的安全性和完整性，防止用户代码篡改或替换。

示例代码

java

public class BootstrapClassLoaderExample {
    public static void main(String[] args) {
        // 获取 Bootstrap ClassLoader
        ClassLoader bootstrapClassLoader = Object.class.getClassLoader();
        System.out.println("Bootstrap ClassLoader: " + bootstrapClassLoader);
    }
}

输出结果通常为 null，因为启动类加载器是用本地代码实现的，不是 Java 类的实例。

扩展类加载器（Extension ClassLoader）

设计目的

扩展类加载器用于加载 Java 扩展库。这些扩展库通常位于 JRE 安装目录的 lib/ext 目录中。通过扩展类加载器，可以将一些常用的第三方库加载到 JVM 中。

设计原理

• 加载扩展库：扩展类加载器负责加载 lib/ext 目录中的库，扩展了 Java 核心类库的功能。
• 模块化：通过将扩展库放置在 lib/ext 目录中，可以实现应用程序的模块化设计，便于管理和更新。

示例代码

java

public class ExtensionClassLoaderExample {
    public static void main(String[] args) {
        ClassLoader extensionClassLoader = ExtensionClassLoaderExample.class.getClassLoader().getParent();
        System.out.println("Extension ClassLoader: " + extensionClassLoader);
    }
}

输出结果通常为 sun.misc.Launcher$ExtClassLoader。

应用程序类加载器（Application ClassLoader）

设计目的

应用程序类加载器是最常用的类加载器，负责加载应用程序类路径（classpath）下的类和资源。它是由 JVM 启动时自动创建的。

设计原理

• 加载应用程序类：应用程序类加载器负责加载应用程序和第三方库的类，是应用程序开发中最常用的类加载器。
• 用户代码加载：通过应用程序类加载器，可以加载用户自己编写的代码和依赖的库。

示例代码

java

public class ApplicationClassLoaderExample {
    public static void main(String[] args) {
        ClassLoader applicationClassLoader = ApplicationClassLoaderExample.class.getClassLoader();
        System.out.println("Application ClassLoader: " + applicationClassLoader);
    }
}

输出结果通常为 sun.misc.Launcher$AppClassLoader。

自定义类加载器（Custom ClassLoader）

设计目的

自定义类加载器允许开发者根据特定需求定制类加载行为。它们可以用于实现特殊的类加载逻辑，例如从数据库或网络加载类，或者实现自定义的安全策略。

设计原理

• 灵活性：自定义类加载器提供了极大的灵活性，可以根据需要实现特殊的类加载逻辑。
• 安全性：通过自定义类加载器，可以实现更细粒度的安全控制，例如限制特定包的访问权限。

示例代码

java

public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class findClass(String name) throws ClassNotFoundException {
        byte[] classData = getClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] getClassData(String name) {
        // 自定义类数据加载逻辑，例如从网络或数据库加载
        return null;
    }
}

public class CustomClassLoaderExample {
    public static void main(String[] args) {
        CustomClassLoader customClassLoader = new CustomClassLoader();
        try {
            Class customClass = customClassLoader.loadClass("com.example.CustomClass");
            System.out.println("Custom Class loaded by: " + customClass.getClassLoader());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}