Java的动态加载及类加载器实践

在Java中，除了事先编写好代码完成执行代码，还可以从任何地方加载类。动态类加载允许程序在运行时动态编译和加载代码，打破了传统静态编译的限制。

主要的应用场景是插件系统、规则引擎、热部署等场景，本文将探讨其实现原理，并给出完整的最佳实践方案。

一、动态加载核心原理

二、动态加载类代码

动态编译

// 该内容是字符串形式的类代码
String sourceCode = "public class DynamicDemo { /*...*/ }";
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
// DynamicDemo是字符串形式类代码的类名
JavaFileObject source = new StringJavaSource("DynamicDemo", sourceCode);

// 使用内存文件管理器
MemoryJavaFileManager fileManager = new MemoryJavaFileManager(
    compiler.getStandardFileManager(null, null, null)
);

// 执行编译任务
compiler.getTask(null, fileManager, null, null, null, 
    Collections.singletonList(source)).call();

字节码内存管理

class MemoryJavaFileObject extends SimpleJavaFileObject {
    private final ByteArrayOutputStream bos = new ByteArrayOutputStream();

    @Override
    public OutputStream openOutputStream() {
        return bos; // 字节码写入内存流
    }

    public byte[] getBytes() {
        return bos.toByteArray();
    }
}

类加载

public class MemoryClassLoader extends ClassLoader {
    private final Map<String, byte[]> classMap;

    @Override
    protected Class<?> findClass(String name) {
        byte[] bytes = classMap.get(name);
        return defineClass(name, bytes, 0, bytes.length);
    }
}

利用反射调用

Class<?> clazz = classLoader.loadClass("DynamicDemo");
Object instance = clazz.newInstance();
Method method = clazz.getMethod("execute");
method.invoke(instance);

三、远程加载JAR到JVM

实现步骤

远程JAR下载

public byte[] downloadRemoteJar(String jarUrl) throws IOException {
    try (InputStream in = new URL(jarUrl).openStream();
         ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        byte[] buffer = new byte[4096];
        int bytesRead;
        while ((bytesRead = in.read(buffer)) != -1) {
            out.write(buffer, 0, bytesRead);
        }
        return out.toByteArray();
    }
}

内存JAR解析

public class JarInMemory {
    private final Map<String, byte[]> classEntries = new HashMap<>();
    private final Map<String, byte[]> resourceEntries = new HashMap<>();

    public JarInMemory(byte[] jarBytes) throws IOException {
        try (JarInputStream jis = new JarInputStream(new ByteArrayInputStream(jarBytes))) {
            JarEntry entry;
            while ((entry = jis.getNextJarEntry()) != null) {
                if (entry.isDirectory()) continue;

                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                byte[] buffer = new byte[4096];
                int bytesRead;
                while ((bytesRead = jis.read(buffer)) != -1) {
                    bos.write(buffer, 0, bytesRead);
                }

                byte[] data = bos.toByteArray();
                String name = entry.getName();
                
                if (name.endsWith(".class")) {
                    String className = name.replace(".class", "").replace('/', '.');
                    classEntries.put(className, data);
                } else {
                    resourceEntries.put(name, data);
                }
            }
        }
    }
}

自定义类加载器

public class RemoteJarClassLoader extends ClassLoader {
    private final Map<String, byte[]> classMap;
    private final Map<String, byte[]> resourceMap;

    public RemoteJarClassLoader(ClassLoader parent, JarInMemory jar) {
        super(parent);
        this.classMap = new HashMap<>(jar.getClassEntries());
        this.resourceMap = new HashMap<>(jar.getResourceEntries());
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classBytes = classMap.get(name);
        if (classBytes == null) {
            throw new ClassNotFoundException(name);
        }
        return defineClass(name, classBytes, 0, classBytes.length);
    }

    @Override
    public InputStream getResourceAsStream(String name) {
        byte[] data = resourceMap.get(name);
        return data != null ? new ByteArrayInputStream(data) : null;
    }
}

四、更简洁的加载远程JAR

利用内置的URLClassLoader类加载器直接加载远程JAR，JVM 会按需下载 JAR 中的类文件，首次访问类时才会触发下载。加载的类遵循父委托机制，优先由父类加载器加载。

// 远程 JAR 地址
String jarUrl = "http://xxxxx.cn/abc.jar";

// 创建 ClassLoader
URL[] urls = { new URL(jarUrl) };
try (URLClassLoader classLoader = new URLClassLoader(urls)) {
    // 加载类
    Class<?> clazz = classLoader.loadClass("cn.tworice.MyClass");

    // 实例化并调用方法
    Object instance = clazz.getDeclaredConstructor().newInstance();
    clazz.getMethod("myMethod").invoke(instance);
}

五、类加载器的注意事项

需要注意的是，不同的类加载器即使加载的是同一个类，它们之间也不能相互转换。类的唯一性由类加载器实例 + 类的全限定类名进行标识。

举个例子，我的项目中有一个业务逻辑是动态加载的类实现了BaseNode接口，但由于BaseNode和动态加载的TestNode实现类使用了不同的类加载器，则无法将动态加载的TestNode实现类转为BaseNode接口。