BlogJava-黑灵客栈-随笔分类-AJAXhttp://www.blogjava.net/mstar/category/2359.html搞软件开发就像被强奸,如果不能反抗,就享受它吧！zh-cnTue, 27 Feb 2007 18:34:38 GMTTue, 27 Feb 2007 18:34:38 GMT60用DWR2.0做的一个Server日志查看器http://www.blogjava.net/mstar/archive/2007/01/03/Ajax_DWR2_LogViewer.html黑灵黑灵Wed, 03 Jan 2007 14:21:00 GMThttp://www.blogjava.net/mstar/archive/2007/01/03/Ajax_DWR2_LogViewer.htmlhttp://www.blogjava.net/mstar/comments/91645.htmlhttp://www.blogjava.net/mstar/archive/2007/01/03/Ajax_DWR2_LogViewer.html#Feedback4http://www.blogjava.net/mstar/comments/commentRss/91645.htmlhttp://www.blogjava.net/mstar/services/trackbacks/91645.html有时候我需要查看已经部署到服务器上的应用程序的日志，每次都要远程登录服务器感觉很麻烦，所以一般我会把log文件的目录用apache做个网站，这样通过IE就可以访问到了。但是有时要看即时输出情况，就要不断的F5，很麻烦。所以就有个想法，不如用DWR2.0的反转Ajax来做个程序，让日志有变化时自动的发送到客户端，这样就我一个劲的按F5了。

我下面就把这个程序分享给大家，希望大家提提意见。

首先是环境：
DWR 2.0.rc1
Sun JDK 1.5

先看张运行起来的图吧，大家一看就知道这是个什么东西了。
logviewer.png
你可以制定要监视的log文件，当然有哪些文件文件可以被监视，你必须在服务端的xml配置中文件设置，当然你也可以监视一个目录里的log文件，这对于而log文件是每天生成一个的情况很有用。你可以设定在浏览器上显示的行数，操作行数，屏幕会自动滚动。你还可以添加一些过滤器，过滤掉不想看见的行，我目前只做了到了过滤掉一些信息，当然如果你有兴趣，你也再添加一些更复杂的过滤器。过滤器的模式是用正则表达式表示的。

下面是点击“开始监听”，运行后样子
logviewer2.png
如果服务器上的catalina.2006-12-09.log文件发生变化，客户端的浏览器上log显示区也会自动的向上滚动。


下面我就大致的介绍一下如何用DWR2.0来实现这样的功能。在这里介绍的可能不是很详细，不清楚的地方请看我提供的源码。

先来介绍一下目录结构
├─lib  -- 编译和测试用的第三方类库
├─webapp -- 部署目录
├─test -- 测试程序
├─java -- 主程序
└─build.xml -- ant构建文件

webapp下的文件和目录
│  style.css  -- 样式表文件
│  index.html -- 主画面文件
│
├─WEB-INF
│  │  web.xml -- 部署配置文件
│  │  dwr.xml -- dwr的配置文件
│  │  conf.xml -- 我们这个应用程序配置文件，主要是配置log文件
│  │
│  ├─classes
│  │
│  └─lib
│
└─script -- javascript文件


index.html中就是我们上面的图片上能看到的页面元素。其中的控件的事件处理都写在\script\logviewer.js文件中。

当页面加载时执行startPoll()方法，复杂开始与服务器的通信，并且把log文件选择框初始化，把已经添加过滤器列表显示出来。

function  startPoll() {
    DWREngine.setActiveReverseAjax( true );

    LogManager.getLogFileNames( function  (data) {
        DWRUtil.removeAllOptions( " log_file " );
        DWRUtil.addOptions( " log_file " , data);
    });

    LogManager.getFilters( function (data) {
         for  ( var  i  =   0 ; i  <  data.length; i ++ ) {
            addFilterDiv(data[i].pattern, data[i].id);
        }
    });
}


当点击“开始监听”按钮时调用服务端的LogManager的send方法，服务端开启监听线程，开始监听做为参数传递的文件，如果文件有变动就会把最近增加的行发送到浏览器上来。

var  startWatch  =   function () {
    clearLog();
    LogManager.send(DWRUtil.getValue( " log_file " ));
}


当点击“结束监听”按钮，调用LogManager的stop()方法，结束掉监听线程。

function  stopWatch() {
    LogManager.stop();
}


当点击“清空日志”按钮，清除mainPanel中的所有子元素

