---------------------------------ajaxUtil-----------------------------------------------------------------------------------
// ajaxUtil.js
var debug = true;
function sendHttpRequest(method, url, params, callback) {
var request;
if (window.XMLHttpRequest)
request = new XMLHttpRequest();
else if (window.ActiveXObject)
request = new ActiveXObject("Microsoft.XMLHTTP");
else
return null;
if (method)
method = method.toUpperCase();
else
method = "GET";
var fullURL = url;
if (params && method == "GET")
fullURL += "?" + buildQueryString(params);
var async = false;
if (callback)
async = true;
request.open(method, fullURL, async);
function calbackWrapper() {
if (async && request.readyState == 4) {
if (request.status == 200)
callback(request);
else
reportError(request, url, params);
}
}
if (async)
request.onreadystatechange = calbackWrapper;
var body = null;
if (method == "POST") {
request.setRequestHeader("Content-Type",
"application/x-www-form-urlencoded");
if (params)
body = buildQueryString(params);
}
request.send(body);
if (!async && (request.readyState != 4
|| request.status != 200)) {
reportError(request, url, params);
return null;
}
return request;
}
function buildQueryString(params) {
var query = "";
for (var i = 0; i < params.length; i++) {
query += (i > 0 ? "&" : "")
+ escape(params[i].name) + "="
+ escape(params[i].value);
}
return query;
}
function reportError(request, url, params) {
if (debug) {
if (request.status != 200) {
if (request.statusText)
alert(request.statusText);
else
alert("HTTP Status: " + request.status);
} else
alert("Response Error");
if (params)
url += "?" + buildQueryString(params);
document.location = url;
}
}
function abortRequest(request) {
function doNothing() {
}
request.onreadystatechange = doNothing;
request.abort();
delete feedRequest;
}
function escapeXML(content) {
if (content == undefined)
return "";
if (!content.length || !content.charAt)
content = new String(content);
var result = "";
var length = content.length;
for (var i = 0; i < length; i++) {
var ch = content.charAt(i);
switch (ch) {
case '&':
result += "&";
break;
case '<':
result += "<";
break;
case '>':
result += ">";
break;
case '"':
result += """;
break;
case '\'':
result += "'";
break;
default:
result += ch;
}
}
return result;
}
function parse(xml) {
var dom;
try {
dom = new ActiveXObject("Microsoft.XMLDOM");
dom.async = false;
dom.loadXML(xml);
} catch (error) {
try {
var parser = new DOMParser();
dom = parser.parseFromString(xml, "text/xml");
delete parser;
} catch (error2) {
if (debug)
alert("XML parsing is not supported.");
}
}
return dom;
}
function serialize(dom) {
var xml = dom.xml;
if (xml == undefined) {
try {
var serializer = new XMLSerializer();
xml = serializer.serializeToString(dom);
delete serializer;
} catch (error) {
if (debug)
alert("DOM serialization is not supported.");
}
}
return xml;
}
-----------------------ajaxLogic---------------------------------------------------------------------------
// ajaxLogic.js
var ctrlURL = "ajaxCtrl.jsp";
var feedRequest = null;
function sendInfoRequest(symbols, callback) {
if (feedRequest)
abortRequest(feedRequest);
var params = new Array();
for (var i = 0; i < symbols.length; i++)
params[i] = {
name: "symbol",
value: symbols[i]
};
feedRequest = sendHttpRequest(
"GET", ctrlURL, params, callback);
}
function sendSaveRequest(xml) {
var params = [ { name: "xml", value: xml } ];
var saveRequest = sendHttpRequest("POST", ctrlURL, params);
if (saveRequest)
delete saveRequest;
}
function sendLoadRequest() {
var model = null;
var loadRequest = sendHttpRequest("GET", ctrlURL);
if (loadRequest) {
model = eval(loadRequest.responseText);
delete loadRequest;
}
return model;
}
------------------------------ajaxCtrl-----------------------------------------------------------------------------------
<%-- ajaxCtrl.jsp --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="tags" tagdir="/WEB-INF/tags" %>
<%@ taglib prefix="feed" uri="/WEB-INF/feed.tld" %>
<tags:setHeader name="Cache-Control" value="no-cache"/>
<jsp:useBean id="dataFeed" scope="application"
class="ajaxapp.feed.DataFeed" />
<jsp:useBean id="dataModel" scope="session"
class="ajaxapp.model.DataModel" />
<c:choose>
<c:when test="${!empty param.symbol}">
${feed:getData(dataFeed, paramValues.symbol)}
</c:when>
<c:when test="${!empty param.xml}">
<c:set target="${dataModel}"
property="data"
value="${param.xml}" />
</c:when>
<c:otherwise>
${dataModel.data}
</c:otherwise>
</c:choose>
-----------------------------------domTest.jsp--------------------------------------------------
<html>
<head>
<script src="ajaxUtil.js">
</script>
</head>
<body>
<script language="javascript">
var xml = "<element>da<!--comment-->ta&"
+ "<![CDATA[cdata]]></element>";
var dom = parse(xml);
var element = dom.documentElement;
var childNodes = element.childNodes;
var text = "";
for (var i = 0; i < childNodes.length; i++)
if (childNodes[i].nodeValue) {
var type = childNodes[i].nodeType;
if (type == 3 || type == 4)
text += childNodes[i].nodeValue;
}
document.writeln("<p>Original:<br>");
document.writeln(escapeXML(xml));
document.writeln("<p>Serialized:<br>");
document.writeln(escapeXML(serialize(dom)));
document.writeln("<p>Text:<br>");
document.writeln(text);
</script>
</body>
</html>
-----------------------------feedTest---------------------------------------------------------------------------
<html>
<head>
<style>
TD { text-align: right; }
</style>
<script src="ajaxUtil.js">
</script>
<script src="ajaxLogic.js">
</script>
<script language="javascript">
var symbols = [ "AAAA", "BBBB", "CCCC" ];
function onLoad() {
sendInfoRequest(symbols, updateInfo);
setInterval("sendInfoRequest(symbols, updateInfo)", 5000);
}
function updateInfo(request) {
var shares = eval(request.responseText);
var table = "<table border=1 cellpadding=5>";
table += "<tr>";
table += "<th>Symbol</th>";
table += "<th>Trend</th>";
table += "<th>Last Price</th>";
table += "</tr>";
for (var i = 0; i < shares.length; i++) {
var share = shares[i];
var symbol = escapeXML(share.symbol)
var trend = share.trend > 0 ? "+" : "-";
var lastPrice = new Number(share.lastPrice).toFixed(2);
table += "<tr>";
table += "<td>" + symbol + "</td>";
table += "<td>" + trend + "</td>";
table += "<td>" + lastPrice + "</td>";
table += "</tr>";
}
table += "</table>";
document.getElementById("table").innerHTML = table;
}
</script>
</head>
<body onLoad="onLoad()">
<div id="table">
</div>
</body>
</html>
--------------------------------------------ModelTest--------------------------------------------------------------------------------------
<html>
<head>
<script src="ajaxUtil.js">
</script>
<script src="ajaxLogic.js">
</script>
<script language="javascript">
function attribute(name, value) {
return " " + name + "=\"" + escapeXML(value) + "\"";
}
function buildPortfolioDoc(stocks) {
var xml = "<portfolio>";
for (var i = 0; i < stocks.length; i++) {
var stock = stocks[i];
xml += "<stock ";
xml += attribute("symbol", stock.symbol);
xml += attribute("shares", stock.shares);
xml += attribute("paidPrice", stock.paidPrice);
xml += "/>";
}
xml += "</portfolio>";
return xml;
}
</script>
</head>
<body>
<p>Saved portfolio: <br>
<script language="javascript">
var savedStocks = [
{ symbol: "AAAA", shares: 1, paidPrice: 10 },
{ symbol: "BBBB", shares: 2, paidPrice: 20 },
{ symbol: "CCCC", shares: 3, paidPrice: 30 }
];
var xml = buildPortfolioDoc(savedStocks);
sendSaveRequest(xml);
document.writeln(escapeXML(xml));
</script>
<p>Loaded portfolio: <br>
<script language="javascript">
var loadedStocks = sendLoadRequest();
document.writeln(escapeXML(buildPortfolioDoc(loadedStocks)));
</script>
</body>
</html>
------------------------------------queryTest----------------------------------------------------------------------
<html>
<head>
<script src="ajaxUtil.js">
</script>
</head>
<body>
<script language="javascript">
var someParams = [
{ name: "name", value: "John Smith" },
{ name: "email", value: "john@company.com" },
{ name: "phone", value: "(123) 456 7890" }
];
someQuery = buildQueryString(someParams);
document.writeln(someQuery);
</script>
</body>
</html>
--------------------------------------------------------------------
java:src
package ajaxapp.feed;
import ajaxapp.util.JSONEncoder;
import java.util.*;
public class DataFeed implements java.io.Serializable {
private HashMap<String, ShareBean> shareMap;
public DataFeed() {
shareMap = new HashMap<String, ShareBean>();
}
public synchronized String getData(String symbols[]) {
JSONEncoder json = new JSONEncoder();
json.startArray();
for (int i = 0; i < symbols.length; i++) {
String symbol = symbols[i];
ShareBean share = shareMap.get(symbol);
if (share == null) {
share = new ShareBean(symbol);
shareMap.put(symbol, share);
}
json.startObject();
json.property("symbol", share.getSymbol());
json.property("trend", share.getTrend());
json.property("lastPrice", share.getLastPrice());
json.endObject();
}
json.endArray();
return json.toString();
}
public static String getData(
DataFeed feed, String symbols[]) {
return feed.getData(symbols);
}
}
package ajaxapp.feed;
public class ShareBean implements java.io.Serializable {
private String symbol;
private int trend;
private double lastPrice;
public ShareBean(String symbol) {
this.symbol = symbol;
trend = 1;
lastPrice = Math.random() * 100;
}
public String getSymbol() {
return symbol;
}
public int getTrend() {
return trend;
}
public double getLastPrice() {
lastPrice += trend * Math.random() * 0.1;
if (Math.random() < 0.2)
trend = -trend;
return lastPrice;
}
}
package ajaxapp.model;
import ajaxapp.util.JSONEncoder;
import ajaxapp.util.XMLUtil;
import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import javax.xml.xpath.*;
import java.io.*;
import java.util.*;
import java.util.logging.*;
public class DataModel implements java.io.Serializable {
private static final String SCHEMA_NAME
= "/ajaxapp/model/portfolio.xsd";
private static DocumentBuilderFactory parserFactory;
private ArrayList<StockBean> stockList;
public DataModel() {
stockList = new ArrayList<StockBean>();
}
private static Document parsePortfolioDoc(String xml)
throws IOException, SAXException,
ParserConfigurationException {
synchronized (DataModel.class) {
if (parserFactory == null)
parserFactory = XMLUtil.newParserFactory(SCHEMA_NAME);
}
DocumentBuilder parser = XMLUtil.newParser(parserFactory);
InputSource in = new InputSource(new StringReader(xml));
return parser.parse(in);
}
public synchronized void setData(String xml)
throws IOException, SAXException,
ParserConfigurationException,
XPathExpressionException {
try {
ArrayList<StockBean> stockList
= new ArrayList<StockBean>();
Document doc = parsePortfolioDoc(xml);
NodeList nodeList = XMLUtil.evalToNodeList(
"/portfolio/stock", doc);
for (int i = 0; i < nodeList.getLength(); i++) {
Node node = nodeList.item(i);
StockBean stock = new StockBean();
stock.setSymbol(
XMLUtil.evalToString("@symbol", node));
stock.setShares(
(int) XMLUtil.evalToNumber("@shares", node));
stock.setPaidPrice(
XMLUtil.evalToNumber("@paidPrice", node));
stockList.add(stock);
}
this.stockList = stockList;
} catch (Exception e) {
Logger.global.logp(Level.SEVERE, "DataModel", "setData",
e.getMessage(), e);
}
}
public synchronized String getData() {
JSONEncoder json = new JSONEncoder();
json.startArray();
for (int i = 0; i < stockList.size(); i++) {
StockBean stock = stockList.get(i);
json.startObject();
json.property("symbol", stock.getSymbol());
json.property("shares", stock.getShares());
json.property("paidPrice", stock.getPaidPrice());
json.endObject();
}
json.endArray();
return json.toString();
}
}
package ajaxapp.model;
public class StockBean implements java.io.Serializable {
private String symbol;
private int shares;
private double paidPrice;
public String getSymbol() {
return symbol;
}
public void setSymbol(String symbol) {
this.symbol = symbol;
}
public int getShares() {
return shares;
}
public void setShares(int shares) {
this.shares = shares;
}
public double getPaidPrice() {
return paidPrice;
}
public void setPaidPrice(double paidPrice) {
this.paidPrice = paidPrice;
}
}
---------------proloi.xsd-----------------------------------------
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="portfolio" type="portfolioType"/>
<xsd:complexType name="portfolioType">
<xsd:sequence>
<xsd:element name="stock"
minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:attribute name="symbol"
type="xsd:string" use="required"/>
<xsd:attribute name="shares"
type="xsd:positiveInteger" use="required"/>
<xsd:attribute name="paidPrice"
type="xsd:decimal" use="required"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
--------------------JSON------------------------------------------------------------------------------
package ajaxapp.util;
public class JSONEncoder {
private StringBuilder buf;
public JSONEncoder() {
buf = new StringBuilder();
}
public void character(char ch) {
switch (ch) {
case '\'':
case '\"':
case '\\':
buf.append('\\');
buf.append(ch);
break;
case '\t':
buf.append('\\');
buf.append('t');
break;
case '\r':
buf.append('\\');
buf.append('r');
break;
case '\n':
buf.append('\\');
buf.append('n');
break;
default:
if (ch >= 32 && ch < 128)
buf.append(ch);
else {
buf.append('\\');
buf.append('u');
for (int j = 12; j >= 0; j-=4) {
int k = (((int) ch) >> j) & 0x0f;
int c = k < 10 ? '0' + k : 'a' + k - 10;
buf.append((char) c);
}
}
}
}
public void string(String str) {
int length = str.length();
for (int i = 0; i < length; i++)
character(str.charAt(i));
}
public void literal(Object value) {
if (value instanceof String) {
buf.append('"');
string((String) value);
buf.append('"');
} else if (value instanceof Character) {
buf.append('\'');
character(((Character) value).charValue());
buf.append('\'');
} else
buf.append(value.toString());
}
private void comma() {
buf.append(',');
}
private void deleteLastComma() {
if (buf.length() > 0)
if (buf.charAt(buf.length()-1) == ',')
buf.deleteCharAt(buf.length()-1);
}
public void startObject() {
buf.append('{');
}
public void property(String name, Object value) {
buf.append(name);
buf.append(':');
literal(value);
comma();
}
public void endObject() {
deleteLastComma();
buf.append('}');
comma();
}
public void startArray() {
buf.append('[');
}
public void element(Object value) {
literal(value);
comma();
}
public void endArray() {
deleteLastComma();
buf.append(']');
comma();
}
public String toString() {
deleteLastComma();
return buf.toString();
}
public void clear() {
buf.setLength(0);
}
}
package ajaxapp.util;
import oracle.xml.jaxp.JXDocumentBuilderFactory;
import oracle.xml.parser.schema.XMLSchema;
import oracle.xml.parser.schema.XSDBuilder;
import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import javax.xml.validation.*;
import javax.xml.xpath.*;
import java.io.*;
import java.util.*;
import java.util.logging.*;
public class XMLUtil {
public static ErrorHandler newErrorHandler() {
return new ErrorHandler() {
public void warning(SAXParseException e)
throws SAXException {
Logger.global.warning(e.getMessage());
}
public void error(SAXParseException e)
throws SAXException {
throw e;
}
public void fatalError(SAXParseException e)
throws SAXException {
throw e;
}
};
}
public static InputStream getResourceAsStream(String name)
throws IOException {
InputStream in = XMLUtil.class.getResourceAsStream(name);
if (in == null)
throw new FileNotFoundException(name);
return in;
}
protected static SchemaFactory schemaFactory;
static {
schemaFactory = SchemaFactory.newInstance(
XMLConstants.W3C_XML_SCHEMA_NS_URI);
schemaFactory.setErrorHandler(newErrorHandler());
}
public static Schema newSchema(String name)
throws IOException, SAXException {
Schema schema;
InputStream in = getResourceAsStream(name);
try {
schema = schemaFactory.newSchema(new StreamSource(in));
} finally {
in.close();
}
return schema;
}
public static XMLSchema newOracleSchema(String name)
throws IOException, SAXException {
XMLSchema schema;
InputStream in = getResourceAsStream(name);
try {
XSDBuilder builder = new XSDBuilder();
schema = builder.build(new InputSource(in));
} catch (Exception e) {
throw new SAXException(e);
} finally {
in.close();
}
return schema;
}
public static DocumentBuilderFactory newParserFactory(
String schemaName) throws IOException, SAXException {
DocumentBuilderFactory parserFactory
= DocumentBuilderFactory.newInstance();
try {
parserFactory.setSchema(newSchema(schemaName));
} catch (UnsupportedOperationException e) {
if (parserFactory instanceof JXDocumentBuilderFactory) {
parserFactory.setAttribute(
JXDocumentBuilderFactory.SCHEMA_OBJECT,
newOracleSchema(schemaName));
}
}
return parserFactory;
}
public static DocumentBuilder newParser(
DocumentBuilderFactory parserFactory)
throws ParserConfigurationException {
DocumentBuilder parser = parserFactory.newDocumentBuilder();
parser.setErrorHandler(newErrorHandler());
return parser;
};
protected static XPathFactory xpathFactory;
static {
xpathFactory = XPathFactory.newInstance();
}
public static XPath newXPath() {
return xpathFactory.newXPath();
}
public static String evalToString(String expression,
Object context) throws XPathExpressionException {
return (String) newXPath().evaluate(expression, context,
XPathConstants.STRING);
}
public static boolean evalToBoolean(String expression,
Object context) throws XPathExpressionException {
return ((Boolean) newXPath().evaluate(expression, context,
XPathConstants.BOOLEAN)).booleanValue();
}
public static double evalToNumber(String expression,
Object context) throws XPathExpressionException {
return ((Double) newXPath().evaluate(expression, context,
XPathConstants.NUMBER)).doubleValue();
}
public static Node evalToNode(String expression,
Object context) throws XPathExpressionException {
return (Node) newXPath().evaluate(expression, context,
XPathConstants.NODE);
}
public static NodeList evalToNodeList(String expression,
Object context) throws XPathExpressionException {
return (NodeList) newXPath().evaluate(expression, context,
XPathConstants.NODESET);
}
public static TransformerFactory serializerFctory;
static {
serializerFctory = TransformerFactory.newInstance();
}
public static void serialize(Node node, OutputStream out)
throws TransformerException {
Transformer serializer = serializerFctory.newTransformer();
Properties serializerProps = new Properties();
serializerProps.put(OutputKeys.METHOD, "xml");
serializer.setOutputProperties(serializerProps);
Source source = new DOMSource(node);
Result result = new StreamResult(out);
serializer.transform(source, result);
}
}