[转]反向Ajax，第3部分：Web服务器和Socket.IO

这一文章系列探讨了如何使用反向Ajax（Reverse Ajax）技术来开发事件驱动的web应用。第1部分介绍了实现反向Ajax通信的不同方法：轮询（polling）、捎带（piggyback）以及使用了长轮询（long polling）和流（streaming）的Comet；第2部分说明了如何使用WebSocket来实现反向Ajax，并讨论了使用Comet和WebSocket的web服务器的局限性。在本篇文章中，我们学习如何在web应用中使用各种web容器和API的Comet和WebSocket，我们还会了解Socket.IO，这是一个可以在web应用中与反向Ajax一起使用的抽象库。抽象库的使用是透明的，其隐藏了Comet和WebSocket后面的所有复杂性。

前言

时至今日，用户期待的是可通过web访问快速、动态的应用。这一文章系列展示了如何使用反向Ajax（Reverse Ajax）技术来开发事件驱动的web应用。系列的第1部分介绍了反向Ajax、轮询（polling）、流（streaming）、Comet和长轮询（long polling）。你已经了解了Comet是如何使用HTTP长轮询的，这是可靠地实现反向Ajax的最好方式，因为现有的所有浏览器都提供支持。系列的第2部分说明了如何使用WebSocket来实现反向Ajax，一些代码例子被用来帮助说明WebSocket、FlashSocket、服务器端的约束、请求作用域（request-scoped）服务以及暂停长生存期请求等。

在本篇文章中，我们深入细节，讨论在web应用中使用不同web容器和API（Servlet 3.0和Jetty Continuations）的Comet和WebSocket，了解如何通过使用诸如Socket.IO一类的抽象库来透明地使用Comet和Websocket。Socket.IO使用功能检测来确定连接是使用WebSocket、Ajax长轮询、Flash还是其他方式来建立。

你可以下载本文中用到的源代码。

前提条件

理想情况下，要充分体会本文的话，你应该对JavaScrpit和Java有一定的了解。本文中创建的例子是使用Google Guice来构建的，这是一个使用Java编写的依赖注入框架。若要读懂文中所谈内容，你应该要熟悉诸如Guice、Spring或是Pico一类的依赖注入框架的概念。

若要运行本文中的例子，你还需要最新版本的Maven和JDK（参见参考资料）。

Comet和WebSocket的服务器端解决方案

你在第1部分内容中已经了解到了，Comet（长轮询或是流）需要服务器端能够暂停某个请求，并在一个可能的长延迟之后恢复或是完成该请求。第2部分内容描述了服务器端如何使用非阻塞式的I/O功能来处理大量的连接，以及它们只能使用线程来服务请求（每个请求一个线程模式）。你也已经了解到了WebSocket的使用是服务器端依赖的，且并非所有的服务器都支持WebSocket。

本节内容说明了如果适用的话，那么在Jetty、Tomcat和Grizzly等web服务器上是如何使用Comet和WebSocket的。本文提供的源代码包含了Jetty和Tomcat的一个聊天web应用例子。本节内容还讨论了下面的这些应用服务器：Jboss、Glassfish和WebSphere所支持的API。

Jetty

Jetty是一个web服务器，支持Java Servlet 3.0规范、WebSocket和其他的许多集成规范。Jetty:

1. 功能强大且灵活

2. 易于嵌入

3. 支持虚拟主机、会话集群和许多可很容易地通过用于Google App Engine的托管服务的Java代码或是XML来配置的功能。

核心的Jetty项目由Eclipse Foundation打理。

从版本6开始，Jetty加入了一个被称作Jetty Continuation（Jetty延续）的异步API，该API允许请求被暂停并在之后被恢复。表1给出了所支持的规范和Jetty的主要版本系列的API之间的一个对照关系。

表1. Jetty的版本和支持

支持　　　　　　　　　　　　　　Jetty 6　　Jetty 7　　Jetty 8

非阻塞式I/O　　　　　　　　　　　　　X　　　　 X　　　　　 X
Servlet 2.5　　　　　　　　　　　　　　X　　　　 X　　　　　 X
Servlet 3.0　　　　　　　　 　　 　　　　  　　　　X　　　　   X
Jetty Continuation（Comet）　　 　　　X　　　　   X　　　　   X
WebSocket　　　　　　　　　　　　 　　　   　　  X　　　　   X