function  clearLog() {
     var  mainPanel  =  $( " main_panel " );
     while  (mainPanel.hasChildNodes()) {
        mainPanel.removeChild(mainPanel.firstChild);
    }
}

当点击“添加过滤器”，填充输入框，要求输入做为过滤器的正则表达式，输入完成后，要做两件事：
1、LogManager.addFilter方法，把输入的正则表达式传送给服务端。
2、把这个正则表达式添加到页面上。

function  addFilter() {
     var  regex  =  prompt( " 输入正则表达式 " ,  "" );
     if  (regex  !=   null   &&  regex  !=   "" ) {
        LogManager.addFilter(regex,  function  (filterId) {
            addFilterDiv(regex, filterId);
        });
    }
}
注意这里，我们用到了DWR的回调模式，在调用服务端方法LogManager.addFilter成功后我们才调用客户端的addFilterDiv方法把这个输入的正则表达式显示到页面上。

如果你足够细心的话，应该会发现在这个js文件中有一个叫做addNewLine的方法在index.html中是没有被调用的。这个方法其实是给服务端的LogManager.send函数调用的。

上面这些内容就是服务端脚本的主要内容了，其实很简单。主要负责通过DWR与服务端通信和处理页面显示。

下面介绍服务端的核心类：LogManager

这个类主要就这样几个方法：
   /**
     * 停止监控
     */
    public void stop() {
        if (watcher != null) {
            watcher.halt();
        }
    }

    /**
     * 发送log信息
     */
    public void send(String filename) {
        WebContext wctx = WebContextFactory.get();
        final ScriptSession scriptSession = wctx.getScriptSession();
        if (watcher != null) {
            watcher.halt();
        }

        try {
            watcher = new LogFileWatcher(filename);
            watcher.addListener(new LogUpdateListener() {
                public void onLogUpdate(List<String> lines) {
                    for (String line : lines) {
                        if (checkFilters(line)) {
                            ScriptBuffer scriptBuffer = new ScriptBuffer();
                            scriptBuffer.appendScript("addNewLine(")
                                    .appendData(line)
                                    .appendScript(");");
                            scriptSession.addScript(scriptBuffer);
                        }
                    }
                }
            });
            watcher.start();
        } catch (IOException e) {
            ScriptBuffer scriptBuffer = new ScriptBuffer();
            scriptBuffer.appendScript("addNewLine(")
                    .appendData(e.getMessage())
                    .appendScript(");");
            scriptSession.addScript(scriptBuffer);
            log.warn(e);
        }
    }

    /**
     * 取得指定的日志文件路径
     *
     * @return 指定的日志文件路径
     */
    public List<String> getLogFileNames() {
        List<String> filenames = new ArrayList<String>();
        try {
            XMLConfiguration config = getConfiguration();
            List logfiles = config.getList("log-files.file");
            for (Object o : logfiles) {
                filenames.add((String) o);
            }
        } catch (ConfigurationException e) {
            log.warn(e);
        }

        return filenames;
    }

    /**
     * 取得指定的日志目录下的文件
     *
     * @return 指定的日志目录下的文件
     */
    public List<String> getLogFileNamesFromDir() {
        List<String> filenames = new ArrayList<String>();
        try {
            XMLConfiguration config = getConfiguration();
            String dir = config.getString("log-dir.dir");
            if (dir != null) {
                File rootDir = new File(dir);
                if (rootDir.exists()) {
                    if (rootDir.isFile()) {
                        filenames.add(rootDir.getPath().replace('\\', '/'));
                    } else if (rootDir.isDirectory()) {
                        String patternString = config.getString("log-dir.filter");
                        File[] files;
                        if (patternString != null && !patternString.equals("")) {
                            files = rootDir.listFiles(new LogFileFilter(patternString));
                        } else {
                            files = rootDir.listFiles();
                        }

                        for (File file : files) {
                            filenames.add(file.getPath().replace('\\', '/'));
                        }
                    }
                }
            }
        } catch (ConfigurationException e) {
            log.warn(e);
        }

        return filenames;
    }

    /**
     * 添加一个过滤器，返回过滤器的id
     */
    public int addFilter(String regex) {
        synchronized (filters) {
            Filter filter = new Filter(regex, SequenceGenerator.getInstance().next(), FilterType.INCLUDE);
            filters.add(filter);
            return filter.getId();
        }

    }

    /**
     * 根据id删除一个过滤器
     */
    public void removeFilter(int id) {
        synchronized (filters) {
            filters.remove(new Filter(id));
        }
    }

    /**
     * 取得现在所有的过滤器列表
     */
    public List<Map<String, Object>> getFilters() {
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        synchronized (filters) {
            for (Filter filter : filters) {
                Map<String, Object> filterItem = new HashMap<String, Object>();
                filterItem.put("id", filter.getId());
                filterItem.put("pattern", filter.getPattern().pattern());
                result.add(filterItem);
            }
        }
        return result;
    }

