软件艺术思考者  
混沌，彷徨，立志，蓄势...
公告
日历
<2024年12月>
日一二三四五六
24252627282930
1234567
891011121314
15161718192021
22232425262728
2930311234

导航

随笔分类(86)

随笔档案(85)

搜索

  •  

最新评论

阅读排行榜

评论排行榜

 
DWR: Easy AJAX for JAVA

DWR is a Java open source library which allows you to write Ajax web sites.

It allows code in a browser to use Java functions running on a web server just as if it was in the browser.

DWR consists of two main parts:

  • A Java Servlet running on the server that processes requests and sends responses back to the browser.
  • JavaScript running in the browser that sends requests and can dynamically update the webpage.

DWR works by dynamically generating Javascript based on Java classes. The code does some Ajax magic to make it feel like the execution is happening on the browser, but in reality the server is executing the code and DWR is marshalling the data back and forwards.

This method of remoting functions from Java to JavaScript gives DWR users a feel much like conventional RPC mechanisms like RMI or SOAP, with the benefit that it runs over the web without requiring web-browser plug-ins.

Java is fundamentally synchronous where Ajax is asynchronous. So when you call a remote method, you provide DWR with a callback function to be called when the data has been returned from the network.

interaction diagramThe diagram shows how DWR can alter the contents of a selection list as a result of some Javascript event like onclick.

DWR dynamically generates an AjaxService class in Javascript to match some server-side code. This is called by the eventHandler. DWR then handles all the remoting details, including converting all the parameters and return values between Javascript and Java. It then executes the supplied callback function (populateList) in the example below which uses a DWR utility function to alter the web page.

DWR helps you in producing highly interactive web-sites by providing some Javascript libraries to help with DHTML and by giving you a set of examples to copy from.

For details on how to get started with DWR see the getting started guide and download instructions.
//---------------------------以下是中文介绍-0--------------------------------------------------------------

dwr学习
这段时间较闲,研究了一番dwr.发现dwr实现的AJAX有些地方确实很是先进.比如动态生成javascript代码;隐藏的http协议;javascript于java代码交互的是javascript对象(或字符串)等.
以下是我临时译的一些东西.本来想全译,发现dwr实在是简单,就随便写了.英文居差,现一把.

1、DWR: Easy AJAX for JAVA

作为一个java open source library,DWR可以帮助开发人员完成应用AJAX技术的web程序。它可以让浏览器上的javascript方法调用运行在web服务器上java方法。

DWR主要由两部门组成。javascript与web服务器通信并更新web页；运行在web服务器的Servlet处理请求并把响应发回浏览器。

DWR 采用新颖的方法实现了AJAX(本来也没有确切的定义)，在java代码基础上动态的生成javascript代码。web开发者可以直接调用这些 javascript代码，然而真正的代码是运行在web服务器上的java code。出与安全考虑，开发者必须配置哪些java class暴露给DWR.(dwr.xml)

这种从(java到javascript)调用机制给用户一种感觉，好象常规的RPC机制，或RMI or SOAP.但是它运行在web上，不需要任何浏览器插件。

DWR 不认为浏览器和web服务器之间协议重要，把系统界面放在首位。最大挑战是java method call的同步特征与ajax异步特性之间的矛盾。在异步模型里，结果只有在方法结束后才有效。DWR解决了这个问题，把回调函数当成参数传给方法，处理完成后，自动调用回调方法。

这个图表显示了，通过javascript事件，DWR能改变select的内容，当然这些内容由 java代码返回。 javascript函数Data.getOptions(populateList)由DWR动态生成，这个函数会调用java class Data类的方法。DWR处理如何远程调用，包括转换所有的参数和返回的结果（javascript\java）。java方法执行完后，执行回调方法 populateList。在整个过程中我们就想在用本地的方法一样。

2、Getting Started

废话少说，试试就ok了。
web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app id="dwr">
<servlet>
<servlet-name>dwr-invoker</servlet-name>
<servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>dwr-invoker</servlet-name>
<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>
</web-app>

dwr.xml 与web.xml同目录
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE dwr PUBLIC "-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN" "http://www.getahead.ltd.uk/dwr/dwr10.dtd">
<dwr>
<allow>
<create creator="new" javascript="JDate">
<param name="class" value="java.util.Date"/>
</create>
</allow>
</dwr>

