Java8的Nashorn脚本引擎教程

本文为了解所有关于 Nashorn JavaScript 引擎易于理解的代码例子。 Nashorn JavaScript 引擎是Java SE 8的一部分，它与其它像Google V8 (它是Google Chrome 和Node.js的引擎)的独立引擎相互竞争。 Nashorn 扩展了Java在JVM上运行动态JavaScript脚本的能力。

创新互联从2013年创立，是专业互联网技术服务公司，拥有项目网站设计制作、做网站网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元泽普做网站,已为上家服务,为泽普各地企业和个人服务,联系电话:028-86922220

在接下来的大约15分钟里，您将学习如何在 JVM 上动态运行 JavaScript。 通过一些简短的代码示例演示最近 Nashorn 的语言特性。 学习 Java 与 JavaScript 的相互调用。***包括如何在日常的 Java 业务中整合动态脚本。

使用Nashorn

Nashorn javascript 引擎要么在java程序中以编程的方式使用要么在命令行工具jjs使用，jjs在目录$JAVA_HOME/bin中。如果你准备建立一个jjs的符号链接，如下：

 
 
    
  
  
  1. $ cd /usr/bin 
    2.   
  
  2. $ ln -s $JAVA_HOME/bin/jjs jjs 
    3.   
  
  3. $ jjs 
    4.   
  
  4. jjs> print('Hello World'); 
    5.

本教程关注的是在java代码中使用 nashorn ，所以我们现在跳过jjs。用java代码来一个简单的  HelloWorld示例，如下：

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

为了在java中执行JavaScript代码，首先使用原先Rhino (旧版Java中来自Mozilla的引擎)中的包javax.script来创建一个nashorn脚本引擎。.

既可以向上面那样把JavaScript代码作为一个字符串来直接执行，也可放入一个js脚本文件中，如：

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

Nashorn javascript是基于 ECMAScript 5.1 ，但nashorn后续版本将支持 ECMAScript 6:

当前Nashorn的策略是遵循ECMAScript规范。 当我们发布JDK 8时，我们将实现ECMAScript 5.1标准。后续的 Nashorn的版本将实现 ECMAScript Edition 6标准。

Nashorn定义了很多语言和扩展了 ECMAScript标准的API 。接下来我们看看java与JavaScript的通信。

Java调用Javascript 函数

Nashorn 支持java代码直接调用定义在脚本文件中JavaScript函数。你可以把java对象作为函数的参数且在调用函数的java方法中接收返回的数据。

如下的JavaScript代码将会在java端调用：

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

为了调用函数，你首先得把脚本引擎转换为 Invocable。NashornScriptEngine 实现了 Invocable 接口且定义一个调用JavaScript函数的方法 invokeFunction ，传入函数名即可。

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

上述代码的执行将在控制台打印三行信息。调用 print 函数将输出内容通过管道送到 System.out 控制台，因此我们首先看到的是 JavaScript打印的信息。

现在我们通过传递任意的 Java 对象去调用第二个函数：

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

你可以传递任意 Java 对象而不会在 JavaScript 这边丢失类型信息。因为脚本本身是在 JVM 虚拟机中执行的，我们可以完全利用 nashorn 引擎的 Java API 和外部库的强大功能。

在 JavaScript 端调用 Java 方法

在 JavaScript 中调用 Java 方法很简单。首先我们定义一个静态的 Java 方法：

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

JavaScript 可通过 Java.type API 来引用 Java 类。这跟在 Java 类中引入其他类是类似的。当定义了 Java 类型后我们可直接调用其静态方法 fun1() 并打印结果到 sout。因为方法是静态的，所以我们无需创建类实例。

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

当调用java 方法时，Nashorn怎样处理原生JavaScript类型与java类型转换？让我们用一个简单的例子来发现。

下面的java方法简单打印实际的类方法参数的类型:

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

为了解引擎如何处理类型转换，我使用不同JavaScript类型来调用java方法：

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

原始的javascript 类型被转换为适当的 java 包装器类。而不是本地javascript对象内部适配器类。请记住，这些类来自于jdk.nashorn.internal，所以你不应该在客户端使用这些类:

Anything marked internal will likely change out from underneath you.

ScriptObjectMirror

当使用ScriptObjectMirror把本地JavaScript对象传入时，实际上是有一个java对象表示JavaScript 对象。 ScriptObjectMirror 实现了接口与jdk.nashorn.api内部的映射。这个包下的类目的就是用于客户端代码使用。

下一个示例更改参数类型Object为ScriptObjectMirror，因此我们能获取到传入JavaScript中对象的一些信息：

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

当我们把传递对象hash到方法中，在Java端就能访问这些属性：

 
 
    
  
  
  1. MyJavaClass.fun3({ 
    2.   
  
  2.     foo: 'bar', 
    3.   
  
  3.     bar: 'foo' 
    4.   
  
  4. }); 
    5.   
  
  5.  
    6.   
  
  6. // Object: [foo, bar] 
    7.

我们也可以在Java端调用JavaScript对象中的函数。我们首先定义一个JavaScript类型 Person，包含属性 firstName 、lastName 和函数getFullName。

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

javascript 函数getFullName 能被 ScriptObjectMirror 的callMember()调用。

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

当我们传入一个新的person给java 方法时，我们能在控制台看到预期结果：

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

语言扩展

Nashorn 定义一系列的语言和扩展了 ECMAScript 标准的API。 让我们直接进入***的功能：

