JavaScript EE

[复制链接]
查看11 | 回复9 | 2007-1-24 12:56:49 | 显示全部楼层 |阅读模式
Typical Ajax applications use JavaScript on the client side and a different language, such as Java, on the server side. As a result, developers must implement some of their routines twice, using JavaScript for the Web browser and another language for the server. This double-coding issue can be avoided by using JavaScript combined with Java code on the server side, getting full support of scripting languages through the javax.script API. In addition, the Java SE Development Kit (JDK) 6 already includes Mozilla's Rhino JavaScript engine, which means no setup is required.
In this first article of the series, you will use a simple script runner that lets you execute JavaScript files within a Java EE application. Scripts will have access to the so-called "implicit objects" that are used in JSP pages, such as application, session, request, and response. Most of the samples consist of reusable code so that you can easily start using JavaScript on the server in your own applications.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
Using the javax.script API
This section provides an overview of the javax.script API. You will learn how to execute scripts that access Java objects, invoke JavaScript functions from your Java code, and implement a caching mechanism for the compiled scripts.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
Executing scripts
The javax.script API is very simple. You start by creating a ScriptEngineManager instance, which lets you obtain a ScriptEngine object (see Listing 1), using one of the following methods:
* getEngineByName()
* getEngineByExtension()
* getEngineByMimeType()

Listing 1. Getting a ScriptEngine instance
import javax.script.*;
...
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
...
engine.eval(...);

You can also obtain the list of available script engines with getEngineFactories(). Currently, only the JavaScript engine is bundled with JDK 6, but ScriptEngineManager implements a discovery mechanism for third-party engines that support JSR-223 Scripting for the Java Platform (see Resources). You just have to place the JAR files of the script engines in your CLASSPATH.
After you get the javax.script.ScriptEngine instance, you can call eval() to execute scripts. You can also export Java objects as script variables, passing a Bindings instance to the eval() method. Listing 2 contains the ScriptDemo.java example, which exports two variables named demoVar and strBuf, executes a script named DemoScript.js, and then gets the variables to output their modified values.
Listing 2. The ScriptDemo.java example
package jsee.demo;
import javax.script.*;
import java.io.*;
public class ScriptDemo {
public static void main(String args[]) throws Exception {
// Get the JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
// Set JavaScript variables
Bindings vars = new SimpleBindings();
vars.put("demoVar", "value set in ScriptDemo.java");
vars.put("strBuf", new StringBuffer("string buffer"));

// Run DemoScript.js
Reader scriptReader = new InputStreamReader(

ScriptDemo.class.getResourceAsStream("DemoScript.js"));
try {

engine.eval(scriptReader, vars);
} finally {

scriptReader.close();
}

// Get JavaScript variables
Object demoVar = vars.get("demoVar");
System.out.println("[Java] demoVar: " + demoVar);
System.out.println("Java object: " + demoVar.getClass().getName());
System.out.println();
Object strBuf = vars.get("strBuf");
System.out.println("[Java] strBuf: " + strBuf);
System.out.println("Java object: " + strBuf.getClass().getName());
System.out.println();
Object newVar = vars.get("newVar");
System.out.println("[Java] newVar: " + newVar);
System.out.println("Java object: " + newVar.getClass().getName());
System.out.println();
}

}

The DemoScript.js file (shown in Listing 3) contains a function named printType(), which is used to output the type of each script variable. The example calls the append() method of the strBuf object, modifies the value of demoVar, and sets a new script variable named newVar.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
If the object passed to printType() has a getClass() method, it must be a Java object whose class name is obtained with obj.getClass().name. This JavaScript expression calls the getName() method of the object's java.lang.Class instance. If the object doesn't have a getClass member, printType()calls the toSource() method, which all JavaScript objects must have.
Listing 3. The DemoScript.js example
println("Start script \r\n");
// Output the type of an object
function printType(obj) {
if (obj.getClass)
println("Java object: " + obj.getClass().name);
else
println("JS object: " + obj.toSource());
println("");
}
// Print variable
println("[JS] demoVar: " + demoVar);
printType(demoVar);
// Call method of Java object
strBuf.append(" used in DemoScript.js");
println("[JS] strBuf: " + strBuf);
printType(strBuf);
// Modify variable
demoVar = "value set in DemoScript.js";
println("[JS] demoVar: " + demoVar);
printType(demoVar);
// Set a new variable
var newVar = { x: 1, y: { u: 2, v: 3 } }
println("[JS] newVar: " + newVar);
printType(newVar);
println("End script \r\n");

