JavaCompiler无法执行两次编译任务的原因及二次编译方案咨询

Java Compiler API的CompilationTask实例是绑定单次编译上下文的设计：它内部封装了编译所需的输入源、编译选项、注解处理器、输出目录等所有上下文信息，调用call()执行编译后，内部资源会被释放，状态会被标记为已完成，因此重复调用call()必然抛出IllegalStateException——这是API的原生约束，并非bug。

要实现两次独立编译，核心是每次编译都新建一个CompilationTask，而非复用之前的实例。同时要确保第二次编译的类路径包含第一次编译的输出产物，避免依赖找不到的问题。

具体步骤与代码示例 #

假设你的流程是：

1. 编译源Java类 → 生成.proto文件（自定义注解处理器）
2. 调用protoc编译.proto → 生成Protobuf Java类
3. 编译Protobuf Java类 → 生成Converter类（另一个自定义注解处理器）

对应的代码实现框架如下：

import javax.tools.*;
import java.io.File;
import java.util.Arrays;

public class DynamicCompiler {
    public static void main(String[] args) throws Exception {
        // 第一步：编译源类，生成.proto文件
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        try (StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null)) {
            // 准备源文件
            Iterable<? extends JavaFileObject> firstSources = fileManager.getJavaFileObjects(
                new File("/path/to/source/classes/MyEntity.java")
            );
            // 编译选项：指定输出目录
            Iterable<String> firstOptions = Arrays.asList("-d", "/path/to/first/output");
            
            CompilationTask firstTask = compiler.getTask(
                null, fileManager, null, firstOptions, null, firstSources
            );
            // 设置自定义注解处理器（生成.proto的处理器）
            firstTask.setProcessors(Arrays.asList(new ProtoGenerationProcessor()));
            
            boolean firstCompileSuccess = firstTask.call();
            if (!firstCompileSuccess) {
                throw new RuntimeException("第一次编译失败");
            }
        }

        // 第二步：调用protoc编译.proto生成Java类（你已实现的逻辑）
        callProtoc("/path/to/generated/proto/MyEntity.proto", "/path/to/proto/output");

        // 第三步：编译Protobuf生成的类，生成Converter
        try (StandardJavaFileManager secondFileManager = compiler.getStandardFileManager(null, null, null)) {
            // 准备Protobuf生成的Java源文件
            Iterable<? extends JavaFileObject> secondSources = secondFileManager.getJavaFileObjects(
                new File("/path/to/proto/output/MyEntityProto.java")
            );
            // 编译选项：指定输出目录 + 类路径（包含第一次编译产物、protobuf依赖）
            String classpath = String.join(File.pathSeparator,
                "/path/to/first/output",
                "/path/to/proto/output",
                "/path/to/dependency/protobuf-java.jar"
            );
            Iterable<String> secondOptions = Arrays.asList(
                "-d", "/path/to/converter/output",
                "-cp", classpath
            );
            
            CompilationTask secondTask = compiler.getTask(
                null, secondFileManager, null, secondOptions, null, secondSources
            );
            // 设置生成Converter的注解处理器
            secondTask.setProcessors(Arrays.asList(new ConverterGenerationProcessor()));
            
            boolean secondCompileSuccess = secondTask.call();
            if (!secondCompileSuccess) {
                throw new RuntimeException("第二次编译失败");
            }
        }
    }

    // 你已实现的protoc调用逻辑
    private static void callProtoc(String protoFilePath, String outputDir) {
        // 你的具体实现
    }
}

关键注意事项 #

• 类路径配置：第二次编译必须将第一次的输出目录、Protobuf生成类的目录、以及protobuf的依赖jar加入类路径，否则编译器无法找到相关类。
• 资源释放：使用try-with-resources自动关闭StandardJavaFileManager，避免资源泄漏。
• JavaCompiler复用：JavaCompiler实例是线程安全的，可以复用，无需每次重新获取；但CompilationTask必须每次新建。

如果你的库是面向构建工具（如Maven/Gradle）的，建议直接集成到构建生命周期中：

1. 用注解处理器生成.proto文件
2. 用protobuf-maven-plugin/protobuf-gradle-plugin编译.proto生成Java类
3. 再用另一个注解处理器生成Converter类

这种方式比动态编译更稳定，且能利用构建工具的缓存、依赖管理能力，避免手动处理类路径等繁琐问题。

内容的提问来源于stack exchange，提问作者Yaroslav Paramonov