Java类加载器双亲委派模型打破与热部署实现

Java 默认的类加载机制遵循双亲委派模型，这保证了 Java 核心类的安全性和唯一性。但在实际开发中，为了实现热部署、模块隔离或动态更新功能，我们需要打破这一模型。本文将直接介绍如何通过自定义类加载器打破双亲委派，并基于此实现一个简单的热部署功能。

1. 双亲委派模型回顾与打破原理

在标准模型中，类加载器收到请求后，会将任务委派给父加载器。只有当父加载器无法完成加载时，当前加载器才会尝试自己加载。其流程如下：

要打破这一机制，核心在于修改类加载的顺序。默认逻辑是“父优先”，我们需要将其改为“自己优先”。

2. 自定义类加载器：打破双亲委派

打破双亲委派的关键在于重写 java.lang.ClassLoader 的 loadClass 方法，而不是通常建议重写的 findClass 方法。

编写自定义加载器

创建一个名为 HotSwapClassLoader 的类，继承 ClassLoader。

1. 定义类的基本结构，指定类文件路径。
2. 重写 loadClass 方法，实现“先自己加载，加载失败再委托父类”的逻辑。

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;

public class HotSwapClassLoader extends ClassLoader {
    private final String classPath;

    public HotSwapClassLoader(String classPath) {
        // 指定父类加载器为 null，这里为了演示隔离，实际可传 getSystemClassLoader()
        super(null); 
        this.classPath = classPath;
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 1. 检查类是否已加载
        Class<?> c = findLoadedClass(name);

        if (c == null) {
            // 2. 尝试自己加载（破坏点：不再先找父类）
            try {
                c = findClass(name);
            } catch (ClassNotFoundException e) {
                // 3. 自己找不到，再委托父类加载器
                if (getParent() != null) {
                    c = getParent().loadClass(name, false);
                } else {
                    c = getSystemClassLoader().loadClass(name, false);
                }
            }
        }

        if (resolve) {
            resolveClass(c);
        }
        return c;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 仅加载指定路径下的类，其他类抛出异常以便走父类加载
        if (!name.startsWith("com.example")) { 
            throw new ClassNotFoundException(name);
        }

        byte[] classData = loadByte(name);
        if (classData == null) {
            throw new ClassNotFoundException(name);
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] loadByte(String name) {
        String fileName = classPath + name.replace('.', '/') + ".class";
        try (InputStream is = Files.newInputStream(Paths.get(fileName));
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {

            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int len;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            return null;
        }
    }
}

3. 实现热部署：动态替换类

热部署的本质是：当类文件的内容发生变化时，丢弃旧的类加载器实例，使用一个新的类加载器实例重新加载该类。JVM 判定类是否相同的条件是（全限定类名 + 类加载器实例），因此更换加载器实例即可实现“重新加载”。

编写测试与加载逻辑

假设我们要监控 com.example.HelloService 类。

1. 编写 HelloService 类并编译。
2. 编写监控循环，检测文件修改时间。
3. 执行替换类加载器操作。

import java.io.File;
import java.lang.reflect.Method;

public class HotDeployTest {
    public static void main(String[] args) throws Exception {
        String classPath = "D:/classes/"; // 你的 .class 文件存放目录
        String className = "com.example.HelloService";

        // 初始加载
        HotSwapClassLoader loader = new HotSwapClassLoader(classPath);
        Class<?> clazz = loader.loadClass(className);
        Object instance = clazz.newInstance();
        Method method = clazz.getMethod("sayHello");
        method.invoke(instance);

        // 模拟热部署监控
        File classFile = new File(classPath + className.replace('.', '/') + ".class");
        long lastModified = classFile.lastModified();

        while (true) {
            // 检查文件是否被修改
            if (classFile.lastModified() > lastModified) {
                System.out.println("检测到类文件变化，重新加载...");
                lastModified = classFile.lastModified();

                // 关键：创建新的类加载器实例
                loader = new HotSwapClassLoader(classPath);
                clazz = loader.loadClass(className);
                instance = clazz.newInstance();
                method = clazz.getMethod("sayHello");
                method.invoke(instance);
            }

            Thread.sleep(2000);
        }
    }
}

执行步骤验证：

1. 编译 HelloService.java 生成 .class 文件放入 D:/classes/com/example/。
2. 运行 HotDeployTest，程序输出初始结果。
3. 修改 HelloService.java 的代码逻辑（例如输出文字改变）。
4. 重新编译 HelloService.java，覆盖旧的 .class 文件。
5. 观察控制台，程序会自动检测变化并输出新的结果，无需重启 JVM。

4. 另一种打破方式：线程上下文类加载器

除了直接重写 loadClass，Java 还提供了线程上下文类加载器（ContextClassLoader）来打破双亲委派，常见于 SPI（Service Provider Interface）机制，如 JDBC 驱动加载。

场景分析

核心接口（如 java.sql.Driver）由启动类加载器加载，但具体实现（如 com.mysql.cj.jdbc.Driver）在第三方包中，通常由应用类加载器加载。根据双亲委派，父加载器（启动类加载器）无法访问子加载器的类。

解决方案

通过获取当前线程的上下文类加载器，通常它默认被设置为应用类加载器（AppClassLoader），从而“逆向”加载实现类。

// 伪代码示例： DriverManager (在 rt.jar 中) 加载第三方驱动
public class DriverManager {
    // 获取当前线程绑定的 ContextClassLoader
    ClassLoader loader = Thread.currentThread().getContextClassLoader();

    // 使用这个加载器去加载第三方实现类
    Class<?> clazz = Class.forName("com.mysql.cj.jdbc.Driver", true, loader);

    Driver driver = (Driver) clazz.newInstance();
    // ...
}

这种模式并没有重写加载器的逻辑，而是利用了一种“显式指定”的加载通道，绕过了双亲委派的限制，实现了父类加载器请求子类加载器完成加载动作。

5. 标准实现与破坏实现的对比

下表总结了常规自定义加载器与破坏双亲委派加载器的核心区别。

6. 注意事项

在实现类隔离或热部署时，必须注意 JVM 的类唯一性标识：(ClassLoader实例 + 类的全限定名)。如果静态变量持有旧类的引用，即使创建了新的类加载器，旧对象依然不会被回收，可能导致内存泄漏或状态不一致。

在热部署场景中，应尽量将需要变更的类及其依赖类，与不变的静态工具类通过不同的类加载器隔离。例如，将公共库交由父加载器加载，将频繁变更的业务代码交由自定义子加载器加载。