Listing 4 contains the output of the ScriptDemo.java example. The first thing you'll notice is that demoVar is exported as a JavaScript String while the type of strBuf remains java.lang.StringBuffer. Primitive variables and Java strings are exported as native JavaScript objects. Any other Java objects (including arrays) are exported unaltered.
Listing 4. The output of ScriptDemo.java
Start script
[JS] demoVar: value set in ScriptDemo.java
JS object: (new String("value set in ScriptDemo.java"))
[JS] strBuf: string buffer used in DemoScript.js
Java object: java.lang.StringBuffer
[JS] demoVar: value set in DemoScript.js
JS object: (new String("value set in DemoScript.js"))
[JS] newVar: [object Object]
JS object: ({x:1, y:{u:2, v:3}})
End script
[Java] demoVar: value set in DemoScript.js
Java object: java.lang.String
[Java] strBuf: string buffer used in DemoScript.js
Java object: java.lang.StringBuffer
[Java] newVar: [object Object]
Java object: sun.org.mozilla.javascript.internal.NativeObject

After running the script, the engine takes all variables (including new ones) and performs the inverse conversion, turning JavaScript primitives and strings into Java objects. Other JavaScript objects are wrapped into Java objects, which use some engine-specific internal API, such as sun.org.mozilla.javascript.internal.NativeObject.
Because you probably want to use only standard APIs, all data exchange between the Java code and the executed script should be done through primitive variables, strings, and Java objects (for example, beans) whose properties and methods can be accessed very easily in the JavaScript code. Simply said, don't try to access native JavaScript objects in your Java code. Use Java objects in the JavaScript code instead.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
Invoking functions
In the previous example, you've seen that it is possible to call Java methods from JavaScript. Now you'll learn how to invoke JavaScript functions from your Java code. First of all, you must execute the script containing the function that you want to call. Then, you'll cast the ScriptEngine instance to javax.script.Invocable, which provides invokeFunction() and invokeMethod(). If your script implements all the methods of a Java interface, you can also use getInterface() to obtain a Java object whose methods are coded in the scripting language.
The InvDemo.java example (shown in Listing 5) executes a script named InvScript.js, which contains the demoFunction() routine. After casting the ScriptEngine instance to Invocable, the Java example passes the function name and the parameters to the engine's invokeFunction() method, which returns the value returned by demoFunction().
Listing 5. The InvDemo.java example
package jsee.demo;
import javax.script.*;
import java.io.*;
public class InvDemo {
public static void main(String args[]) throws Exception {
// Get the JavaScript engine
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

// Run InvScript.js
Reader scriptReader = new InputStreamReader(

InvDemo.class.getResourceAsStream("InvScript.js"));
try {

engine.eval(scriptReader);
} finally {

scriptReader.close();
}

// Invoke a JavaScript function
if (engine instanceof Invocable) {

Invocable invEngine = (Invocable) engine;

Object result = invEngine.invokeFunction("demoFunction", 1, 2.3);

System.out.println("[Java] result: " + result);

System.out.println("Java object: "

+ result.getClass().getName());

System.out.println();
} else

System.out.println("NOT Invocable");
}

}

The InvScript.js file (see Listing 6) contains the demoFunction() routine and the same printType() function that was used in the previous script example.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
Listing 6. The InvScript.js example
println("Start script \r\n");
function printType(obj) {
if (obj.getClass)
println("Java object: " + obj.getClass().name);
else
println("JS object: " + obj.toSource());
println("");
}
function demoFunction(a, b) {
println("[JS] a: " + a);
printType(a);
println("[JS] b: " + b);
printType(b);
var c = a + b;
println("[JS] c: " + c);
printType(c);
return c;
}
println("End script \r\n");

If you look at the output of InvDemo.java (shown in Listing 7), you'll observe that the numeric parameters are converted to JavaScript objects and the value returned by demoFunction() is obtained as a Java object. These conversions are performed only for primitives and strings. Any other objects are passed unchanged between the JVM and the JavaScript engine, and vice-versa.
Listing 7. The output of InvDemo.java
Start script
End script
[JS] a: 1
JS object: (new Number(1))
[JS] b: 2.3
JS object: (new Number(2.3))
[JS] c: 3.3
JS object: (new Number(3.3))
[Java] result: 3.3
Java object: java.lang.Double