对于大家都做过Java的朋友来说，这些代码应该很容易就能看懂，我就不多说了。大家主要注意一下ScriptSession类，这个类就是起到主要功能的类了。

其中的LogFileWatcher是一个Thread类，它是用来监视log文件的。

SequenceGenerator.java是用来生成过滤器的id的。

LogUpdateListener.java是一个接口，用于实现事件回调的。

然后看一个dwr的配置文件
<dwr>
    <allow>
        <create creator="new" javascript="LogManager" scope="session">
            <param name="class" value="org.devside.logviewer.LogManager"/>
            <include method="send"/>
            <include method="stop"/>
            <include method="getLogFileNames"/>
            <include method="getLogFileNamesFromDir"/>
            <include method="addFilter"/>
            <include method="removeFilter"/>
            <include method="getFilters"/>
        </create>
    </allow>
</dwr>

这里的配置文件和1.x几乎没什么两样，就是scope我这里设置成了session范围的。这样就可以多个人同时监视不同的log文件了。

web.xml文件也基本上是老样子
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="LogViewer" version="2.4"
         xmlns="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">
    <display-name>Web Log Viewer</display-name>

    <servlet>
        <description>Direct Web Remoter Servlet</description>
        <display-name>DWR Servlet</display-name>
        <servlet-name>dwr-invoker</servlet-name>
        <servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>pollAndCometEnabled</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

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

    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>
dwr的包名发生了变化，并且要开启反转ajax，就要把pollAndCometEnabled参数设置为true。

总结，总体来说DWR2.0中的反转ajax还是很容易使用的，这也是dwr的一贯风格，不用知道过多的细节就能容易的实现ajax。dwr绝对是Java开发者的首选ajax框架。
另外我这个程序其实还是为了演示用的，如果想要用户实际开发可能还需要修改，比如安全性上面，性能上面。而性能上面的主要问题是客户端浏览器，如果服务端的log文件过大，而浏览器有不能即时的回收内存，就会造成客户端浏览器内存占用过大而死掉的问题。而服务端由于java的内容回收机制已经比较成熟应该不会有什么问题。我在ie6和firefox2都试过了，firefox效果能好一些。

源码下载：
http://www.blogjava.net/Files/mstar/LogViewer.part1.rar
http://www.blogjava.net/Files/mstar/LogViewer.part2.rar

黑灵 2007-01-03 22:21 发表评论
]]>把DWR的配置写到Spring的配置文件里（Spring2 新特性-自定义schema初体验） http://www.blogjava.net/mstar/archive/2006/11/16/81542.html黑灵黑灵Thu, 16 Nov 2006 07:50:00 GMThttp://www.blogjava.net/mstar/archive/2006/11/16/81542.htmlhttp://www.blogjava.net/mstar/comments/81542.htmlhttp://www.blogjava.net/mstar/archive/2006/11/16/81542.html#Feedback5http://www.blogjava.net/mstar/comments/commentRss/81542.htmlhttp://www.blogjava.net/mstar/services/trackbacks/81542.html你要知道Spring是什么，并且要知道Spring已经出了2.0的版本了。
你要知道DWR是什么，并且要知道DWR也要出2.0的版本了。

呵呵，开个玩笑……。这年头在BlogJava上混的，估计没几个不知道上面这两个项了。

好了，现在言归正传。DWR本身就提供对Spring的支持，可以直接把Spring中的Bean暴露给客户端浏览器的Javascript调用。在dwr.xml中的写法是这样的：

<dwr>
    <allow>
        <create creator="spring" javascript="AjaxPortalService">
            <param name="beanName" value="AjaxPortalService"/>
            <include method="changeWondowState"/>
            <include method="changeWorkbenchState"/>
            <include method="changeWindowOrder"/>
        </create>
    </allow>
</dwr>

这样写到也没什么，只是把项目分模块以后，虽有的配置都写到一个dwr.xml文件里面维护起来比较麻烦，尤其再遇到版本管理中的代码合并。所以曾经我扩展了DWR，让它可以从多个文件读取配置信息。然后每个模块自己一个配置文件，跟着source一起走。这样做也有问题，就是现在Java应用程序的配置文件太多啦！Spring的配置，WebWork的配置，Hibernate的配置，DWR的配置，再加上一些杂七杂八的xml和properties。看着这些配置文件简直要疯掉了。