若要实现使用Comet的反向Ajax的话，你可以使用Jetty的Continuation API，如清单1所示：

清单1. 用于Comet的Jetty Continuation API

// 暂停一个来自servlet方法（get、post......）的请求：

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

Continuation continuation = ContinuationSupport.getContinuation(req);
// 可选的做法，设置超时以避免请求挂起过久
continuation.setTimeout(0);
// 挂起请求
continuation.suspend();
// 保存引用，以备将来另一线程使用
continuations.offer(continuation);

}

// 然后，来自另一个想给客户发送事件的线程：

while (!continuations.isEmpty()) {
    Continuation continuation = continuations.poll();
    HttpServletResponse response =
        (HttpServletResponse) continuation.getServletResponse();
    // 向响应中写入
continuation.complete();
}

完整的web应用在本文所带的源代码中。Jetty Continuation被打包放在一个JAR归档文件中，你需要把这一JAR文件放在web应用的WEB-INF/lib目录下才能使用Jetty的Comet功能。Jetty Continuation在Jetty 6、7和8上都是可用的。

从Jetty 7开始，你还可以访问WebSocket功能，把Jetty的WebSocket JAR文件放在web应用的WEB-INF/lib目录下以获得对Jetty的WebSocket API的访问，如清单2所示：

清单2. Jetty的Websocket API

// 实现doWebSocketConnect并返回WebSocket的实现

public final class ReverseAjaxServlet extends WebSocketServlet {
    @Override
    protected WebSocket doWebSocketConnect(HttpServletRequest request,
                                           String protocol) {
        return [...]
    }
}

// WebSocket的示例实现

class Endpoint implements WebSocket {
    Outbound outbound;
    public void onConnect(Outbound outbound) {
        this.outbound = outbound;   
    }
    public void onMessage(byte opcode, String data) {
        outbound.sendMessage("Echo: " + data);
        if("close".equals(data))
             outbound.disconnect();
    }
    public void onFragment(boolean more, byte opcode,
                           byte[] data, int offset, int length) {
    }
    public void onMessage(byte opcode, byte[] data,
                          int offset, int length) {
        onMessage(opcode, new String(data, offset, length));
    }
    public void onDisconnect() {
        outbound = null;
    }
}

在下载的源代码的jetty-websocket目录下有一个聊天应用的例子，该例子说明了如何使用Jetty的WebSocket API。

Tomcat

Tomcat可能是最广为人知的web服务器了，其已经使用多年，且被作为web容器整合在Jboss应用服务器的早期版本中。Tomcat也被用作是servlet规范的参考实现，但到了servlet API 2.5后就不再是了，这时人们开始寻求另一种基于非阻塞式I/O的做法（比如说Jetty）。表2给出了所支持的规范和两个最新的Tomcat版本系列的API之间的对照。

表2. Tomcat的支持

支持　　　　　　　　　　Tomcat 6　　　　Tomcat 7

非阻塞式I/O　　　　　　　　X　　　　　　　　X
Servlet 2.5　　　　　　　　  X　　　　　　　　X
Servlet 3.0　　　　　　　　　　　　　　　　　　X
Advanced I/O（Comet）　　 X　　　　　　　　X
WebSocket　　　　　　

正如表2所示的那样，Tomcat不支持WebSocket；它有一个相当于Jetty的Continuation的API，这一被称为Advanced I/O的API支持Comet。与其说Advanced I/O是一个很好地方便了Comet使用的API，倒不如说它是一个封装了NIO的低层面包装器。它缺乏文档资料，几乎没有什么使用API的应用例子。清单3给出了一个servlet例子，该例子挂起并恢复聊天web应用中的请求。你可以在本文的源代码中找到完整的web应用。

清单3. Tomcat用于Comet的API

