現在Java SE 5已經發布，在明年Java SE 6也將發布。Java SE 6較Java SE5有了很大的改進，它的功能更強，而且是專為Vista所設計，這就意味著Java SE 6將是Vista上的最佳選擇。而Java SE 6所提供的最眾多的新功能必將成為它的最大賣點。
Java SE 6最引人注目的新功能之一就是內嵌了腳本支持。在默認情況下，Java SE 6只支持JavaScript，但這並不以為著Java SE 6只能支持Javascript。在Java SE 6中提供了一些接口來定義一個腳本規范，也就是JSR223。通過實現這些接口，Java SE 6可以支持任意的腳本語言（如PHP或Ruby）。
運行第一個腳本程序
在使用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了。
通過運行Java ListScriptEngines，將顯示如下信息
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, text/ecmascript]中的任何一個，可以將text/Javascript改成text/ecmascript。
根據名稱得到腳本引擎
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");
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.invoke("reverse", name);
out.printf("翻轉後的字符串：%s", name);
}
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方法。