正在此时，spring2横空出世，现在你可以把一些配置文件合并到一起了。正好趁此机会体验一下Spring2的自定义schema特性。

目标：
把DWR的配置写成这样：
<?xml version="1.0" encoding="GBK"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:dwr="http://www.devside.org/schema/spring/dwr"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
           http://www.devside.org/schema/spring/dwr http://www.devside.org/schema/spring/dwr.xsd"
    default-autowire="byName">
    
    <bean id="departmentDao" class="cn.com.legendapl.hellostruts2.dao.DepartmentDao"/>
    <bean id="employeeDao" class="cn.com.legendapl.hellostruts2.dao.EmployeeDao"/>
    <bean id="companyService" class="cn.com.legendapl.hellostruts2.service.CompanyService"/>
    
    <aop:config>
        <aop:pointcut id="companyServiceOperation" expression="execution(* cn.com.legendapl.hellostruts2.service.ICompanyService.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="companyServiceOperation" />
    </aop:config>    
    
    <bean id="ajaxCompanyProxy" class="cn.com.legendapl.hellostruts2.ajax.AjaxCompanyProxy"/>
    
    <dwr:allow id="ajaxCompanyProxyAllow">
        <dwr:create beanName="ajaxCompanyProxy" javascript="CompanyProxy">
            <dwr:include method="findEmployeeById"/>
        </dwr:create>
        <dwr:convert converter="bean" match="cn.com.legendapl.hellostruts2.entity.*"/>
    </dwr:allow>
</beans>


重点在这里：
    <dwr:allow id="ajaxCompanyProxyAllow">
        <dwr:create beanName="ajaxCompanyProxy" javascript="CompanyProxy">
            <dwr:include method="findEmployeeById"/>
        </dwr:create>
        <dwr:convert converter="bean" match="cn.com.legendapl.hellostruts2.entity.*"/>
    </dwr:allow>

好了现在动手开始做。

原理其实很简单，现在看张图。画的不好，敬请原谅！



spring-dwr.png

从这样图中我们可以看出我们要做如下工作：
1、做一个dwr.xsd，定义spring配置文件中的dwr这部分配置的schema。
   要做这个需要有一定xml和xsd的知识，我也是现学现用啦！

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.devside.org/schema/spring/dwr"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:beans="http://www.springframework.org/schema/beans"
    targetNamespace="http://www.devside.org/schema/spring/dwr" 
    elementFormDefault="qualified"    
    attributeFormDefault="unqualified">

    <xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"/>
    
    <xsd:element name="allow">
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType">
                    <xsd:sequence>
                        <xsd:element name="create" type="createType" minOccurs="0" maxOccurs="unbounded"/>                
                        <xsd:element name="convert" type="convertType" minOccurs="0" maxOccurs="unbounded"/>                
                    </xsd:sequence>  
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>    
    <xsd:complexType name="createType">        
        <xsd:sequence>
            <xsd:element name="auth" type="authType" minOccurs="0" maxOccurs="unbounded"/>
            <xsd:element name="include" type="includeType" minOccurs="0" maxOccurs="unbounded"/>
            <xsd:element name="exclude" type="excludeType" minOccurs="0" maxOccurs="unbounded"/>                            
        </xsd:sequence>
        <xsd:attribute name="beanName" type="xsd:string" use="required"/>
        <xsd:attribute name="javascript" type="xsd:string" use="required"/>                                                
    </xsd:complexType>   
    
    <xsd:complexType name="convertType">
        <xsd:attribute name="converter" type="xsd:string" use="required"/>
        <xsd:attribute name="match" type="xsd:string" use="required"/>
    </xsd:complexType>  
    
    <xsd:complexType name="authType">
        <xsd:attribute name="method" type="xsd:string" use="required"/>
        <xsd:attribute name="role" type="xsd:string" use="required"/>
    </xsd:complexType>
    <xsd:complexType name="includeType">
        <xsd:attribute name="method" type="xsd:string" use="required"/>
    </xsd:complexType>
    <xsd:complexType name="excludeType">
        <xsd:attribute name="method" type="xsd:string" use="required"/>
    </xsd:complexType>
</xsd:schema>

