<p>
Name:
<input type="text" id="demoName"/>
<input value="Send" type="button" onclick="update()"/>
<br/>
Reply: <span id="demoReply"></span>
</p>

function update() {
var name = dwr.util.getValue("demoName");
Demo.sayHello(name, function(data) {
dwr.util.setValue("demoReply", data);
});
}

package org.getahead.dwrdemo.simpletext;
public class Demo {
public String sayHello(String name) {
return "Hello, " + name;
}
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE dwr PUBLIC
"-//GetAhead Limited//DTD Direct Web Remoting 2.0//EN"
"http://getahead.org/dwr/dwr20.dtd">
<dwr>
<allow>
<create creator="new" javascript="Demo">
<param name="class" value="org.getahead.dwrdemo.simpletext.Demo"/>
</create>
</allow>
</dwr>

if (typeof this['Person'] != 'function') {
  function Person() {
    this.address = null;
    this.phoneNumber = null;
    this.name = null;
    this.id = 0;
    this.salary = 0;
  }
}

// Provide a default path to dwr.engine
if (typeof this['dwr'] == 'undefined') this.dwr = {};
if (typeof dwr['engine'] == 'undefined') dwr.engine = {};

if (typeof this['Demo'] == 'undefined') this.Demo = {};

Demo._path = '/dwr/dwr';

Demo.sayHello = function(p0, callback) {
  return dwr.engine._execute(Demo._path, 'Demo', 'sayHello', p0, callback);
};

Demo.getInclude = function(callback) {
  return dwr.engine._execute(Demo._path, 'Demo', 'getInclude', callback);
};

    这样我们就知道了，实际上Demo.java类的sayHello方法已经被解释到Demo.js中了，只不过后面的调用还不是很清楚而已。
继续！
public String sayHello(String name) {
return "Hello, " + name;
}
 翻译成
       Demo._path = '/dwr/dwr';
 Demo.sayHello = function(p0, callback) {
  return dwr.engine._execute(Demo._path, 'Demo', 'sayHello', p0, callback);
};
  在调用engine.execute()方法时，最终采用无刷新访问服务器技术。
 采用该技术的关键问题是两个参数，一个是url，往什么地方发送；一个是doc，发送什么内容
 通过跟踪engine.js我们知道
url=/dwr/dwr/call/plaincall/Demo.sayHello.dwr
发送内容如下：

callCount=1
windowName=DWR-442B435899
c0-scriptName=Demo
c0-methodName=sayHello
c0-id=0
c0-param0=string:Joe
batchId=1
page=/dwr/simpletext/index.html
httpSessionId=
scriptSessionId=1CC3A.0A3

实际上url=/dwr/dwr/call/plaincall/Demo.sayHello.dwr，转向的是DwrServlet，DwrServlet实际上获取了两部分信息，一部分是url，根据这个能够解析到我们的目标java类、方法，另外一部分是发送信息包，实际上这就是SayHello所需要的参数输入信息，最后，返回数据，这些数据格式通过response返回，在engine.js中对应于return batch.reply;通过解析返回对象，采用javascirpt将数据动态刷新到页面。

