Java 運行時動態編譯、加載、實例化：基於 JavaCompiler API 實現熱加載

Java 運行時動態編譯、加載、實例化：基於 JavaCompiler API 實現熱加載

Java 6 引入 `javax.tools.JavaCompiler` API，使得在運行時將字符串形式的 Java 源碼編譯為字節碼、加載到 JVM、實例化對象成為可能。這是實現動態腳本、規則引擎、熱插拔、代碼生成器的基石。本文構建一個完整、可生產的動態編譯引擎，涵蓋源碼管理、編譯任務、類文件管理、自定義類加載器全鏈路。

一、核心組件架構

1. CharSequenceJavaFileObject：實現 `SimpleJavaFileObject`，將源碼字符串包裝為編譯器可識別的「文件對象」。
2. JavaClassObject：承接編譯器輸出的字節碼流 (`byte[]`)，內部持有 `ByteArrayOutputStream`。
3. ClassFileManager：繼承 `ForwardingJavaFileManager`，將編譯輸出導向 `JavaClassObject`。
4. DynamicClassLoader：自定義 `ClassLoader`，將 `byte[]` 定義為 `Class` 對象。
5. DynamicEngine：門面協調者，串聯編譯、加載、實例化流程，管理類路徑、編碼、診斷收集。

二、完整實現代碼

1. 源碼文件對象

package com.example.dynamic;

import javax.tools.SimpleJavaFileObject;
import java.net.URI;

public class CharSequenceJavaFileObject extends SimpleJavaFileObject {
    private final String content;