2、我们要做一个DWRNamespaceHandler来处理DWR的配置信息，其实里面就做一件事把AllowBeanDefinitionParser注册给allow节点。因为我们dwr的配置部分根节点就一个标签allow，所以我们就做一个用于解析allow标签的AllowBeanDefinitionParser解析器就行。如果我们的根节点还有其他的标签，同样也要做相应的解析器。

public class DWRNamespaceHandler extends NamespaceHandlerSupport {

    public void init() {
        //把AllowBeanDefinitionParser注册到allow节点
        registerBeanDefinitionParser("allow", new AllowBeanDefinitionParser());
    }

}

其实难点是做AllowBeanDefinitionParser，这里你需要一些DOM模型的知识，来操作配置节点的内容。然后根据内容进行处理。在这里我们，需要做三件事：
   [1]  把配置节点的内容转换成对象模型，即AllowBean（其实就是一些POJO罢了）。
   [2]  把这个AllowBean注册给Spring的Context，这一步是可选的。因为我们主要是把这个Bean给DWR，当然顺道给Spring一份也没什么问题。
   [3] 把这个AllowBean注册到AllowBeanHolder。

3、AllowBeanHolder。
   其实这就是个简单的singleton类，整个运行期只有一个实例。它就像一个容器，AllowBeanDefinitionParser往里放，DWR的Configuration再从这里取。

4、扩展DWR的DefaultConfiguration，我们做一个SpringConfiguration。DWR的DefaultConfiguration是负责读取配置信息的。我们在其中加入从AllowBeanHolder读取配置信息的功能即可。

5、扩展DWR的DWRServlet，我们做一个SpringDWRServlet，原来的DWRServlet加载的是DefaultConfiguration，我们的Serlvet加载我们自己的SpringConfiguration即可。

6、万事俱备，只欠东风啦。就是让Spring知道我们干了这些！
   在META-INF目录下（如果没有在src目录下创建一个）加入spring.handlers和spring.schemas两个文件。
   spring.handlers中的内容：
   http\://www.devside.org/schema/spring/dwr=org.devside.core.support.dwr.DWRNamespaceHandler
   spring.schemas中的内容：
   http\://www.devside.org/schema/spring/dwr.xsd=org/devside/core/support/dwr/dwr.xsd
   
   注意不要写错字哦，我一开始就写错一个字母，结果怎么调试都不能成功，还以为Spring2有问题呢。

ok了，下面我们就可以写一个spring的配置文件来试试喽。

下面提供两个源码包，一个是spring-dwr的源码，一个是hellosturts2，一个struts2+spring2+hibernate3.2的例子，其中有用到spring-dwr的例子。

为了减小容量，我把jar都去掉了，lib目录下提供了一个列表，你可以自己去找相关的jar包。

http://www.blogjava.net/Files/mstar/HelloStruts2.zip

http://www.blogjava.net/Files/mstar/spring-dwr.zip

黑灵 2006-11-16 15:50 发表评论
]]>dwr简介--一个例子(续二) http://www.blogjava.net/mstar/archive/2005/08/09/9674.html黑灵黑灵Tue, 09 Aug 2005 09:56:00 GMThttp://www.blogjava.net/mstar/archive/2005/08/09/9674.htmlhttp://www.blogjava.net/mstar/comments/9674.htmlhttp://www.blogjava.net/mstar/archive/2005/08/09/9674.html#Feedback5http://www.blogjava.net/mstar/comments/commentRss/9674.htmlhttp://www.blogjava.net/mstar/services/trackbacks/9674.html阅读全文

黑灵 2005-08-09 17:56 发表评论
]]>dwr简介--一个例子(续)http://www.blogjava.net/mstar/archive/2005/08/09/9673.html黑灵黑灵Tue, 09 Aug 2005 09:34:00 GMThttp://www.blogjava.net/mstar/archive/2005/08/09/9673.htmlhttp://www.blogjava.net/mstar/comments/9673.htmlhttp://www.blogjava.net/mstar/archive/2005/08/09/9673.html#Feedback5http://www.blogjava.net/mstar/comments/commentRss/9673.htmlhttp://www.blogjava.net/mstar/services/trackbacks/9673.html阅读全文

黑灵 2005-08-09 17:34 发表评论
]]>dwr简介--一个例子http://www.blogjava.net/mstar/archive/2005/08/08/9566.html黑灵黑灵Mon, 08 Aug 2005 05:58:00 GMThttp://www.blogjava.net/mstar/archive/2005/08/08/9566.htmlhttp://www.blogjava.net/mstar/comments/9566.htmlhttp://www.blogjava.net/mstar/archive/2005/08/08/9566.html#Feedback4http://www.blogjava.net/mstar/comments/commentRss/9566.htmlhttp://www.blogjava.net/mstar/services/trackbacks/9566.html阅读全文

