Nashorn Chapter added

Author: shekhargulati

10-nashorn.md

@@ -14,11 +14,11 @@ In this chapter, we will cover the following:
 
 * Working with Nashorn command-line
 * Accessing Java classes and methods
-* Working with Java collections
 * Using external JavaScript libraries
 * Writing scripts
 * Using Nashorn from Java code
 * Using Java 8 features like Streams and Lambdas inside JavaScript code
+* Turning off Java language access
 
 
 ## Working with Nashorn command-line
@@ -94,6 +94,23 @@ jjs> userAndAge["shekhar"]
 32
 ```
 
+Similarly, you can work with other Java collections. To use an `ArrayList` you will write code as shown below.
+
+```bash
+jjs> var List = Java.type("java.util.ArrayList")
+jjs> var names = new List()
+jjs> names.add("shekhar")
+true
+jjs> names.add("rahul")
+true
+jjs> names.add("sameer")
+true
+jjs> names.get(0)
+shekhar
+jjs> names[1]
+rahul
+```
+
 ### Accessing static methods
 
 To access static methods you have to first get the Java type using `Java.type` method and then calling method on `JavaClass` function object.
@@ -104,3 +121,219 @@ jjs>
 jjs> UUID.randomUUID().toString()
 e4242b89-0e94-458e-b501-2fc4344d5498
 ```
