public interface JavaCompiler extends Tool, OptionChecker
The compiler might generate diagnostics during compilation (for
example, error messages). If a diagnostic listener is provided,
the diagnostics will be supplied to the listener. If no listener
is provided, the diagnostics will be formatted in an unspecified
format and written to the default output, which is System.err
unless otherwise specified. Even if a diagnostic
listener is supplied, some diagnostics might not fit in a Diagnostic
and will be written to the default output.
A compiler tool has an associated standard file manager, which is the file manager that is native to the tool (or built-in). The standard file manager can be obtained by calling getStandardFileManager.
A compiler tool must function with any file manager as long as any additional requirements as detailed in the methods below are met. If no file manager is provided, the compiler tool will use a standard file manager such as the one returned by getStandardFileManager.
An instance implementing this interface must conform to
The Java™ Language Specification
and generate class files conforming to
The Java™ Virtual Machine Specification.
The versions of these
specifications are defined in the Tool interface.
Additionally, an instance of this interface supporting SourceVersion.RELEASE_6
or higher must also support annotation processing.
The compiler relies on two services: diagnostic listener and file manager. Although most classes and interfaces in this package defines an API for compilers (and tools in general) the interfaces DiagnosticListener, JavaFileManager, FileObject, and JavaFileObject are not intended to be used in applications. Instead these interfaces are intended to be implemented and used to provide customized services for a compiler and thus defines an SPI for compilers.
There are a number of classes and interfaces in this package which are designed to ease the implementation of the SPI to customize the behavior of a compiler:
StandardJavaFileManager
The standard file manager serves two purposes:
Reusing a file manager can potentially reduce overhead of scanning the file system and reading jar files. Although there might be no reduction in overhead, a standard file manager must work with multiple sequential compilations making the following example a recommended coding pattern:
File[] files1 = ... ; // input for first compilation task File[] files2 = ... ; // input for second compilation task JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);Iterable<? extends JavaFileObject>
compilationUnits1 = fileManager.getJavaFileObjectsFromFiles(Arrays.asList(files1)); compiler.getTask(null, fileManager, null, null, null, compilationUnits1).call();Iterable<? extends JavaFileObject>
compilationUnits2 = fileManager.getJavaFileObjects(files2); // use alternative method // reuse the same file manager to allow caching of jar files compiler.getTask(null, fileManager, null, null, null, compilationUnits2).call(); fileManager.close();
DiagnosticCollector
Iterable<? extends JavaFileObject>
compilationUnits = ...; JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null); compiler.getTask(null, fileManager, diagnostics, null, null, compilationUnits).call(); for (Diagnostic<? extends JavaFileObject>
diagnostic : diagnostics.getDiagnostics()) System.out.format("Error on line %d in %s%n", diagnostic.getLineNumber(), diagnostic.getSource().toUri()); fileManager.close();
ForwardingJavaFileManager
, ForwardingFileObject
, and
ForwardingJavaFileObject
final Logger logger = ...;
Iterable<? extends JavaFileObject>
compilationUnits = ...;
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, null, null);
JavaFileManager fileManager = new ForwardingJavaFileManager(stdFileManager) {
public void flush() throws IOException {
logger.entering(StandardJavaFileManager.class.getName(), "flush");
super.flush();
logger.exiting(StandardJavaFileManager.class.getName(), "flush");
}
};
compiler.getTask(null, fileManager, null, null, null, compilationUnits).call();
SimpleJavaFileObject
/** * A file object used to represent source coming from a string.*
/ public class JavaSourceFromString extends SimpleJavaFileObject { /** * The source code of this "file".*
/ final String code; /** * Constructs a new JavaSourceFromString. *@
param name the name of the compilation unit represented by this file object *@
param code the source code for the compilation unit represented by this file object*
/ JavaSourceFromString(String name, String code) { super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE); this.code = code; }@
Override public CharSequence getCharContent(boolean ignoreEncodingErrors) { return code; } }
DiagnosticListener
,
Diagnostic
,
JavaFileManager
Modifier and Type | Interface and Description |
---|---|
static interface |
JavaCompiler.CompilationTask
Interface representing a future for a compilation task.
|
Modifier and Type | Method and Description |
---|---|
StandardJavaFileManager |
getStandardFileManager(DiagnosticListener<? super JavaFileObject> diagnosticListener,
Locale locale,
Charset charset)
Gets a new instance of the standard file manager implementation
for this tool.
|
JavaCompiler.CompilationTask |
getTask(Writer out,
JavaFileManager fileManager,
DiagnosticListener<? super JavaFileObject> diagnosticListener,
Iterable<String> options,
Iterable<String> classes,
Iterable<? extends JavaFileObject> compilationUnits)
Creates a future for a compilation task with the given
components and arguments.
|
getSourceVersions, run
isSupportedOption
JavaCompiler.CompilationTask getTask(Writer out, JavaFileManager fileManager, DiagnosticListener<? super JavaFileObject> diagnosticListener, Iterable<String> options, Iterable<String> classes, Iterable<? extends JavaFileObject> compilationUnits)
If a file manager is provided, it must be able to handle all
locations defined in StandardLocation
.
Note that annotation processing can process both the
compilation units of source code to be compiled, passed with
the compilationUnits
parameter, as well as class
files, whose names are passed with the classes
parameter.
out
- a Writer for additional output from the compiler;
use System.err
if null
fileManager
- a file manager; if null
use the
compiler's standard filemanagerdiagnosticListener
- a diagnostic listener; if null
use the compiler's default method for reporting
diagnosticsoptions
- compiler options, null
means no optionsclasses
- names of classes to be processed by annotation
processing, null
means no class namescompilationUnits
- the compilation units to compile, null
means no compilation unitsRuntimeException
- if an unrecoverable error
occurred in a user supplied component. The
cause will be the error in
user code.IllegalArgumentException
- if any of the options are invalid,
or if any of the given compilation units are of other kind than
sourceStandardJavaFileManager getStandardFileManager(DiagnosticListener<? super JavaFileObject> diagnosticListener, Locale locale, Charset charset)
The standard file manager will be automatically reopened if
it is accessed after calls to flush
or close
.
The standard file manager must be usable with other tools.
diagnosticListener
- a diagnostic listener for non-fatal
diagnostics; if null
use the compiler's default method
for reporting diagnosticslocale
- the locale to apply when formatting diagnostics;
null
means the default locale.charset
- the character set used for decoding bytes; if
null
use the platform default Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2016, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.