public final class ChatServlet extends HttpServlet
                               implements CometProcessor {

    private final BlockingQueue events =
         new LinkedBlockingQueue();

    public void event(CometEvent evt)
        throws IOException, ServletException {

        HttpServletRequest request = evt.getHttpServletRequest();
        String user =
            (String) request.getSession().getAttribute("user");
        switch (evt.getEventType()) {
            case BEGIN: {
                if ("GET".equals(request.getMethod())) {
                    evt.setTimeout(Integer.MAX_VALUE);
                    events.offer(evt);
                } else {
                    String message = request.getParameter("message");
                    if ("/disconnect".equals(message)) {
                        broadcast(user + " disconnected");
                        request.getSession().removeAttribute("user");
                        events.remove(evt);
                    } else if (message != null) {
                        broadcast("[" + user + "]" + message);
                    }
                    evt.close();
                }
            }
        }
    }

    void broadcast(String message) throws IOException {
        Queue q = new LinkedList();
        events.drainTo(q);
        while (!q.isEmpty()) {
            CometEvent event = q.poll();
            HttpServletResponse resp = event.getHttpServletResponse();
            resp.setStatus(HttpServletResponse.SC_OK);
            resp.setContentType("text/html");
            resp.getWriter().write(message);
            event.close();
        }
    }
}

在Tomcat中，异步的servlet必须要实现CometProcessor。对于异步的servlet来说，Tomcat并不调用标准的HTTP方法（doGet、doPost等），取而代之的是，事件会被发送给event（CometEvent）方法。当请求首次到达时，例子查看是否是一个GET，是的话便挂起它，evt.close()没有被调用。如果是一个POST的话，这意味着是用户发送了一个消息，因此给其他CometEvent广播消息，然后调用evt.close()来完成该post请求。在客户这一端，广播会让所有的长轮询请求完成消息的发送，另一个长轮询请求会被立刻发送出去以接收接下来的事件。

Grizzly和Glassfish

Grizzly不是一个web容器，它更像是一个用来帮助开发者构建可伸缩应用的NIO框架。它是被作为Glassfish项目的一部分开发出来的，但也可以独立或是嵌入使用。Grizzly提供了充当HTTP/HTTPS服务器的组件，除了其他的一些组件之外，其还提供了Bayeux Protocol、Servlet、HttpService OSGi和Comet组件。Grizzly支持WebSocket，其被用在Glassfish中提供Comet和WebSocket支持。

Oracle的应用服务器Glassfish是J2EE 6规范的参考实现。Glassfish是一个完整的套件，类似WebSphere和Jboss，使用Grizzly来支持NIO、Websocket和Comet。它的基于OSGI的模块化架构，使得其在更换组件时具有真正的灵活性。表3说明了Glassfish对Comet和WebSocket的支持。

表3. Glashfish的支持

支持　　　　　　　　Glassfish 2　　　Glassfish 3

非阻塞式的I/O　　　　X　　　　　　　　X
Servlet 2.5　　　　　　X　　　　　　　　X
Servlet 3.0　　　　　　 　　　　　　　　X
Comet　　　　　　　　X　　　　　　　　X
WebSocket　　　　　　　　　　　　　　X

Grizzly的用法值得一说，因为它原本打算是以嵌入的方式或是直接通过Java代码来使用的。它被广泛用作支持Comet和WebSocket的框架，可被嵌入到一个更大的应用中，比如说Glassfish，该应用提供了web部署功能和Servlet规范API。

请参阅参考资料一节获得到Grizzly或是Glassfish中的WebSocket和Comet的例子的链接，因为Glassfish使用了Grizzly，所以例子在两者上面都是应该能够运行的。WebSocket API与Jetty中的非常类似，但Comet API就更复杂一些。

Jboss

Jboss是一个构建在Tomcat之上的应用服务器，它从版本5开始支持Comet和NIO。Jboss 7还在开发中，不过也被放在了下面的表4中进行比较。

表4. Jboss的支持

支持　　　　　　　　Jboss 5　　　Jboss 6         Jboss 7

非阻塞式的I/O　　　　X　　　　　　　　X         　　　X  
Servlet 2.5　　　　　　X　　　　　　　　X       　　　  X
Servlet 3.0　　　　　　 　　　　　　　　X       　　　　X
Comet　　　　　　　　X　　　　　　　　X         　　　X
WebSocket　　　　　　　　　　　　　　

WebSphere

WebSphere是一个IBM的应用服务器，版本8的WebSphere支持Servlet 3 API（包含了用于Comet的标准的异步API）（请参阅参考资料来了解发布公告的内容）。

表5. WebSphere的支持

支持　　　　　　　　WebSphere 8　　

非阻塞式的I/O　　　　X　　　　
Servlet 2.5　　　　　　X　　　
Servlet 3.0　　　　　　 X　　　
Comet　　　　　　　　X　　　　
WebSocket　　　　　　　　　　

