Java类加载机制与自定义ClassLoader实现热部署

Java程序运行时，.class文件需要被加载到JVM中才能执行。这个过程由类加载器（ClassLoader）完成。理解其机制，可以让我们在不重启应用的情况下动态替换代码，实现“热部署”。

一、Java类加载机制基础

JVM使用双亲委派模型加载类：

1. 启动类加载器（Bootstrap ClassLoader）：加载JAVA_HOME/lib下的核心类（如java.lang.*），由C++实现。
2. 扩展类加载器（Extension ClassLoader）：加载JAVA_HOME/lib/ext目录下的JAR。
3. 应用程序类加载器（Application ClassLoader）：加载用户classpath指定的类。

当一个类被请求加载时：

• 首先委托给父加载器尝试加载；
• 父加载器无法加载时，才由自己加载；
• 这样保证核心类不会被用户代码篡改。

关键点：同一个类在JVM中由“全限定类名 + 加载它的ClassLoader”共同唯一确定。即使字节码相同，不同ClassLoader加载的类也被视为不同类型，不能互相赋值。

二、为什么默认机制不支持热部署？

因为：

• 类一旦被ClassLoader加载，就不会重新加载；
• 修改了.class文件，JVM仍使用内存中已加载的旧版本；
• 要更新类，必须创建新的ClassLoader加载新版本。

因此，热部署的核心思路是：每次加载新代码时，都用一个新的ClassLoader实例。

三、实现自定义ClassLoader

下面通过一个简单示例，展示如何实现可热部署的ClassLoader。

1. 准备待热部署的接口

// IHello.java
public interface IHello {
    String say();
}

此接口由系统默认ClassLoader加载，确保新旧版本都能兼容。

2. 编写初始实现类

// HelloImpl.java
public class HelloImpl implements IHello {
    public String say() {
        return "Hello v1";
    }
}

编译后生成HelloImpl.class，放在某个目录（如/tmp/classes/）。

3. 实现自定义ClassLoader

// HotSwapClassLoader.java
import java.io.*;

public class HotSwapClassLoader extends ClassLoader {
    private String classPath;

    public HotSwapClassLoader(String classPath) {
        this.classPath = classPath;
    }

    @Override
    protected 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 className) {
        String fileName = classPath + File.separatorChar
                + className.replace('.', File.separatorChar) + ".class";
        try (FileInputStream fis = new FileInputStream(fileName);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int ch;
            while ((ch = fis.read()) != -1) {
                baos.write(ch);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            return null;
        }
    }
}

该类重写了findClass方法，从指定目录读取.class文件字节码，并通过defineClass将其转为Class对象。

4. 编写主程序测试热部署

// Main.java
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        String classPath = "/tmp/classes";
        String className = "HelloImpl";

        // 第一次加载
        HotSwapClassLoader loader1 = new HotSwapClassLoader(classPath);
        Class<?> clazz1 = loader1.loadClass(className);
        IHello hello1 = (IHello) clazz1.getDeclaredConstructor().newInstance();
        System.out.println(hello1.say()); // 输出: Hello v1

        // 模拟修改代码：将say()返回值改为"Hello v2"
        // 手动替换 /tmp/classes/HelloImpl.class 文件（需提前编译好新版本）

        Thread.sleep(3000); // 等待你手动替换文件

        // 第二次加载（使用新的ClassLoader）
        HotSwapClassLoader loader2 = new HotSwapClassLoader(classPath);
        Class<?> clazz2 = loader2.loadClass(className);
        IHello hello2 = (IHello) clazz2.getDeclaredConstructor().newInstance();
        System.out.println(hello2.say()); // 输出: Hello v2
    }
}

操作步骤：

1. 编译所有Java文件；
2. 将HelloImpl.class复制到/tmp/classes/；
3. 运行Main程序；
4. 在程序暂停的3秒内，修改HelloImpl.java中的返回值为"Hello v2"，重新编译，并覆盖/tmp/classes/HelloImpl.class；
5. 程序继续执行，输出新版本结果。

四、关键注意事项

五、生产环境中的热部署方案

上述示例仅用于理解原理。实际项目中推荐使用成熟框架：

• Spring Boot DevTools：开发时自动重启或热替换；
• JRebel：商业工具，支持字段、方法、注解等全方位热更新；
• OSGi：模块化框架，支持动态卸载/加载Bundle（即模块）。

这些工具内部均基于自定义ClassLoader机制，但增加了缓存管理、依赖解析、状态同步等复杂逻辑。

创建新的ClassLoader实例 加载 更新后的.class文件，即可绕过JVM类缓存限制，实现热部署。