1、下載Rhino安裝包，下載地址：官網http://www.mozilla.org/rhino。

2、rhino環境配置，把解壓出來的js.jar文件加入到系統的環境變量classpath

3、在命令提示符窗口下，調用javascript引擎，如：java org.mozilla.javascript.tools.shell.Main，即可進入js shell.

4、將javascript代碼文件加載到引擎的內存緩沖區中，如：

load("C:/ws/job/vqq1.0/WebRoot/js/mergeJsFile.js");

5、執行合并操作，會一些相關js文件合并到一個js文件中，以減少瀏覽器對服務器端發出的http請求，提高性能問題。

如：runMerge(parameter1,parameter2, .., ...)

6、為了加快js文件運行的速度，可以把它編譯為class文件,

compile:

java org.mozilla.javascript.tools.jsc.Main C:/ws/job/vqq1.0/WebRoot/js/mergeJsFile.js

編譯產生mergeJsFile.class文件,然后直接執行class文件，java mergeJsFile.

Rhino的特點如下：

JavaScript 1.5的全部特性

◆ 允許使用腳本直接操作Java

◆ 提供JavaScript Shell執行其它JavaScript腳本

◆ 提供JavaScript編譯器將JavaScript源程序轉換成Java類文件

Rhino語言特點

Java是一種面對對象的編譯型語言。它首先將源代碼編譯成二進制字節碼(bytecode)，然后依賴各種不同平臺上的虛擬機來解釋執行字節碼，從而實現了“一次編譯、到處執行”的跨平臺特性。

JavaScript是一種動態、弱類型、基于原型的客戶端腳本語言。JavaScript 包括一個基于對象的 API，稱為文檔對象模型(Document Object Model)或 DOM，用以訪問和操作 Web 頁面的內容，給HTML網頁添加動態功能。

Rhino是一個介于Java與JavaScript之間的語言。它的基礎是 Java 語言，這使得它簡單易學，但相比于JavaScript腳本語言來說，它又太過復雜。不過，Rhino 的主要缺點也正是它的強大之處，Rhino 是一種輕量級的、功能強大的腳本語言。Rhino 使用原型而不是類，這使它比很多腳本語言更適合開發 GUI 應用程序，在考慮性能和風格等因素時更是如此。

Rhino語言特點的優缺點

一方面，作為一種動態類型的、基于原型的腳本語言，Rhino借用了很多JavaScript語法。比如，Rhino不再使用語句結束符( ; )，放寬了變量聲明規則，并且極大地簡化了修改和檢索對象屬性的語法。另一方面，作為JavaScript 的Java實現，Rhino語法非常類似于Java編程語言。比如，Rhino采用了與 Java 編程語言相似的循環和條件結構，并且遵循類似的語法模式來表示這些結構。

Rhino 和 Java 語言之間有一些顯著的區別。Rhino 是一種基于原型的(prototype-based)語言，而不是一種基于類的(class-based)語言。Rhino中，函數和變量的聲明中看不到 類型，取而代之的是，使用 function關鍵字聲明函數，使用 var關鍵字聲明局部變量。

Rhino的原始想法是將JavaScript 編譯成Java字節碼執行，即采用編譯執行的方式。由于JVM存在垃圾收集、編譯和裝載過程的開銷過大等限制，Rhino采用了解釋執行的方式。

Rhino支持的腳本語言

在可以找到官方的腳本引擎的實現項目。這一項目基于BSD License ，表示這些腳本引擎的使用將十分自由。目前該項目已對包括 Groovy, JavaScript, Python, Ruby, PHP 在內的二十多種腳本語言提供了支持。這一支持列表還將不斷擴大。

在 Mustang 中對腳本引擎的檢索使用了工廠模式。首先需要實例化一個工廠 —— ScriptEngineManager。

// create a script engine manager

ScriptEngineManager factory = new ScriptEngineManager();

ScriptEngineManager 將在 Thread Context ClassLoader 的 Classpath 中根據 jar 文件的 META-INF 來查找可用的腳本引擎。它提供了 3 種方法來檢索腳本引擎：

// create engine by name

ScriptEngine engine = factory.getEngineByName ("JavaScript");

// create engine by name

ScriptEngine engine = factory.getEngineByExtension ("js");

// create engine by name

ScriptEngine engine = factory.getEngineByMimeType ("application/javascript");

下面的代碼將會打印出當前的 JDK 所支持的所有腳本引擎

ScriptEngineManager factory = new ScriptEngineManager();

for (ScriptEngineFactory available : factory.getEngineFactories()) {

System.out.println(available.getEngineName());

}

JavaScript操縱Java對象

1. Rhino如何訪問Java包與類文件

