All clips tagged ajax : clipclip

Servlet 3.0 实战：异步 Servlet 与 Comet 风格应用程序 - 喝咖啡 - 博客园

http://www.cnblogs.com/hasv/archive/2011/10/11/...

clipped by wqmd Dec 23, 2011

其中，在开源社区中讨论得最多的就是 Servlet 异步处理的支持，所谓 Servlet 异步处理，包括了非阻塞的输入/输出、异步事件通知、延迟 request 处理以及延迟 response 输出等几种特性。这些特性大多并非 JSR 315 规范首次提出，譬如非阻塞输入/输出，在 Tomcat 6.0 中就提供了 Advanced NIO 技术以便一个 Servlet 线程能处理多个 Http Request，Jetty、GlassFish 也曾经有过类似的支持。但是使用这些 Web 容器提供的高级特性时，因为现有的 Servlet API 没有对这类应用的支持，所以都必须引入一些 Web 容器专有的类、接口或者 Annotations，导致使用了这部分高级特性，就必须与特定的容器耦合在一起，这对很多项目来说都是无法接受的。因此 JSR 315 将这些特性写入规范，提供统一的 API 支持后，这类异步处理特性才真正具备广泛意义上的实用性，只要支持 Servlet 3.0 的 Web 容器，就可以不加修改的运行这些 Web 程序。

JSR 315 中的 Servlet 异步处理系列特性在很多场合都有用武之地，但人们最先看到的，是它们在“服务端推”（Server-Side Push）方式 —— 也称为 Comet 方式的交互模型中的价值。在 JCP（Java Community Process）网站上提出的 JSR 315 规范目标列表，关于异步处理这个章节的标题就直接定为了“Async and Comet support”（异步与 Comet 支持）。

本文将详细介绍 Comet 风格应用的实现方式，以及 Servlet 3.0 中的异步处理特性在 Comet 风格程序中的实际应用。

经典 Request-Response 交互模型的突破

“Comet 技术”、“服务端推技术（Server-Side Push）”、“反向 Ajax 技术”这几个名称说的是同一件事情，可能您已经听说过其中的一项或者几项。但没听说过也没有关系，一句话就足以表达它们全部的意思：“在没有客户端请求的情况下，服务端向客户端发送数据”。

这句话听起来很简单很好理解，但是任何一个长期从事 B/S 应用程序开发的程序都清楚，这实现起来并不简单，甚至很长一段时间内，人们认为这是并不可能的。因为这种做法完全不符合传统基于 HTTP 协议的交互思想：只有基于 Socket 层次的应用才能做到 Server 和 Client 端双方对等通讯，而基于 HTTP 的应用中，Server 只是对来自 Client 的请求进行回应，不关心客户端的状态，不主动向客户端请求信息，因此 Http 协议被称为无状态、单向性协议，这种交互方式称为 Request-Response 交互模型。

无状态、单向的经典 Request-Response 交互模型有很多优点，譬如高效率、高可伸缩等。对于被动响应用户请求为主的应用，像 CMS、MIS、ERP 等非常适合，但是对于另外一些需要服务端主动发送的需求，像聊天室（用户不发言的时候也需要把其它用户的发言传送回来）、日志系统（客户端没有请求，当服务端有日志输出时主动发送到客户端）则处理起来很困难，或者说这类应用根本不适合使用经典的 Request-Response 交互模型来处理。当“不适合”与“有需求”同时存在时，人们就开始不断寻找突破这种限制的方法。

Comet 实现的方法

简单轮询

最早期的 Web 应用中，主要通过 JavaScript 或者 Meta HTML 标签等手段，定时刷新页面来检测服务端的变化。显然定时刷新页面服务端仍然在被动响应客户端的请求，只不过客户端的请求是连续、频繁的，让用户看起来产生有服务端自动将信息发过来的错觉。这种方式简单易行，但缺陷也非常明显：可能大部分请求都是无意义的，因为服务端期待的事件没有发生，实际上并没有需要发送的信息，而不得不重复的回应着页面上所有内容给浏览器；另外就是当服务端发生变化时，并不能“实时”的返回，刷新的间隔太短，产生很大的性能浪费，间隔太长，事件通知又可能晚于用户期望的时间到达。

当绝大部分浏览器提供了 XHR（XmlHttpRequest）对象支持后，Ajax 技术出现并迅速流行，这一阶段做的轮询就不必每次都返回都返回整个页面中所有的内容，如果服务端没有事件产生，只需要返回极少量内容的 http 报文体。Ajax 可以节省轮询传输中大量的带宽浪费，但它无法减少请求的次数，因此 Ajax 实现的简单轮询仍然有轮询的局限性，对其缺陷只能一定程度缓解，而无法达到质变。

长轮询（混合轮询）

长轮询与简单轮询的最大区别就是连接时间的长短：简单轮询时当页面输出完连接就关闭了，而长轮询一般会保持 30 秒乃至更长时间，当服务器上期待的事件发生，将会立刻输出事件通知到客户端，接着关闭连接，同时建立下一个连接开始一次新的长轮询。