    至此，dwr的核心原理，基本清晰

开始使用 DWR
    原文出处: http://www.javatang.com/archives/2006/10/20/254879.html
    翻译: Jet Mah
    有两种方法来开始 DWR 的学习，最简单的做法是下载官方提供的 WAR 文件然后对此深入研究。不过这种方式不能使你感到将 DWR 整合到你现有的 web 程序有多么的简单，所以我们推荐你跟随下面三个步骤：

1. 安装 DWR JAR 包
下载 dwr.jar 文件，然后将它放在 web 程序的 WEB-INF/lib 目录下面，很可能在这个目录下已经有一些 jar 文件了。

2. 编辑 config 文件

将下面的代码添加到 WEB-INF/web.xml 文件中，<servlet>需要放在另外的<servlet>之后，<servlet-mapping>也是如此。

<servlet>
  <servlet-name>dwr-invoker</servlet-name>
  <display-name>DWR Servlet</display-name>
  <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>
  <init-param>
     <param-name>debug</param-name>
     <param-value>true</param-value>
  </init-param>
</servlet>

<servlet-mapping>
  <servlet-name>dwr-invoker</servlet-name>
  <url-pattern>/dwr/*</url-pattern>
</servlet-mapping>

接下来创建 dwr.xml 文件并将此放在 web.xml 所在的 WEB-INF 目录下。文件中类似下面的内容：

<!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>
    <create creator=”new” javascript=”Demo”>
      <param name=”class” value=”your.java.Bean”/>
    </create>
  </allow>
</dwr>

DWR 配置文件定义了由 DWR 创建和被 Javascript 远程使用的类。在上面的例子中我们在远程创建了2个类，并且给出了在 Javascript 中的类名。

上面使用的 new creator 使用了所有的 JavaBeans 必须含有的公有（public）无参（no-args）的构造函数。值得一提的是， DWR 还有一些限制：

    每个convert都包含两个方法convertInbound，convertOutbound,这两个方法相反
    convertInbound    进站转换 将字符串转换为java可识别的对象                                针对调用方法的输入参数
    convertOutbound 出站转换 将java对象转换为javascript可识别的json格式的字符串 针对调用方法的返回值

下面这些可以实现基于web的实时事件通知的方法：

    1.HTTP流：这种方法由存在于不间断的HTTP连接响应中或某个XMLHttpRequest连接中的服务器数据流所组成。

　　2.HTTP拉取方式：在这种传统的方法中，客户端以用户可定义的时间间隔去检查服务器上的最新数据。这种拉取方式的频率要足够高才能保证很高的数据精确度，
但高频率可能会导致多余的检查，从而导致较高的网络流量。而另一方面，低频率则会导致错过更新的数据。理想地，拉取的时间间隔应该等于服务器状态改变的速度。

　　3.反转AJAX：服务流应用到AJAX，就是所谓的反转AJAX 或者COMET 。它使得服务器在某事件发生时可以发送消息给客户端，而不需要客户端显式的请求。
目标在于达到状态变化的实时更新。COMET使用了HTTP/1.1中的持续连接的特性。通过HTTP/1.1，除非另作说明，服务器和浏览器之间的TCP连接会一直保持连接状态，
直到其中一方发送了一条明显的“关闭连接”的消息，或者有超时以及网络错误发生。

　　4.长时间轮询：也就是所谓的异步轮询，这种方式是纯服务器端推送方式和客户端拉取方式的混合。它是基于BAYEUX协议的。这个协议遵循基于主题的发布——订阅机制。
在订阅了某个频道后，客户端和服务器间的连接会保持打开状态，并保持一段事先定义好的时间。如果服务器端没有事件发生，而发生了超时，
服务器端就会请求客户端进行异步重新连接。如果有事件发生，服务器端会发送数据到客户端，然后客户端重新连接

    注：Comet：基于 HTTP 长连接的“服务器推”技术
】
        Bayeux是Dojo基金会定义的一个协议。dwr在去年的时候就开始支持该协议，随着dwr项目2008年初加入到Dojo基金会，ajax技术(dwr)和comet(cometd)技术将会融合的更加紧密(说明：dwr,cometd现在都属于dojo基金会下面的项目)，本包将来估计会作很大的变化。ajax技术和comet技术的融合，参看使用 Jetty 和 Direct Web Remoting 编写可扩展的 Comet 应用程序，
        这个包是dwr外部支持包，并未被其他包引用。
        org.directwebremoting.bayeux.BayeuxClient                                                        Bayeux协议客户端
        org.directwebremoting.bayeux.BayeuxScriptConduit                                            Bayeux协议Script管道
        org.directwebremoting.bayeux.BayeuxServletContextAttributeListener                  该监听器由web.xml注册，如果要使用推的技术，那么你就必须注册，BayeuxServletContextAttributeListener，会调用BayeuxClient，按comet原理将script推送的客户端。具体细节未作研究。
     
        
       

 hub   
           集线器，提供多个ajax互相操作接口，使得一个界面中多个ajax可以互相调用，参考openajax联盟制定的规则，dwr已经是联盟的会员之一
           org.directwebremoting.export包会用到，具体细节不清楚

 ScriptBuffer
            采用list储存script，功能类似于StringBuffer

 ServerContext
            服务器端上下文

 WebContext
            浏览器上下文，好像是每个客户一个（红色表示没仔细看）
 auth.js 
            AuthHandler负责读取这个js文件
            细节由CachingFileHandler读取
             readResource()将字节符转换为字符串
             继承JavaScriptHandler接口，专门处理读取js文件

             JavaScriptHandler extends TemplateHandler implements CachingFileHandler implements Handler

             CachingFileHandler
             读取数据文件，根据req的报头属性判断，如果修改过，那么重新下载，否则不用 
             下载读取资源文件，由不同的handle处理，这些handle都继承于JavaScriptHandler
             如：AuthHandler extends JavaScriptHandler
             实际上客户端会将js文件下载到缓存区，这种机制可以使得浏览的时候检查是否js文件内容发生变化。从而重新下载。

 dwr20.dtd  
            org.directwebremoting.impl.DTDEntityResolve处理
 dwr20.xsd 
             实际上没用到
             两种xml框架类型文件，可以被parse识别。

engine.js 
            引擎js,在浏览器缓存中会发现这个文件已经下载到本地。EngineHandler处理,

 messages.properties 
            语言资源文件
            由org.directwebremoting.util.Messages读取
            private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle("org.directwebremoting.messages");

public void init(ServletConfig servletConfig) throws ServletException
    {
        super.init(servletConfig);
        ServletContext servletContext = servletConfig.getServletContext();

        try
        {
            // setupLogging() only needed for servlet logging if commons-logging is unavailable
            // logStartup() just outputs some version numbers
            日志初始化开始
            StartupUtil.logStartup(servletConfig);

            // create and setup a DefaultContainer
             DWR对于Servelet容器内部设一个配置容器，该容器装载dwr隐射相关信息。
            container = ContainerUtil.createAndSetupDefaultContainer(servletConfig);

            StartupUtil.initContainerBeans(servletConfig, servletContext, container);
            webContextBuilder = container.getBean(WebContextBuilder.class);

            ContainerUtil.prepareForWebContextFilter(servletContext, servletConfig, container, webContextBuilder, this);
            ContainerUtil.publishContainer(container, servletConfig);
            ContainerUtil.configureContainerFully(container, servletConfig);
        }
        catch (ExceptionInInitializerError ex)
        {
            log.fatal("ExceptionInInitializerError. Nested exception:", ex.getException());
            throw new ServletException(ex);
        }
        catch (Exception ex)
        {
            log.fatal("DwrServlet.init() failed", ex);
            throw new ServletException(ex);
        }
        finally
        {
            if (webContextBuilder != null)
            {
                webContextBuilder.unset();
            }
        }
    }

比较细致的环节：
 init()调用
     createAndSetupDefaultContainer()
        调用
         setupDefaultContainer(defaultContainer, servletConfig)
             调用如下步骤
                   1)setupDefaults(container);
                   包括：
                   容器相关管理工具配置集，也就是要实现的一些接口。这种方式蛮好，当容器需要具备很多接口功能时，把这些接口全部做成隐射，并设置成可配置的实现
                    container.addImplementation(AccessControl.class, DefaultAccessControl.class);
                    // Mapping handlers to URLs，路径配置
                    createUrlMapping(container, "/index.html", IndexHandler.class, "indexHandlerUrl");
                    //读取servlet配置属性
                   2)setupFromServletConfig(container, servletConfig);
                     额外处理1)中多选类型
                   3)resolveMultipleImplementations(container, servletConfig);

                    里面使用了通用yui型压缩器 
                   【使用 YUI Compressor 压缩 Javascript 和 CSS 
        
                    工具下载： http://www.julienlecomte.net/yuicompressor/ 
                    英文介绍： http://com3.devnet.re3.yahoo.com/yui/compressor/

                    YUI Compressor是使用Java编写的工具，需要Java版本大于等于1.4。

                    工作原理简介： 
                    主要是去掉冗余的空白，主要包括空格，换行符、制表符。 
                    对于 Javascript，还采用缩短变量名的方法压缩文件，就是在保证代码正确性的情况下将变量名用只有1个字符的字符串代替，或者2个、3个字符，总之尽量短。 
                    对于 CSS，还有采用优化0值属性值的表示，优化颜色值的方法压缩文件。 
                     CSS的优化比 CSSTidy 功能弱。CSSTidy还能支持一些相关属性的合并。】
                     //工具配置集 加载，显现，检查
                   4)container.setupFinished();
                     容器内容bean初始化 ,包括系统默认？？？
                     initContainerBeans

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException
    {
        doPost(req, resp);
    }

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
    {
        try
        {
            webContextBuilder.set(request, response, getServletConfig(), getServletContext(), container);

            UrlProcessor processor = container.getBean(UrlProcessor.class);
            processor.handle(request, response);
        }
        finally
        {
            webContextBuilder.unset();
        }
    }