java ScriptEngine 使用（支持JavaScript脚本，eval()函数等）

时间 2019-11-10

标签 java scriptengine 使用支持 javascript 脚本 eval 函数栏目 Java 繁體版

原文原文链接

Java SE 6最引人注目的新功能之一就是内嵌了脚本支持。在默认状况下，Java SE 6只支持JavaScript，但这并不觉得着Java SE 6只能支持JavaScript。在Java SE 6中提供了一些接口来定义一个脚本规范，也就是JSR223。经过实现这些接口，Java SE 6能够支持任意的脚本语言(如PHP或Ruby)。javascript

　　运行第一个脚本程序java

　　在使用Java SE 6运行脚本以前，必需要知道你的Java SE 6支持什么脚本语言。在javax.script包中有不少的类，但这些类中最主要的是ScriptEngineManager。能够经过这个类获得当前 Java SE 6所支持的全部脚本。以下面例子将列出全部可使用的脚本引擎工厂。多线程

　import javax.script.*;
　　import java.io.*;
　　import java.util.*;
　　import static java.lang.System.*;
　　public class ListScriptEngines
　　{
　　public static void main(String args[]){
　　ScriptEngineManager manager = new ScriptEngineManager();
　　// 获得全部的脚本引擎工厂

　　List factories = manager.getEngineFactories();
　　// 这是Java SE 5 和Java SE 6的新For语句语法

　　for (ScriptEngineFactory factory: factories){
　　// 打印脚本信息

　　out.printf("Name: %s%n" +
　　"Version: %s%n" +
　　"Language name: %s%n" +
　　"Language version: %s%n" +
　　"Extensions: %s%n" +
　　"Mime types: %s%n" +
　　"Names: %s%n",
　　factory.getEngineName(),
　　factory.getEngineVersion(),
　　factory.getLanguageName(),
　　factory.getLanguageVersion(),
　　factory.getExtensions(),
　　factory.getMimeTypes(),
　　factory.getNames());
　　// 获得当前的脚本引擎

　　ScriptEngine engine = factory.getScriptEngine();
　　} 　 } }

　　上面的例子必需要在Java SE 6中编译。其中import static java.lang.System.*是新的语法，将System中的全部静态成员进行引用，之后就能够直接使用out、in或err了。app

　　经过运行java ListScriptEngines，将显示以下信息ecmascript

　　Name: Mozilla Rhino

　　Version: 1.6 release 2

　　Language name: ECMAScript

　　Language version: 1.6

　　Extensions: [js]

　　Mime types: [application/javascript, application/ecmascript, text/javascript, text/ecmascript]

　　Names: [js, rhino, JavaScript, javascript, ECMAScript, ecmascript]

　　在最下面一行是脚本的别名，也就是使用它们中的任意一个均可以。获得一个具体的脚本引擎有3种方法。异步

　　根据扩展名获得脚本引擎

ScriptEngine engine = manager.getEngineByExtension("js");

　　getEngineByExtension的参数就是Extensions:[js]中[…]里的部分。函数

　　根据Mime类型获得脚本引擎

ScriptEngine engine = manager.getEngineByMimeType("text/javascript");

　　getEngineByMimeType的参数能够是Mime types: [application/javascript, application/ecmascript, text/javascript,this

　　text/ecmascript]中的任何一个，能够将text/javascript改为text/ecmascript。spa

　　根据名称获得脚本引擎

ScriptEngine engine = manager.getEngineByName("javascript");

　　getEngineByName后的参数能够是Names: [js, rhino, JavaScript, javascript, ECMAScript, ecmascript]中的任何一个，线程

　　如能够将javascript改为ecmascript。

============================================================================================

　　上面已经讨论了执行脚本的第一步，就是获得一个可用的脚本引擎。在完成这项工做以后就能够利用这个脚本引擎执行相应的脚本了。咱们可使用ScriptEngine的eval方法来执行脚本。eval方法被重载的屡次，但最经常使用的是 public Object eval(String script)。

　　下面的例子演示了如何使用eval方法来执行javascript脚本。