Note that javax.script.Invocable is an optional interface, which some script engines may not implement. The JavaScript engine that comes with JDK 6 does support this interface.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
Compiling scripts
Interpreting scripts every time they are executed wastes CPU resources. If you run the same scripts multiple times, you can significantly reduce the execution time by compiling the scripts, using the methods provided by another optional interface named javax.script.Compilable, which is supported by the JavaScript engine of JDK 6.
The CachedScript class (see Listing 8) takes a script file and recompiles it only when the source code is modified. The getCompiledScript() method calls the script engine's compile(), which returns a javax.script.CompiledScript object whose eval() methods execute the script.
Listing 8. The CachedScript class
package jsee.cache;
import javax.script.*;
import java.io.*;
import java.util.*;
public class CachedScript {
private Compilable scriptEngine;
private File scriptFile;
private CompiledScript compiledScript;
private Date compiledDate;
public CachedScript(Compilable scriptEngine, File scriptFile) {
this.scriptEngine = scriptEngine;
this.scriptFile = scriptFile;
}

public CompiledScript getCompiledScript()

throws ScriptException, IOException {
Date scriptDate = new Date(scriptFile.lastModified());
if (compiledDate == null || scriptDate.after(compiledDate)) {

Reader reader = new FileReader(scriptFile);

try {

compiledScript = scriptEngine.compile(reader);

compiledDate = scriptDate;

} finally {

reader.close();

}
}
return compiledScript;
}
}

The ScriptCache class (shown in Listing 9) implements a repository for the compiled scripts, using a java.util.LinkedHashMap object. The map's initial capacity is set to a maximum number of cached scripts and the load factor is 1. These two parameters guarantee that cacheMap will never need a rehash.
By default, the LinkedHashMap class uses the insert-order for its entries. The third parameter of the LinkedHashMap() constructor must be true to use the access-order for the map's entries instead of the default order.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
After the maximum capacity of the cache is reached, the removeEldestEntry() method starts returning true so that an entry is automatically removed from cacheMap each time a new compiled script is added to the cache.
By using the auto-removal mechanism of LinkedHashMap in combination with the access-order, ScriptCache ensures that the Least Recently Used (LRU) script will be removed from the full cache when a new script is added.
Listing 9. The ScriptCache class
package jsee.cache;
import javax.script.*;
import java.io.*;
import java.util.*;
public abstract class ScriptCache {
public static final String ENGINE_NAME = "JavaScript";
private Compilable scriptEngine;
private LinkedHashMap cacheMap;
public ScriptCache(final int maxCachedScripts) {
ScriptEngineManager manager = new ScriptEngineManager();
scriptEngine = (Compilable) manager.getEngineByName(ENGINE_NAME);
cacheMap = new LinkedHashMap(

maxCachedScripts, 1, true) {

protected boolean removeEldestEntry(Map.Entry eldest) {

return size() > maxCachedScripts;

}
};
}
public abstract File getScriptFile(String key);
public synchronized CompiledScript getScript(String key)

throws ScriptException, IOException {
CachedScript script = cacheMap.get(key);
if (script == null) {

script = new CachedScript(scriptEngine, getScriptFile(key));

cacheMap.put(key, script);
}
return script.getCompiledScript();
}

public ScriptEngine getEngine() {
return (ScriptEngine) scriptEngine;
}

}

The next section uses the ScriptCache class, implementing the abstract getScriptFile() method and using getScript() to retrieve compiled scripts from the cache.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
Building a script runner
In this section, you'll learn how to create a simple Java servlet that implements a URL-script mapping, which allows you to invoke server-side scripts from the Web browser. In addition, the servlet will expose several Java EE objects as variables that can be used in your JavaScript code. You'll also learn how to use script contexts that let you run multiple concurrent scripts with a single JavaScript engine.
Initializing the servlet
The name of the servlet class is JSServlet. Its init() method (see Listing 10) gets several configuration parameters and creates a ScriptCache object. The servlet's script cache uses getRealPath() to obtain the path of the script file that is mapped to a given URI.
Listing 10. The init() method of JSServlet
package jsee.servlet;
import javax.script.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import jsee.cache.*;
public class JSServlet extends HttpServlet {
private String cacheControlHeader;
private String contentTypeHeader;
private ScriptCache scriptCache;

public void init() throws ServletException {
ServletConfig config = getServletConfig();
cacheControlHeader = config.getInitParameter("Cache-Control");
contentTypeHeader = config.getInitParameter("Content-Type");
int maxCachedScripts = Integer.parseInt(

config.getInitParameter("Max-Cached-Scripts"));
scriptCache = new ScriptCache(maxCachedScripts) {

public File getScriptFile(String uri) {

return new File(getServletContext().getRealPath(uri));

}
};
}
...
}

