運行第一個腳本程序
在使用Java SE 6運行腳本之前，必須要知道你的Java SE 6支持什麼腳本語言。在javax.script包中有很多的類，但這些類中最主要的是ScriptEngineManager。可以通過這個類得到當前 Java SE 6所支持的所有腳本。如下面例子將列出所有可以使用的腳本引擎工廠。
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 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 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 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 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 " );
String name = " abcdefg " ;
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.invokeFunction( " reverse " , name);
out .printf( " 翻轉後的字符串：%s " , o);
}
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 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方法。