import javax.script.*;
　　import java.io.*;
　　import static java.lang.System.*;
　　public class FirstJavaScript
　　{
　　public static void main(String args[])
　　{
　　ScriptEngineManager manager = new ScriptEngineManager();
　　// 获得javascript脚本引擎

　　ScriptEngine engine = manager.getEngineByName("javascript");
　　try
　　{
　　// 开始运行脚本，并返回当前的小时

　　Double hour = (Double)engine.eval("var date = new Date();" +"date.getHours();");
　　String msg;
　　// 将小时转换为问候信息

　　if (hour < 10)
　　{
　　msg = "上午好";
　　}
　　else if (hour < 16)
　　{
　　msg = "下午好";
　　}
　　else if (hour < 20)
　　{
　　msg = "晚上好";
　　}
　　else
　　{
　　msg = "晚安";
　　}
　　out.printf("小时%s: %s%n", hour, msg);
　　}
　　catch (ScriptException e)
　　{
　　err.println(e);
　　}
　　}
　　}

　　上面的例子经过获得当前的小时，并将其转化为问候语。上面的程序的输出信息为：

 小时9.0：上午好

　　这个例子最值得注意的是执行的2句脚本，最后一句是date.getHours()。并未将这个值赋给一个javascript变量。这时，eval方法就将这样的值返回。这有些相似C语言的(…)运算符。如(c=a+b, c + d),这个表达式的返回值是a+b+d。

=======================================================================================

　　和脚本语言进行交互

　　上面例子只是运行了一个很是简单的脚本。这个脚本是孤立的，并未经过Java向这脚本传递任何的值。虽然从这个脚本返回了一个值，但这种返回方式是隐式的。

　　脚本引擎除了这些简单的功能，还为咱们提供了更强大的功能。甚至能够经过Java向脚本语言中传递参数，还能够将脚本语言中的变量的值取出来。这些功能要依靠ScriptEngine中的两个方法put和get。

　　put 有两个参数，一个是脚本变量名，另外一个是变量的值，这个值是Object类型，所以，能够传递任何值。

　　get 有一个参数，就是脚本变量的名。

　　下面的代码经过javascript脚本将一个字符串翻转(这个字符串是经过java传给javascript的)，而后经过java获得这个被翻转后的字符后，而后输出。

import javax.script.*;
　　import java.io.*;
　　import static java.lang.System.*;
　　public class ReverseString
　　{
　　public static void main(String args[])
　　{
　　ScriptEngineManager manager = new ScriptEngineManager();
　　// 创建javascript脚本引擎

　　ScriptEngine engine = manager.getEngineByName("javascript");
　　try
　　{
　　// 将变量name和变量值abcdefg传给javascript脚本

　　engine.put("name", "abcdefg");
　　// 开始执行脚本

　　engine.eval("var output ='' ;" +
　　"for (i = 0; i <= name.length; i++) {" +
　　" output = name.charAt(i) + output" +
　　"}");
　　// 获得output变量的值

　　String name = (String)engine.get("output");
　　out.printf("被翻转后的字符串：%s", name);
　　}
　　catch (ScriptException e)
　　{
　　err.println(e);
　　}
　　}
　　}

　　以上代码的输出结果为：

被翻转后的字符串：gfedcba

==========================================================================================================================

　　让脚本运行得更快

　　众所周知，解释运行方式是最慢的运行方式。上述的几个例子无一例外地都是以解释方式运行的。因为Java EE 6的脚本引擎能够支持任何实现脚本引擎接口的语言。有不少这样的语言提供了编译功能，也就是说，在运行脚本以前要先将这些脚本进行编译(这里的编译通常将不是生成可执行文件，而只是在内存中编译成更容易运行的方式)，而后再执行。若是某段脚本要运行之交屡次的话，使用这种方式是很是快的。咱们可使用 ScriptEngine的compile方法进行编译。并非全部脚本引擎都支持编译，只有实现了Compilable接口的脚本引擎才可使用 compile进行编译，不然将抛出一个错误。下面的例子将演示如何使用compile方法编译并运行javascript脚本。

