Core Java Advanced LiveLessons

Compiling and Scripting

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

.jpg

Run the Java compiler from a Java program

The Compiler API

The compiler API lets you run javac from a Java program.
Applications:
- Development environments.
- Java tutoring programs.
- Test and build automation tools.
- Frameworks that use Java scripting such as JSP.

Invoking the compiler:

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
OutputStream outStream = ...;
OutputStream errStream = ...;
int result = compiler.run(null, outStream, errStream,
    "-sourcepath", "src", "Test.java");

If the compiler runs successfully, result is 0.

Compilation Tasks

For additional control over the compilation process, use a compilation task:

JavaCompiler.JavaCompiler.CompilationTask task = compiler.getTask(
   errorWriter, fileManager, diagnosticListener,
   options, classes, sources);
Boolean success = task.call(); // Call Future<Boolean>

options is an Iterable<String> such as Arrays.asList("-d", "bin").
classes is only used for annotation processing.

For compiling disk files, get sources as:

StandardJavaFileManager fileManager
   = compiler.getStandardFileManager(null, null, null);
Iterable<JavaFileObject> sources
   = fileManager.getJavaFileObjectsFromFiles("File1.java", "File2.java");

Capturing Diagnostics

API is more convenient than parsing error output.
To listen to error messages, install a DiagnosticLister instance.

The DiagnosticCollector class implements the listener interface:

DiagnosticListener<JavaFileObject> diagnosticListener
   = new DiagnosticCollector<>();

After the compiler has finished, iterate over the collected Diagnostic objects:

for (Diagnostic<? extends JavaFileObject> d : collector.getDiagnostics()) ...

For each diagnostic, you can get the file name and line number of the error or warning, and a humanly readable description:

String filename = d.getSource().getName();
long lineNumber = d.getLineNumber();
String description = d.getMessage(Locale.getDefault());

In-Memory Compilation

If source code is dynamically generated, you don't have to save it to a file.

Use this wrapper class:

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;
    }
}

Pass a List<StringSource> to the compiler.getTask method.
With a similar approach, you can generate classes in memory and load them.

lesson06/compiler

Use a scripting language in a Java program

The Scripting API

Scripting languages are interpreted, lightweight languages that are suitable for end users.
Adding scripting support to your application enables end users to automate tasks or add new capabilities.
With the Java scripting API, you can invoke scripts in languages such as JavaScript, Groovy, Ruby, or Scheme.
The language must provide an adapter with “JSR 223 support”.
Add adapter JAR to the class path.

Get a ScriptEngine object:

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

Call a script:

Object result = engine.eval(scriptString);

Bindings

A binding consists of a name and an associated Java object.

Use the put method to add a binding to the script engine:

engine.put("k", 1728);
Object result = engine.eval("k + 1");

Bindings are added to the “engine scope” and persist across calls.

You can also define scopes that don't persist:

Bindings scope = engine.createBindings();
scope.put("k", 1728);
Object result = engine.eval("k + 1", scope);

Calling Functions and Methods

Define a function in the scripting language:

engine.eval("function greet(how, whom) { return how + ', ' + whom + '!' }");

Call the function from Java:

result = ((Invocable) engine).invokeFunction(
    "greet", "Hello", "World");

If the scripting language is object-oriented, you can invoke methods.

First define a class in the scripting language:

engine.eval("function Greeter(how) { this.how = how }");
engine.eval("Greeter.prototype.welcome = "
   + " function(whom) { return this.how + ', ' + whom + '!' }");

Construct an instance and call invokeMethod:

Object yo = engine.eval("new Greeter('Yo')");
result = ((Invocable) engine).invokeMethod(yo, "welcome", "World");

Implementing Java Interfaces

Scripting engines can implement Java interfaces.
Advantage: You can invoke functions and methods with Java syntax instead of engine API.
Define the interface in Java with the function that you want to call:
```
public interface Greeter {
   String welcome(String whom);
}
```

Provide a script implementation of the function:

engine.eval("function welcome(whom) { return 'Hello, ' + whom + '!' }");

Call the function from Java:

Greeter g = ((Invocable) engine).getInterface(Greeter.class);
result = g.welcome("World");

