| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
Based on 154 examples
public interface JavaCompiler extends OptionChecker
Interface to invoke Java™ programming language compilers from programs.
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 {@code System.err} unless otherwise specified. Even if a diagnostic listener is supplied, some diagnostics might not fit in a {@code 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 {@linkplain #getStandardFileManager 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 {@linkplain #getStandardFileManager 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 {@linkplain Tool} interface. Additionally, an instance of this interface supporting {@link javax.lang.model.SourceVersion#RELEASE_6 SourceVersion.RELEASE_6} or higher must also support {@linkplain javax.annotation.processing annotation processing}.
The compiler relies on two services: {@linkplain DiagnosticListener diagnostic listener} and {@linkplain JavaFileManager file manager}. Although most classes and interfaces in this package defines an API for compilers (and tools in general) the interfaces {@linkplain DiagnosticListener}, {@linkplain JavaFileManager}, {@linkplain FileObject}, and {@linkplain 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:
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:
Files[] files1 = ... ; // input for first compilation task Files[] files2 = ... ; // input for second compilation task JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); {@code Iterable extends JavaFileObject>} compilationUnits1 = fileManager.getJavaFileObjectsFromFiles({@linkplain java.util.Arrays#asList Arrays.asList}(files1)); compiler.getTask(null, fileManager, null, null, null, compilationUnits1).call(); {@code 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();
{@code Iterable extends JavaFileObject>} compilationUnits = ...; JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); {@code DiagnosticCollectordiagnostics = new DiagnosticCollector ();} StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null); compiler.getTask(null, fileManager, diagnostics, null, null, compilationUnits).call(); for (Diagnostic diagnostic : diagnostics.getDiagnostics()) System.out.format("Error on line %d in %d%n", diagnostic.getLineNumber() diagnostic.getSource().toUri()); fileManager.close();
final {@linkplain java.util.logging.Logger Logger} logger = ...; {@code Iterable extends JavaFileObject>} compilationUnits = ...; JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, null, null); JavaFileManager fileManager = new ForwardingJavaFileManager(stdFileManager) { public void flush() { logger.entering(StandardJavaFileManager.class.getName(), "flush"); super.flush(); logger.exiting(StandardJavaFileManager.class.getName(), "flush"); } }; compiler.getTask(null, fileManager, null, null, null, compilationUnits).call();
/** * A file object used to represent source coming from a string. {@code *}/ public class JavaSourceFromString extends SimpleJavaFileObject { /** * The source code of this "file". {@code *}/ final String code; /** * Constructs a new JavaSourceFromString. * {@code @}param name the name of the compilation unit represented by this file object * {@code @}param code the source code for the compilation unit represented by this file object {@code *}/ JavaSourceFromString(String name, String code) { super({@linkplain java.net.URI#create URI.create}("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE); this.code = code; } {@code @}Override public CharSequence getCharContent(boolean ignoreEncodingErrors) { return code; } }
Nested Class Summary | |
---|---|
static interface |
Interface representing a future for a compilation task. |
Method Summary | |
---|---|
StandardJavaFileManager |
getStandardFileManager(DiagnosticListener 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 diagnosticListener, Iterable options, Iterable classes, Iterable compilationUnits) Creates a future for a compilation task with the given components and arguments. |
Methods inherited from class javax.tools.OptionChecker |
---|
isSupportedOption |
Method Detail |
---|
public StandardJavaFileManager getStandardFileManager(DiagnosticListener diagnosticListener, Locale locale, Charset charset)
The standard file manager will be automatically reopened if it is accessed after calls to {@code flush} or {@code close}. The standard file manager must be usable with other tools.
diagnosticListener
- a diagnostic listener for non-fatal
diagnostics; if {@code null} use the compiler's default method
for reporting diagnosticslocale
- the locale to apply when formatting diagnostics;
{@code null} means the {@linkplain Locale#getDefault() default locale}.charset
- the character set used for decoding bytes; if
{@code null} use the platform defaultpublic JavaCompiler.CompilationTask getTask(Writer out, JavaFileManager fileManager, DiagnosticListener diagnosticListener, Iterable options, Iterable classes, Iterable compilationUnits)
If a file manager is provided, it must be able to handle all locations defined in {@link StandardLocation}.
out
- a Writer for additional output from the compiler;
use {@code System.err} if {@code null}fileManager
- a file manager; if {@code null} use the
compiler's standard filemanagerdiagnosticListener
- a diagnostic listener; if {@code
null} use the compiler's default method for reporting
diagnosticsoptions
- compiler options, {@code null} means no optionsclasses
- class names (for annotation processing), {@code
null} means no class namescompilationUnits
- the compilation units to compile, {@code
null} means no compilation units
| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |