Core Java Advanced LiveLessons

Compiling and Scripting

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

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