长轮询的实现方式优势在于当服务端期待事件发生，数据便立即返回到客户端，期间没有数据返回，再较长的等待时间内也没有新的请求发生，这样可以让发送的请求减少很多，而事件通知的灵敏度却大幅提高到几乎是“实时”的程度。

Comet 流（Forever Frame）

Comet 流是按照长轮询的实现思路进一步发展的产物。令长轮询将事件通知发送回客户端后不再关闭连接，而是一直保持直到超时事件发生才重新建立新的连接，这种变体我们就称为 Comet 流。客户端可以使用 XmlHttpRequest 对象中的 readyState 属性来判断是 Receiving 还是 Loaded。Comet 流理论上可以使用一个链接来处理若干次服务端事件通知，更进一步节省了发送到服务端的请求次数。

无论是长轮询还是 Comet 流，在服务端和客户端都需要维持一个比较长时间的连接状态，这一点在客户端不算什么太大的负担，但是服务端是要同时对多个客户端服务的，按照经典 Request-Response 交互模型，每一个请求都占用一个 Web 线程不释放的话，Web 容器的线程则会很快消耗殆尽，而这些线程大部分时间处于空闲等待的状态。这也就是为什么 Comet 风格服务非常期待异步处理的原因，希望 Web 线程不需要同步的、一对一的处理客户端请求，能做到一个 Web 线程处理多个客户端请求。

实战 Servlet 异步处理

当前已经有不少支持 Servlet API 3.0 的 Web 容器，如 GlassFish v3、Tomcat 7.0、Jetty 8.0 等，在本文撰写时，Tomcat 7 和 Jetty 8 都仍然处于测试阶段，虽然支持 Servlet 3.0，但是提供的样例代码仍然是与容器耦合的 NIO 实现，GlassFish v3 提供的样例（玻璃鱼聊天室）则是完全标准的 Servlet 3.0 实现，如果读者需要做找参考样例，不妨优先查看 GlassFish 的 example 目录。本文后一部分会提供另外一个更具备实用性的例子“Web 日志系统”作为 Servlet API 3.0 的实战演示进行讲解。

Web 日志系统实战

Apache Log4j 是当前最主流的日志处理器，它有许多不同的 Appender 可以将日志输出到控制台、文件、数据库、Email 等等。在大部分应用中用户都不可能查看服务器的控制台或者日志文件，如果能直接在浏览器上“实时”的查看日志将会是给开发维护带来方便，在本例中将实现一个日志输出到浏览器的 Appender 实现。

清单 1. Log4j 异步 Web Appender

            /**
            * 基于 AsyncContext 支持的 Appender
            * @author zzm
            */
            public class WebLogAppender extends WriterAppender {
            /**
            * 异步 Servlet 上下文队列
            */
            public static final Queue&lt;AsyncContext&gt; ASYNC_CONTEXT_QUEUE
            = new ConcurrentLinkedQueue&lt;AsyncContext&gt;();
            /**
            * AsyncContextQueue Writer
            */
            private Writer writer = new AsyncContextQueueWriter(ASYNC_CONTEXT_QUEUE);
            public WebLogAppender() {
            setWriter(writer);
            }
            public WebLogAppender(Layout layout) {
            this();
            super.layout = layout;
            }
            }

上面是 Appender 类的代码模版，派生自 org.apache.log4j.WriterAppender，Log4j 默认提供的所有 Appender 都从此类继承，子类代码执行的逻辑仅仅是告知 WriterAppender 如何获取 Writer。而我们最关心的如何异步将日志信息输出至浏览器，则在 AsyncContextQueueWriter 中完成。

清单 2：异步上下文队列 Writer

            /**
            * 向一个 Queue&lt;AsyncContext&gt; 中每个 Context 的 Writer 进行输出
            * @author zzm
            */
            public class AsyncContextQueueWriter extends Writer {
            /**
            * AsyncContext 队列
            */
            private Queue&lt;AsyncContext&gt; queue;
            /**
            * 消息队列
            */
            private static final BlockingQueue&lt;String&gt; MESSAGE_QUEUE
            = new LinkedBlockingQueue&lt;String&gt;();
            /**
            * 发送消息到异步线程，最终输出到 http response 流
            * @param cbuf
            * @param off
            * @param len
            * @throws IOException
            */
            private void sendMessage(char[] cbuf, int off, int len) throws IOException {
            try {
            MESSAGE_QUEUE.put(new String(cbuf, off, len));
            } catch (Exception ex) {
            IOException t = new IOException();
            t.initCause(ex);
            throw t;
            }
            }
            /**
            * 异步线程，当消息队列中被放入数据，将释放 take 方法的阻塞，将数据发送到 http response 流上
            */
            private Runnable notifierRunnable = new Runnable() {
            public void run() {
            boolean done = false;
            while (!done) {
            String message = null;
            try {
            message = MESSAGE_QUEUE.take();
            for (AsyncContext ac : queue) {
            try {
            PrintWriter acWriter = ac.getResponse().getWriter();
            acWriter.println(htmlEscape(message));
            acWriter.flush();
            } catch (IOException ex) {
            System.out.println(ex);
            queue.remove(ac);
            }
            }
            } catch (InterruptedException iex) {
            done = true;
            System.out.println(iex);
            }
            }
            }
            };
            /**
            * @param message
            * @return
            */
            private String htmlEscape(String message) {
            return &quot;&lt;script type='text/javascript'&gt;\nwindow.parent.update(\&quot;&quot;
            + message.replaceAll(&quot;\n&quot;, &quot;&quot;).replaceAll(&quot;\r&quot;, &quot;&quot;) + &quot;\&quot;);&lt;/script&gt;\n&quot;;
            }
            /**
            * 保持一个默认的 writer，输出至控制台
            * 这个 writer 是同步输出，其它输出到 response 流的 writer 是异步输出
            */
            private static final Writer DEFAULT_WRITER = new OutputStreamWriter(System.out);
            /**
            * 构造 AsyncContextQueueWriter
            * @param queue
            */
            AsyncContextQueueWriter(Queue&lt;AsyncContext&gt; queue) {
            this.queue = queue;
            Thread notifierThread = new Thread(notifierRunnable);
            notifierThread.start();
            }
            @Override
            public void write(char[] cbuf, int off, int len) throws IOException {
            DEFAULT_WRITER.write(cbuf, off, len);
            sendMessage(cbuf, off, len);
            }
            @Override
            public void flush() throws IOException {
            DEFAULT_WRITER.flush();
            }
            @Override
            public void close() throws IOException {
            DEFAULT_WRITER.close();
            for (AsyncContext ac : queue) {
            ac.getResponse().getWriter().close();
            }
            }
            }

