javax.script包探秘 javascript与java交互执行

这个包用来和JavaScript进行互操作,比如Java类可以调用JavaScript中的方法,而JS也可调用 JAVA中的方法.

1、可用的脚本引擎

Java 6提供对执行脚本语言的支持，这个支持来自于JSR223规范，对应的包是javax.script。默认情况下，Java 6只支持javascript脚本，它底层的实现是Mozilla Rhino，它是个纯Java的javascript实现。可以通过下面的代码列出当前环境中支持的脚本引擎：

[java]  view plain  copy

 

1. // create a script engine manager  
2. ScriptEngineManager factory = new ScriptEngineManager();  
3. // create a JavaScript engine  
4. ScriptEngine engine = factory.getEngineByName("JavaScript");  
5. // evaluate JavaScript code from String  
6. engine.eval("print('Welocme to java world')");  
7. System.out.println();  
8. ScriptEngineManager manager = new ScriptEngineManager();  
9. List<ScriptEngineFactory> factories = manager.getEngineFactories();  
10. for (ScriptEngineFactory f : factories) {  
11.     System.out.println("egine name:" + f.getEngineName() + "\n"  
12.             + "engine version:" + f.getEngineVersion() + "\n"  
13.             + "language name:" + f.getLanguageName());  
14. }  

结果输出：

Welocme to java world
egine name:Mozilla Rhino
engine version:1.6 release 2
language name:ECMAScript

可以看到，Java内置只支持javascript一种脚本。但是，只要遵循 JSR223，便可以扩展支持多种脚本语言，可以从https://scripting.dev.java.net/上查找当前已被支持的脚本的第三方库。

2、hello script

示例如上面的代码所示。

　使用的API还是很简单的，ScriptEngineManager是ScriptEngine的工厂，实例化该工厂的时候会加载可用的所有脚本引擎。从工厂中创建ScriptEngine可以使用getEngineByName、getEngineByExtension或 getEngineByMimeType来得到，只要参数名字能对上。执行脚本调用eval方法即可（效果等同于javascript中的eval）。

3、传递变量

　　可以向脚本中传递变量，使得Java代码可以和脚本代码交互，示例如下：

[java]  view plain  copy

 

1. // create a script engine manager  
2. ScriptEngineManager factory = new ScriptEngineManager();  
3. // create a JavaScript engine  
4. ScriptEngine engine = factory.getEngineByName("JavaScript");  
5. engine.put("a", 4);  
6. engine.put("b", 6);  
7. try {  
8.     Object maxNum = engine  
9.             .eval("function max_num(a,b){return (a>b)?a:b;}max_num(a,b);");  
10.     System.out.println("max_num:" + maxNum);  
11. } catch (Exception e) {  
12.     e.printStackTrace();  
13. }  

输出内容：max_num:6

　　对于上面put的变量，它作用于自身engine范围内，也就是ScriptContext.ENGINE_SCOPE，put 的变量放到一个叫Bindings的Map中，可以通过 engine.getBindings(ScriptContext.ENGINE_SCOPE).get(“a”);得到put的内容。和 ENGINE_SCOPE相对，还有个ScriptContext.GLOBAL_SCOPE 作用域，其作用的变量是由同一ScriptEngineFactory创建的所有ScriptEngine共享的全局作用域。

　　4、动态调用

　　上面的例子中定义了一个javascript函数max_num，可以通过Invocable接口来多次调用脚本库中的函数，Invocable接口是 ScriptEngine可选实现的接口。下面是个使用示例：

[java]  view plain  copy

 

1.     // create a script engine manager  
2. ScriptEngineManager factory = new ScriptEngineManager();  
3. // create a JavaScript engine  
4. ScriptEngine engine = factory.getEngineByName("JavaScript");  
5. try {  
6.     engine.eval("function max_num(a,b){return (a>b)?a:b;}");  
7.     Invocable invoke = (Invocable) engine;  
8.     Object maxNum = invoke.invokeFunction("max_num", 4, 6);  
9.     System.out.println(maxNum);  
10.     maxNum = invoke.invokeFunction("max_num", 7, 6);  
11.     System.out.println(maxNum);  
12. } catch (Exception e) {  
13.     // TODO: handle exception  
14. }  

上面的invokeFunction，第一个参数调用的脚本函数名，后面跟的可变参数是对应的脚本函数参数。

　　Invocable还有个很酷的功能，就是动态实现接口，它可以从脚本引擎中得到Java Interface 的实例；也就是说，可以定义个一个Java接口，其实现是由脚本完成。以上面的例子为例，定义接口JSLib，该接口中的函数和javascript中的函数签名保持一致：

[java]  view plain  copy

 

1. public interface JSLib {  
2.     public int max_num(int a, int b);  
3. }  

[java]  view plain  copy

 

1. // create a script engine manager  
2. ScriptEngineManager factory = new ScriptEngineManager();  
3. // create a JavaScript engine  
4. ScriptEngine engine = factory.getEngineByName("JavaScript");  
5. try {  
6.     engine.eval("function max_num(a,b){return (a>b)?a:b;}");  
7.     Invocable invoke = (Invocable) engine;  
8.     JSLib jslib = invoke.getInterface(JSLib.class);  
9.     int maxNum = jslib.max_num(4, 6);  
10.     System.out.println(maxNum);  
11. } catch (Exception e) {  
12.     // TODO: handle exception  
13. }  

