首页 > 代码库 > Java 脚本化编程指南
Java 脚本化编程指南
译文出处: coyee 原文出处:docs.oracle
Java脚本化API为谁准备?
脚本语言的一些有用的特性是:
- 方便:大多数脚本语言都是动态类型的。您通常可以创建新的变量,而不声明变量类型,并且您可以重用变量来存储不同类型的对象。此外,脚本语言往往会自动执行许多类型的转换,例如, 必要时 将数字10转换为“10”。
- 开发快速原型:您可以避免编辑编译运行周期,只使用“编辑运行”!
- 应用扩展/定制:你可以“具体化”的部分应用程序,例如一些配置脚本,业务逻辑/规则和财务应用中的数学表达式 。
- 为应用添加命令行模式,用于调试、运行时配置/部署时间。现在大多数应用程序都有一个基于Web的GUI配置工具。但是系统管理员/部署人员常常喜欢命令行工具。一个“标准”的脚本语言可以用来实现这个目的,而不是发明特设的脚本语言。
脚本包
Java 脚本功能是在 javax.script 包中。这是一个比较小的,简单的API。脚本的出发点是 ScriptEngineManager 类。一个 ScriptEngineManager 对象可以通过jar文件的服务发现机制发现脚本引擎。它也可以实例化脚本引擎来解释使用特定的脚本语言编写的脚本。使用脚本编程接口的最简单的方法如下:
- 创建一个
ScriptEngineManager
对象 - 从
ScriptEngineManager
获取ScriptEngine
对象 - 使用
ScriptEngine的eval方法执行脚本
实例
“Hello,World”
从ScriptEngineManager实例中,我们通过 getEngineByName
方法得到一个JavaScript引擎实例。通过脚本引擎的eval方法来执行给定的JavaScript代码。为简便起见,本例以及随后的例子中,我们不对异常进行处理。javax.script API有检查和运行时异常,你必须妥善处理异常。
1
2
3
4
5
6
7
8
9
10
11
|
import javax.script.*; public class EvalScript { public static void main(String[] args) throws Exception { // create a script engine manager ScriptEngineManager factory = new ScriptEngineManager(); // create a JavaScript engine ScriptEngine engine = factory.getEngineByName( "JavaScript" ); // evaluate JavaScript code from String engine.eval( "print(‘Hello, World‘)" ); } } |
执行一个脚本文件
在这个例子中,我们调用eval方法来接收java.io.Reader作为输入源。读入的脚本被执行。这种方式能够成文件执行脚本,用相关的输入流对象读取URL和资源。
1
2
3
4
5
6
7
8
9
10
11
|
import javax.script.*; public class EvalFile { public static void main(String[] args) throws Exception { // create a script engine manager ScriptEngineManager factory = new ScriptEngineManager(); // create JavaScript engine ScriptEngine engine = factory.getEngineByName( "JavaScript" ); // evaluate JavaScript code from given file - specified by first argument engine.eval( new java.io.FileReader(args[ 0 ])); } } |
1
|
println( "This is hello from test.js" ); |
1
|
java EvalFile test.js |
脚本变量
当你的java应用程序嵌入脚本引擎和脚本,你可能希望将您的应用程序对象为全局变量暴露于脚本中。这个例子演示了如何将您的应用程序对象作为全局变量暴露于脚本中。我们在应用程序中创建一个 java.io.File对象作为全局变量,名称是file。该脚本可以访问变量,例如,它可以调用它的公共方法。注意访问java对象、领域和方法的语法依赖于脚本语言。JavaScript支持最“自然”的类似java的语法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class ScriptVars { public static void main(String[] args) throws Exception { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName( "JavaScript" ); File f = new File( "test.txt" ); // expose File object as variable to script engine.put( "file" , f); // evaluate a script string. The script accesses "file" // variable and calls method on it engine.eval( "print(file.getAbsolutePath())" ); } } |
调用脚本函数和方法
有些时候,你可能需要多次调用一个特定脚本函数,例如你的应用程序菜单功能可能由脚本来实现。在菜单中的操作事件处理程序中,可能需要调用一个特定的脚本函数。下面的示例演示在Java代码调用一个特定的脚本。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import javax.script.*; public class InvokeScriptFunction { public static void main(String[] args) throws Exception { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName( "JavaScript" ); // JavaScript code in a String String script = "function hello(name) { print(‘Hello, ‘ + name); }" ; // evaluate script engine.eval(script); // javax.script.Invocable is an optional interface. // Check whether your script engine implements or not! // Note that the JavaScript engine implements Invocable interface. Invocable inv = (Invocable) engine; // invoke the global function named "hello" inv.invokeFunction( "hello" , "Scripting!!" ); } } |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import javax.script.*; public class InvokeScriptMethod { public static void main(String[] args) throws Exception { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName( "JavaScript" ); // JavaScript code in a String. This code defines a script object ‘obj‘ // with one method called ‘hello‘. String script = "var obj = new Object(); obj.hello = function(name) { print(‘Hello, ‘ + name); }" ; // evaluate script engine.eval(script); // javax.script.Invocable is an optional interface. // Check whether your script engine implements or not! // Note that the JavaScript engine implements Invocable interface. Invocable inv = (Invocable) engine; // get script object on which we want to call the method Object obj = engine.get( "obj" ); // invoke the method named "hello" on the script object "obj" inv.invokeMethod(obj, "hello" , "Script Method !!" ); } } |
通过脚本实现Java接口
有些时候通过脚本函数或者方法可以很方便的实现java接口,而不是在Java中调用。同时,通过接口我们可以避免在很多地方使用javax.script API接口。我们可以得到一个接口实现者对象并将其传递给不同的Java api。下面的例子演示了通过脚本实现 java.lang.Runnable接口。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import javax.script.*; public class RunnableImpl { public static void main(String[] args) throws Exception { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName( "JavaScript" ); // JavaScript code in a String String script = "function run() { println(‘run called‘); }" ; // evaluate script engine.eval(script); Invocable inv = (Invocable) engine; // get Runnable interface object from engine. This interface methods // are implemented by script functions with the matching name. Runnable r = inv.getInterface(Runnable. class ); // start a new thread that runs the script implemented // runnable interface Thread th = new Thread(r); th.start(); } } |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
import javax.script.*; public class RunnableImplObject { public static void main(String[] args) throws Exception { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName( "JavaScript" ); // JavaScript code in a String String script = "var obj = new Object(); obj.run = function() { println(‘run method called‘); }" ; // evaluate script engine.eval(script); // get script object on which we want to implement the interface with Object obj = engine.get( "obj" ); Invocable inv = (Invocable) engine; // get Runnable interface object from engine. This interface methods // are implemented by script methods of object ‘obj‘ Runnable r = inv.getInterface(obj, Runnable. class ); // start a new thread that runs the script implemented // runnable interface Thread th = new Thread(r); th.start(); } } |
脚本的多作用域
在 script variables 例子中,我们看到怎样将应用对象暴露为脚本的全局变量。它有可能暴露为多个全局的作用域 。 单作用域是javax.script.Bindings的实例中
. 这个借口派生至java.util.Map<String, Object>。
scope 键值对的集合,其中键为非空、非空字符串。 多scopes 是 javax.script.ScriptContext
接口支持的。支持一个或多个脚本上下文与相关的域绑定。默认情况下, 每一个脚本引擎都有一个默认的脚本上下文。 默认的脚本上下文有至少一个域叫 ”ENGINE_SCOPE”。不同域的脚本上下文支持可以通过 getscopes 方法获取。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
import javax.script.*; public class MultiScopes { public static void main(String[] args) throws Exception { ScriptEngineManager manager = new ScriptEngineManager(); ScriptEngine engine = manager.getEngineByName( "JavaScript" ); engine.put( "x" , "hello" ); // print global variable "x" engine.eval( "println(x);" ); // the above line prints "hello" // Now, pass a different script context ScriptContext newContext = new SimpleScriptContext(); Bindings engineScope = newContext.getBindings(ScriptContext.ENGINE_SCOPE); // add new variable "x" to the new engineScope engineScope.put( "x" , "world" ); // execute the same script - but this time pass a different script context engine.eval( "println(x);" , newContext); // the above line prints "world" } } |
JavaScript 脚本引擎
Sun的JDK 6中包含了一个基于 Mozilla Rhino JavaScript 脚本引擎。 这个引擎是基于版本为1.6R2的Mozilla Rhino 。多数 Rhino 实现都被包含在内。少部分组件由于大小和安全原因被排除了:
- JavaScript转字节码编译 (也称 ”优化器”).。此功能依赖一个类生成库。 去掉本功能意味着:JavaScript是解释执行,且不影响脚本执行,因为优化器是透明的。
- Rhino的JavaAdapter 也被去掉了。 JavaAdapter是一个JavaScript可扩展Java类和JavaScript可实现Java接口功能。此功能也是需要类生成库的。我们把Rhino的JavaAdapter替换为Sun实现的JavaAdapter。在Sun的实现中,仅仅实现了JavaScript对象可实现Java单接口功能。例如,下面的代码会正确执行。
1234
var
v =
new
java.lang.Runnable() {
run:
function
() { print(
‘hello‘
); }
}
v.run();
在大多数情况下,JavaAdapter是采用匿名类语法来实现单接口。 使用JavaAdapter来扩展Java类或实现多接口并不常见。
- E4X (ECMAScript for XML – ECMA Standard 357) 被去掉了. 使用XML JavaScript代码会产生一个语法错误. 请注意,E4X支持ECMAScript标准是可选的-省略E4X的实现是被支持也是兼容 ECMAScript 。
- Rhino的命令行工具 (Rhino shell, debugger 等) 没有被包含在内。但你可以用使用 jrunscript来代替。
JavaScript与Java的通信
在大多数情况下,访问Java类、对象和方法很简单。从JavaScript中访问属性和方法与同Java中一样。这里,我们突出JavaScript Java访问的重要方面.。更多的细节请阅读http://www.mozilla.org/rhino/scriptjava.html。下面是一些JavaScript访问Java的代码片段。本节需要一些JavaScript知识。如果你打算使用JSR-223中非JavaScript脚本语言,那么本节可以跳过。
引入Java 包, 类
内置的函数importPackage
和importClass
可以用于引入Java 包和类。
1
2
3
4
5
6
7
8
9
10
11
|
// Import Java packages and classes // like import package.*; in Java importPackage(java.awt); // like import java.awt.Frame in Java importClass(java.awt.Frame); // Create Java Objects by "new ClassName" var frame = new java.awt.Frame( "hello" ); // Call Java public methods from script frame.setVisible( true ); // Access "JavaBean" properties like "fields" print(frame.title); |
Packages.java.util.Vector
, Packages.javax.swing.JFrame
. 请注意: ”java” 是 “Packages.java”的快捷引用。还有一些等价的快捷引用前缀 : javax, org, edu, com, net, 所以几乎所有的 JDK 平台下的类都可以不使用”Packages” 前缀而访问到。importPackage
和importClass
函数”污染” 了JavaScript中的全局变量。为了避免这种情况,你可以使用JavaImporter。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// create JavaImporter with specific packages and classes to import var SwingGui = new JavaImporter(javax.swing, javax.swing.event, javax.swing.border, java.awt.event); with (SwingGui) { // within this ‘with‘ statement, we can access Swing and AWT // classes by unqualified (simple) names. var mybutton = new JButton( "test" ); var myframe = new JFrame( "test" ); } |
C创建和使用Java的数组
在JavaScript中,创建一个对象时与Java中一样,而创建Java数组时需要显式的使用Java反射。但一旦创建好后,访问其中的元素或获取大小就和Java中一样。 另外,也可以使用脚本数组用在Java方法中期望的Java数组(因为可以自动转换)。所以在大多数情况下我们不需要显式地创建Java数组。
1
2
3
4
5
6
|
// create Java String array of 5 elements var a = java.lang.reflect.Array.newInstance(java.lang.String, 5); // Accessing elements and length access is by usual Java syntax a[0] = "scripting is great!" ; print(a.length); |
实现Java 接口
在JavaScript中,可以使用Java匿名类语法形式实现Java中接口:
1
2
3
4
5
6
7
8
9
|
var r = new java.lang.Runnable() { run: function () { print( "running...\n" ); } }; // "r" can be passed to Java methods that expect java.lang.Runnable var th = new java.lang.Thread(r); th.start(); |
1
2
3
4
5
6
7
|
function func() { print( "I am func!" ); } // pass script function for java.lang.Runnable argument var th = new java.lang.Thread(func); th.start(); |
重载
Java方法是使用参数类型重载的。在Java中,重载发生在编译阶段 (执行 javac)。当脚本中调用Java方法时,脚本的翻译器或编译器需要选择适当的方法。对于JavaScript引擎,您不需要做任何特别的——正确的Java方法重载变体是根据参数类型选择的。 但有时,您可能希望(或有)显式地选择一个特定的过载变体。
1
2
3
4
|
var out = java.lang.System.out; // select a particular println function out[ "println(java.lang.Object)" ]( "hello" ); |
自定义脚本引擎
我们不会覆盖的JSR-223兼容脚本引擎实现细节. 至少, 您需要实现javax.script.ScriptEngine
和javax.script.ScriptEngineFactory
接口。 抽象类javax.script.AbstractScriptEngine
提供了一些ScriptEngine
接口中定义的方法。
在开始实现 JSR-223 引擎之前,您可能需要下载 http://scripting.dev.java.net 工程。这个工程维护了一些流行的开源脚本语言的 JSR-223 实现。
引用
- JSR-223 Scripting for the Java Platform
- JavaScript Developer Connection
- Java Method Overloading and LiveConnect 3
- Rhino:JavaScript for Java
- Scripting Java (from JavaScript)
- scripting.dev.java.net project
from: http://www.importnew.com/22675.html
Java 脚本化编程指南