+
+You can sort list using `Collections.sort` method as shown below.
+
+```bash
+jjs> var Collections = Java.type("java.util.Collections")
+jjs>
+jjs> Collections.sort(names)
+jjs> names
+[rahul, sameer, shekhar]
+jjs>
+```
+
+## Using external JavaScript libraries
+
+Let's suppose we want to use an external JavaScript library in our JavaScript code. Nashorn comes up with a built-in function -- `load` that loads and evaluates a script from a path, URL, or script object. To use `lodash` library we can write code as shown below.
+
+```
+jjs> load("https://raw.github.com/lodash/lodash/3.10.1/lodash.js")
+
+jjs> _.map([1, 2, 3], function(n) { return n * 3; });
+3,6,9
+```
+
+## Writing scripts
+
+You can use Nashorn extensions that enable users to write scripts that can use Unix shell scripting features. To enable shell scripting features, you have to start `jjs` with `-scripting` option as shown below.
+
+```bash
+jjs -scripting
+jjs>
+```
+
+Now you have access to Nashorn shell scripting global objects.
+
+**$ARG:** This global object can be used to access the arguments passed to the script
+```
+$ jjs -scripting -- hello hey
+jjs>
+jjs> $ARG
+hello,hey
+```
+
+**$ENV:** A map containing all the current environment variables
+
+```bash
+jjs> $ENV["HOME"]
+/Users/shekhargulati
+
+jjs> $ENV.JAVA_HOME
+/Library/Java/JavaVirtualMachines/jdk1.8.0_60.jdk/Contents/Home
+```
+
+**$EXEC:** launches processes to run commands
+
+```bash
+jjs> $EXEC("pwd")
+/Users/shekhargulati/java8-the-missing-tutorial
+```
+
+### Writing executable scripts
+
+You can use shebang(#!) at the beginning of the script to make a script file run as shell executable. Let's write a simple script that reads content of a file. We will use Java's `Files` and `Paths` API.
+
+```javascript
+#!/usr/bin/jjs
+
+var Paths = Java.type("java.nio.file.Paths");
+var Files = Java.type("java.nio.file.Files");
+
+Files.lines(Paths.get($ARG[0])).forEach(function(line){print(line);})
+```
+
+We will invoke it as
+
+```bash
+$ jjs ch10/lines.js -- README.md
+```
+
+## Using Nashorn from Java code
+
+To use Nashorn from inside Java code, you have to create an instance of ScriptEngine from `ScriptEngineManager` as shown below. Once you have `ScriptEngine` you can evaluate expressions.
+
+```java
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+
+public class NashornExample1 {
+
+    public static void main(String[] args) throws ScriptException {
+        ScriptEngineManager manager = new ScriptEngineManager();
+        ScriptEngine nashorn = manager.getEngineByName("nashorn");
+        Integer eval = (Integer) nashorn.eval("10 + 20");
+        System.out.println(eval);
+    }
+}
+```
+
+
+Using bindings
+
+```java
+import javax.script.*;
+import java.util.AbstractMap.SimpleEntry;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toMap;
+
+public class NashornExample2 {
+
+    public static void main(String[] args) throws ScriptException {
+        ScriptEngineManager manager = new ScriptEngineManager();
+        ScriptEngine nashorn = manager.getEngineByName("nashorn");
+
+        Bindings bindings = new SimpleBindings(Stream.of(
+                new SimpleEntry<>("a", 10),
+                new SimpleEntry<>("b", 20))
+                .collect(toMap(SimpleEntry::getKey, SimpleEntry::getValue)));
+        Double eval = (Double) nashorn.eval("a + b", bindings);
+        System.out.println(eval);
+    }
+}
+```
+
+## Using Java 8 features like Streams and Lambdas inside JavaScript code
+
+Java 8 supports lambdas and many API in JDK make use of them. Every collection in Java has `forEach` method that accepts a consumer. Consumer is an interface with one method. In Java, you can write following:
+
+```java
+Arrays.asList("shekhar","rahul","sameer").forEach(name -> System.out.println(name));
+
+// shekhar
+// rahul
+// sameer
+```
+
+In Nashorn, you can use them same API but you will pass JavaScript function instead as shown below.
+
+```javascript
+jjs> var Arrays = Java.type("java.util.Arrays")
+jjs> Arrays.asList("shekhar","rahul","sameer")
+[shekhar, rahul, sameer]
+jjs> var names = Arrays.asList("shekhar","rahul","sameer")
+jjs> names.forEach(function(name){print(name);})
+shekhar
+rahul
+sameer
+```
+
+You can also use Stream API with Nashorn as shown below.
+
+```
+jjs> names
+    .stream().filter(function(name){return name.startsWith("s");})
+    .forEach(function(name){print(name);})
+
+shekhar
+sameer
+```
+
+## Turning off Java language access
+
+In case you need to disallow Java usage, you can very easily turn off by passing `--no-java` option to `jjs` as shown below.
+
+```
+→ jjs --no-java
+jjs>
+jjs> var HashMap = Java.type("java.util.HashMap")
+<shell>:1 TypeError: null has no such function "type"
+```
+
+Now when you will try to use `java.util.HashMap` you will get `TypeError`.
+
+You can do the same with Java code as well.
+
+```java
+
+import jdk.nashorn.api.scripting.ClassFilter;
+import jdk.nashorn.api.scripting.NashornScriptEngineFactory;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptException;
+
+public class NashornExample3 {
+
+    public static void main(String[] args) throws ScriptException {
+        NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
+        ScriptEngine nashorn = factory.getScriptEngine(new NoJavaFilter());
+        Integer eval = (Integer) nashorn.eval("var HashMap = Java.type('java.util.HashMap')");
+        System.out.println(eval);
+    }
+
+    private static class NoJavaFilter implements ClassFilter{
+
+        @Override
+        public boolean exposeToScripts(String s) {
+            return false;
+        }
+    }
+}
+```
+
+You will get following exception when you run this program.
+
+```
+Caused by: java.lang.ClassNotFoundException: java.util.HashMap
+	at jdk.nashorn.internal.runtime.Context.findClass(Context.java:1032)
+	at jdk.nashorn.internal.objects.NativeJava.simpleType(NativeJava.java:493)
+	at jdk.nashorn.internal.objects.NativeJava.type(NativeJava.java:322)
+	at jdk.nashorn.internal.objects.NativeJava.type(NativeJava.java:314)
+	at jdk.nashorn.internal.objects.NativeJava.type(NativeJava.java:310)
+	at jdk.nashorn.internal.scripts.Script$\^eval\_.:program(<eval>:1)
+	at jdk.nashorn.internal.runtime.ScriptFunctionData.invoke(ScriptFunctionData.java:640)
+	at jdk.nashorn.internal.runtime.ScriptFunction.invoke(ScriptFunction.java:228)
+	at jdk.nashorn.internal.runtime.ScriptRuntime.apply(ScriptRuntime.java:393)
+```

README.md

@@ -14,7 +14,7 @@ Java 8 is not a new topic anymore. There are many good books published on it. St
 * [Building functional programs](./07-building-functional-programs.md): Not written yet
 * [Date Time API](./08-date-time-api.md)
 * [Completable Futures](./09-completable-futures.md): Not written yet
-* [Nashorn](./10-nashorn.md): Not written yet
+* [Nashorn](./10-nashorn.md)
 * [Tools](./11-tools.md): Not written yet
 * [Annotation improvements](./12-annotations.md)
 

ch10/lines.js

@@ -0,0 +1,6 @@
+#!/usr/bin/jjs
+
+var Paths = Java.type("java.nio.file.Paths");
+var Files = Java.type("java.nio.file.Files");
+
+Files.lines(Paths.get($ARG[0])).forEach(function(line){print(line);})

code/src/main/java/com/shekhargulati/java8_tutorial/ch10/NashornExample1.java

@@ -0,0 +1,15 @@
+package com.shekhargulati.java8_tutorial.ch10;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+
+public class NashornExample1 {
+
+    public static void main(String[] args) throws ScriptException {
+        ScriptEngineManager manager = new ScriptEngineManager();
+        ScriptEngine nashorn = manager.getEngineByName("nashorn");
+        Integer eval = (Integer) nashorn.eval("10 + 20");
+        System.out.println(eval);
+    }
+}

code/src/main/java/com/shekhargulati/java8_tutorial/ch10/NashornExample2.java

@@ -0,0 +1,22 @@
+package com.shekhargulati.java8_tutorial.ch10;
+
+import javax.script.*;
+import java.util.AbstractMap.SimpleEntry;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toMap;
+
+public class NashornExample2 {
+
+    public static void main(String[] args) throws ScriptException {
+        ScriptEngineManager manager = new ScriptEngineManager();
+        ScriptEngine nashorn = manager.getEngineByName("nashorn");
+
+        Bindings bindings = new SimpleBindings(Stream.of(
+                new SimpleEntry<>("a", 10),
+                new SimpleEntry<>("b", 20))
+                .collect(toMap(SimpleEntry::getKey, SimpleEntry::getValue)));
+        Double eval = (Double) nashorn.eval("a + b", bindings);
+        System.out.println(eval);
+    }
+}

code/src/main/java/com/shekhargulati/java8_tutorial/ch10/NashornExample3.java

@@ -0,0 +1,25 @@
+package com.shekhargulati.java8_tutorial.ch10;
+
+import jdk.nashorn.api.scripting.ClassFilter;
+import jdk.nashorn.api.scripting.NashornScriptEngineFactory;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptException;
+
+public class NashornExample3 {
+
+    public static void main(String[] args) throws ScriptException {
+        NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
+        ScriptEngine nashorn = factory.getScriptEngine(new NoJavaFilter());
+        Integer eval = (Integer) nashorn.eval("var HashMap = Java.type('java.util.HashMap')");
+        System.out.println(eval);
+    }
+
+    private static class NoJavaFilter implements ClassFilter{
+
+        @Override
+        public boolean exposeToScripts(String s) {
+            return false;
+        }
+    }
+}