这个类是 Web 日志实现的关键类之一，它继承至 Writer，实际上是一组 Writer 的集合，其中包含至少一个默认 Writer 将数据输出至控制台，另包含零至若干个由 Queue<AsyncContext> 所决定的 Response Writer 将数据输出至客户端。输出过程中，控制台的 Writer 是同步的直接输出，输出至 http 客户端的则由线程 notifierRunnable 进行异步输出。具体实现方式是信息放置在阻塞队列 MESSAGE_QUEUE 中，子线程循环时使用到这个队列的 take() 方法，当队列没有数据这个方法将会阻塞线程直到等到新数据放入队列为止。

我们在 Log4j.xml 中修改一下配置，将 Appender 切换为 WebLogAppender，那对 Log4j 本身的扩展就算完成了：

清单 3：Log4j.xml 配置

            &lt;appender name=&quot;CONSOLE&quot; class=&quot;org.fenixsoft.log.WebLogAppender
            &quot;&gt;
            &lt;param name=&quot;Threshold&quot; value=&quot;DEBUG&quot;/&gt;
            &lt;layout class=&quot;org.apache.log4j.PatternLayout&quot;&gt;
            &lt;!-- The default pattern: Date Priority [Category] Message\n --&gt;
            &lt;param name=&quot;ConversionPattern&quot; value=&quot;%d %p [%c] %m%n&quot;/&gt;
            &lt;/layout&gt;
            &lt;/appender&gt;

接着，建立一个支持异步的 Servlet，目的是每个访问这个 Servlet 的客户端，都在 ASYNC_CONTEXT_QUEUE 中注册一个异步上下文对象，这样当有 Logger 信息发生时，就会输出到这些客户端。同时，将建立一个针对这个异步上下文对象的监听器，当产生超时、错误等事件时，将此上下文从队列中移除。

清单 4：Web 日志注册 Servlet

            /**
            * Servlet implementation class WebLogServlet
            */
            @WebServlet(urlPatterns = { &quot;/WebLogServlet&quot; }, asyncSupported = true)
            public class WebLogServlet extends HttpServlet {
            /**
            * serialVersionUID
            */
            private static final long serialVersionUID = -260157400324419618L;
            /**
            * 将客户端注册到监听 Logger 的消息队列中
            */
            @Override
            protected void doGet(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
            res.setContentType(&quot;text/html;charset=UTF-8&quot;);
            res.setHeader(&quot;Cache-Control&quot;, &quot;private&quot;);
            res.setHeader(&quot;Pragma&quot;, &quot;no-cache&quot;);
            req.setCharacterEncoding(&quot;UTF-8&quot;);
            PrintWriter writer = res.getWriter();
            // for IE
            writer.println(&quot;&lt;!-- Comet is a programming technique that enables web
            servers to send data to the client without having any need for the client
            to request it. --&gt;\n&quot;);
            writer.flush();
            final AsyncContext ac = req.startAsync();
            ac.setTimeout(10 * 60 * 1000);
            ac.addListener(new AsyncListener() {
            public void onComplete(AsyncEvent event) throws IOException {
            WebLogAppender.ASYNC_CONTEXT_QUEUE.remove(ac);
            }
            public void onTimeout(AsyncEvent event) throws IOException {
            WebLogAppender.ASYNC_CONTEXT_QUEUE.remove(ac);
            }
            public void onError(AsyncEvent event) throws IOException {
            WebLogAppender.ASYNC_CONTEXT_QUEUE.remove(ac);
            }
            public void onStartAsync(AsyncEvent event) throws IOException {
            }
            });
            WebLogAppender.ASYNC_CONTEXT_QUEUE.add(ac);
            }
            }