通用API方面的情况

每个服务器都有自己的本地Comet和WebSocket API，正如你或已猜到的那样，编写一个可移植的web应用可能会很难。Servlet 3.0包含了挂起和之后再恢复请求的附加方法，允许所有支持Servlet 3.0规范的web容器支持Comet和长轮询请求。

Jetty提供了一个被称作Jetty Continuation的库，该库独立于Jetty容器存在。Jetty Continuation库非常聪明，能够检测出可用的容器或是规范。如果是运行在Jetty服务器上，应用所使用的就是本地的Jetty API；如果是运行在支持Servlet 3.0规范的容器上的话，应用所使用的就是这一通用的API；否则的话，就要使用一个无伸缩性的实现。

关于WebSocket，现在在Java中还没有一个标准，因此，如果你想要使用WebSocket的话，就需要在web应用中使用容器供应商的API。

表6总结了各种服务器支持的技术。

表6. 服务器支持的技术

容器　　　　　　Comet　　　　　　　　WebSocket

Jetty 6        　　Jetty Continuation            N/A

Jetty 7        　　Servlet 3.0                    本地Jetty API
　　　　Jetty Continuation           

Jetty 8        　　Servlet 3.0                    本地Jetty API
　　Jetty Continuation           

Tomcat 6    　　Advanced I/O                N/A

Tomcat 7    　　Servlet 3.0                    N/A
　　Advanced I/O
　　Jetty Continuation

Glassfish 2    本地Grizzly API                N/A

Glassfish 3    Servlet 3.0                    本地Grizzly API
　　本地Grizzly API
　　Jetty Continuation

Jboss 5        本地Jboss API                N/A

Jboss 6        Servlet 3.0                    N/A
　　本地Jboss API
　　Jetty Continuation

Jboss 7        Servlet 3.0                    N/A
　　本地Jboss API
　　Jetty Continuation

WebSphere 8    Servlet 3.0                    N/A
　　 Jetty Continuations

除了使用容器的API之外，在WebSocket方面显然还没有什么解决方案。至于Comet，每个支持Servlet 3.0规范的容器都支持Comet。Jetty Continuation在这方面的优势是在所有的这些容器上都提供了对Comet的支持，因此，某些反向Ajax库（这在下一节内容和本系列的下一篇文章中会谈到）使用Jetty Continuation来作为它们的服务器端API。

Jetty Continuation API在本文的Jetty例子中有说明，Servlet 3.0规范已经在本系列第1部分的两个Comet例子中用到并做了介绍。

抽象库

考虑一下所有主要的API（Servlet 3.0和Jetty Continuation），加上服务器端的所有本地化支持，以及客户端的两种主要的实现反向Ajax的方式（Comet和WebSocket），通过编写自己的JavaScript和Java代码来捆绑它们实属不易，你还要考虑超时、连接失败、确认、排序、缓冲等等。

本文余下部分的内容说明了Socket.IO的用途，本系列的第4部分内容则会探讨Atmosphere和CometD，这三个库都是开源的，它们在许多服务器上都支持Comet和WebSocket。

Socket.IO

Socket.IO是一个JavaScript客户端库，类似于WebSocket，其提供了单个的API来连接远程服务器，异步地发送和接收消息。通过提供一个通用的API，Socket.IO支持如下多种传输：WebSocket、Flash Socket、长轮询、流、永久Iframe和JSONP轮询。Socket.IO检测浏览器的功能，然后尝试选择可用的最好传输方式。Socket.IO库几乎兼容所有的浏览器（包括较旧的那些，比如IE 5.5）和移动浏览器，它还拥有其他的一些功能，比如说心跳、超时、断开连接和错误处理等。

Socket.IO网站（参见参考资料）详细描述了该库的使用方式，以及其所用到的浏览器和反向Ajax技术。基本情况是这样，Socket.IO用到了一个通信协议，该协议使得客户端的库能够与服务器端的端点进行通信，服务器端的端点能够理解Socket.IO协议。Socket.IO一开始是为Node JS这一用来构建更快的服务器的JavaScript引擎开发的，许多项目带来了对其他语言的支持，其中就包括了Java语言。

清单4给出了一个在客户端使用Socket.IO JavaScript库的例子，Socket.IO网站上有文档和例子。

清单4. Socket.IO客户端库的用法