类型数组

原始javascript 数组时无类型的。 Nashorn 运行你在JavaScript中使用java数组：

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

int[] 数组的行为像一个真正的 java int 数组。 但当我们试图添加非整数的值的数组时，Nashorn 会执行隐式类型转换。 字符串会自动转换为int，这相当方便。

集合与For Each

我们可以使用java的集合来代替数组。首先定义使用 Java.type定义一个java类型，而后根据需要创建一个实例。

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

为了遍历集合和数组中的元素，Nashorn 引入了 for each 语句。这就像是 Java 的 for 循环一样。

这里是一个对集合元素进行遍历的例子，使用的是 :

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

Lambda 表达式和 Streams

似乎大家都比较喜欢 Lambda 和 Streams —— Nashorn 也是！虽然 ECMAScript 5.1 中缺少 Java 8 Lambda 表达式中的紧缩箭头的语法，但我们可以在接受 Lambda 表达式的地方使用函数来替代。

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

扩展类

Java 的类型可以简单的通过 Java.extend 进行扩展，在下个例子你将在脚本中创建一个多线程示例：

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

参数重载

方法和函数可以使用点符号或方括号来进行调用。

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

在使用重载的参数来调用方法时可以传递可选参数来确定具体调用了哪个方法，如 println(double)。

Java Beans

我们不需要常规的用 getter 或者 setter 来访问类成员属性，可直接用属性名简单访问 Java Bean 中的属性。例如：

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

函数语法

如果只是简单的一行函数我们可以不用大括号：

 
 
    
  
  
  1. function sqr(x) x * x; 
    2.   
  
  2. print(sqr(3));    // 9 
    3.

属性绑定

来自不同对象的属性可以绑定在一起：

 
 
    
  
  
  1. function sqr(x) x * x; 
    2.   
  
  2. print(sqr(3));    // 9 
    3.

字符串处理

我喜欢字符串裁剪.

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

在哪里

以防忘记你在哪里:

 
 
    
  
  
  1. print(__FILE__, __LINE__, __DIR__); 
    2.

Import 的范围

有时，这在一次性导入多个java 包时非常有用。我们可以使用JavaImporter并结合with，在with块范围内引用：

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

数组转换

有些包时可以直接使用而不必利用 Java.type 或JavaImporter引入，如 java.util:

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

如下的代码演示了将java list转换为JavaScript的数组：

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

其他的方式：

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

调用父类函数

在 JavaScript 中访问重载的成员会有一点点尴尬，因为 ECMAScript 没有类似 Java 的 super 关键字一样的东西。所幸的是 Nashorn 有办法解决。

首先我们在 Java 代码中定义一个超类：

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

接下来我们在 JavaScript 中重载 SuperRunner 。创建一个新的 Runner 实例时请注意 Nashorn 的扩展语法：其重载成员的语法是参考 Java 的匿名对象的做法。

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

我们使用Java.super调用了重载方法 SuperRunner.run()。

在JavaScript中执行其它脚本是十分容易的。我们可以load函数载入本地或远程的脚本。

在我的很多web前端中都使用了 Underscore.js ，因此在Nashorn中我们可以重用 Underscore：

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

扩展脚本的执行是在同一个 JavaScript 上下文中，因此我们可以直接访问 underscore 变量。记住脚本的加载可能会因为变量名的重叠导致代码出问题。

我们可以通过将加载的脚本文件放置到一个新的全局上下文来解决这个问题：

 
 
    
  
  
  1. loadWithNewGlobal('script.js'); 
    2.

命令行脚本

如果你对用 Java 编写命令行脚本很感兴趣的话，可以试试 Nake 。Nake 是一个为 Java 8 Nashorn 准备的简单 Make 工具。你可以在 Nakefile 文件中定义任务，然后使用 nake — myTask 来运行任务。任务使用 JavaScript 编写并通过 Nashorn 脚本模式运行，因此你可以让你的终端应用完全利用 Java 8 API 和其他 Java 库强大的功能。

对 Java 开发者而言，编写命令行脚本从来没有如此简单过。

总结

我希望这篇文章对你有用，可以让你轻松理解 Nashorn JavaScript 引擎。更多关于 Nashorn 的信息请阅读 这里, 这里 和 这里. 如果你是要用 Nashorn 编写 Shell 脚本的话可以参考 这里.

过去我也发表了一些 文章 是关于如何在 Nashron 引擎中使用 Backbone.js 模型数据的。如果你想要了解更多 Java 8 的话可以去看看我的文章 Java 8 Tutorial 和 Java 8 Stream Tutorial.

本文中的示例代码可以通过 GitHub 获取，你可以 fork 这个仓库并通过 Twitter 来给我反馈。

坚持编程！

网站题目：Java8的Nashorn脚本引擎教程
网站URL：http://www.shufengxianlan.com/qtweb/news38/492588.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网页设计公司知识

同城分类信息

成都画册制作　　 　成都广告招牌　　 　晟和广告　　 　重庆电商网站建设　　 　乐山网站建设　　 　成都网站建设　　 　成都包装盒设计　　 　资阳网站建设　　 　注册域名　　 　成都网页制作　　 　手机APP开发　　 　温江做网站　　 　租用服务器　　 　成都网站建设公司　　 　成都网络公司　　 　定制网站　　 　成都外贸网站建设公司　　 　软文推广　　 　主机租用　　 　成都响应式网站建设