If the scripting language is object-oriented, you can do the same with classes:

engine.eval(script for defining Greeter class);
Object obj = engine.eval(script for defining Greeter object);
Greeter g = ((Invocable) engine).getInterface(obj, Greeter.class);
result = g.welcome("World");

lesson06/script

Become familiar with the Nashorn JavaScript interpreter

The Nashorn JavaScript Engine

Nashorn is a JavaScript interpreter written in Java.
Replacement for the “Rhino” interpreter.
- Faster and standards-compliant (ECMAScript 5.1).
- “Nashorn” is the German word for rhinoceros.
Included with the JDK.
Easy to call Java from Nashorn.

Launch interpreter with the jjs command:

~$ jjs
jjs> var url = new java.net.URL('http://horstmann.com')
jjs> var input = new java.util.Scanner(url.openStream())
jjs> input.useDelimiter('$')
java.util.Scanner[delimiters=$][position=0]...
jjs> input.next()
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head>
...

jjs

$ rlwrap jjs
var url = new java.net.URL('http://horstmann.com')
var input = new java.util.Scanner(url.openStream())
input.useDelimiter('$')
input.next()

Working with Java from Nashorn

Access classes by their fully qualified name:
```
java.lang.Math.floorMod(-2, 24)
```

For shorter names, store the class in an object:

var JMath = java.lang.Math // Avoids conflict with JavaScript Math object
JMath.floorMod(-2, 24)

Property access for getters and setters:

var frame = new javax.swing.JFrame
frame.title = "Hello" // Calls frame.setTitle("Hello")
frame.visible // Calls frame.getVisible()

JavaScript has no method overloading. Can explicitly specify desired method:
```
list['remove(Object)'](1) // Don't want the remove(int) method
```

jjs

var frame = new javax.swing.JFrame
frame.title = "Hello"
frame.setSize(200, 200)
frame.visible

Arrays, Lists, and Maps

JavaScript arrays are untyped. To get a Java array, first make a class object:
```
var intArray = Java.type('int[]')
```
Then construct the array:
```
var numbers = new intArray(10)
```

Can turn a JavaScript array into a Java array:

var jsNumbers = [1, 2, 3]
var javaNumbers = Java.to(jsNumbers, intArray)

You can use brackets with Java lists and maps:

var names = java.util.Arrays.asList('Fred', 'Wilma', 'Barney')
var first = names[0]
names[0] = 'Duke'

var scores = new java.util.HashMap
scores['Fred'] = 10 // Calls scores.put('Fred', 10)

Lambdas

JavaScript has anonymous functions:

var square = function(x) { return x * x }
var result = square(2)

Nashorn converts anonymous functions to functional interface instance:

java.util.Arrays.sort(words,
   function(a, b) { return a.length - b.length })

If the function just returns a single expression, you can omit return and the braces:
```
java.util.Arrays.sort(words,
   function(a, b) a.length - b.length)
```

Just like a Java lambda:

Arrays.sort(words, (a, b) -> a.length - b.length)

Shell Scripting

To use Nashorn with scripting extensions, invoke as jjs -scripting
Or start your script with a “shebang”:
```
#!/opt/java/bin/jjs
```
Execute shell commands in backticks:
```
`ls -al`
```
You can use string interpolation:
```
OPTS='-al'
`ls ${OPTS}`
```
To pass input to stdin, call $EXEC(cmd, input)

A variant of “here documents” is supported:

$EXEC("asadmin", <<END)
start-domain
start-database
deploy ${name} ${dir}
exit
END

$ENV and $ARG hold environment variables and command line arguments:
```
var classpath=$ENV.CLASSPATH + ":" + $ARG[1]
```
Since jjs can take multiple script arguments, you need to provide -- before command-line arguments:
```
jjs script1.js script2.js -- arg0 arg1
```

lesson06/swapdir

Java 9 News Flash - Nashorn Updates

.png

Some ECMAScript 6 features are implemented (JEP 292).

Redirection, pipes, semicolon in shell scripting:

`sort < /etc/group`
`ls -al > /tmp/dir.txt`
`ls -al | wc`
`cd /usr/bin ; ls -al`