5、使用Java对象

　　可以在javascript中使用Java代码，这确实是很酷的事情。在Rhino中，可以通过importClass导入一个类，也可以通过importPackage导入一个包，也可以直接使用全路经的类。在创建对象时，new也不是必须的。示例代码如下：

[java]  view plain  copy

 

1. try {  
2.     String script = "var list = java.util.ArrayList();list.add(\"kafka0102\");print(list.get(0));";  
3.     engine.eval(script);  
4. } catch (Exception e) {  
5.     e.printStackTrace();  
6. }  

又例如：

[java]  view plain  copy

 

1. try {  
2.     engine.eval("importPackage(javax.swing);" + "var optionPane = "  
3.             + "  JOptionPane.showMessageDialog(null, 'Hello, world!');");  
4. } catch (ScriptException ex) {  
5.     ex.printStackTrace();  
6. }  

　6、编译执行

　　脚本引擎默认是解释执行的，如果需要反复执行脚本，可以使用它的可选接口Compilable来编译执行脚本，以获得更好的性能，示例代码如下：

[java]  view plain  copy

 

1. try {  
2.     Compilable compEngine = (Compilable) engine;  
3.     CompiledScript script = compEngine  
4.             .compile("function max_num(a,b){return (a>b)?a:b;}");  
5.     script.eval();  
6.     Invocable invoke = (Invocable) engine;  
7.     Object maxNum = invoke.invokeFunction("max_num", 4, 6);  
8.     System.out.println(maxNum);  
9. } catch (Exception e) {  
10.     e.printStackTrace();  
11. }  

　7、总结

　　除了上面提到的特性，脚本引擎还有一些不错的功能，比如可以执行脚本文件，可以由多线程异步执行脚本等功能。引入脚本引擎，可以对一些配置扩展和业务规则做更强大而灵活的支持，也方便使用者选择自己熟悉的脚本语言来编写业务规则等

[java]  view plain  copy

 

1. public class JSTest {  
2.     public static void main(String[] args) throws Exception {  
3.         // 根据js的后缀名生成一个解析JS的脚本解析引擎  
4.   
5.         ScriptEngine engin = new ScriptEngineManager()  
6.                 .getEngineByExtension("js");  
7.         // 查询一下这个引擎是否实现了下面很实用的接口  
8.   
9.         System.out.println(engin instanceof Invocable);  
10.         // 声明两个对象，传入到JS里面去  
11.   
12.         JFrame jf = new JFrame("test");  
13.         List list = new ArrayList();  
14.         // 得到挷定的键值对象，把当前的两个JAVA对象放进去  
15.   
16.         Bindings bind = engin.createBindings();  
17.         bind.put("jf", jf);  
18.         bind.put("list", list);  
19.         // 把挷下的键值对象放进去，作用域是当前引擎的范围  
20.   
21.         engin.setBindings(bind, ScriptContext.ENGINE_SCOPE);  
22.         // 用引擎执行一段写在JS文件里面的代码  
23.   
24.         Object obj = engin.eval(new FileReader("test.js"));  
25.         // 这个时候返回值当然 是null了  
26.   
27.         System.out.println(obj);  
28.         // 把当前的引擎强制转为Invocable，这样就可以调用定义在JS文件里面的一个一个函数了  
29.   
30.         Invocable in = (Invocable) engin;  
31.         // 得到了从JS里面返回来的对象  
32.   
33.         List l = (List) in.invokeFunction("getNames");  
34.         System.out.println(l);  
35.         // 调用一下定义在JS里面的另一个函数  
36.   
37.         in.invokeFunction("testJS");  
38.         // 最后调用一个函数，该函数可以使我们前面定义的窗体显示出来  
39.   
40.         in.invokeFunction("doSth");  
41.     }  
42. }  

下面是定义在test.js里面的内容

[javascript]  view plain  copy

 

1. function doSth()  
2. {  
3.     jf.setSize(500,300);  
4.     jf.setVisible(true);  
5.     jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE);　　  
6. }　　  
7. function getNames()  
8. { 　　  
9.     list.add("doSth");  
10.     list.add("getNames");  
11.     return list;  
12. }　　  
13. function testJS()  
14. {  
15.     print('Hello world!');  
16. }  

我们可以看到，在JAVA运行了以后，窗体会显示出来，并且我们可以接收到从JS解析引擎里面传回的数据，当然我们也可以调用一个很普通的JS函数，想象一下，如果我们把我们程序运行时的一些对象都设到Bindings里面去，那么我们JS岂不是有很大的自由度了吗?因为JS里面也可以操作我们的Java对象了，并且我们可以像ava编程一样的对JS编程了，还不用再编译，马上就可以运行.灵活性岂不是变得更高了吗?

参考自：

【1】javax.script包探秘 javascript与java交互执行

http://blog.csdn.net/lvshow/article/details/7252236

【2】Scripting for the Java Platform

http://java.sun.com/developer/technicalArticles/J2SE/Desktop/scripting/

http://blog.csdn.net/defineshan/article/details/52676230