Java語法規定，任何代碼都必須以class文件的形式存在，而每個class文件必須屬于一個package，默認為default。而JavaScript并沒有類似package的層級結構概念，那么如何使用Rhino訪問Java包呢?

Rhino定義了一個top-level變量Packages。變量Packages對應的所有屬性均對應Java包名。比如，我們需要訪問某一個Java的Package com.example，輸入如下：

js> Packages.com.example

剛才演示了如何通過js shell訪問Java包，訪問Java類的方式類似。假如我們需要訪問標準的Java 文件類java.io.File，如下。

js> java.io.File

或者，為避免輸入全名，我們先導入包，然后輸入Class類名，如下：

js> importPackage(java.io)

js>File

這里的importPackage(java.io)，在效果上等價于Java聲明import java.io.*; 不同的是，Java會隱式import java.lang.*，而Rhino不會。因為Rhino定義的對象Boolean, Math, Number, Object, String等與Java語法完全不同，兩者無法等價。

2. Rhino如何與Java對象交互

與Java類似，Rhino使用new操作符創建對象。

js> new java.util.Date()

Thu May 06 16:19:04 CST 2011

可以使用JavaScript變量存儲Java對象，并調用其方法，如下：

js> f = new java.io.File("sample.txt")

sample.txt

js> f.isDirectory()

false

對于static方法與變量，調用如下：

js> java.lang.Math.PI

3.141592653589793

js> java.lang.Math.cos(0)

1

在JavaScript中，方法本身就是對象，這一點與Java不同。我們可以通過下列方式查看方法的重載：

js> f.listFiles

function listFiles() {/*

java.io.File[] listFiles()

java.io.File[] listFiles(java.io.FilenameFilter)

java.io.File[] listFiles(java.io.FileFilter)

*/}

輸出中列出三個重載方法。第一個為無參函數，第二與第三個對應的參數分別為FilenameFilter與FileFilter。

另一個比較有意思的特點是通過構造for..in，查看對象對應的所有方法與變量。如下：

js> for (i in f) { print(i) }

屏幕輸出為：

exists

parentFile

mkdir

toString

wait

[44 others]

這里列出的方法一部分來自于父類，比如wait來自父類java.lang.Object。

對于JavaBean，Rhino也提供按名字訪問的簡單方式。比如，通過下面這種方式，我們就可以調用File對象的getName與isDirectory方法：

js> f.name

test.txt

js> f.directory

false

3. Rhino如何實現Java接口

JavaScript當中，方法本身就是對象。下面我們通過JavaScript語法{propertyName: value}聲明一個JavaScript方法，并調用該方法如下：

js> obj = { run: function () { print("\nrunning"); } }

[object Object]

js> obj.run()

running

現在我們構造一個JavaScript對象，實現Runnable接口。并將該對象作為參數，構造一個新的線程，并啟動該線程。

js> r = new java.lang.Runnable(obj);

adapter1@291aff

js> t = new java.lang.Thread(r)

Thread[Thread-0,5,main]

js> t.start()

js>

running

最后的js>提示符與新線程的打印輸出running的先后順序是隨機的，取決于線程的調度策略。

從后端的處理流程來講，Rhino首先為Runnable接口的實現類生成Java字節碼文件。然后調用JavaScript對象定義的Run方法。

4. Rhino如何創建Java 數組

Rhino使用Java的發射機制生成數組。下面是生成2個String對象的代碼：

js> array = java.lang.reflect.Array.newInstance(java.lang.String, 2);

