您现在的位置是：首页 > Java

当前栏目

java Compiler API (java编译api)

JAVA 文件输出编译器 API

2023-02-26 12:35:39 时间

在早期的版本中(Java SE5及以前版本)中只能通过**tools.jar**中的`com.sun.tools.javac`包来调用Java编译器，但由于`tools.jar`不是标准的Java库，在使用时必须要设置这个jar的路径。而在Java SE6中为我们提供了标准的包来操作Java编译器，这就是`javax.tools`包。

## 编译java文件 ##

使用Java API来编译Java源代码有非常多方法，目前让我们来看一种最简单的方法，通过JavaCompiler进行编译。

使用`ToolProvider.getSystemJavaCompiler`来得到一个`JavaCompiler`接口的实例。

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

`JavaCompiler`中最核心的方法是`run()`。通过这个方法能编译java源代码。

int run(InputStream in, OutputStream out, OutputStream err, String... arguments)

参数分别用来为：

1.  java编译器提供参数
2.  得到Java编译器的输出信息
3.  接收编译器的错误信息，
4.  一个或多个Java源程式文件

如果run编译成功，返回  0。

如果前3个参数传入的是`null`，那么run方法将以标准的输入、输出代替，即`System.in`、`System.out`和`System.err`。如果我们要编译一个`test.java`文件，并将使用标准输入输出，run的使用方法如下：

int results = tool.run(null, null, null, "F:\\demo\\Test.java");

完整的例子：

//CompileMain.java
    import javax.tools.JavaCompiler;
    import javax.tools.ToolProvider;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class CompileMain {
    
        public static void main(String[] args) throws IOException {
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            int result = compiler.run(null, null, null, "F:\\demo\\Test.java");
            System.out.println(result == 0 ? "编译成功" : "编译失败");
    
    //执行java 命令 , 空参数, 所在文件夹
            Process process = Runtime.getRuntime().exec("java Test",null,new File("F:\\demo\\"));
                   
    
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String str;
            while ((str = bufferedReader.readLine()) != null) {
                System.out.println(str);
            }
        }
    }

public class Test {
    
        public static void main(String[] args) {
            System.out.println("this is a test.java file ,thank you very much");
        }
    
    }

$ javac CompileMain.java 
    
    $ java CompileMain             
    编译成功
    this is a test.java file ,thank you very much

## 编译非文件形式源代码 ##

JDK 6 的编译器 API 的另外一个强大之处在于，它可以编译的源文件的形式并**不局限于文本文件**。`JavaCompiler` 类依靠文件管理服务可以编译多种形式的源文件。比如直接由内存中的字符串构造的文件，或者是从数据库中取出的文件。这种服务是由 `JavaFileManager` 类提供的。

在Java SE6中最佳的方法是使用`StandardJavaFileManager`类。这个类**能非常好地控制输入、输出，并且能通过`DiagnosticListener`得到诊断信息**，而`DiagnosticCollector`类就是listener的实现。新的 JDK 定义了 `javax.tools.FileObject` 和 `javax.tools.JavaFileObject` 接口。任何类，只要实现了这个接口，就可以被 `JavaFileManager` 识别。

![编译流程][up-d6a35e38c85fc2c7b61fabddcf9c44b9.jpg]

使用`StandardJavaFileManager`步骤：

1.  建立一个`DiagnosticCollector`实例
2.  通过`JavaCompiler.getStandardFileManager()`方法得到一个`StandardFileManager`对象。
3.  使用`StandardFileManager`获取需要编译的源代码。从文件或者字符流中获取源代码。
4.  `JavaCompiler.getTask()`生成编译任务抽象。
5.  通过`CompilationTask.call()`方法编译源代码。
6.  关闭`StandardFileManager`。

在使用这种方法调用Java编译时最复杂的方法就是`getTask`，下面让我们讨论一下`getTask`方法。这个方法有如下所示的6个参数。

getTask(Writer out,
            JavaFileManager fileManager,
            DiagnosticListener<? super JavaFileObject> diagnosticListener,
            Iterable<String> options,
            Iterable<String> classes,
            Iterable<? extends JavaFileObject> compilationUnits)