index.html
<html>
<head>
<title>DWR - Test Home</title>
<script type='text/javascript' src='dwr/interface/JDate.js'></script>
<script type='text/javascript' src='dwr/engine.js'></script>
<script>
function init(){
JDate.getYear(load);
}
function load(data){
alert(data+1900+'年')
}
</script>
</head>
<body onload="init()">
</body>
</html>

dwr.jar 下载放lib下

完了，什么，够了，就这些。访问ok!
3、Examples
http://www.aboutmyhealth.org/ 这不是Google Suggest吗!ok.
4、源码浅析
dwr的设计很象webwork2的设计,隐藏http协议,扩展性，兼容性及强。

通过研究uk.ltd.getahead.dwr.DWRServlet这个servlet来研究下dwr到底是如何工作滴。

java代码: 

web.xml配置
<servlet>
    <servlet-name>dwr-invoker</servlet-name>
    <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>dwr-invoker</servlet-name>
    <url-pattern>/dwr/*</url-pattern>
</servlet-mapping>


这样所有的/dwr/*所有请求都由这个servlet来处理，它到底处理了些什么能。我们还以上面最简单的例子来看。
1、 web服务器启动，DWRServlet init()方法调用，init主要做了以下工作。
设置日志级别、实例化DWR用到的单例类（这些类在jvm中只有一个实例对象）、读去配置文件（包括dwr.jar包中的dwr.xml,WEB-INF/dwr.xml. config*.xml）。
2、请求处理
DWRServlet.doGet, doPost方法都调用processor.handle(req, resp)方法处理。Processor对象在init()方法中已经初始化了。
java代码: 

publicvoid handle(HttpServletRequest req, HttpServletResponse resp)
        throwsIOException
    {
        String pathinfo = req.getPathInfo();
        if(pathinfo == null || pathinfo.length() == 0 || pathinfo.equals("/"))
        {
            resp.sendRedirect(req.getContextPath() + req.getServletPath() + '/' + "index.html");
        }else
        if(pathinfo != null && pathinfo.equalsIgnoreCase("/index.html"))
        {
            doIndex(req, resp);
        }else
        if(pathinfo != null && pathinfo.startsWith("/test/"))
        {
            doTest(req, resp);
        }else
        if(pathinfo != null && pathinfo.equalsIgnoreCase("/engine.js"))
        {
            doFile(resp, "engine.js", "text/javascript");
        }else
        if(pathinfo != null && pathinfo.equalsIgnoreCase("/util.js"))
        {
            doFile(resp, "util.js", "text/javascript");
        }else
        if(pathinfo != null && pathinfo.equalsIgnoreCase("/deprecated.js"))
        {
            doFile(resp, "deprecated.js", "text/javascript");
        }else
        if(pathinfo != null && pathinfo.startsWith("/interface/"))
        {
            doInterface(req, resp);
        }else
        if(pathinfo != null && pathinfo.startsWith("/exec"))
        {
            doExec(req, resp);
        }else
        {
            log.warn("Page not found. In debug/test mode try viewing /[WEB-APP]/dwr/");
            resp.sendError(404);
        }
    }


哦。这些恍然大悟。dwr/*处理的请求也就这几种。
（1）dwr/index.html，dwr/test/这种只能在debug模式下使用，调试用。
dwr/engine.js，dwr/util.js，dwr/deprecated.js当这个请求到达，从dwr.jar包中读取文件流，响应回去。（重复请求有缓存）
（2）当dwr/interface/这种请求到来，（例如我们在index.html中的 <script type='text/javascript' src='dwr/interface/JDate.js'></script>）DWR做一件伟大的事。把我们在WEB- INF/dwr.xml中的
<create creator="new" javascript="JDate">
<param name="class" value="java.util.Date"/>
</create>
java.util.Date转化为javascript函数。
http://localhost:port/simpledwr/dwr/interface/JDate.js看看吧。
细节也比较简单，通过java反射，把方法都写成javascript特定的方法。（我觉得这些转换可以放到缓存里，下次调用没必要再生成一遍，不知道作者为什么没这样做）。
（3）dwr/exec
javascript调用方法时发送这种请求，可能是XMLHttpRequest或IFrame发送。
当然，javascript调用的方法签名与java代码一致，包括参数，还有javascript的回调方法也传到了服务器端，在服务器端很容易实现。回调方法的java的执行结果 返回类似 <script>callMethod(结果)<script>的javascript字符串,在浏览器执行。哈，一切就这么简单，巧妙。

dwr的设计构思很是巧妙。
第一、把java类转化为javascript类由dwr自动完成，只需简单的配置。
第二、应用起来极其简单。开发者不要该服务器代码就可以集成。
第三、容易测试。和webwork一样，隐藏的http协议。
第四、及强扩展性。例如与spring集成，只需修改一点代码。
第五、性能。就我与jason,等简单比较，dwr性能可能是最好的。
第六、自动把java对象转化为javascript对象，并且及易扩展。

posted on 2006-09-21 16:51 智者无疆 阅读(743) 评论(2)  编辑  收藏 所属分类: Client teachnolgy research
评论:
  • # re: DWR: Easy AJAX for JAVA  智者无疆 Posted @ 2006-11-27 13:07
    AJAX实例入门之JSP+AJAX篇　楼主　只看楼主

    　　一、开门见山

    　　这些时间，瞎子也看得见，AJAX正大踏步的朝我们走来。不管我们是拥护也好，反对也罢，还是视而不见，AJAX像一阵潮流，席转了我们所有的人。

    　　关于AJAX的定义也好，大话也好，早有人在网上发表了汗牛充栋的文字，在这里我也不想照本宣科。

    　　只想说说我感觉到的一些优点，对于不对，大家也可以和我讨论：

    　　首先是异步交互，用户感觉不到页面的提交，当然也不等待页面返回。这是使用了AJAX技术的页面给用户的第一感觉。

    　　其次是响应速度快，这也是用户强烈体验。

    　　然后是与我们开发者相关的，复杂UI的成功处理，一直以来，我们对B/S模式的UI不如C/S模式UI丰富而苦恼。现在由于AJAX大量使用JS，使得复杂的UI的设计变得更加成功。

    　　最后，AJAX请求的返回对象为XML文件，这也是一个潮流，就是WEB SERVICE潮流一样。易于和WEB SERVICE结合起来。

    　　好了，闲话少说，让我们转入正题吧。

    　　我们的第一个例子是基于Servlet为后台的一个web应用。

    　　二、基于Servlet的AJAX

    　　这是一个很常见的UI，当用户在第一个选择框里选择ZHEJIANG时，第二个选择框要出现ZHEJIANG的城市；当用户在第一个选择框里选择JIANGSU时，第二个选择框里要出现JIANGSU的城市。

    　　首先，我们来看配置文件web.xml，在里面配置一个servlet，跟往常一样：

    <web-app version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee"">http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

    <servlet>
    <servlet-name>SelectCityServlet</servlet-name>
    <servlet-class>com.stephen.servlet.SelectCityServlet</servlet-class>
    </servlet>

    <servlet-mapping>
    <servlet-name>SelectCityServlet</servlet-name>
    <url-pattern>/servlet/SelectCityServlet</url-pattern>
    </servlet-mapping>

    </web-app>

    　　然后，来看我们的JSP文件：

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <title>MyHtml.html</title>

    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">

    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

    </head>
    <script type="text/javascript">
    function getResult(stateVal) {
    　　var url = "servlet/SelectCityServlet?state="+stateVal;
    　　if (window.XMLHttpRequest) {
    　　req = new XMLHttpRequest();
    　　}else if (window.ActiveXObject) {
    　　req = new ActiveXObject("Microsoft.XMLHTTP");
    　　}
    　　if(req){
    　　req.open("GET",url, true);
    　　req.onreadystatechange = complete;
    　　req.send(null);
    　　}
    }
    function complete(){
    　　if (req.readyState == 4) {
    　　if (req.status == 200) {
    　　var city = req.responseXML.getElementsByTagName("city");
    　　file://alert(city.length);
    　　var str=new Array();
    　　for(var i=0;i<city.length;i++){
    　　str[i]=city[i].firstChild.data;
    　　}
    　　file://alert(document.getElementById("city"));
    　　buildSelect(str,document.getElementById("city"));
    　　}
    　　}
    }
    function buildSelect(str,sel) {
    　　sel.options.length=0;
    　　for(var i=0;i<str.length;i++) {
    　　sel.options[sel.options.length]=new Option(str[i],str[i])
    　　}
    }
    </script>
    <body>
    <select name="state" onChange="getResult(this.value)">
    　　<option value="">Select</option>>
    　　<option value="zj">ZEHJIANG</option>>
    　　<option value="zs">JIANGSU</option>>
    </select>
    <select id="city">
    　　<option value="">CITY</option>
    </select>
    </body>
    </html>

    　　第一眼看来，跟我们平常的JSP没有两样。仔细一看，不同在JS里头。

    　　我们首先来看第一个方法：getResult(stateVal)，在这个方法里，首先是取得XmlHttpRequest；然后设置该请求的url：req.open("GET",url, true);接着设置请求返回值的接收方法：req.onreadystatechange = complete;该返回值的接收方法为——complete();最后是发送请求：req.send(null);

    　　然后我们来看我们的返回值接收方法：complete()，这这个方法里，首先判断是否正确返回，如果正确返回，用DOM对返回的XML文件进行解析。关于DOM的使用，这里不再讲述，请大家参阅相关文档。得到city的值以后，再通过buildSelect(str,sel)方法赋值到相应的选择框里头去。

    　　最后我们来看看Servlet文件：

    import java.io.IOException;
    import java.io.PrintWriter;

    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;

    /**
    * @author Administrator
    *
    * TODO To change the template for this generated type comment go to
    * Window - Preferences - Java - Code Style - Code Templates
    */
    public class SelectCityServlet extends HttpServlet {


    　　public SelectCityServlet() {
    　　super();
    　　}

    　　public void destroy() {
    　　super.destroy();
    　　}

    　　public void doGet(HttpServletRequest request, HttpServletResponse response)
    　　throws ServletException, IOException {
    　　response.setContentType("text/xml");
    　　response.setHeader("Cache-Control", "no-cache");
    　　String state = request.getParameter("state");
    　　StringBuffer sb=new StringBuffer("<state>");
    　　if ("zj".equals(state)){
    　　sb.append("<city>hangzhou</city><city>huzhou</city>");
    　　} else if("zs".equals(state)){
    　　sb.append("<city>nanjing</city><city>yangzhou</city><city>suzhou</city>");
    　　}
    　　sb.append("</state>");
    　　PrintWriter out=response.getWriter();
    　　out.write(sb.toString());
    　　out.close();
    　　}
    }

    　　这个类也十分简单，首先是从request里取得state参数，然后根据state参数生成相应的XML文件，最后将XML文件输出到PrintWriter对象里。

    　　到现在为止，第一个例子的代码已经全部结束。是不是比较简单？我们进入到第二个实例吧！这次是基于JSP的AJAX的一个应用。

    　　三、基于JSP的AJAX

    这个例子是关于输入校验的问题，我们知道，在申请用户的时候，需要去数据库对该用户性进行唯一性确认，然后才能继续往下申请。

    　　这种校验需要访问后台数据库，但又不希望用户在这里提交后等待，当然是AJAX技术大显身手的时候了。

    　　首先来看显示UI的JSP:

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <title>Check.html</title>

    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">

    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

    </head>
    <script type="text/javascript">
    var http_request = false;
    function send_request(url) {//初始化、指定处理函数、发送请求的函数
    http_request = false;
    file://开始初始化XMLHttpRequest对象
    if(window.XMLHttpRequest) { file://Mozilla 浏览器
    　　http_request = new XMLHttpRequest();
    　　if (http_request.overrideMimeType) {//设置MiME类别
    　　http_request.overrideMimeType('text/xml');
    　　}
    }
    else if (window.ActiveXObject) { // IE浏览器
    　　try {
    　　http_request = new ActiveXObject("Msxml2.XMLHTTP");
    　　} catch (e) {
    　　try {
    　　http_request = new ActiveXObject("Microsoft.XMLHTTP");
    　　} catch (e) {}
    　　}
    }
    if (!http_request) { // 异常，创建对象实例失败
    　　window.alert("不能创建XMLHttpRequest对象实例.");
    　　return false;
    }
    http_request.onreadystatechange = processRequest;
    // 确定发送请求的方式和URL以及是否同步执行下段代码
    http_request.open("GET", url, true);
    http_request.send(null);
    }
    // 处理返回信息的函数
    　　function processRequest() {
    　　if (http_request.readyState == 4) { // 判断对象状态
    　　if (http_request.status == 200) { // 信息已经成功返回，开始处理信息
    　　alert(http_request.responseText);
    　　} else { file://页面不正常
    　　alert("您所请求的页面有异常。");
    　　}
    　　}
    　　}
    function userCheck() {
    var f = document.form1;
    var username = f.username.value;
    if(username=="") {
    　　window.alert("The user name can not be null!");
    　　f.username.focus();
    　　return false;
    }
    else {
    　　send_request('check1.jsp?username='+username);
    }
    }

    </script>
    <body>
    <form name="form1" action="" method="post">
    User Name:<input type="text" name="username" value="">&nbsp;
    <input type="button" name="check" value="check" onClick="userCheck()">
    <input type="submit" name="submit" value="submit">
    </form>
    </body>
    </html>

    　　所有的JS都跟上一个例子一样，不同的只是对返回值的操作，这次是用alert来显示：alert(http_request.responseText);

    　　我们来看处理逻辑JSP:

    <%@ page contentType="text/html; charset=gb2312" language="java" errorPage="" %>
    <%
    String username= request.getParameter("username");
    if("educhina".equals(username)) out.print("用户名已经被注册，请更换一个用户名。");
    else out.print("用户名尚未被使用，您可以继续。");
    %>

    　　非常简单，先取得参数，然后作处理，最后将结果打印在out里。
    　　我们的第三个例子仍然以这个唯一性校验为例子，这次结合Struts开发框架来完成AJAX的开发。

    　　四、基于Struts的AJAX

    　　首先，我们仍然是对Struts应用来做配置，仍然是在struts-config,xml文件里做配置，如下：

    <action type="com.ajax.CheckAction"
    　　scope="request" path="/ajax/check">
    　　<forward name="success" path="/check.jsp"/>
    </action>


    　　跟普通的Struts应用的配置一样，只是没有ActionForm的配置。

    　　下面是Action类：

    package com.ajax;

    import java.io.PrintWriter;

    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;

    import org.apache.struts.action.Action;
    import org.apache.struts.action.ActionForm;
    import org.apache.struts.action.ActionForward;
    import org.apache.struts.action.ActionMapping;
    import org.apache.struts.action.DynaActionForm;

    /**
    * @author Administrator
    *
    * TODO To change the template for this generated type comment go to
    * Window - Preferences - Java - Code Style - Code Templates
    */
    public class CheckAction extends Action
    {
    public final ActionForward execute(ActionMapping mapping, ActionForm form,
    　　HttpServletRequest request,
    　　HttpServletResponse response)
    throws Exception
    {
    　　System.out.println("haha...............................");
    　　String username= request.getParameter("username");
    　　System.out.println(username);
    　　String retn;
    　　if("educhina".equals(username)) retn = "Can't use the same name with the old use,pls select a difference...";
    　　else retn = "congraducation!you can use this name....";
    　　PrintWriter out=response.getWriter();
    　　out.write(retn);
    　　out.close();
    　　return mapping.findForward("success");
    }
    public static void main(String[] args)
    {
    }
    }

    　　我们可以看到里面的逻辑跟上例中Servlet里的逻辑一样。最后，我们来看看JSP:

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <title>Check.html</title>

    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">

    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

    </head>
    <script type="text/javascript">
    var http_request = false;
    function send_request(url) {//初始化、指定处理函数、发送请求的函数
    http_request = false;
    file://开始初始化XMLHttpRequest对象
    if(window.XMLHttpRequest) { file://Mozilla 浏览器
    　　http_request = new XMLHttpRequest();
    　　if (http_request.overrideMimeType) {//设置MiME类别
    　　http_request.overrideMimeType('text/xml');
    　　}
    }
    else if (window.ActiveXObject) { // IE浏览器
    　　try {
    　　http_request = new ActiveXObject("Msxml2.XMLHTTP");
    　　} catch (e) {
    　　try {
    　　http_request = new ActiveXObject("Microsoft.XMLHTTP");
    　　} catch (e) {}
    　　}
    }
    if (!http_request) { // 异常，创建对象实例失败
    　　window.alert("不能创建XMLHttpRequest对象实例.");
    　　return false;
    }
    http_request.onreadystatechange = processRequest;
    // 确定发送请求的方式和URL以及是否同步执行下段代码
    http_request.open("GET", url, true);
    http_request.send(null);
    }
    // 处理返回信息的函数
    　　function processRequest() {
    　　if (http_request.readyState == 4) { // 判断对象状态
    　　if (http_request.status == 200) { // 信息已经成功返回，开始处理信息
    　　alert(http_request.responseText);
    　　} else { file://页面不正常
    　　alert("您所请求的页面有异常。");
    　　}
    　　}
    　　}
    function userCheck() {
    var f = document.forms[0];
    var username = f.username.value;
    if(username=="") {
    　　window.alert("The user name can not be null!");
    　　f.username.focus();
    　　return false;
    }
    else {
    　　send_request('ajax/check.do?username='+username);
    }
    }

    </script>
    <body>
    <form name="form1" action="" method="post">
    User Name:<input type="text" name="username" value="">&nbsp;
    <input type="button" name="check" value="check" onClick="userCheck()">
    <input type="submit" name="submit" value="submit">
    </form>
    </body>
    </html>

    　　我们可以看到，JSP基本是一样的，除了要发送的url：ajax/check.do?username='+username。

    　　最后，我们来看一个基于Struts和AJAX的复杂一些的例子，如果不用AJAX技术，UI的代码将十分复杂。

    　　五、一个复杂的实例

    　　这是一个比较复杂的级联：一共八个列表框，三个下拉框。从第一个列表框里选择到第二个列表框里后，第一个选择框里的选项是第二个列表框的选择；然后，在第一个选择框里选择以后，与选择值关联的一些选项出现在第三个列表框里。从第三个列表框里选择选项到第四个列表框里，同样，第二个选择框的选项也是第四个列表框的选项；如果对第二个选择框进行选择后，与选择值关联的一些选项出现在第六个列表框里，依次类推……

    　　这个UI的逻辑就比较复杂，但使用了AJAX使得我们实现起来就简单多了，这个例子我们除了使用Action类，还要用到POJO类和Business类，然后我们扩展的话，可以通过Business类和数据库连接起来。

    　　我们还是先看配置文件：

    <action type="com.ajax.SelectAction"
    　　scope="request" path="/ajax/select">
    　　<forward name="success" path="/select.jsp"/>
    </action>

    然后看看Action类：

    /*
    /**
    * Title : Base Dict Class
    * Description : here Description is the function of class, here maybe multirows
    * Copyright: Copyright (c) 2004
    * @company Freeborders Co., Ltd.
    * @Goal Feng 　　
    * @Version 　　1.0
    */

    package com.ajax;

    import java.io.PrintWriter;
    import java.util.List;

    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;

    import org.apache.struts.action.Action;
    import org.apache.struts.action.ActionForm;
    import org.apache.struts.action.ActionForward;
    import org.apache.struts.action.ActionMapping;

    /**
    * @author Administrator
    *
    * TODO To change the template for this generated type comment go to
    * Window - Preferences - Java - Code Style - Code Templates
    */
    public class SelectAction extends Action
    {
    public final ActionForward execute(ActionMapping mapping, ActionForm form,
    　　HttpServletRequest request,
    　　HttpServletResponse response)
    throws Exception
    {
    　　response.setContentType("text/xml");
    　　response.setHeader("Cache-Control", "no-cache");
    　　String type = request.getParameter("type");
    　　String id = request.getParameter("id");
    　　System.out.println(id);
    　　StringBuffer sb=new StringBuffer("<select>");
    　　sb.append("<type>"+type+"</type>");
    　　
    　　List list = new SelectBusiness().getData(id);
    　　for(int i=0;i<list.size();i++)
    　　{
    　　SelectForm sel = (SelectForm)list.get(i);
    　　sb.append("<text>"+sel.getText()+"</text><value>"+sel.getValue()+"</value>");
    　　}

    　　sb.append("</select>");
    　　PrintWriter out=response.getWriter();
    　　out.write(sb.toString());
    　　out.close();
    　　System.out.println(sb.toString());
    　　return mapping.findForward("success");
    }
    public static void main(String[] args)
    {
    }
    }

    　　POJO类和Business类：
    package com.ajax;
    /**
    * @author Administrator
    *
    * TODO To change the template for this generated type comment go to
    * Window - Preferences - Java - Code Style - Code Templates
    */
    public class SelectForm
    {
    private String text;
    private String value;

    /**
    * @return Returns the text.
    */
    public String getText()
    {
    return text;
    }
    /**
    * @param text The text to set.
    */
    public void setText(String text)
    {
    this.text = text;
    }
    /**
    * @return Returns the value.
    */
    public String getValue()
    {
    return value;
    }
    /**
    * @param value The value to set.
    */
    public void setValue(String value)
    {
    this.value = value;
    }
    public static void main(String[] args)
    {
    }
    }


    package com.ajax;

    import java.util.ArrayList;
    import java.util.List;

    /**
    * @author Administrator
    *
    * TODO To change the template for this generated type comment go to
    * Window - Preferences - Java - Code Style - Code Templates
    */
    public class SelectBusiness
    {
    public List getData(String id)
    {
    ArrayList list = new ArrayList();
    for(int i=1;i<6;i++)
    {
    　　SelectForm form = new SelectForm();
    　　form.setText(id+i);
    　　form.setValue(id+i);
    　　list.add(form);
    }
    return list;
    }

    public static void main(String[] args)
    {
    }
    }

      回复  更多评论   

  • # re: DWR: Easy AJAX for JAVA  self Posted @ 2006-11-28 11:08
    XMLHttpRequest 是 Ajax 的关键技术.Javascript也是靠 XMLHttpRequest 来获取XML的. 现在我们来看看如何建立 XMLHttpRequest 对象,然后读取XML.

    Mozilla和IE同样支持 XMLHttpRequest ,不过在使用过程中是不一样的.

    - Mozilla 浏览器自带了 XMLHttpRequest 接口
    new XMLHttpRequest()

    - 而 IE 需要使用ActiveX对象来建立.
    new ActiveXObject("Microsoft.XMLHTTP")

    XMLHttpRequest 的常用属性和方法
    属性
    onreadystatechange
    readyState
    responseText
    responseXML
    status
    statusText

    方法
    abort()
    getAllResponseHeaders()
    getResponseHeader("<headerName>")
    open("<method>", "URL"[,asyncFlag[, "<username>"[,"<password>"]]])
    send(content)
    setRequestHeader("<name>", "<value>")


    下面开始我们的程序,为了方便使用 XML 我把操作XML的方法用一个 function 封装起来
    程序代码
    function XMLHttpObject(url,Syne){
    var XMLHttp=null
    var o=this
    this.url=url
    this.Syne=Syne

    this.sendData = function()
    {
    if (window.XMLHttpRequest) {
    XMLHttp = new XMLHttpRequest();
    } else if (window.ActiveXObject) {
    XMLHttp = new ActiveXObject("Microsoft.XMLHTTP");
    }
    with(XMLHttp){
    open("GET", this.url, this.Syne);
    onreadystatechange = o.CallBack;
    send(null);
    }
    }

    this.CallBack=function()
    {
    if (XMLHttp.readyState == 4) {
    if (XMLHttp.status == 200) {
    //Xml加载成功后的操作
    }
    }
    }

    this.getText=function()
    {
    if (XMLHttp==null) {return "还没加载 XMLHttpRequest"}
    if (XMLHttp.readyState==4) {return XMLHttp.responseText}
    return XMLHttp.readyState
    }
    }


    - 现在我们根据上面写好的Function建立一个XML对象
    var XMLDoc1=new XMLHttpObject("1.xml",true)

    - 发送数据,这个过程将调用 XMLHttpRequest 来对 1.xml 进行request
    XMLDoc1.sendData()

    - 当加载完成后,可以用下面的方法获取 XML 文档的文本内容了
    XMLDoc1.getText()

    这样 XMLHttpRequest 建立基本上完成了.
    请看完整的代码演示

    本站原创文章,如需转载请注明出处
      回复  更多评论   


只有注册用户登录后才能发表评论。
网站导航:
 
 
Copyright © 智者无疆 Powered by: 博客园 模板提供：沪江博客


   观音菩萨赞