Java 8 Nashorn 教程

    这个教程中，你会通过简单易懂的代码示例，来了解Nashorn JavaScript引擎。Nashorn JavaScript引擎是Java SE 8 的一部分，并且和其它独立的引擎例如Google V8（用于Google Chrome和的引擎）互相竞争。Nashorn通过在JVM上，以原生方式运行动态的JavaScript代码来扩展Java的功能。

    在接下来的15分钟内，你会学到如何在JVM上在运行时动态执行JavaScript。我会使用小段代码示例来演示最新的Nashron语言特性。你会学到如何在Java代码中调用JavaScript函数，或者相反。最后你会准备好将动态脚本集成到你的Java日常业务中。

    更新 - 我现在正在编写用于浏览器的Java8数据流API的JavaScript实现。如果你对此感兴趣，请在Github上访问Stream.js。非常期待你的反馈。

    Nashorn JavaScript引擎可以在Java代码中编程调用，也可以通过命令行工具jjs使用，它在$JAVA_HOME/bin中。如果打算使用jjs，你可能希望设置符号链接来简化访问：

    这个教程专注于在Java代码中调用Nashron，所以让我们先跳过jjs。Java代码中简单的HelloWorld如下所示：

    1. ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    2. engine.eval("print('Hello World!');");

    为了在Java中执行JavaScript，你首先要通过javax.script包创建脚本引擎。这个包已经在（来源于Mozilla、Java中的遗留JS引擎）中使用了。

    JavaScript代码既可以通过传递JavaScript代码字符串，也可以传递指向你的JS脚本文件的FileReader来执行：

    1. ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    2. engine.eval(new FileReader("script.js"));

    Nashorn JavaScript基于ECMAScript 5.1，但是它的后续版本会对ES6提供支持：

    Nashorn定义了大量对ECMAScript标准的语言和API扩展。但是首先让我们看一看Java和JavaScript代码如何交互。

    在Java中调用JavaScript函数

    Nashorn 支持从Java代码中直接调用定义在脚本文件中的JavaScript函数。你可以将Java对象传递为函数参数，并且从函数返回数据来调用Java方法。

    下面的JavaScript函数稍后会在Java端调用：

    1. var fun1 = function(name) {
    2.     print('Hi there from Javascript, ' + name);
    3.     return "greetings from javascript";
    4. };
    6. var fun2 = function (object) {
    7.     print("JS Class Definition: " + Object.prototype.toString.call(object));
    8. };

    为了调用函数，你首先需要将脚本引擎转换为Invocable。Invocable接口由NashornScriptEngine实现，并且定义了invokeFunction方法来调用指定名称的JavaScript函数。

    1. ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    2. engine.eval(new FileReader("script.js"));
    4. Invocable invocable = (Invocable) engine;
    6. Object result = invocable.invokeFunction("fun1", "Peter Parker");
    7. System.out.println(result);
    8. System.out.println(result.getClass());
    10. // Hi there from Javascript, Peter Parker
    11. // greetings from javascript
    12. // class java.lang.String

    执行这段代码会在控制台产生三行结果。调用函数print将结果输出到System.out，所以我们会首先看到JavaScript输出。

    现在让我们通过传入任意Java对象来调用第二个函数：

    1. invocable.invokeFunction("fun2", new Date());
    2. // [object java.util.Date]
    4. invocable.invokeFunction("fun2", LocalDateTime.now());
    5. // [object java.time.LocalDateTime]
    7. invocable.invokeFunction("fun2", new Person());
    8. // [object com.winterbe.java8.Person]

    Java对象在传入时不会在JavaScript端损失任何类型信息。由于脚本在JVM上原生运行，我们可以在Nashron上使用Java API或外部库的全部功能。

    在JavaScript中调用Java方法十分容易。我们首先需要定义一个Java静态方法。

    1. static String fun1(String name) {
    2.     System.out.format("Hi there from Java, %s", name);
    3.     return "greetings from java";
    4. }

    Java类可以通过Java.typeAPI扩展在JavaScript中引用。它就和Java代码中的import类似。只要定义了Java类型，我们就可以自然地调用静态方法fun1()，然后像sout打印信息。由于方法是静态的，我们不需要首先创建实例。

    1. var MyJavaClass = Java.type('my.package.MyJavaClass');
    3. var result = MyJavaClass.fun1('John Doe');
    4. print(result);
    6. // Hi there from Java, John Doe
    7. // greetings from java

    下面的Java方法简单打印了方法参数的实际类型：

    1. static void fun2(Object object) {
    2.     System.out.println(object.getClass());
    3. }

    为了理解背后如何处理类型转换，我们使用不同的JavaScript类型来调用这个方法：

    1. MyJavaClass.fun2(123);
    2. // class java.lang.Integer
    4. MyJavaClass.fun2(49.99);
    5. // class java.lang.Double
    7. MyJavaClass.fun2(true);
    8. // class java.lang.Boolean
    10. MyJavaClass.fun2("hi there")
    11. // class java.lang.String
    13. // class jdk.nashorn.internal.objects.NativeNumber
    15. MyJavaClass.fun2(new Date());
    16. // class jdk.nashorn.internal.objects.NativeDate
    18. MyJavaClass.fun2(new RegExp());
    19. // class jdk.nashorn.internal.objects.NativeRegExp
    21. MyJavaClass.fun2({foo: 'bar'});
    22. // class jdk.nashorn.internal.scripts.JO4

    JavaScript原始类型转换为合适的Java包装类，而JavaScript原生对象会使用内部的适配器类来表示。要记住jdk.nashorn.internal中的类可能会有所变化，所以不应该在客户端面向这些类来编程。

    ScriptObjectMirror

    在向Java传递原生JavaScript对象时，你可以使用ScriptObjectMirror类，它实际上是底层JavaScript对象的Java表示。ScriptObjectMirror实现了接口，位于jdk.nashorn.api中。这个包中的类可以用于客户端代码。

    下面的例子将参数类型从Object改为ScriptObjectMirror，所以我们可以从传入的JavaScript对象中获得一些信息。

    1. static void fun3(ScriptObjectMirror mirror) {
    2.     System.out.println(mirror.getClassName() + ": " +
    3.         Arrays.toString(mirror.getOwnKeys(true)));
    4. }

    当向这个方法传递对象（哈希表）时，在Java端可以访问其属性：

    我们也可以在Java中调用JavaScript的成员函数。让我们首先定义JavaScript Person类型，带有属性firstName 和 lastName，以及方法getFullName。

    1. function Person(firstName, lastName) {
    2.     this.firstName = firstName;
    3.     this.lastName = lastName;
    4.     this.getFullName = function() {
    5.         return this.firstName + " " + this.lastName;
    6.     }
    7. }

    JavaScript方法getFullName可以通过callMember()在ScriptObjectMirror上调用。

    1. static void fun4(ScriptObjectMirror person) {
    2.     System.out.println("Full Name is: " + person.callMember("getFullName"));
    3. }

    当向Java方法传递新的Person时，我们会在控制台看到预期的结果：

    1. var person1 = new Person("Peter", "Parker");
    2. MyJavaClass.fun4(person1);
    4. // Full Name is: Peter Parker

    Nashorn定义了多种对ECMAScript标准的语言和API扩展。让我们看一看最新的特性：

    JavaScript的原生数组是无类型的。Nashron允许你在JavaScript中使用Java的类型数组：

    1. var IntArray = Java.type("int[]");
    3. var array = new IntArray(5);
    4. array[0] = 5;
    5. array[1] = 4;
    6. array[2] = 3;
    7. array[3] = 2;
    8. array[4] = 1;
    10. try {
    11.     array[5] = 23;
    12. } catch (e) {
    13.     print(e.message);  // Array index out of range: 5
    14. }
    16. array[0] = "17";
    17. print(array[0]);  // 17
    19. array[0] = "wrong type";
    20. print(array[0]);  // 0
    22. array[0] = "17.3";
    23. print(array[0]);  // 17

    int[]数组就像真实的Java整数数组那样。但是此外，在我们试图向数组添加非整数时，Nashron在背后执行了一些隐式的转换。字符串会自动转换为整数，这十分便利。

    集合和范围遍历

    我们可以使用任何Java集合，而避免使用数组瞎折腾。首先需要通过Java.type定义Java类型，之后创建新的实例。

    1. var ArrayList = Java.type('java.util.ArrayList');
    2. var list = new ArrayList();
    3. list.add('a');
    4. list.add('b');
    5. list.add('c');
    7. for each (var el in list) print(el);  // a, b, c

    为了迭代集合和数组，Nashron引入了for each语句。它就像Java的范围遍历那样工作。

    下面是另一个集合的范围遍历示例，使用HashMap：

    1. var map = new java.util.HashMap();
    2. map.put('foo', 'val1');
    3. map.put('bar', 'val2');
    5. for each (var e in map.keySet()) print(e);  // foo, bar
    7. for each (var e in map.values()) print(e);  // val1, val2

    Lambda表达式和数据流

    每个人都热爱lambda和数据流 — Nashron也一样！虽然ECMAScript 5.1没有Java8 lmbda表达式的简化箭头语法，我们可以在任何接受lambda表达式的地方使用函数字面值。

    1. var list2 = new java.util.ArrayList();
    2. list2.add("ddd2");
    3. list2.add("aaa2");
    4. list2.add("bbb1");
    5. list2.add("aaa1");
    6. list2.add("bbb3");
    7. list2.add("ccc");
    8. list2.add("bbb2");
    9. list2.add("ddd1");
    11. list2
    12.     .stream()
    13.     .filter(function(el) {
    14.         return el.startsWith("aaa");
    15.     .sorted()
    16.     .forEach(function(el) {
    17.         print(el);
    18.     });

    类的继承

    Java类型可以由Java.extend轻易扩展。就像你在下面的例子中看到的那样，你甚至可以在你的脚本中创建多线程的代码：

    1. var Runnable = Java.type('java.lang.Runnable');
    2. var Printer = Java.extend(Runnable, {
    3.     run: function() {
    4.         print('printed from a separate thread');
    5.     }
    6. });
    8. var Thread = Java.type('java.lang.Thread');
    9. new Thread(new Printer()).start();
    11. new Thread(function() {
    12.     print('printed from another thread');
    13. }).start();
    15. // printed from a separate thread
    16. // printed from another thread

    方法和函数可以通过点运算符或方括号运算符来调用：

    1. var System = Java.type('java.lang.System');
    2. System.out.println(10);              // 10
    3. System.out["println"](11.0);         // 11.0
    4. System.out["println(double)"](12);   // 12.0

    当使用重载参数调用方法时，传递可选参数类型println(double)会指定所调用的具体方法。

    Java Beans

    你可以简单地使用属性名称来向Java Beans获取或设置值，不需要显式调用读写器：

    1. var Date = Java.type('java.util.Date');
    2. var date = new Date();
    3. date.year += 1900;
    4. print(date.year);  // 2014

    函数字面值

    属性绑定

    两个不同对象的属性可以绑定到一起：

    1. var o1 = {};
    2. var o2 = { foo: 'bar'};
    4. Object.bindProperties(o1, o2);
    6. print(o1.foo);    // bar
    7. o1.foo = 'BAM';
    8. print(o2.foo);    // BAM

    我喜欢去掉空白的字符串：

    1. print("   hehe".trimLeft());            // hehe
    2. print("hehe    ".trimRight() + "he");   // hehehe

    位置

    以防你忘了自己在哪里：

    1. print(__FILE__, __LINE__, __DIR__);

    导入作用域

    有时一次导入多个Java包会很方便。我们可以使用JavaImporter类，和with语句一起使用。所有被导入包的类文件都可以在with语句的局部域中访问到。

    1. var imports = new JavaImporter(java.io, java.lang);
    2. with (imports) {
    3.     var file = new File(__FILE__);
    4.     System.out.println(file.getAbsolutePath());
    5.     // /path/to/my/script.js
    6. }

    数组转换

    一些类似java.util的包可以不使用java.type或JavaImporter直接访问：

    1. var list = new java.util.ArrayList();
    2. list.add("s1");
    3. list.add("s2");
    4. list.add("s3");

    下面的代码将Java列表转换为JavaScript原生数组：

    1. var jsArray = Java.from(list);
    2. print(jsArray);                                  // s1,s2,s3
    3. print(Object.prototype.toString.call(jsArray));  // [object Array]

    下面的代码执行相反操作：

    1. var javaArray = Java.to([3, 5, 7, 11], "int[]");

    在JavaScript中访问被覆盖的成员通常比较困难，因为Java的super关键字在ECMAScript中并不存在。幸运的是，Nashron有一套补救措施。

    首先我们需要在Java代码中定义超类：

    1. class SuperRunner implements Runnable {
    2.     @Override
    3.     public void run() {
    4.         System.out.println("super run");
    5.     }
    6. }

    下面我在JavaScript中覆盖了SuperRunner。要注意创建新的Runner实例时的Nashron语法：覆盖成员的语法取自Java的匿名对象。

    1. var SuperRunner = Java.type('com.winterbe.java8.SuperRunner');
    2. var Runner = Java.extend(SuperRunner);
    4. var runner = new Runner() {
    5.     run: function() {
    6.         Java.super(runner).run();
    7.         print('on my run');
    8.     }
    9. }
    10. runner.run();
    12. // super run
    13. // on my run

    我们通过Java.super()扩展调用了被覆盖的SuperRunner.run()方法。

    加载脚本

    在JavaScript中加载额外的脚本文件非常方便。我们可以使用load函数加载本地或远程脚本。

    我在我的Web前端中大量使用，所以让我们在Nashron中复用它：

    1. load('http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js');
    3. var odds = _.filter([1, 2, 3, 4, 5, 6], function (num) {
    4.     return num % 2 == 1;
    5. });

    外部脚本会在相同JavaScript上下文中被执行，所以我们可以直接访问underscore 的对象。要记住当变量名称互相冲突时，脚本的加载可能会使你的代码崩溃。

    这一问题可以通过把脚本文件加载到新的全局上下文来绕过：

    命令行脚本

    如果你对编写命令行（shell）脚本感兴趣，来试一试吧。Nake是一个Java 8 Nashron的简化构建工具。你只需要在项目特定的中定义任务，之后通过在命令行键入nake -- myTask来执行这些任务。任务编写为JavaScript，并且在Nashron的脚本模式下运行，所以你可以使用你的终端、JDK8 API和任意Java库的全部功能。

    对Java开发者来说，编写命令行脚本是前所未有的简单…

    我希望这个教程对你有所帮助，并且你能够享受Nashron JavaScript引擎之旅。有关Nashron的更多信息，请见这里、和这里。使用Nashron编写shell脚本的教程请见。

    我最近发布了一篇后续文章，关于如何在Nashron中使用Backbone.js模型。如果你想要进一步学习Java8，请阅读我的Java8教程，和我的。

    这篇Nashron教程中的可运行的源代码托管在Github上。请随意，或者在Twitter上向我反馈。

    请坚持编程！