这些参数大多数都可为`null`。他们的含义所下。

*  `out`: 用于输出错误的流，默认是`System.err`。
 *  `fileManager`:标准的文件管理。
 *  `diagnosticListener`: 编译器的默认行为。
 *  `options`: 编译器的选项
 *  `classes`：参和编译的class。
 *  `compilationUnits`: 待编译的Java文件，不能为`null`。

`CompilationTask` 提供了 `setProcessors(Iterable<? extends Processor>processors)`方法，用户可以制定处理 annotation 的处理器。

在使用完`getTask`前，需要通过`StandardJavaFileManager.getJavaFileObjectsFromFiles()`或`StandardJavaFileManager.getJavaFileObjectsFromStrings`方法得到待编译的`compilationUnits`对象。

> 也可以通过继承/实现`SimpleJavaObject`获取带编译的对象。

调用这两个方法的方式如下：

Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(Iterable<? extends File> files)
    Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names)
    
    String[] filenames = …;
    Iterable<? extends JavaFileObject> compilationUnits =
    fileManager.getJavaFileObjectsFromFiles(Arrays.asList(filenames));
    
    JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager,
    diagnostics, options, null, compilationUnits);

**最后需要关闭`fileManager.close()`**;

例如：

package win.hgfdodo.dynamic;
    
    import javax.tools.JavaCompiler;
    import javax.tools.JavaFileObject;
    import javax.tools.StandardJavaFileManager;
    import javax.tools.ToolProvider;
    import java.util.Arrays;
    
    public class JavaFileManagerMain {
        public static void main(String[] args) {
            String fullQuanlifiedFileName = "win.hgfdodo.dynamic.".replaceAll("\\.", java.io.File.separator) + "Calculator.java";
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager fileManager =
                    compiler.getStandardFileManager(null, null, null);
    
            Iterable<? extends JavaFileObject> files =
                    fileManager.getJavaFileObjectsFromStrings(
                            Arrays.asList(fullQuanlifiedFileName));
            JavaCompiler.CompilationTask task = compiler.getTask(
                    null, fileManager, null, null, null, files);
    
            Boolean result = task.call();
            if (result == true) {
                System.out.println("Succeeded");
            }
        }
    }

package win.hgfdodo.dynamic;
    
    public class Calculator {
        public int multiply(int multiplicand, int multiplier) {
            return multiplicand * multiplier;
        }
    }

### JavaFileObject获取java源程序 ###

开发者希望生成 `Calculator` 的一个测试类，而不是手工编写。使用 compiler API，可以将内存中的一段字符串，编译成一个 CLASS 文件。

定制 JavaFileObject 对象：

package win.hgfdodo.dynamic;
    
    import javax.tools.SimpleJavaFileObject;
    import java.io.IOException;
    import java.net.URI;
    import java.net.URISyntaxException;
    
    public class StringObject extends SimpleJavaFileObject {
        private String content = null;
    
        protected StringObject(String className, String contents) throws URISyntaxException {
            super(new URI(className), Kind.SOURCE);
            this.content = contents;
        }
    
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
            return content;
        }
    }

`SimpleJavaFileObject` 是 `JavaFileObject` 的子类，它提供了默认的实现。继承 `SimpleJavaObject` 之后，只需要实现 `getCharContent` 方法。

接下来，在内存中构造 `Calculator` 的测试类 `CalculatorTest`，并将代表该类的字符串放置到 `StringObject` 中，传递给 `JavaCompiler.getTask` 方法。

具体如下：

