标签：util standard java方法 开源 define 状态 ide 多次 令行
译文出处： coyee 原文出处：docs.oracle
脚本语言的一些有用的特性是：
Java 脚本功能是在 javax.script 包中。这是一个比较小的，简单的API。脚本的出发点是 ScriptEngineManager 类。一个 ScriptEngineManager 对象可以通过jar文件的服务发现机制发现脚本引擎。它也可以实例化脚本引擎来解释使用特定的脚本语言编写的脚本。使用脚本编程接口的最简单的方法如下：
ScriptEngineManager 对象ScriptEngineManager 获取 ScriptEngine 对象ScriptEngine的eval方法执行脚本
从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中调用。同时，通过接口我们可以避免在很多地方使用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" }} |
Sun的JDK 6中包含了一个基于 Mozilla Rhino JavaScript 脚本引擎。 这个引擎是基于版本为1.6R2的Mozilla Rhino 。多数 Rhino 实现都被包含在内。少部分组件由于大小和安全原因被排除了:
|
1
2
3
4
|
var v = new java.lang.Runnable() { run: function() { print(‘hello‘); } }v.run(); |
在大多数情况下，JavaAdapter是采用匿名类语法来实现单接口。 使用JavaAdapter来扩展Java类或实现多接口并不常见。
在大多数情况下,访问Java类、对象和方法很简单。从JavaScript中访问属性和方法与同Java中一样。这里，我们突出JavaScript Java访问的重要方面.。更多的细节请阅读http://www.mozilla.org/rhino/scriptjava.html。下面是一些JavaScript访问Java的代码片段。本节需要一些JavaScript知识。如果你打算使用JSR-223中非JavaScript脚本语言，那么本节可以跳过。
内置的函数importPackage 和importClass 可以用于引入Java 包和类。
|
1
2
3
4
5
6
7
8
9
10
11
|
// Import Java packages and classes // like import package.*; in JavaimportPackage(java.awt);// like import java.awt.Frame in JavaimportClass(java.awt.Frame);// Create Java Objects by "new ClassName"var frame = new java.awt.Frame("hello");// Call Java public methods from scriptframe.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 importvar 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");} |
在JavaScript中,创建一个对象时与Java中一样，而创建Java数组时需要显式的使用Java反射。但一旦创建好后,访问其中的元素或获取大小就和Java中一样。 另外，也可以使用脚本数组用在Java方法中期望的Java数组(因为可以自动转换)。所以在大多数情况下我们不需要显式地创建Java数组。
|
1
2
3
4
5
6
|
// create Java String array of 5 elementsvar a = java.lang.reflect.Array.newInstance(java.lang.String, 5);// Accessing elements and length access is by usual Java syntaxa[0] = "scripting is great!";print(a.length); |
在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.Runnablevar 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 argumentvar 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 实现。
from: http://www.importnew.com/22675.html
标签：util standard java方法 开源 define 状态 ide 多次 令行
原文地址：http://www.cnblogs.com/GarfieldEr007/p/7050962.html