[Ljava.lang.String;@a20892

js> array[0] = "Double"

Double

js> array[1] = "Life"

Life

js> array[0] + array[1]

DoubleLife

js>

5. Rhino如何捕獲與處理異常

與Java類似，Rhino使用try...catch關鍵字處理異常。

js> function classForName(name) {

try {

return java.lang.Class.forName(name);

} catch (e if e.javaException instanceof java.lang.ClassNotFoundException) {

print("Class " + name + " not found");

} catch (e if e.javaException instanceof java.lang.NullPointerException) {

print("Class name is null");

}

}

js> classForName("NonExistingClass");

Class NonExistingClass not found

js> classForName(null);

Class name is null

6. Rhino如何調用js文件

當然，除了在命令行的方式，我們還可以使用操縱JavaScript文件。下面是一段JavaScript代碼，主要目的是判斷該數是否為質數。代碼如下：

function isPrime (num)

{

if (num <= 1) {

print("Enter an integer no less than 2.")

return false

}

var prime = true

var sqrRoot = Math.round(Math.sqrt(num))

for (var n = 2; prime & n <= sqrRoot; ++n) {

prime = (num % n != 0)

}

return prime

}

我們保存文件為C:\isPrime.js。然后我們需要調用load方法加載該腳本。最后，我們可以調用isPrime方法來判斷是否為質數。

js> load("C:/isPrime.js")

js> isPrime(33);

false

js> isPrime(31)

true

需要注意的是，注意：文件分隔符需要調整，是“/”而不是“\”。

剛才使用JavaScript操縱Java對象。接下來我們看看如何使用Java程序訪問JavaScript

Java對象操縱JavaScript

下面是一段Java代碼，用來運行數學表達式。代碼如下：

package com.example;

import sun.org.mozilla.javascript.internal.Context;

import sun.org.mozilla.javascript.internal.Scriptable;

publicclass Test {

publicstaticvoid main(String[] args) {

Context cx = Context.enter();

try {

Scriptable scope = cx.initStandardObjects();

String str = "3/(1+2)";

Object result = cx.evaluateString(scope, str, null, 1, null);

System.out.println(str + "=" + Context.toNumber(result));

} finally {

Context.exit();

}

}

}

運行Java com.example.Test，輸出結果如下：

3/(1+2)=1.0

之所以是1.0而不是1，是因為Context.toNumber(result)返回的類型為double。

另一個值得注意的是，這里import的package屬于JDK 6.0。

因此，在不需要Rhino提供的js.jar，該程序仍能獨立運行。因為rhino已經是jdk 6.0 的正規軍了，即是它的一部分。

A Java program for running JavaScript scripts

import javax.script.*; import java.io.*; // Evaluate a file of JavaScript and print its result public class RunScript { public static void main(String[] args) throws IOException { // Obtain an interpreter or "ScriptEngine" to run the script. ScriptEngineManager scriptManager = new ScriptEngineManager( ); ScriptEngine js = scriptManager.getEngineByExtension("js"); // The script file we are going to run String filename = null; // A Bindings object is a symbol table for or namespace for the // script engine. It associates names and values and makes // them available to the script. Bindings bindings = js.createBindings( ); // Process the arguments. They may include any number of // -Dname=value arguments, which define variables for the script. // Any argument that does not begin with -D is taken as a filename for(int i = 0; i < args.length; i++) { String arg = args[i]; if (arg.startsWith("-D")) { int pos = arg.indexOf('='); if (pos == -1) usage( ); String name = arg.substring(2, pos); String value = arg.substring(pos+1); // Note that all the variables we define are strings. // Scripts can convert them to other types if necessary. // We could also pass a java.lang.Number, a java.lang.Boolean // or any Java object or null. bindings.put(name, value); } else { if (filename != null) usage( ); // only one file please filename = arg; } } // Make sure we got a file out of the arguments. if (filename == null) usage( ); // Add one more binding using a special reserved variable name // to tell the script engine the name of the file it will be executing. // This allows it to provide better error messages. bindings.put(ScriptEngine.FILENAME, filename); // Get a stream to read the script. Reader in = new FileReader(filename); try { // Evaluate the script using the bindings and get its result. Object result = js.eval(in, bindings); // Display the result. System.out.println(result); } catch(ScriptException ex) { // Or display an error message. System.out.println(ex); } } static void usage( ) { System.err.println( "Usage: java RunScript [-Dname=value...] script.js"); System.exit(1); } }

A Java configuration file utility that interprets JavaScript expressions

import javax.script.*; import java.util.*; import java.io.*; /** * This class is like java.util.Properties but allows property values to * be determined by evaluating JavaScript expressions. */ public class Configuration { // Here is where we store name/value pairs of defaults. Map defaults = new HashMap( ); // Accessors for getting and setting values in the map public Object get(String key) { return defaults.get(key); } public void put(String key, Object value) { defaults.put(key, value); } // Initialize the contents of the Map from a file of name/value pairs. // If a value is enclosed in curly braces, evaluate it as JavaScript. public void load(String filename) throws IOException, ScriptException { // Get a JavaScript interpreter. ScriptEngineManager manager = new ScriptEngineManager( ); ScriptEngine engine = manager.getEngineByExtension("js"); // Use our own name/value pairs as JavaScript variables. Bindings bindings = new SimpleBindings(defaults); // Create a context for evaluating scripts. ScriptContext context = new SimpleScriptContext( ); // Set those Bindings in the Context so that they are readable // by the scripts but so that variables defined by the scripts do // not get placed into our Map object. context.setBindings(bindings, ScriptContext.GLOBAL_SCOPE); BufferedReader in = new BufferedReader(new FileReader(filename)); String line; while((line = in.readLine( )) != null) { line = line.trim( ); // strip leading and trailing space if (line.length( ) == 0) continue; // skip blank lines if (line.charAt(0) == '#') continue; // skip comments int pos = line.indexOf(":"); if (pos == -1) throw new IllegalArgumentException("syntax: " + line); String name = line.substring(0, pos).trim( ); String value = line.substring(pos+1).trim( ); char firstchar = value.charAt(0); int len = value.length( ); char lastchar = value.charAt(len-1); if (firstchar == '"' && lastchar == '"') { // Double-quoted quoted values are strings defaults.put(name, value.substring(1, len-1)); } else if (Character.isDigit(firstchar)) { // If it begins with a number, try to parse a number try { double d = Double.parseDouble(value); defaults.put(name, d); } catch(NumberFormatException e) { // Oops. Not a number. Store as a string defaults.put(name, value); } } else if (value.equals("true")) // handle boolean values defaults.put(name, Boolean.TRUE); else if (value.equals("false")) defaults.put(name, Boolean.FALSE); else if (value.equals("null")) defaults.put(name, null); else if (firstchar == '{' && lastchar == '}') { // If the value is in curly braces, evaluate as JavaScript code String script = value.substring(1, len-1); Object result = engine.eval(script, context); defaults.put(name, result); } else { // In the default case, just store the value as a string. defaults.put(name, value); } } } // A simple test program for the class public static void main(String[] args) throws IOException, ScriptException { Configuration defaults = new Configuration( ); defaults.load(args[0]); Set> entryset = defaults.defaults.entrySet( ); for(Map.Entry entry : entryset) { System.out.printf("%s: %s%n", entry.getKey( ), entry.getValue( )); } } }

Compiling Scripts

// This is the text of the script we want to compile. String scripttext = "x * x"; // Get the script engine. ScriptEngineManager scriptManager = new ScriptEngineManager( ); ScriptEngine js = scriptManager.getEngineByExtension("js"); // Cast it to the Compilable interface to get compilation functionality. Compilable compiler = (Compilable)js; // Compile the script to a form that we can execute repeatedly. CompiledScript script = compiler.compile(scripttext); // Now execute the script five times, using a different value for the // variable x each time. Bindings bindings = js.createBindings( ); for(int i = 0; i < 5; i++) { bindings.put("x", i); Object result = script.eval(bindings); System.out.printf("f(%d) = %s%n", i, result); }

Invoking JavaScript Functions

// Obtain an interpreter or "ScriptEngine" to run the script ScriptEngineManager scriptManager = new ScriptEngineManager( ); ScriptEngine js = scriptManager.getEngineByExtension("js"); // Evaluate the script. We discard the result since we only // care about the function definition. js.eval("function f(x) { return x*x; }"); // Now, invoke a function defined by the script. try { // Cast the ScriptEngine to the Invokable interface to // access its invocation functionality. Invocable invocable = (Invocable) js; for(int i = 0; i < 5; i++) { Object result = invocable.invoke("f", i); // Compute f(i) System.out.printf("f(%d) = %s%n", i, result); // Print result } } catch(NoSuchMethodException e) { // This happens if the script did not define a function named "f". System.out.println(e); }

Implementing a Java interface with JavaScript code

import javax.script.*; import java.io.*; import java.awt.event.*; import javax.swing.*; public class Keys { public static void main(String[] args) throws ScriptException, IOException { // Obtain an interpreter or "ScriptEngine" to run the script. ScriptEngineManager scriptManager = new ScriptEngineManager( ); ScriptEngine js = scriptManager.getEngineByExtension("js"); // Evaluate the script. We discard the result since we only // care about the function definitions in it. js.eval(new FileReader("listener.js")); // Cast to Invocable and get an object that implements KeyListener. Invocable invocable = (Invocable) js; KeyListener listener = invocable.getInterface(KeyListener.class); // Now use that KeyListener in a very simple GUI. JFrame frame = new JFrame("Keys Demo"); frame.addKeyListener(listener); frame.setSize(200, 200); frame.setVisible(true); } }

Implementing an interface in JavaScript simply means defining a function with the same name as each method defined by the interface. Here, for example, is a simple script that implements?KeyListener:

function keyPressed(e) {

print("key pressed: " + String.fromCharCode(e.getKeyChar( )));

}

function keyReleased(e) {

/* do nothing */

}

function keyTyped(e) {

/* do nothing */

}

Note that the JavaScript?keyPressed( )?method defined here accepts ajava.awt.event.KeyEvent?object as its argument and actually invokes a method on that Java object. The next section explains how this is done.

總結

以上是生活随笔為你收集整理的rhino java api demo_javascript与java的相互调用，纯java的javascript引擎rhino(转载)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。