package win.hgfdodo.dynamic;
    
    import javax.tools.JavaCompiler;
    import javax.tools.JavaFileObject;
    import javax.tools.StandardJavaFileManager;
    import javax.tools.ToolProvider;
    import java.net.URISyntaxException;
    import java.util.Arrays;
    
    public class StringClassCompilerMain {
        public static void main(String[] args) {
            JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager standardJavaFileManager = javaCompiler.getStandardFileManager(null, null, null);
            JavaFileObject testFile = generateTest();
            Iterable<? extends JavaFileObject> classes = Arrays.asList(testFile);
            JavaCompiler.CompilationTask task = javaCompiler.getTask(null, standardJavaFileManager, null, null, null, classes);
            if(task.call()){
                System.out.println("success");
            }else{
                System.out.println("failure!");
            }
    
        }
    
        private static JavaFileObject generateTest() {
            String contents = new String(
                    "package win.hgfdodo.dynamic;" +
                            "class CalculatorTest {\n" +
                            "  public void testMultiply() {\n" +
                            "    Calculator c = new Calculator();\n" +
                            "    System.out.println(c.multiply(2, 4));\n" +
                            "  }\n" +
                            "  public static void main(String[] args) {\n" +
                            "    CalculatorTest ct = new CalculatorTest();\n" +
                            "    ct.testMultiply();\n" +
                            "  }\n" +
                            "}\n");
            StringObject so = null;
            try {
                so = new StringObject("win.hgfdodo.dynamic.CalculatorTest", contents);
            } catch (URISyntaxException e) {
                e.printStackTrace();
            }
    
            return so;
    
        }
    }

## 采集编译器的诊断信息 ##

收集编译过程中的诊断信息是JDK6新增的内容。诊断信息，通常指错误、警告或是编译过程中的详尽输出。

JDK 6 通过 `Listener` 机制，获取这些信息。如果要注册一个 `DiagnosticListener`，必须使用 `CompilationTask` 来进行编译，因为 `Tool.run` 方法没有办法注册 `Listener`。

步骤:

1.  构造一个 `Listener`；
2.  传递给 `JavaFileManager` 的构造函数；
3.  编译完成后，获取`Diagnostic`列表；
4.  输出诊断信息。

例子：

package win.hgfdodo.dynamic;
    
    import javax.tools.*;
    import java.net.URISyntaxException;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Locale;
    
    public class StringClassCompilerMain {
        public static void main(String[] args) {
            JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
            DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<>();
            StandardJavaFileManager standardJavaFileManager = javaCompiler.getStandardFileManager(null, null, null);
            JavaFileObject testFile = generateTest();
            Iterable<? extends JavaFileObject> classes = Arrays.asList(testFile);
            JavaCompiler.CompilationTask task = javaCompiler.getTask(null, standardJavaFileManager, collector, null, null, classes);
            if(task.call()){
                System.out.println("success");
            }else{
                System.out.println("failure!");
            }
    
            List<Diagnostic<? extends JavaFileObject>> diagnostics = collector.getDiagnostics();
            for (Diagnostic<? extends JavaFileObject> diagnostic: diagnostics){
                System.out.println("line:"+ diagnostic.getLineNumber());
                System.out.println("msg:"+ diagnostic.getMessage(Locale.ENGLISH));
                System.out.println("source:"+ diagnostic.getSource());
    
            }
        }
    
        private static JavaFileObject generateTest() {
            String contents = new String(
                    "package win.hgfdodo.dynamic;" +
                            "class CalculatorTest {\n" +
                            "  public void testMultiply() {\n" +
                            "    Calculator c = new Calculator()\n" +
                            "    System.out.println(c.multiply(2, 4));\n" +
                            "  }\n" +
                            "  public static void main(String[] args) {\n" +
                            "    CalculatorTest ct = new CalculatorTest();\n" +
                            "    ct.testMultiply();\n" +
                            "  }\n" +
                            "}\n");
            StringObject so = null;
            try {
                so = new StringObject("win.hgfdodo.dynamic.CalculatorTest", contents);
            } catch (URISyntaxException e) {
                e.printStackTrace();
            }
    
            return so;
    
        }
    }

`generateTest`方法在构造`Calculator`时，将行尾`;`去掉，造成java 源文件错误，在编译时，会输出：

line:3
    msg:需要';'
    source:win.hgfdodo.dynamic.StringObject[win.hgfdodo.dynamic.CalculatorTest]

## 运行时编译和运行java类 ##