Listing 11 contains the servlet's parameters, which are specified in the web.xml file. The Cache-Control header has nothing to do with the script cache. Both headers will be part of the HTTP responses returned by the servlet. The no-cache value will tell the browser not to cache the servlet's response, which should be treated as text/plain.
Listing 11. The web.xml file


JSServlet
jsee.servlet.JSServlet


Cache-Control

no-cache



Content-Type

text/plain



Max-Cached-Scripts

1000

1


JSServlet
*.jss



As you can see in Listing 11, the *.jss pattern is mapped to the servlet. This means that JSServlet will handle all requests whose URLs end with the .jss extension. When the user enters such a URL in the Web browser or clicks a .jss link, the browser sends the HTTP request to the Web server (for example, Apache), which should be configured to dispatch it to the servlet container (for example, Tomcat). If the servlet container acts as Web server as well, no extra configuration is required.
When the servlet container gets the request whose URL ends with .jss, it invokes the service() method that JSServlet inherits from javax.servlet.http.HttpServlet. This method calls either doGet() or doPost(), depending on the HTTP method of the request. Both methods are overridden by JSServlet as you'll see later in this section.
回复

使用道具 举报

千问 | 2007-1-24 12:56:49 | 显示全部楼层
Using script contexts


Threading models for script engines
JSR-223 Scripting for the Java Platform (see Resources) defines three types of script engines:
* Multithreaded engines that are capable of executing concurrent scripts that may modify variables seen by other threads
* Thread-isolated engines, which are multithreaded too, but each thread has its own engine scope for keeping variables
* Stateless engines, which are defined as thread-isolated engines that let the engine scope unmodified after the execution of any script
The type of script engine can be obtained with engine.getFactory().getParameter("THREADING"), which may return "MULTITHREADED", "THREAD-ISOLATED", or "STATELESS"
Each script-engine instance has a default context where you can store variables with the put() method and the output of any executed script is directed to System.out by default. In a server environment, you'll want to run concurrent scripts with each of them having its own context. The javax.script API satisfies this need, providing the ScriptContext interface and the SimpleScriptContext implementation.
Mozilla's Rhino JavaScript engine is a multithreaded engine (see the sidebar), allowing you to execute concurrent scripts that share the same context. In our case, however, you want to isolate the engine scopes and the output of the scripts running in different threads, which means you must create a new ScriptContext instance for each HTTP request.
Listing 12 shows the createScriptContext() method of the JSServlet class. This method sets the context's writer property in order to send the script's output to the writer of the response object when the script is executed. This means that everything you pass to print() or println() in your script will be included in the servlet's response.
In addition, createScriptContext() defines the following script variables with the setAttribute() method of the script context:
Table 1. Variables available in scripts that are executed by JSServlet
Script variable
Description
config
the javax.servlet.ServletConfig instance of the servlet
application
the javax.servlet.ServletContext instance of the Web app
session
the javax.servlet.http.HttpSession object
request
the javax.servlet.http.HttpServletRequest object
response
the javax.servlet.http.HttpServletResponse object
out
the java.io.PrintWriter object that is used to output the response
factory
the javax.script.ScriptEngineFactory of the script engine
The factory variable can be used to obtain information about the JavaScript engine, such as the language version or the engine version. The rest of the variables have the same roles that they have in JSP pages.
Listing 12. The createScriptContext() method of JSServlet
public class JSServlet extends HttpServlet {
...
protected ScriptContext createScriptContext(

HttpServletRequest request, HttpServletResponse response)

throws IOException {
ScriptContext scriptContext = new SimpleScriptContext();
scriptContext.setWriter(response.getWriter());
int scope = ScriptContext.ENGINE_SCOPE;
scriptContext.setAttribute("config", getServletConfig(), scope);
scriptContext.setAttribute("application", getServletContext(), scope);
scriptContext.setAttribute("session", request.getSession(), scope);
scriptContext.setAttribute("request", request, scope);
scriptContext.setAttribute("response", response, scope);
scriptContext.setAttribute("out", response.getWriter(), scope);
scriptContext.setAttribute("factory",

scriptCache.getEngine().getFactory(), scope);
return scriptContext;
}
...
}

The runScript() method (see Listing 13) gets a compiled script from the cache and calls the eval() method, passing the given script context as parameter.
Listing 13. The runScript() method of JSServlet
public class JSServlet extends HttpServlet {
...
protected void runScript(String uri, ScriptContext scriptContext)

throws ScriptException, IOException {
scriptCache.getScript(uri).eval(scriptContext);
}
...
}
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

主题

0

回帖

4882万

积分

论坛元老

Rank: 8Rank: 8

积分
48824836
热门排行