在早期的版本中(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 识别。



使用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类



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

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

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

2019年5月23日09:59:23

【0】README

0.1）以下内容转自： http://suntips.iteye.com/blog/69002

0.2）for basic java compiler API, please visit  http://blog.csdn.net/pacosonswjtu/article/details/50718494

更特别的是,这第二种方式允许开发者将编译输出结果用一种更有意义的方式表现出来,而不是简单的那种送往stdeer的错误文本. 利用 StandardJavaFileManager 类我们有这种更好的途径使用编译器. 这个文件管理器提供了一种方式,用来处理普通文件的输入输出操作. 它同时利用 DiagnosticListener 实例来报告调试信息. 你需要使用的 DiagnosticCollector 类其实是监听器的一种实现.

2）在搞清楚你需要编译什么之前,你需要一个文件管理器. 生成一个管理器基本上需要两步:  创建一个DiagnosticCollector 和 使用 JavaCompiler 的 getStandardFileManager() 方法获得一个文件管理器. 把DiagnosticListener 对象传入 getStandardFileManager() 方法中. 这个监听器可以报告一些非致命的问题,到后来你可以选择性的通过把它传入 getTask() 方法来和编译器共享. 

DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>(); 
StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, aLocale, aCharset);

3）你也可以往这个调用里传入一个 null 值的诊断器,但这样也就等于用以前的编译器方法了.

3.1）在详细查看 StandardJavaFileManager 之前 ,编译过程涉及到 JavaCompiler 的一个方法叫做 getTask() . 它有六个参数,返回一个叫做 CompilationTask  内部类的实例： 

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

3.2）缺省情况下,大部分它的参数可以是 null.

* out: System.err 
* fileManager: compiler's standard file manager
* diagnosticListener: compiler's default behavior
* options: no command-line options to compiler
* classes: no class names for annotation processing

3.3）最后一个参数 compilationUnits 却是不能够为null ,因为它是你要去编译的东西. 它把我们又带回了StandardJavaFileManager 类.注意这个参数类型: Iterable<? extends JavaFileObject> .  StandardJavaFileManager 有两个方法返回这样的结果. 你可以使用一个文件对象的List或者String 对象的List,用它们来表示文件名:  

Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(Iterable<? extends File> files) 
Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings( Iterable<String> names)

3.4）并不仅仅 List ,实际上,任何一个能够标识需要编译的内容的集合的 Iterable 都可以.  List 出现在这里只是因为它容易生成: 

String[] filenames = ...; 
Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjectsFromFiles(Arrays.asList(filenames)); 

3.5）现在你有了编译源文件的所有的必要的信息. 从 getTask( ) 返回的 JavaCompiler.CompilationTask  实现了Callable .接口 这样,想让任务开始就去调用call()方法. 

JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, compilationUnits);
Boolean success = task.call(); 

4）如果没有编译警告和错误,这个call() 方法会编译所有的 compilationUnits 变量指定的文件,以及有依赖关系的可编译的文件. 

想要知道是否所有的都成功了,去查看一下返回的 Boolean 值. 只有当所有的编译单元都执行成功了,这个 call() 方法才返回 Boolean.TRUE  . 一旦有任何错误,这个方法就会返回 Boolean.FALSE .

在展示运行这个例子之前,让我们添加最后一个东西,DiagnosticListener , 或者更确切的说, DiagnosticCollector .的实现类.把这个监听器当作getTask()的第三个参数传递进去,你就可以在编译之后进行一些调式信息的查询了. 

for (Diagnostic diagnostic : diagnostics.getDiagnostics()) { 
  System.console().printf( 
      "Code: %s%n" + 
      "Kind: %s%n" + 
      "Position: %s%n" + 
      "Start Position: %s%n" + 
      "End Position: %s%n" + 
      "Source: %s%n" + 
      "Message:  %s%n", 
      diagnostic.getCode(), diagnostic.getKind(), 
      diagnostic.getPosition(), diagnostic.getStartPosition(), 
      diagnostic.getEndPosition(), diagnostic.getSource(), 
      diagnostic.getMessage(null)); 
}

5）在最后,你应该调用管理器的close() 方法.

6）把所有的放在一起,就得到的了下面的程序,让我们重新编译Hello（StandardJavaFileManagerTest）类.  

package com.corejava.chapter10_2;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Locale;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class AdvancedJavaCompiler
{
 public static void main(String[] args) throws IOException
 {
  JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); // 返回java 编译器
  // DiagnosticCollector 是监听器的一种实现
  DiagnosticCollector<JavaFileObject>  diagnostics = new DiagnosticCollector<>(); 
  // java 文件管理器
  StandardJavaFileManager manager = compiler.getStandardFileManager(diagnostics, Locale.CHINA, Charset.forName("UTF-8")); 
  /* Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(Iterable<? extends File> files) 
     Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names) */
  
  // 所要编译的源文件
  Iterable<? extends JavaFileObject> compilationUnits = manager.getJavaFileObjects("com/corejava/chapter10_2/StandardJavaFileManagerTest.java");
  CompilationTask task = compiler.getTask(null, manager, diagnostics, null, null, compilationUnits);
  // 如果没有编译警告和错误,这个call() 方法会编译所有的 compilationUnits 变量指定的文件,以及有依赖关系的可编译的文件.
  Boolean suc = task.call();
  
  /* 只有当所有的编译单元都执行成功了,这个 call() 方法才返回 Boolean.TRUE  . 一旦有任何错误,这个方法就会返回 Boolean.FALSE .
   * 在展示运行这个例子之前,让我们添加最后一个东西,DiagnosticListener , 或者更确切的说,  DiagnosticCollector .的实现类.
   * 把这个监听器当作getTask()的第三个参数传递进去,你就可以在编译之后进行一些调式信息的查询了. */
  for(Diagnostic diagnostic : diagnostics.getDiagnostics())
  {
   System.console().printf(
    "Code: %s%n" + 
          "Kind: %s%n" + 
          "Position: %s%n" + 
          "Start Position: %s%n" + 
          "End Position: %s%n" + 
          "Source: %s%n" + 
          "Message:  %s%n", 
          diagnostic.getCode(), diagnostic.getKind(), 
          diagnostic.getPosition(), diagnostic.getStartPosition(), 
          diagnostic.getEndPosition(), diagnostic.getSource(), 
          diagnostic.getMessage(null));
  }
  manager.close();
  System.out.println("success : " + suc);
 }
}

7）然而,如果你把 println  方法改成书写错误的 pritnln 方法,当你运行时你会得到下面的信息: 

E:\bench-cluster\cloud-data-preprocess\CoreJavaAdvanced\src>java com.corejava.chapter10_2.AdvancedJa 
vaCompiler 
Code: compiler.err.cant.resolve.location.args 
Kind: ERROR 
Position: 139 
Start Position: 129 
End Position: 147 
Source: RegularFileObject[com\corejava\chapter10_2\StandardJavaFileManagerTest.java] 
Message:  找不到符号 
  符号:   方法 printnl(java.lang.String) 
  位置: 类型为java.io.PrintStream的变量 out 
success : false

Attention） for source code about instances above, please visit  https://github.com/pacosonTang/core-java-volume/tree/master/coreJavaAdvanced/chapter10/10_2

使用Compiler API,你可以实现比在这篇简要的提示介绍的更多的事情. 例如,你可以控制输入输出的目录或者在集成编译器里高亮一些编译错误. 现在,向 Java Compiler API表示感谢,你可以使用标准API了. For more information on the Java Compiler API and JSR 199, see the JSR 199 specification.