Java使用ScriptEngine(javax.script)
import javax.script.ScriptEngine; import javax.script.ScriptEngineManager; import javax.script.Bindings; import javax.script.ScriptContext; import javax.script.Invocable; import javax.script.ScriptException;
ScriptEngine engine = new ScriptEngineManager() .getEngineByName("javascript"); // 建立上下文变量 Bindings bind = engine.createBindings(); // 加入变量champion值为GSP bind.put("champion", "GSP");
// 绑定上下文，作用域为当前引擎范围 engine.setBindings(bind, ScriptContext.ENGINE_SCOPE); // 执行脚本(另外还有文件读取方式 //如:engine.eval(new FileReader("xx.js"))); engine.eval("function sayName(){return champion;}"); // 可有调用方法 Invocable invoke = (Invocable) engine; // 调用方法，此处无参数列表 String result = invoke.invokeFunction("sayName", null).toString(); System.out.println(result);
1、可用的脚本引擎
Java 6提供对执行脚本语言的支持，这个支持来自于JSR223规范，对应的包是javax.script。默认情况下，Java 6只支持javascript脚本，它底层的实现是Mozilla Rhino，它是个纯Java的javascript实现。可以通过下面的代码列出当前环境中支持的脚本引擎：
1.ScriptEngineManager manager = new ScriptEngineManager();
2. ListScriptEngineFactory> factories = manager.getEngineFactories();
3. for (ScriptEngineFactory f : factories) {
4. System.out.println(
5. "egine name:"+f.getEngineName()+
6. ",engine version:"+f.getEngineVersion()+
7. ",language name:"+f.getLanguageName()+
8. ",language version:"+f.getLanguageVersion()+
9. ",names:"+f.getNames()+
10. ",mime:"+f.getMimeTypes()+
11. ",extension:"+f.getExtensions());
12. }
输出结果：egine name:Mozilla Rhino,engine version:1.6 release 2,language name:ECMAScript,language version:1.6,names:[js, rhino, javascript, javascript, ECMAScript, ecmascript],mime:[application/javascript, application/ecmascript, text/javascript, text/ecmascript],extension:[js]。
可以看到，Java内置只支持javascript一种脚本。但是，只要遵循 JSR223，便可以扩展支持多种脚本语言，可以从https://scripting.dev.java.net/上查找当前已被支持的脚本的第三方库。
2、hello script
接下来给出在Java中使用javascript的Hello world示例：
13.ScriptEngineManager manager = new ScriptEngineManager ();
14. ScriptEngine engine = manager.getEngineByName ("js");
15. String script = "print ('hello script')";
16. try {
17. engine.eval (script);
18. } catch (ScriptException e) {
19. e.printStackTrace();
20. }
使用的API还是很简单的，ScriptEngineManager是ScriptEngine的工厂，实例化该工厂的时候会加载可用的所有脚本引擎。从工厂中创建ScriptEngine可以使用getEngineByName、getEngineByExtension或 getEngineByMimeType来得到，只要参数名字能对上。执行脚本调用eval方法即可（效果等同于javascript中的eval）。
3、传递变量
可以向脚本中传递变量，使得Java代码可以和脚本代码交互，示例如下：
21.ScriptEngineManager manager = new ScriptEngineManager();
22. ScriptEngine engine = manager.getEngineByName("js");
23. engine.put("a", 4);
24. engine.put("b", 6);
25. try {
26. Object maxNum = engine.eval("function max_num(a,b){return (a>b)?a:b;}max_num(a,b);");
27. System.out.println("max_num:" + maxNum);
28. } catch (Exception e) {
29. e.printStackTrace();
30. }
输出内容：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可选实现的接口。下面是个使用示例：
31.ScriptEngineManager manager = new ScriptEngineManager();
32. ScriptEngine engine = manager.getEngineByName("js");
33. try {
34. engine.eval("function max_num(a,b){return (a>b)?a:b;}");
35. Invocable invoke = (Invocable) engine;
36. Object maxNum = invoke.invokeFunction("max_num",4,6);
37. System.out.println(maxNum);
38. maxNum = invoke.invokeFunction("max_num", 7,6);
39. System.out.println(maxNum);
40. } catch (Exception e) {
41. // TODO: handle exception
42. }
上面的invokeFunction，第一个参数调用的脚本函数名，后面跟的可变参数是对应的脚本函数参数。
Invocable还有个很酷的功能，就是动态实现接口，它可以从脚本引擎中得到Java Interface 的实例；也就是说，可以定义个一个Java接口，其实现是由脚本完成。以上面的例子为例，定义接口JSLib，该接口中的函数和javascript中的函数签名保持一致：
1.public interface JSLib {
2. public int max_num(int a,int b);
3. }
调用示例：
4.ScriptEngineManager manager = new ScriptEngineManager();
5. ScriptEngine engine = manager.getEngineByName("js");
6. try {
7. engine.eval("function max_num(a,b){return (a>b)?a:b;}");
8. Invocable invoke = (Invocable) engine;
9. JSLib jslib = invoke.getInterface(JSLib.class);
10. int maxNum = jslib.max_num(4,6);
11. System.out.println(maxNum);
12. } catch (Exception e) {
13. // TODO: handle exception
14. }
5、使用Java对象
可以在javascript中使用Java代码，这确实是很酷的事情。在Rhino中，可以通过importClass导入一个类，也可以通过importPackage导入一个包，也可以直接使用全路经的类。在创建对象时，new也不是必须的。示例代码如下：
15.ScriptEngineManager manager = new ScriptEngineManager();
16. ScriptEngine engine = manager.getEngineByName("js");
17. try {
18. String script = "var list = java.util.ArrayList();list.add(\"kafka0102\");print(list.get(0));";
19. engine.eval(script);
20. } catch (Exception e) {
21. e.printStackTrace();
22. }
6、编译执行
脚本引擎默认是解释执行的，如果需要反复执行脚本，可以使用它的可选接口Compilable来编译执行脚本，以获得更好的性能，示例代码如下：
23.ScriptEngineManager manager = new ScriptEngineManager();
24. ScriptEngine engine = manager.getEngineByName("js");
25. try {
26. Compilable compEngine = (Compilable) engine;
27. CompiledScript script = compEngine.compile("function max_num(a,b){return (a>b)?a:b;}");
28. script.eval();
29. Invocable invoke = (Invocable) engine;
30. Object maxNum = invoke.invokeFunction("max_num",4,6);
31. System.out.println(maxNum);
32. } catch (Exception e) {
33. e.printStackTrace();
34. }
7、总结
除了上面提到的特性，脚本引擎还有一些不错的功能，比如可以执行脚本文件，可以由多线程异步执行脚本等功能。引入脚本引擎，可以对一些配置扩展和业务规则做更强大而灵活的支持，也方便使用者选择自己熟悉的脚本语言来编写业务规则等
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import javax.script.Bindings;
import javax.script.Invocable;
import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.swing.JFrame;
/**
*
* @author hadeslee
*/
publicclass Test {
publicstaticvoid main(String[] args)throws Exception {
//根据js的后缀名生成一个解析JS的脚本解析引擎
ScriptEngine engin=new ScriptEngineManager().getEngineByExtension("js");
//查询一下这个引擎是否实现了下面很实用的接口
System.out.println(engin instanceof Invocable);
//声明两个对象，传入到JS里面去
JFrame jf=new JFrame("test");
List list=new ArrayList();
//得到挷定的键值对象，把当前的两个JAVA对象放进去
Bindings bind=engin.createBindings();
bind.put("jf"，jf);
bind.put("list"，list);
//把挷下的键值对象放进去，作用域是当前引擎的范围
engin.setBindings(bind， ScriptContext.ENGINE_SCOPE);
//用引擎执行一段写在JS文件里面的代码
Object obj=engin.eval(new FileReader("test.js"));
//这个时候返回值当然 是null了
System.out.println(obj);
//把当前的引擎强制转为Invocable，这样就可以调用定义在JS文件里面的一个一个函数了
Invocable in=(Invocable)engin;
//得到了从JS里面返回来的对象
List l=(List)in.invokeFunction("getNames");
System.out.println(l);
//调用一下定义在JS里面的另一个函数
in.invokeFunction("testJS");
//最后调用一个函数，该函数可以使我们前面定义的窗体显示出来
in.invokeFunction("doSth");
}
}
下面是定义在test.js里面的内容
function doSth(){ jf.setSize(500，300); jf.setVisible(true); jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE); } function getNames(){ list.add("doSth"); list.add("getNames"); return list; } function testJS(){ print('Hello world!'); }
我们可以看到，在JAVA运行了以后，窗体会显示出来，并且我们可以接收到从JS解析引擎里面传回的数据，当然我们也可以调用一个很普通的JS函数，想象一下，如果我们把我们程序运行时的一些对象都设到Bindings里面去，那么我们JS岂不是有很大的自由度了吗?因为JS里面也可以操作我们的Java对象了，并且我们可以像ava编程一样的对JS编程了，还不用再编译，马上就可以运行.灵活性岂不是变得更高了吗?