黑灵 2005-08-08 13:58 发表评论
]]>dwr简介http://www.blogjava.net/mstar/archive/2005/08/08/9561.html黑灵黑灵Mon, 08 Aug 2005 05:26:00 GMThttp://www.blogjava.net/mstar/archive/2005/08/08/9561.htmlhttp://www.blogjava.net/mstar/comments/9561.htmlhttp://www.blogjava.net/mstar/archive/2005/08/08/9561.html#Feedback11http://www.blogjava.net/mstar/comments/commentRss/9561.htmlhttp://www.blogjava.net/mstar/services/trackbacks/9561.html最近Ajax比较火，全世界都在讨论。于是我也掺和掺和，直接用XMLHttpRequest？现在的我还没有那个水平。用Echo2或者backbase，又感觉那些纯Ajax的framework太重量级了。我要的只是一些简单的应用而已。于是寻觅的重点放在了一些对xmlhttpRequest进行轻量级包装的代码库上了。于是我找到了DWR（Direct Web Remoting）。DWR的口号是AJAX and XMLHttpRequest made easy，并且它也基本上做到了这一点。它提供了一个友好的框架和一些很有用的JavaScript库，可以让我用起Ajax更容易些。详细的信息可以到他们的网站http://www.getahead.ltd.uk/dwr/。顺便在介绍一个网站吧：http://www.ajaxmatters.com 这里也有很多关于Ajax的资源。

 

下面来简单介绍一下DWR。

其实在没有XMLHttpRequest前DWR就有了，那时它用的是IFrame，效果很差，所以我看看了就没有再diao它。现在的DWR主要用XMLHttpRequest，当然也可以选者用IFrame，但是不推荐。

DWR是个open source software，授权方式是 ASL version 2.0的。现在网站上examples and tutorials做的也不错。我就根据这些东西自己也做了一个应用，在本文的后面我会详细讲到。

现在DWR的最新版本是1.0RC1。在我的试用环境相还算比较稳定，没有出现什么问题。

DWR本身以一个dwr.jar的jar包存在，它的入口时一个Servlet（uk.ltd.getahead.dwr.DWRServlet）所以要在web.xml里配置一下就可以了。具体配置看这里http://www.getahead.ltd.uk/dwr/intro.html。比较简单。dwr为我们提供了一个framework帮我们很容易的实现JavaScript和java之间的通信。

howitworks.png
我还没有看过dwr的源码，具体他是怎么实现的我也不太清楚。但大致上肯定是通过xmlhttprequest来调用它的servlet然后把数据用xml打包解包了。其实我觉得这部分到不是dwr给我带来的最方便的地方。最方便的地方应该是他的那些js的库。

所以下面我要介绍一下它的两个重要js对象。

DWREngine （engine.js中），DWRUtil (util.js中)。

DWREngine中的方法是基本上是关于XMLHttpRequest的。

下面中介绍一些

DWREngine.setErrorHandler(handler)

默认的错误处理时弹出一个对话框，你可以通过这个方法改变成你需要的表现形式。

DWREngine.setWarningHandler(handler)

改变默认的警告处理形式

DWREngine.beginBatch()

Some Remote Function…

DWREngine.endBatch()

当你有几个远程调用要一起进行时，就要用到这两个方法。

如果不用这两个方法，你就会发现你的远程调用并不以你想象的顺序进行。

DWREngine中还有一些其它的方法，我没有用过。你可以通过dwr的js-doc来看。如果通过文档看不懂它是干什么用的，就看js源码，源码的注释也是比较详细的。

DWRUtil中也有一些很有用的方法。这些方法一般是编写js的辅助方法。

比如setValue和getValue。大多数html标签有value属性，这时你要获取或者设置它的值时就用$(“someid”).value就可以了。但是有些html标记是没有value属性的，它的值时在标签的中间，如<span id=”span1”>some value</span>这时你要取或设它的值的时候就用DWRUtil.setValue($(“span1”)，someValue)。这样你就可以在客户端动态的表现一些数据了。

还有很多很好用的方法，dwr的例子中有一些说明，源码中的注释也比较详细。

Dwr就介绍到这里吧。下一篇，我做了个table的例子。
screen.jpg



黑灵 2005-08-08 13:26 发表评论
]]>