var socket = new io.Socket(document.domain, {
    resource: 'chat'
});
socket.on('connect', function() {
    // Socket.IO已连接
});
socket.on('disconnect', function(disconnectReason, errorMessage) {
    // Socket.IO已断开连接
});
socket.on('message', function(mtype, data, error) {
    // 服务器发送一个事件
});

// 现在处理程序已经定义好了，可以建立连接：
socket.connect();

若要使用Socket.IO JavaScript库的话，你需要有相应的被称作Socket.IO Java（参见参考资料）的Java部分。这一项目最初是由Apach Wave团队启动的，是为了给Wave提供反向Ajax支持，这是在WebSocket可用之前的事。Socket.IO Java派生出来后由Ovea（一家专门从事事件驱动的web开发的公司）来维护，再后来就被弃之不顾了。由于有多种传输的缘故，开发支持Socket.IO客户端库的后端是很复杂的过程。本系列的第4部分内容会说明，为了获得更好的伸缩性和浏览器支持，在客户端库中支持多种传输是没有必要的，因为有长轮询和WebSocket就足够了。在WebSocket不可用时，Socket.IO确实是一个不错的选择。

Socket.IO Java使用Jetty Continuation API来挂起和恢复请求，其使用本地的Jetty WebSocket API作为WebSocket支持。你可以确定使用了Socket.IO Java的web应用可在哪个服务器上正确地运行。

下面清单5中的例子说明了在服务器端如何使用Socket.IO，你需要定义一个继承了SocketIOServlet的servlet，并实现一个返回某种端点表示的方法。这一API非常类似于WebSocket API，它的优点是用在服务器端，独立于客户端所选择的传输方式。Socket.IO把所有的传输类型都转换成服务器端的同一API。

清单5. 聊天例子中的Socket.IO Java的使用——servlet

public final class ChatServlet extends SocketIOServlet {
    private final BlockingQueue endpoints =
        new LinkedBlockingQueue();

    @Override
    protected SocketIOInbound doSocketIOConnect
                                        (HttpServletRequest request) {
        String user =
                (String) request.getSession().getAttribute("user");
        return user == null ? null : new Endpoint(this, user, request);
    }

    void broadcast(String data) {
        for (Endpoint endpoint : endpoints) {
            endpoint.send(data);
        }
    }

    void add(Endpoint endpoint) {
        endpoints.offer(endpoint);
    }

    void remove(Endpoint endpoint) {
        endpoints.remove(endpoint);
    }
}

清单6说明了返回端点的方式。

清单6. 聊天例子中的Socket.IO Java库的用法——endpoint

class Endpoint implements SocketIOInbound {

    [...]

    private SocketIOOutbound outbound;

    [...]

    @Override
    public void onConnect(SocketIOOutbound outbound) {
        this.outbound = outbound;
        servlet.add(this);
        servlet.broadcast(user + " connected");
    }

    @Override
    public void onDisconnect(DisconnectReason reason,
                             String errorMessage) {
        outbound = null;
        request.getSession().removeAttribute("user");
        servlet.remove(this);
        servlet.broadcast(user + " disconnected");
    }

    @Override
    public void onMessage(int messageType, String message) {
        if ("/disconnect".equals(message)) {
            outbound.close();
        } else {
            servlet.broadcast("[" + user + "] " + message);
        }
    }

    void send(String data) {
        try {
            if (outbound != null
    && outbound.getConnectionState() == ConnectionState.CONNECTED) {
                outbound.sendMessage(data);
            }
        } catch (IOException e) {
            outbound.close();
        }
    }

}

Socket.IO的完整例子放在源代码的socketio目录下。

结束语

所有的web容器都支持Comet，且大部分的容器都支持WebSocket，即使规范带来了几种不同的本地化实现，你还是可以使用Comet和通用API（Servlet 3.0和Jetty Continuation）来开发web应用。且更乐观的情况是，你可以使用诸如Socket.IO一类的库，以透明的方式来利用Comet和WebSocket的强大功能。还有两个库，Atmosphere和CometD，会在本系列的下一篇文章中谈及。这三个库提供了多浏览器支持、非常出色的用户体验，以及错误处理、更简单的API、超时和重连接等多方面的好处。

作者：gykxp 发表于2012-6-6 14:59:26 原文链接

阅读：24211 评论：0 查看评论