服务端处理到此为止差不多就结束了，我们再看看客户端的实现。其实客户端我们直接访问这个 Servlet 就可以看到浏览器不断的有日志输出，并且这个页面的滚动条会一直持续，显示 http 连接并没有关闭。为了显示，我们还是对客户端进行了包装，通过一个隐藏的 frame 去读取 WebLogServlet 发出的信息，既 Comet 流方式实现。

清单 5：客户端页面

            &lt;html&gt;
            &lt;head&gt;&lt;/head&gt;
            &lt;script type=&quot;text/javascript&quot; src=&quot;js/jquery-1.4.min.js&quot;&gt;&lt;/script&gt;
            &lt;script type=&quot;text/javascript&quot; src=&quot;js/application.js&quot;&gt;&lt;/script&gt;
            &lt;style&gt;
            .consoleFont{font-size:9; color:#DDDDDD; font-family:Fixedsys}
            .inputStyle{font-size:9; color:#DDDDDD; font-family:Fixedsys; width:100%;
            height:100%; border:0; background-color:#000000;}
            &lt;/style&gt;
            &lt;body style=&quot;margin:0; overflow:hidden&quot; &gt;
            &lt;table width=&quot;100%&quot; height=&quot;100%&quot; border=&quot;0&quot; cellpadding=&quot;0&quot;
            cellspacing=&quot;0&quot; bgcolor=&quot;#000000&quot;&gt;
            &lt;tr&gt;
            &lt;td colspan=&quot;2&quot;&gt;&lt;textarea name=&quot;result&quot; id=&quot;result&quot; readonly=&quot;true&quot; wrap=&quot;off&quot;
            style=&quot;padding: 10; overflow:auto&quot; class=&quot;inputStyle&quot; &gt;&lt;/textarea&gt;&lt;/td&gt;
            &lt;/tr&gt;
            &lt;/table&gt;
            &lt;iframe id=&quot;comet-frame&quot; style=&quot;display: none;&quot;&gt;&lt;/iframe&gt;
            &lt;/body&gt;
            &lt;/html&gt;

清单 6：客户端引用的 application.js

            $(document).ready(function() {
            var url = '/AsyncServlet/WebLogServlet';
            $('#comet-frame')[0].src = url;
            });
            function update(data) {
            var resultArea = $('#result')[0];
            resultArea.value = resultArea.value + data + '\n';
            }

为了模拟日志输出，我们读取了一个已有的日志文件，将内容调用 Logger 输出到浏览器，读者在调试时直接运行源码包中的 TestServlet 即可，运行后整体效果如下所示：

图 1. 运行效果

结束语

Comet 的出现为 Web 交互带来了全新的体验，而 Servlet 3.0 和异步 IO 则为 Comet 实现过程中服务端 Web 线程占用的问题提供了规范的解决方案。随着各种支持 Servlet 3.0 容器的出现，Comet 的应用将越来越频繁，目前开发 Comet 应用还是具有一定的挑战性，但随着需求推动技术的发展，相信 Comet 的应用会变得和 AJAX 一样普及。

浅析Comet技术在Java Web实时系统开发中的应用 - 岁月联盟 www.Syue.com

http://www.syue.com/Paper/Computer/App/245823.html

clipped by wqmd Dec 22, 2011

ajax 异步servlet

Show Clip

HTTP协议是互联网上大量信息交换的基础,其特点是,它是基于请求—响应模式的无状态的单向协议,即必须由客户端发起一个请求建立连接,服务器接收请求,把数据返回给客户端,然后释放连接。下一次,再由客户端发起另一次请求,重复上述过程。服务器始终处于“被动”地位。

　　HTTP协议这一特点,既成就了它的成功,也导致了它的局限性。服务器处理请求的经典模式是一个线程处理一个连接,结束之后,关闭该连接,释放线程以服务于其他请求。只要响应速度足够快,那么我们可以以相对较少的服务器为数量庞大的用户提供服务。这非常适合于传统的Web应用,比如:搜索引擎、内容管理系统和商务网站等。然而,这种方式并不能满足有实时性要求的应用的需求,很多应用都需要服务器能实时地将更新的信息传送到客户端,而无须客户端发出请求。例如,新闻标题、证券报价和拍卖行情等。

　　在Web的早期,人们通过在HTML头部加入META元信息来实现HTML自动刷新。该标记指示浏览器每隔一定的时间间隔刷新一次页面。这不仅带来糟糕的用户体验,而且是一种低效的做事方式。因为如果没有新的数据,该页面就没必要刷新;如果页面只存在小范围内的变化,该页面就没有必要全部刷新。

　　AJAX(Asynchronous JavaScript and XML,异步JavaScript和XML)的出现改变了上述情况。Ajax的工作原理相当于在客户和服务器之间加了—个中间层,使客户请求与服务器响应异步化。并不是所有的请求都提交给服务器,像—些数据验证和数据处理等都交给AJAX引擎自己来做,只有确定需要从服务器读取新数据时再由AJAX引擎代为向服务器提交请求。使用Ajax的最大优点就是能在不刷新整个页面的前提下维护数据,使得Web应用程序更为迅捷地响应用户交互,并避免了在上发送那些没有改变的信息。然而,AJAX仍然受限于Web请求/响应模式的弱点,使得服务器不能推送实时动态的Web数据。

　　

　　1 Comet技术实现方式[1]

　　Comet技术被称为反AJAX(Reverse AJAX)技术,它通过实现服务器推(server push)来解决AJAX需要定时频繁发送请求的问题。通过Comet,客户端所需要的响应信息不再需要主动地去索取,而是在服务器端以事件(Event)的形式推至客户端。

　　Comet技术的实现方式有两种:长轮询方式(long-polling)和流方式(streaming)。

　　长轮询:HTTP的连接保持,服务器端会阻塞请求,直到服务器端有一个事件触发或者到达超时。客户端在收到响应后再次发出请求,重新建立连接。通过这种方式,服务器可以在数据可用的任何时候将数据“推”到客户端。因为这种方案基于AJAX,请求异步发出,无须安装插件,IE、Mozilla FireFox都支持。

　　流方式:在流方式中,服务器推数据返回客户端,但不关闭连接,连接始终保持,直到超时,超时后通知客户端重新建立连接,并关闭原来的连接。

　　在长轮询方式下,客户端是在XMLHttpRequest的readystate为4(即数据传输结束)时调用回调函数,进行信息处理。当readystate为4时,数据传输结束,连接已经关闭。Mozilla Firefox提供了对流方式的支持,即readystate为3时(数据仍在传输中),客户端可以读取数据,从而无须关闭连接,就能读取处理服务器端返回的信息。IE在readystate为3时,不能读取服务器返回的数据,目前IE不支持流方式。

　　不管是长轮询还是流,请求都需要在服务器上存在一段较长时间,因此Comet被称为“基于HTTP长连接的服务器推技术”。这打破了每个请求一个线程的模型。这个模型显然对Comet不适用。Java对此提出了非阻塞IO(non-blocking IO)解决方案,Java通过它的NIO库提供非阻塞IO处理Comet。

　　传统的阻塞式IO,每个连接必须要开一个线程来处理,您始终从一个线程中读取流直到整个流完成,然后关闭连接。因此阻塞式IO对大量并发的短生命周期连接不会造成问题。而非阻塞IO处理连接是异步的。当某个连接发送请求到服务器,服务器把这个连接请求当作一个请求“事件”,并把这个“事件”分配给相应的函数处理。我们把这个处理函数放到线程中去执行,执行完就把线程归还。这样一个线程就可以异步地处理多个事件。

　　为了获得事件通知,我们需要一个机制,它只在需要读时才读,需要写时才写,但又保持连接打开以迅速响应发生的事件。为了方便这个过程,就要用到NIO,它已是1.4版本以后的Java语言的一部分。

　　

　　2 使用Java开发Comet风格的Web应用

　　支持Comet的Java Web开源服务器有Tomcat 6.0.14和Jetty 6.1.14,它们的实现方法各不相同。下面我们以Tomcat为例来说明开发Comet风格的Web应用的步骤[2]。

　　本例以流方式实现了一个Comet应用。服务器每隔一定的时间间隔产生一个0~9之间的随机数,将数据推送到客户端。客户端接收并显示。

　　第一,要下载和安装Tomcat6.X(本文截稿时,Tomcat最新版本是6.0.24)。

　　第二,为了使用Comet,要求服务器支持NIO,所以要修改Tomcat配置文件conf/server.xml, 即启用异步版本的IO连接器,这个非常关键。如下所示:

　　

　　第三,该项目需要Comet的API支持,Tomcat6自带的Comet API包为catalina.jar,在Tomcat安装目录下的lib目录中。

　　第四,编写Servlet。通过servlet实现CometProcessor接口。这个接口要求实现event()方法,在配置的Http11NioProtocol调用event()方法来处理请求,而不是doGet或doPost。最基本的支持Comet的servlet实现如程序清单1所示。

　　

　　在event()方法中,分别处理连接开始(BEGIN)、新数据可用(READ),连接结束(END),或出错等事件。Comet允许针对不同的事件指定不同的连接超时。这意味着可以给常规的请求设置很短的生命周期,但是对于响应长连接请求的机制,可以将这个生命周期延长至几分钟。

　　TestComet Servlet中,在连接开始时首先设置连接超时为60秒,接着启动一个推送数据的线程。该线程的实现类为RandomSender,如程序清单2所示。请注意,这个类含有一个 ServletResponse对象。回头看看清单1中的event()方法,当事件为BEGIN时,response对象被传入到 RandomSender中。RandomSender的run()使用ServletResponse将数据发送回客户机。因为要实现流风格的Comet,所以不能关闭连接。而要使连接保持开启。如果要实现长轮询,则一旦发送完所有消息后,就要关闭连接。

　　

　　第五,编写客户端。在客户端,发出AJAX请求。请求和常规请求差不多。程序清单3测试了最基本的AJAX请求,它基于XMLHttpRequest,能够很好地响应来自Comet服务器的事件。客户端在readystate为3时(数据仍在传输中)读取数据,从而无须关闭连接,就能读取处理服务器端返回的数据,将它显示在浏览器上。

　　

　　第六,运行程序。首先进行部署,为了使程序正常运行,先要删除本应用的lib目录下的catalina.jar,如果不这么做,会出现异常:java.lang.ClassCastException: org.apache.catalina.util.DefaultAnnotationProcessor cannot be cast to org.apache.AnnotationProcessor。

　　最后,重启Tomcat6,用FireFox浏览器调用主页面index.jsp,就可以看到随机数不断地涌现。

　　

　　3 结束语

　　采用Comet技术实现的Java Web实时系统带来了全新的交互性,目前Java Web服务器正在为实现Comet提供成熟、稳定的技术,不久的将来,Comet将成为Servlet 3.0和JavaEE6的标准的一部分。

Servlet 3.0笔记之异步请求Comet推送长轮询(long polling)篇 - Java@Free - BlogJava

http://www.blogjava.net/yongboy/archive/2011/02...

clipped by wqmd Dec 22, 2011

ajax 异步servlet

Show Clip

Comet另一种形式为长轮询（long polling），客户端会与服务器建立一个持久的连接，直到服务器端有数据发送过来，服务器端断开，客户端处理完推送的数据，会再次发起一个持久的连接，循环往复。

和流（Streaming）区别主要在于，在一次长连接中，服务器端只推送一次，然后断开连接。

其实现形式大概可分文AJAX长轮询和JAVASCRIPT轮询两种。

AJAX方式请求长轮询

服务器端可以返回原始的数据，或格式化的JSON、XML、JAVASCRIPT信息，客户端可拥有更多的处理自由。在形式上和传统意义上的AJAX GET方式大致一样，只不过下一次的轮询需要等到上一次的轮询数据返回处理完方可进行。

这里给出客户端的小示范：

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">


<html>


<head>


<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">


<title>jQuery 1.5 with long poll</title>


</head>


<body>


<div id="tip"></div>


<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.min.js"></script>


<script type="text/javascript">


$(function (){


 function log(resp){


  $("#tip").html("<b>" + resp + "</b>");


 }


 


 log("loading");


 


 // 去除缓存


    $.ajaxSetup({ cache: false });





 function initGet(){


  $.get("getNextTime")


    .success(function(resp){


   log(resp);


  }).error(function(){


   log("ERROR!");


  }).done(initGet);


 }


 


 initGet();


});


</script>


</body>


</html>

基于jQuery 1.5,事件链，比以往更简洁明了，尤其是在done方法中又一次调用自身，棒极了。

服务器端很简单，每1秒输出一次当前系统时间:

/**


 * 简单模拟每秒输出一次当前系统时间，精细到毫秒


 * 


 * @author yongboy


 * @date 2011-2-11


 * @version 1.0


 */


@WebServlet("/getNextTime")


public class GetNextTimeServlet extends HttpServlet {


 private static final long serialVersionUID = 1L;





 protected void doGet(HttpServletRequest request,


   HttpServletResponse response) throws ServletException, IOException {


  try {


   Thread.sleep(1000L);


  } catch (InterruptedException e) {


   e.printStackTrace();


  }





  response.setContentType("text/plain");


  PrintWriter out = response.getWriter();





  out.print(DateFormatUtils.format(System.currentTimeMillis(),


    "yyyy-MM-dd HH:mm:ss SSS"));


  out.flush();





  out.close();


 }


}

JAVASCRIPT标签轮询（Script tag long polling）

引用的JAVASCRIPT脚本文件是可以跨域的，再加上JSONP,更为强大了。

这里给出一个演示，实现功能类似上面。

客户端清单：

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">


<html>


<head>


<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">


<title>jQuery 1.5 with JSONP FOR Comet</title>


</head>


<body>


<div id="tip"></div>


<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.min.js"></script>


<script type="text/javascript">


$(function (){


 function log(resp){


  $("#tip").html("<b>"   resp   "</b>");


 }


 


 log("loading");





 function jsonp(){


  $.getJSON('http://192.168.0.99:8080/servlet3/getNextTime2?callback=?').success(function(resp){


   log("now time : "   resp);


  }).done(jsonp);


  


  // 以下方式也是合法的


  /*


  $.getJSON('http://192.168.0.99:8080/servlet3/getNextTime2?callback=?',function(date){


   log(date);


  }).done(jsonp);


  */


 }


 


 jsonp();


});


</script>


</body>


</html>

服务器端清单:

/**


 * JSONP形式简单模拟每秒输出一次当前系统时间，精细到毫秒


 * @author yongboy


 * @date 2011-2-11


 * @version 1.0


 */


@WebServlet("/getNextTime2")


public class GetNextTimeServlet2 extends HttpServlet {


 private static final long serialVersionUID = 1L;





 protected void doGet(HttpServletRequest request,


   HttpServletResponse response) throws ServletException, IOException {


  try {


   Thread.sleep(1000L);


  } catch (InterruptedException e) {


   e.printStackTrace();


  }





  String callback = request.getParameter("callback");


  


  if(StringUtils.isBlank(callback)){


   callback = "showResult";


  }





  PrintWriter out = response.getWriter();





  StringBuilder resultBuilder = new StringBuilder();


  resultBuilder


    .append(callback)


    .append("('")


    .append(DateFormatUtils.format(System.currentTimeMillis(), "yyyy-MM-dd HH:mm:ss SSS"))


    .append("');");





  out.print(resultBuilder);


  out.flush();





  out.close();


 }


}

每次请求时，都会在HTML头部生成一个JS网络地址(实现跨域):

http://192.168.0.99:8080/servlet3/getNextTime2?callback=jQuery150832738454006945_1297761629067&_=1297761631777

我们不用指定，jquery会自动生成一个随机的函数名。

请求上面地址服务器端在有新的数据输出时，生成的回调JS函数：

jQuery150832738454006945_1297761629067('2011-02-15 17:20:33 921');

从下面截图可以看到这一点。

jspon snapshot

生成相应内容：

不过，长连接情况下，浏览器认为当前JS文件还没有加载完，会一直显示正在加载中。

上面的JSONP例子太简单，服务器和客户端的连接等待时间不过1秒钟时间左右，若在真实环境下，需要设置一个超时时间。

以往可能会有人告诉你，在客户端需要设置一个超时时间，若指定期限内服务器没有数据返回，则需要通知服务器端程序，断开连接，然后自身再次发起一个新的连接请求。

但在Servlet 3.0 异步连接的规范中，我们就不用那么劳心费神，那般麻烦了。掉换个儿，让服务器端通知客户端超时啦，赶紧重新连接啊。

在前面几篇博客中，演示了一个伪真实场景，博客主添加博客，然后主动以流形式推送给终端用户。这里采用JSONP跨域长轮询连接形式。

客户端：

<html>


<head>


<title>Comet JSONP %u63A8%u9001%u6D4B%u8BD5</title>


    <meta http-equiv="X-UA-Compatible" content="IE=8" />


    <meta http-equiv="content-type" content="text/html;charset=UTF-8"/>


<meta name="author" content="yongboy@gmail.com"/>


<meta name="keywords" content="servlet3, comet, ajax"/>


<meta name="description" content=""/>


<link type="text/css" rel="stylesheet" href="css/main.css"/>


<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.min.js"></script>


<script type="text/javascript">


String.prototype.template=function(){


    var args=arguments;


    return this.replace(/\{(\d )\}/g, function(m, i){


        return args[i];


    });


}


var html = '<div class="logDiv">'


   '<div class="contentDiv">{0}</div>'


      '<div class="tipDiv">last date : {1}</div>'


      '<div class="clear">&nbsp;</div>'


      '</div>';





function showContent(json) {


 $("#showDiv").prepend(html.template(json.content, json.date));


}


function initJsonp(){


 $.getJSON('http://192.168.0.99/servlet3/getjsonpnew?callback=?').success(function(json){


  if(json.state == 1){


   showContent(json);


  }else{


   initJsonp();


   return;


  }


 }).done(initJsonp)


   .error(function(){


  alert("error!");


 });


}


$(function (){


 initJsonp();


});


</script>


</head>


<body style="margin: 0; overflow: hidden">


<div id="showDiv" class="inputStyle">loading ...</div>


</body>


</html>

服务器端接收长轮询连接请求：

/**


 * JSONP获取最新信息


 * 


 * @author yongboy


 * @date 2011-2-17


 * @version 1.0


 */


@WebServlet(urlPatterns = "/getjsonpnew", asyncSupported = true)


public class GetNewJsonpBlogPosts extends HttpServlet {


 private static final long serialVersionUID = 565698895565656L;


 private static final Log log = LogFactory.getLog(GetNewJsonpBlogPosts.class);





 protected void doGet(HttpServletRequest request,


   HttpServletResponse response) throws ServletException, IOException {


  response.setHeader("Cache-Control", "private");


  response.setHeader("Pragma", "no-cache");


  response.setHeader("Connection", "Keep-Alive");


  response.setHeader("Proxy-Connection", "Keep-Alive");


  response.setContentType("text/javascript;charset=UTF-8");


  response.setCharacterEncoding("UTF-8");





  String timeoutStr = request.getParameter("timeout");





  long timeout;





  if (StringUtils.isNumeric(timeoutStr)) {


   timeout = Long.parseLong(timeoutStr);


  } else {


   // 设置1分钟


   timeout = 1L * 60L * 1000L;


  }





  log.info("new request ...");


  final HttpServletResponse finalResponse = response;


  final HttpServletRequest finalRequest = request;


  final AsyncContext ac = request.startAsync(request, finalResponse);


  // 设置成长久链接


  ac.setTimeout(timeout);


  ac.addListener(new AsyncListener() {


   public void onComplete(AsyncEvent event) throws IOException {


    log.info("onComplete Event!");


    NewBlogJsonpListener.ASYNC_AJAX_QUEUE.remove(ac);


   }





   public void onTimeout(AsyncEvent event) throws IOException {


    // 尝试向客户端发送超时方法调用，客户端会再次请求/blogpush，周而复始


    log.info("onTimeout Event!");





    // 通知客户端再次进行重连


    final PrintWriter writer = finalResponse.getWriter();





    String outString = finalRequest.getParameter("callback")


    + "({state:0,error:'timeout is now'});";


    writer.println(outString);


    writer.flush();


    writer.close();


    


    NewBlogJsonpListener.ASYNC_AJAX_QUEUE.remove(ac);


   }





   public void onError(AsyncEvent event) throws IOException {


    log.info("onError Event!");


    NewBlogJsonpListener.ASYNC_AJAX_QUEUE.remove(ac);


   }





   public void onStartAsync(AsyncEvent event) throws IOException {


    log.info("onStartAsync Event!");


   }


  });





  NewBlogJsonpListener.ASYNC_AJAX_QUEUE.add(ac);


 }


}

很显然，在有博客数据到达时，会通知到已注册的客户端。

注意，推送数据之后，需要调用当前的异步上下文complete()函数:

/**


 * 监听器单独线程推送到客户端


 * 


 * @author yongboy


 * @date 2011-2-17


 * @version 1.0


 */


@WebListener


public class NewBlogJsonpListener implements ServletContextListener {


 private static final Log log = LogFactory.getLog(NewBlogListener.class);


 public static final BlockingQueue BLOG_QUEUE = new LinkedBlockingQueue();


 public static final Queue ASYNC_AJAX_QUEUE = new ConcurrentLinkedQueue();





 public void contextDestroyed(ServletContextEvent arg0) {


  log.info("context is destroyed!");


 }





 public void contextInitialized(ServletContextEvent servletContextEvent) {


  log.info("context is initialized!");


  // 启动一个线程处理线程队列


  new Thread(runnable).start();


 }





 private Runnable runnable = new Runnable() {


  public void run() {


   boolean isDone = true;





   while (isDone) {


    if (!BLOG_QUEUE.isEmpty()) {


     try {


      log.info("ASYNC_AJAX_QUEUE size : "


        + ASYNC_AJAX_QUEUE.size());


      MicBlog blog = BLOG_QUEUE.take();





      if (ASYNC_AJAX_QUEUE.isEmpty()) {


       continue;


      }





      String targetJSON = buildJsonString(blog);





      for (AsyncContext context : ASYNC_AJAX_QUEUE) {


       if (context == null) {


        log.info("the current ASYNC_AJAX_QUEUE is null now !");


        continue;


       }


       log.info(context.toString());


       PrintWriter out = context.getResponse().getWriter();





       if (out == null) {


        log.info("the current ASYNC_AJAX_QUEUE's PrintWriter is null !");


        continue;


       }





       out.println(context.getRequest().getParameter(


         "callback")


         + "(" + targetJSON + ");");


       out.flush();





       // 通知，执行完成函数


       context.complete();


      }


     } catch (Exception e) {


      e.printStackTrace();


      isDone = false;


     }


    }


   }


  }


 };





 private static String buildJsonString(MicBlog blog) {


  Map info = new HashMap();


  info.put("state", 1);


  info.put("content", blog.getContent());


  info.put("date",


    DateFormatUtils.format(blog.getPubDate(), "HH:mm:ss SSS"));





  JSONObject jsonObject = JSONObject.fromObject(info);





  return jsonObject.toString();


 }


}

长连接的超时时间，有人贴切的形容为“心跳频率”，联动着两端，需要根据环境设定具体值。

JSONP方式无论是轮询还是长轮询，都是可以很容易把目标程序融合到第三方网站，当前的个人主页、博客等很多小挂件大多也是采用这种形式进行跨域获取数据的。

I Love Script - Themes, Clones, and Scripts from AJAX to ZenCart

http://www.ilovescript.com/

clipped by azaz2 Apr 07, 2011

Ajax ASP CGI JavaScript Perl PHP wordpress themes

Notes by azaz2: I Love Scripts is a collection of themes, templates, clones, applications, dynamic tools, and resources for web developers and webmasters.

No selection was clipped for this page. Watch how to make a clip

Home - Web Parts for Microsoft SharePoint 2007 (MOSS 2007/WSS v.3)

http://www.virtosoftware.com

clipped by dnavertical1 Jan 04, 2010

ajax sharepoint web part

Notes by dnavertical1: sharepoint, web part, ajax

No selection was clipped for this page. Watch how to make a clip

Microsoft SharePoint Development in UK

http://www.silvertouchtech.co.uk/services/micro...

clipped by marksmith08 Oct 22, 2009

ajax ajax developer ajax development ajax web development

Notes by marksmith08: Silver Touch Technologies provides Ajax Development Services, Ajax for Web Development, Ajax Software Development and Ajax based Application development. We also offer Framework Development and Rapid development with AJAX Technologies at Cost Effective an

No selection was clipped for this page. Watch how to make a clip

Ajax Development, Ajax Web Development, Ajax Application Software Development

http://www.silvertouchtech.co.uk/services/ajax-...

clipped by marksmith08 Oct 21, 2009

ajax ajax developer ajax development ajax web development

Notes by marksmith08: Silver Touch Technologies provides Ajax Development Services, Ajax for Web Development, Ajax Software Development and Ajax based Application development. We also offer Framework Development and Rapid development with AJAX Technologies at Cost Effective an

No selection was clipped for this page. Watch how to make a clip