    public CharSequenceJavaFileObject(String className, String content) {
        super(URI.create("string:///" + className.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
        this.content = content;
    }

    @Override
    public CharSequence getCharContent(boolean ignoreEncodingErrors) {
        return content;
    }
}

2. 字節碼輸出承接對象

package com.example.dynamic;

import javax.tools.SimpleJavaFileObject;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URI;

public class JavaClassObject extends SimpleJavaFileObject {
    protected final ByteArrayOutputStream bos = new ByteArrayOutputStream();

    public JavaClassObject(String name, Kind kind) {
        super(URI.create("string:///" + name.replace('.', '/') + kind.extension), kind);
    }

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

    @Override
    public OutputStream openOutputStream() throws IOException {
        return bos;
    }
}

3. 文件管理器：連接編譯器與輸出對象

package com.example.dynamic;

import javax.tools.*;
import java.io.IOException;

public class ClassFileManager extends ForwardingJavaFileManager {
    private JavaClassObject classObject;

    public ClassFileManager(StandardJavaFileManager standardManager) {
        super(standardManager);
    }

    @Override
    public JavaFileObject getJavaFileForOutput(Location location, String className,
                                               JavaFileObject.Kind kind, FileObject sibling) throws IOException {
        if (classObject == null) {
            classObject = new JavaClassObject(className, kind);
        }
        return classObject;
    }

    public JavaClassObject getClassObject() {
        return classObject;
    }
}

4. 自定義類加載器：定義字節碼為 Class

package com.example.dynamic;

import java.net.URL;
import java.net.URLClassLoader;

public class DynamicClassLoader extends URLClassLoader {
    public DynamicClassLoader(ClassLoader parent) {
        super(new URL[0], parent); // 無額外 URL，委派給父加載器
    }

    public Class loadClass(String fullName, JavaClassObject classObject) {
        byte[] classData = classObject.getBytes();
        return defineClass(fullName, classData, 0, classData.length);
    }
}

5. 動態編譯引擎核心

package com.example.dynamic;

import javax.tools.*;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;

public class DynamicEngine {
    private static final DynamicEngine INSTANCE = new DynamicEngine();
    public static DynamicEngine getInstance() { return INSTANCE; }

    private final URLClassLoader parentClassLoader;
    private final String classpath;

    private DynamicEngine() {
        this.parentClassLoader = (URLClassLoader) getClass().getClassLoader();
        this.classpath = buildClassPath();
    }

    private String buildClassPath() {
        StringBuilder sb = new StringBuilder();
        for (URL url : parentClassLoader.getURLs()) {
            String path = url.getFile();
            // Windows 路徑可能以 / 開頭，去除
            if (path.startsWith("/")) path = path.substring(1);
            sb.append(path).append(File.pathSeparator);
        }
        return sb.toString();
    }

    /**
     * 核心方法：源碼字符串 → 實例對象
     */
    public Object compileAndInstantiate(String fullClassName, String javaCode) throws Exception {
        // 1. 獲取系統編譯器
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        if (compiler == null) {
            throw new IllegalStateException("未找到系統編譯器，請確保運行在 JDK 而非 JRE 環境");
        }

        // 2. 診斷收集器
        DiagnosticCollector diagnostics = new DiagnosticCollector<>();

        // 3. 文件管理器
        StandardJavaFileManager stdManager = compiler.getStandardFileManager(diagnostics, null, null);
        ClassFileManager fileManager = new ClassFileManager(stdManager);

        // 4. 構建編譯單元
        List compilationUnits = new ArrayList<>();
        compilationUnits.add(new CharSequenceJavaFileObject(fullClassName, javaCode));

        // 5. 編譯選項
        List options = new ArrayList<>();
        options.add("-encoding"); options.add("UTF-8");
        options.add("-classpath"); options.add(classpath);
        // 可選：-parameters 保留參數名、-Xlint:unchecked 等

        // 6. 執行編譯任務
        JavaCompiler.CompilationTask task = compiler.getTask(
                null, fileManager, diagnostics, options, null, compilationUnits);
        Boolean success = task.call();

        if (!success) {
            StringBuilder err = new StringBuilder("編譯失敗:\n");
            for (Diagnostic d : diagnostics.getDiagnostics()) {
                err.append(formatDiagnostic(d));
            }
            throw new RuntimeException(err.toString());
        }

        // 7. 加載並實例化
        JavaClassObject classObject = fileManager.getClassObject();
        DynamicClassLoader classLoader = new DynamicClassLoader(parentClassLoader);
        Class clazz = classLoader.loadClass(fullClassName, classObject);
        return clazz.getDeclaredConstructor().newInstance(); // 假設有無參構造器
    }

    private String formatDiagnostic(Diagnostic d) {
        return String.format("  行%d:%d [%s] %s%n", 
                d.getLineNumber(), d.getColumnNumber(), d.getKind(), d.getMessage(null));
    }
}

三、使用示例

public class DynamicCompileDemo {
    public static void main(String[] args) throws Exception {
        // 1. 定義動態類源碼 (實現某個介面以便類型安全調用)
        String className = "com.example.dynamic.GreetingImpl";
        String source = """
            package com.example.dynamic;
            public class GreetingImpl implements Greeting {
                public String sayHello(String name) {
                    return "Hello, " + name + "! (動態編譯於 " + java.time.LocalDateTime.now() + ")";
                }
            }
            """;

        // 2. 編譯並獲取實例
        DynamicEngine engine = DynamicEngine.getInstance();
        Object instance = engine.compileAndInstantiate(className, source);

        // 3. 類型安全調用 (需共享介面)
        if (instance instanceof Greeting greeting) {
            System.out.println(greeting.sayHello("World"));
        }
    }
}

interface Greeting { String sayHello(String name); }

四、進階場景與擴展

1. 支援多源文件編譯 (相互依賴)

List units = List.of(
    new CharSequenceJavaFileObject("pkg.A", "package pkg; public class A {}"),
    new CharSequenceJavaFileObject("pkg.B", "package pkg; public class B extends A {}")
);
// 同一 CompilationTask 編譯所有單元

2. 注解處理器整合

options.add("-processor"); options.add("com.example.MyProcessor");
// 或使用 ServiceLoader 機制自動發現

3. 緩存編譯結果 (避免重複編譯)

// Key: sourceHash (MD5/SHA256) + className + optionsHash
// Value: byte[] classData
// 命中緩存時直接 defineClass，跳過編譯

4. 安全沙箱 (限制動態代碼權限)

• 使用 `SecurityManager` (舊) 或模塊化封鎖敏感 API 訪問。
• 自定義 `ClassLoader` 重寫 `loadClass` 禁止加載 `java.lang.Runtime`、`java.io.File` 等危險類。
• 編譯選項 `-Xlint:-options` 等減少信息洩露。

5. 非 JDK 環境兼容 (如 Spring Boot 打包為 fat jar)

`ToolProvider.getSystemJavaCompiler()` 在 JRE 或某些打包環境返回 `null`。解決方案：

• 確保生產環境使用 JDK 運行 (推薦)。
• 引入 `org.eclipse.jdt:ecj` (Eclipse 編譯器) 作為備選實現。Spring Boot `spring-boot-devtools` 內嵌了此方案。

五、關鍵技術點總結

六、避坑指南

1. 類路徑必須包含所有依賴：動態代碼引用的第三方類、項目自身類必須在 `classpath` 選項中，否則編譯報「找不到符號」。
2. 包名與類名一致：源碼 `package com.example; class A {}` 對應 `fullClassName = "com.example.A"`，否則 `defineClass` 失敗。
3. 無參構造器假設：示例用 `getDeclaredConstructor().newInstance()`，若類無無參構造器需反射獲取帶參構造器並傳遞實參。
4. 線程安全：`DynamicEngine` 單例無狀態安全；`ClassFileManager`、`JavaClassObject` 每次編譯新建，隔離狀態。
5. 內存洩漏風險：動態生成的類由自定義 `ClassLoader` 加載，若長期持有 `Class`/實例引用，需定期卸載 `ClassLoader` (置 null 並 GC) 釋放元空間。

七、應用場景

• 動態規則引擎：用戶配置 Java 片段實現業務規則，運行時編譯執行。
• 代碼生成器：根據元數據生成 Entity、Mapper、Controller 等樣板代碼並熱加載驗證。
• 熱插拔插件系統：外部 Jar/源碼動態載入，實現功能擴展無需重啟。
• 測試框架：動態生成測試用例類 (如 JUnit 5 動態測試)。
• REPL / Notebook 內核：逐行編譯執行用戶輸入。

掌握 `JavaCompiler` API，賦予 Java 應用「自我進化」的能力，是構建高靈活性平台化產品的關鍵技術。