import javax.script.*;
　　import java.io.*;
　　import static java.lang.System.*;
　　public class CompileScript
　　{
　　public static void main(String args[])
　　{
　　ScriptEngineManager manager = new ScriptEngineManager();
　　ScriptEngine engine = manager.getEngineByName("javascript");
　　engine.put("counter", 0); // 向javascript传递一个参数
　　// 判断这个脚本引擎是否支持编译功能

　　if (engine instanceof Compilable)
　　{
　　Compilable compEngine = (Compilable)engine;
　　try
　　{
　　// 进行编译

　　CompiledScript script = compEngine.compile("function count() { " +
　　" counter = counter +1; " +
　　" return counter; " +
　　"}; count();");
　　out.printf("Counter: %s%n", script.eval());
　　out.printf("Counter: %s%n", script.eval());
　　out.printf("Counter: %s%n", script.eval());
　　}
　　catch (ScriptException e)
　　{
　　err.println(e);
　　}
　　}
　　else
　　{
　　err.println("这个脚本引擎不支持编译!");
　　}
　　}
　　}

　　上面的代码运行后的显示信息以下：

　　Counter: 1.0

　　Counter: 2.0

　　Counter: 3.0

　　在这个例子中，先经过compile方法将脚本编译，而后经过eval方法屡次进行调用。在这段代码中只有一个函数，所以，eval就返回了这个函数的值。

=========================================================================================================================

　　动态调用脚本语言的方法

　　上面的例子只有一个函数，能够经过eval进行调用并将它的值返回。但若是脚本中有多个函数或想经过用户的输入来决定调用哪一个函数，这就须要使用invoke方法进行动态调用。和编译同样，脚本引擎必须实现Invocable接口才能够动态调用脚本语言中的方法。下面的例子将演示如何经过动态调用的方式来运行上面的翻转字符串的javascript脚本。

import javax.script.*;
　　import java.io.*;
　　import static java.lang.System.*;
　　public class InvocableTest
　　{
　　public static void main(String args[])
　　{
　　ScriptEngineManager manager = new ScriptEngineManager();
　　ScriptEngine engine = manager.getEngineByName("javascript");
　　String name="abcdefg";
　　if (engine instanceof Invocable)
　　{
　　try
　　{
　　engine.eval("function reverse(name) {" +
　　" var output =' ';" +
　　" for (i = 0; i <= name.length; i++) {" +
　　" output = name.charAt(i) + output" +
　　" } return output;}");
　　Invocable invokeEngine = (Invocable)engine;
　　Object o = invokeEngine.invokeFunction("reverse", name);
　　out.printf("翻转后的字符串：%s", o);
　　}
　　catch (NoSuchMethodException e)
　　{
　　err.println(e);
　　}
　　catch (ScriptException e)
　　{
　　err.println(e);
　　}
　　}
　　else
　　{
　　err.println("这个脚本引擎不支持动态调用");
　　}
　　}

======================================================================================================================

　　动态实现接口

　　脚本引擎还有一个更吸引的功能，那就是动态实现接口。如咱们要想让脚本异步地执行，即经过多线程来执行，那InvokeEngine类必须实现 Runnable接口才能够经过Thread启动多线程。所以，能够经过getInterface方法来使InvokeEngine动态地实现 Runnable接口。这样通常可分为3步进行。

　　1. 使用javascript编写一个run函数

　　engine.eval("function run() {print(异步执行);}");

　　2. 经过getInterface方法实现Runnable接口

　　Runnable runner = invokeEngine.getInterface(Runnable.class);

　　3. 使用Thread类启动多线程

　　Thread t = new Thread(runner);

　　t.start();

　　下面是实现这个功能的详细代码。

　import javax.script.*;
　　import static java.lang.System.*;
　　public class InterfaceTest
　　{
　　public static void main(String args[])
　　{
　　ScriptEngineManager manager = new ScriptEngineManager();
　　ScriptEngine engine = manager.getEngineByName("javascript");
　　try
　　{
　　engine.eval("function run() {print(异步调用);}");
　　Invocable invokeEngine = (Invocable)engine;
　　Runnable runner = invokeEngine.getInterface(Runnable.class);
　　Thread t = new Thread(runner);
　　t.start();
　　t.join();
　　}
　　catch (InterruptedException e)
　　{
　　err.println(e);
　　}
　　catch (ScriptException e)
　　{
　　System.err.println(e);
　　}
　　}
　　}

　　其实上面的代码是经过javascript实现了Runnable接口的run方法。

java ScriptEngine 使用 （支持JavaScript脚本，eval()函数等）

java ScriptEngine 使用（支持JavaScript脚本，eval()函数等）