Core Java for the Impatient (2013)

The getTask method returns the task object but does not yet start the compilation process. The CompilationTask class extends Callable<Boolean>. You can pass it to an ExecutorService for concurrent execution, or you can just make a synchronous call:

Click here to view code image

Boolean success = task.call();

14.1.3 Reading Source Files from Memory

If you generate source code on the fly, you can have it compiled from memory, without having to save files to disk. Use this class to hold the code:

Click here to view code image

public class StringSource extends SimpleJavaFileObject {
private String code;

StringSource(String name, String code) {
super(URI.create("string:///" + name.replace('.','/') + ".java"),
Kind.SOURCE);
this.code = code;
}

public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return code;
}
}

Then generate the code for your classes and give the compiler a list of StringSource objects.

Click here to view code image

String pointCode = ...;
String rectangleCode = ...;
List<StringSource> sources = Arrays.asList(
new StringSource("Point", pointCode),
new StringSource("Rectangle", rectangleCode));
task = compiler.getTask(null, null, null, null, null, sources);

14.1.4 Writing Byte Codes to Memory

If you compile classes on the fly, there is no need to save the class files to disk. You can save them to memory and load them right away.

First, here is a class for holding the bytes:

Click here to view code image

public class ByteArrayClass extends SimpleJavaFileObject {
private ByteArrayOutputStream out;

ByteArrayClass(String name) {
super(URI.create("bytes:///" + name.replace('.','/') + ".class"),
Kind.CLASS);
}

public byte[] getCode() {
return out.toByteArray();
}

public OutputStream openOutputStream() throws IOException {
out = new ByteArrayOutputStream();
return out;
}
}

Next, you need to rig the file manager to use these classes for output:

Click here to view code image

List<ByteArrayClass> classes = new ArrayList<>();
StandardJavaFileManager stdFileManager
= compiler.getStandardFileManager(null, null, null);
JavaFileManager fileManager
= new ForwardingJavaFileManager<JavaFileManager>(stdFileManager) {
public JavaFileObject getJavaFileForOutput(Location location,
String className, Kind kind, FileObject sibling)
throws IOException {
if (kind == Kind.CLASS) {
ByteArrayClass outfile = new ByteArrayClass(className);
classes.add(outfile);
return outfile;
} else
return super.getJavaFileForOutput(
location, className, kind, sibling);
}
};

To load the classes, you need a class loader (see Chapter 4):

Click here to view code image

public class ByteArrayClassLoader extends ClassLoader {
private Iterable<ByteArrayClass> classes;

public ByteArrayClassLoader(Iterable<ByteArrayClass> classes) {
this.classes = classes;
}

@Override public Class<?> findClass(String name) throws ClassNotFoundException {
for (ByteArrayClass cl : classes) {
if (cl.getName().equals("/" + name.replace('.','/') + ".class")) {
byte[] bytes = cl.getCode();
return defineClass(name, bytes, 0, bytes.length);
}
}
throw new ClassNotFoundException(name);
}
}

After compilation has finished, call the Class.forName method with that class loader:

Click here to view code image

ByteArrayClassLoader loader = new ByteArrayClassLoader(classes);
Class<?> cl = Class.forName("Rectangle", true, loader);

14.1.5 Capturing Diagnostics

To listen to error messages, install a DiagnosticListener. The listener receives a Diagnostic object whenever the compiler reports a warning or error message. The DiagnosticCollector class implements this interface. It simply collects all diagnostics so that you can iterate through them after the compilation is complete.

Click here to view code image

DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<>();
compiler.getTask(null, fileManager,
collector, null, null, sources).call();
for (Diagnostic<? extends JavaFileObject> d : collector.getDiagnostics()) {
System.out.println(d);
}

A Diagnostic object contains information about the problem location (including file name, line number, and column number) as well as a human-readable description.

You can also install a DiagnosticListener to the standard file manager, in case you want to trap messages about missing files:

Click here to view code image

StandardJavaFileManager fileManager
= compiler.getStandardFileManager(diagnostics, null, null);

14.2 The Scripting API

A scripting language is a language that avoids the usual edit/compile/link/run cycle by interpreting the program text at runtime. This encourages experimentation. Also, scripting languages tend to be less complex, which makes them suitable as extension languages for expert users of your programs.

The scripting API lets you combine the advantages of scripting and traditional languages. It enables you to invoke scripts written in JavaScript, Groovy, Ruby, and even exotic languages such as Scheme and Haskell, from a Java program. In the following sections, you will see how to select an engine for a particular language, how to execute scripts, and how to take advantage of advanced features that some scripting engines offer.

14.2.1 Getting a Scripting Engine

A scripting engine is a library that can execute scripts in a particular language. When the virtual machine starts, it discovers the available scripting engines. To enumerate them, construct a ScriptEngineManager and invoke the getEngineFactories method.

Usually, you know which engine you need, and you can simply request it by name. For example:

Click here to view code image

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("nashorn");

The Java Development Kit contains a JavaScript engine called “Nashorn” described in Section 14.3, “The Nashorn Scripting Engine,” on p. 428. You can add more languages by providing the necessary JAR files on the class path. There is no longer an official list of languages with Java scripting integration. Just use your favorite search engine to find “JSR 223 support” for your favorite language.

Once you have an engine, you can call a script simply by invoking

Click here to view code image

Object result = engine.eval(scriptString);

You can also read a script from a Reader:

Click here to view code image

Object result = engine.eval(Files.newBufferedReader(path, charset));

You can invoke multiple scripts on the same engine. If one script defines variables, functions, or classes, most scripting engines retain the definitions for later use. For example,

Click here to view code image

engine.eval("n = 1728");
Object result = engine.eval("n + 1");

will return 1729.