![运行时编译运行图解][up-b46dc2907d339d48d6097cdbc74659b8.png]

### CharSequenceJavaFileObject -- 存储源代码 ###

package win.hgfdodo.compiler;
    
    import javax.tools.SimpleJavaFileObject;
    import java.io.IOException;
    import java.net.URI;
    
    /**
     * 字符串java源代码。JavaFileObject表示
     */
    public class CharSequenceJavaFileObject extends SimpleJavaFileObject {
    
        //表示java源代码
        private CharSequence content;
    
        protected CharSequenceJavaFileObject(String className, String content) {
            super(URI.create("string:///" + className.replaceAll("\\.", "/") + Kind.SOURCE.extension), Kind.SOURCE);
            this.content = content;
        }
    
        /**
         * 获取需要编译的源代码
         * @param ignoreEncodingErrors
         * @return
         * @throws IOException
         */
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
            return content;
        }
    }

### JavaClassObject 保存编译结果 ###

package win.hgfdodo.compiler;
    
    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 {
    
        /**
         * Compiler编译后的byte数据会存在这个ByteArrayOutputStream对象中，
         * 后面可以取出，加载到JVM中。
         */
        private ByteArrayOutputStream byteArrayOutputStream;
    
        public JavaClassObject(String className, Kind kind) {
            super(URI.create("string:///" + className.replaceAll("\\.", "/") + kind.extension), kind);
            this.byteArrayOutputStream = new ByteArrayOutputStream();
        }
    
        /**
         * 覆盖父类SimpleJavaFileObject的方法。
         * 该方法提供给编译器结果输出的OutputStream。
         * 
         * 编译器完成编译后，会将编译结果输出到该 OutputStream 中，我们随后需要使用它获取编译结果
         *
         * @return
         * @throws IOException
         */
        @Override
        public OutputStream openOutputStream() throws IOException {
            return this.byteArrayOutputStream;
        }
    
        /**
         * FileManager会使用该方法获取编译后的byte，然后将类加载到JVM
         */
        public byte[] getBytes() {
            return this.byteArrayOutputStream.toByteArray();
        }
    }

### JavaFileManager 处理编译结果 ###

JavaFileManager提供了**编译结果存储**和**编译类的加载**。

package win.hgfdodo.compiler;
    
    import javax.tools.FileObject;
    import javax.tools.ForwardingJavaFileManager;
    import javax.tools.JavaFileManager;
    import javax.tools.JavaFileObject;
    import java.io.IOException;
    import java.security.SecureClassLoader;
    
    /**
     * 输出字节码到JavaClassFile
     */
    public class ClassFileManager extends ForwardingJavaFileManager {
    
        /**
         * 存储编译后的代码数据
         */
        private JavaClassObject classJavaFileObject;
    
        protected ClassFileManager(JavaFileManager fileManager) {
            super(fileManager);
        }
    
        /**
         * 编译后加载类
         * <p>
         * 返回一个匿名的SecureClassLoader:
         * 加载由JavaCompiler编译后，保存在ClassJavaFileObject中的byte数组。
         */
        @Override
        public ClassLoader getClassLoader(Location location) {
            return new SecureClassLoader() {
                @Override
                protected Class<?> findClass(String name) throws ClassNotFoundException {
                    byte[] bytes = classJavaFileObject.getBytes();
                    return super.defineClass(name, bytes, 0, bytes.length);
                }
            };
        }
    
        /**
         * 给编译器提供JavaClassObject，编译器会将编译结果写进去
         */
        @Override
        public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
            this.classJavaFileObject = new JavaClassObject(className, kind);
            return this.classJavaFileObject;
        }
    
    }

### DynamicCompiler -- 自定义编译器 ###

`DynamicCompiler`实现将源代码编译并加载的功能。

package win.hgfdodo.compiler;
    
    import javax.tools.*;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 运行时编译
     */
    public class DynamicCompiler {
        private JavaFileManager fileManager;
    
        public DynamicCompiler() {
            this.fileManager = initManger();
        }
    
        private JavaFileManager initManger() {
            if (fileManager != null) {
                return fileManager;
            } else {
                JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
                DiagnosticCollector diagnosticCollector = new DiagnosticCollector();
                fileManager = new ClassFileManager(javaCompiler.getStandardFileManager(diagnosticCollector, null, null));
                return fileManager;
            }
        }
    
        /**
         * 编译源码并加载，获取Class对象
         * @param fullName
         * @param sourceCode
         * @return
         * @throws ClassNotFoundException
         */
        public Class compileAndLoad(String fullName, String sourceCode) throws ClassNotFoundException {
            JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
            List<JavaFileObject> javaFileObjectList = new ArrayList<JavaFileObject>();
            javaFileObjectList.add(new CharSequenceJavaFileObject(fullName, sourceCode));
            boolean result = javaCompiler.getTask(null, fileManager, null, null, null, javaFileObjectList).call();
            if (result) {
                return this.fileManager.getClassLoader(null).loadClass(fullName);
            } else {
                return Class.forName(fullName);
            }
        }
    
        /**
         * 关闭fileManager
         * @throws IOException
         */
        public void closeFileManager() throws IOException {
            this.fileManager.close();
        }
    
    }

### 测试 ###

package win.hgfdodo.compiler;
    
    import java.io.IOException;
    import java.lang.reflect.InvocationTargetException;
    
    public class DynamicCompilerTest {
        public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException {
            StringBuilder src = new StringBuilder();
            src.append("package win.hgfdodo.compiler;");
            src.append("public class DynaClass {\n");
            src.append("    public String toString() {\n");
            src.append("        return \"Hello, I am \" + ");
            src.append("this.getClass().getSimpleName();\n");
            src.append("    }\n");
            src.append("}\n");
    
            String fullName = "win.hgfdodo.compiler.DynaClass";
    
            DynamicCompiler compiler = new DynamicCompiler();
            Class clz = compiler.compileAndLoad(fullName, src.toString());
    
            System.out.println(clz.getConstructor().newInstance());
            compiler.close();
        }
    }

编译加载`win.hgfdodo.compiler.DynaClass`后，创建新的对象，并调用`toString()`输出：

Hello, I am DynaClass

## 参考 ##

1.  [javafile compiler， classloader and run][javafile compiler_ classloader and run]

本文根据博客[https://my.oschina.net/hgfdoing/blog/3052263][https_my.oschina.net_hgfdoing_blog_3052263]

修改而来,注意, 编译.java源码, 和执行.class 都需要制定文件夹,这里我使用了绝对路径

2019年5月23日09:59:23

[up-d6a35e38c85fc2c7b61fabddcf9c44b9.jpg]: /images/20220128/75e5f55b675a4570a2f015220dee3ca9.png
[up-b46dc2907d339d48d6097cdbc74659b8.png]: /images/20220128/42f9123ac44d44c7969c86c6eae9e852.png
[javafile compiler_ classloader and run]: https://gist.github.com/chrisvest/9873843
[https_my.oschina.net_hgfdoing_blog_3052263]: https://my.oschina.net/hgfdoing/blog/3052263

猜你喜欢

11、Eclipse 创建 Java 接口
重读百度移动生态：“第一曲线”的创新“延长线”
10、Eclipse 创建 Java 类
9、Eclipse 创建 Java 包
租房“免押金”大面积落地，年底租房人群迎来一点甜
8、Eclipse 创建 Java 项目
7、Eclipse 工作空间(Workspace)
人工智能的2022：技术的价值在于生产力
智慧城市赛道中的昇腾AI：在深圳龙岗勾勒新图景
6、什么是透视图？
2023年，智能终端新生产力从云开始
末端物流自动配送车交付超1000台，毫末智行加速无人配送商业化
5、Eclipse 视图
word标题升级降级
戴尔U3223QZ深度体验：生产力工具的多元进化
智能综合运维管理平台能否解决企业目前面临的困难？
4、Eclipse 菜单
3、Eclipse 窗口说明
.netcore入门
2、Eclipse 修改字符集

zl程序教程

当前栏目

java Compiler API (java编译api)

相关文章