首页 > 代码库 > 反向Ajax，第3部分：Web服务器和Socket.IO

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

2024-10-27 07:57:02   208人阅读

英文原文：Reverse Ajax, Part 3: Web servers and Socket.IO

　　前言

　　时至今日，用户期待的是可通过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的版本和支持

SupportsJetty 6Jetty 7Jetty 8
Non-blocking I/OXXX
Servlet 2.5XXX
Servlet 3.0 XX
Jetty Continuations (Comet)XXX
WebSockets XX

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

　　清单1. 用于Comet的Jetty Continuation API

[java] view plaincopy
 
  1. // 暂停一个来自servlet方法（get、post......）的请求：  
  2. protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
  3. throws ServletException, IOException {  
  4. Continuation continuation = ContinuationSupport.getContinuation(req);  
  5. // 可选的做法，设置超时以避免请求挂起过久  
  6. continuation.setTimeout(0);  
  7. // 挂起请求  
  8. continuation.suspend();  
  9. // 保存引用，以备将来另一线程使用  
  10. continuations.offer(continuation);  
  11. }  
  12. // 然后，来自另一个想给客户发送事件的线程：  
  13. while (!continuations.isEmpty()) {  
  14. Continuation continuation = continuations.poll();  
  15. HttpServletResponse response =  
  16. (HttpServletResponse) continuation.getServletResponse();  
  17. // 向响应中写入  
  18. continuation.complete();  
  19. }  

　　完整的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

[java] view plaincopy
 
  1. // 实现doWebSocketConnect并返回WebSocket的实现  
  2.   
  3. publicfinalclass ReverseAjaxServlet extends WebSocketServlet {  
  4. @Override  
  5. protected WebSocket doWebSocketConnect(HttpServletRequest request,  
  6. String protocol) {  
  7. return [...]  
  8. }  
  9. }  
  10.   
  11. // WebSocket的示例实现  
  12.   
  13. class Endpoint implements WebSocket {  
  14. Outbound outbound;  
  15. publicvoid onConnect(Outbound outbound) {  
  16. this.outbound = outbound;   
  17. }  
  18. publicvoid onMessage(byte opcode, String data) {  
  19. outbound.sendMessage("Echo: "+ data);  
  20. if("close".equals(data))  
  21. outbound.disconnect();  
  22. }  
  23. publicvoid onFragment(boolean more, byte opcode,  
  24. byte[] data, int offset, int length) {  
  25. }  
  26. publicvoid onMessage(byte opcode, byte[] data,  
  27. int offset, int length) {  
  28. onMessage(opcode, new String(data, offset, length));  
  29. }  
  30. publicvoid onDisconnect() {  
  31. outbound =null;  
  32. }  
  33. }  

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

　　Tomcat

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

　　表2. Tomcat的支持

SupportsTomcat 6Tomcat 7
Non-blocking I/OXX
Servlet 2.5XX
Servlet 3.0 X
Advanced I/O (Comet)XX
WebSockets  

　　正如表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

[java] view plaincopy
 
  1. publicfinalclass ChatServlet extends HttpServlet implements CometProcessor {  
  2.     privatefinal BlockingQueue events = new LinkedBlockingQueue();  
  3.   
  4.     public void event(CometEvent evt) throws IOException, ServletException {  
  5.         HttpServletRequest request = evt.getHttpServletRequest();  
  6.         String user = (String) request.getSession().getAttribute("user");  
  7.         switch (evt.getEventType()) {  
  8.             case BEGIN: {  
  9.             if ("GET".equals(request.getMethod())) {  
  10.                 evt.setTimeout(Integer.MAX_VALUE);  
  11.                 events.offer(evt);  
  12.             } else {  
  13.                 String message = request.getParameter("message");  
  14.                 if ("/disconnect".equals(message)) {  
  15.                     broadcast(user +" disconnected");  
  16.                     request.getSession().removeAttribute("user");  
  17.                     events.remove(evt);  
  18.                 } elseif (message !=null) {  
  19.                     broadcast("["+ user +"]"+ message);  
  20.                 }   
  21.                 evt.close();  
  22.             }  
  23.         }  
  24.     }  
  25. }  
  26.   
  27.     void broadcast(String message) throws IOException {  
  28.         Queue q =new LinkedList();  
  29.         events.drainTo(q);  
  30.         while (!q.isEmpty()) {  
  31.             CometEvent event = q.poll();  
  32.             HttpServletResponse resp = event.getHttpServletResponse();  
  33.             resp.setStatus(HttpServletResponse.SC_OK);  
  34.             resp.setContentType("text/html");  
  35.             resp.getWriter().write(message);  
  36.             event.close();  
  37.         }  
  38.     }  
  39. }  

　　在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的支持

SupportsGlassfish 2Glassfish 3
Non-blocking I/OXX
Servlet 2.5XX
Servlet 3.0 X
CometXX
WebSockets 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的支持

 

SupportsJboss 5Jboss 6Jboss 7
Non-blocking I/OXXX
Servlet 2.5XXX
Servlet 3.0 XX
CometXXX
WebSockets   

　　WebSphere

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

　　表5. WebSphere的支持　　

SupportsWebSphere 8
Non-blocking I/OX
Servlet 2.5X
Servlet 3.0X
CometX
WebSockets 

　　通用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. 服务器支持的技术

ContainerCometWebSocket
Jetty 6Jetty ContinuationsN/A
Jetty 7Servlet 3.0
Jetty Continuations		Native Jetty API
Jetty 8Servlet 3.0 
Jetty Continuations		Native Jetty API
Tomcat 6Advanced I/ON/A
Tomcat 7Servlet 3.0
Advanced I/O
Jetty Continuations		N/A
Glassfish 2Native Grizzly APIN/A
Glassfish 3Servlet 3.0
Native Grizzly API
Jetty Continuations		Native Grizzly API
Jboss 5Native Jboss APIN/A
Jboss 6Servlet 3.0 
Native Jboss API 
Jetty Continuations		N/A
Jboss 7Servlet 3.0
Native Jboss API
Jetty Continuations		N/A
WebSphere 8Servlet 3.0
Jetty Continuations		N/A

　　除了使用容器的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客户端库的用法

[javascript] view plaincopy
 
  1. var socket = new io.Socket(document.domain, {  
  2. resource: ‘chat‘  
  3. });  
  4. socket.on(‘connect‘, function() {  
  5. // Socket.IO已连接  
  6. });  
  7. socket.on(‘disconnect‘, function(disconnectReason, errorMessage) {  
  8. // Socket.IO已断开连接  
  9. });  
  10. socket.on(‘message‘, function(mtype, data, error) {  
  11. // 服务器发送一个事件  
  12. });  
  13.   
  14. // 现在处理程序已经定义好了，可以建立连接：  
  15. 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

[java] view plaincopy
 
  1. public final class ChatServlet extends SocketIOServlet {  
  2. private final BlockingQueue endpoints =  
  3. new LinkedBlockingQueue();  
  4.   
  5. @Override  
  6. protected SocketIOInbound doSocketIOConnect  
  7. (HttpServletRequest request) {  
  8. String user =  
  9. (String) request.getSession().getAttribute("user");  
  10. return user == null?null : new Endpoint(this, user, request);  
  11. }  
  12.   
  13. void broadcast(String data) {  
  14. for (Endpoint endpoint : endpoints) {  
  15. endpoint.send(data);  
  16. }  
  17. }  
  18.   
  19. void add(Endpoint endpoint) {  
  20. endpoints.offer(endpoint);  
  21. }  
  22.   
  23. void remove(Endpoint endpoint) {  
  24. endpoints.remove(endpoint);  
  25. }  
  26. }    

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

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

[java] view plaincopy
 
  1. class Endpoint implements SocketIOInbound {  
  2. [...]  
  3. private SocketIOOutbound outbound;  
  4. [...]  
  5.   
  6. @Override  
  7. publicvoid onConnect(SocketIOOutbound outbound) {  
  8. this.outbound = outbound;  
  9. servlet.add(this);  
  10. servlet.broadcast(user +" connected");  
  11. }  
  12.   
  13. @Override  
  14. publicvoid onDisconnect(DisconnectReason reason,  
  15. String errorMessage) {  
  16. outbound = null;  
  17. request.getSession().removeAttribute("user");  
  18. servlet.remove(this);  
  19. servlet.broadcast(user +" disconnected");  
  20. }  
  21.   
  22. @Override  
  23. public void onMessage(int messageType, String message) {  
  24. if ("/disconnect".equals(message)) {  
  25. outbound.close();  
  26. } else {  
  27. servlet.broadcast("["+ user +"] "+ message);  
  28. }  
  29. }  
  30.   
  31. void send(String data) {  
  32. try {  
  33. if (outbound !=null  
  34. && outbound.getConnectionState() == ConnectionState.CONNECTED) {  
  35. outbound.sendMessage(data);  
  36. }  
  37. } catch (IOException e) {  
  38. outbound.close();  
  39. }  
  40. }  
  41.   
  42. }  

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

　　结束语

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

　　下载

　　描述　　　　　　　　名称　　　　　　　　　　　大小　　　下载方法

　　文章的源代码　　　　reverse_ajaxpt3_source.zip　　 21KB 　　　 HTTP

　　学习资料

　　1. 阅读这一系列之前的部分：

　　　　1.1. 第1部分：Comet介绍

　　　　1.2. 第2部分：Websocket

　　2. JSR 315：Java Servlet 3.0规范是2.5规范的更新。

　　3. 阅读IBM WebSphere Application Server V8.0的发布公告。

　　4. “Google AppEngine uses Jetty!”介绍了Google的Jetty定制。

　　5. 了解更多关于Jetty Continuation的功能。

　　6. 了解一个使用Grizzly的Glassfish WebSocket例子。

　　7. WebSphere Application Server：了解更多关于IBM WebSphere系列中的这一旗舰产品。

　　8. WebSphere 8（支持Comet）启用了智能化的应用环境管理，有助于更快地提交丰富的用户体验。

　　9. Socket.IO的目标是使实时应用在每种浏览器和移动设备上都成为可能，其减轻了不同传输机制之间的区别。

　　10. “Start using HTML5 WebSockets today”（Nettuts+）：重温在PHP中如何运行一个WebSocket服务器，并考虑如何构建一个客户端来通过WebSocket协议发送和接收消息。

　　11. “The WebSocket API”（W3C, July 2011）：这一规范定义的API使得网页能够使用WebSocket协议来和远程主机进行双向通信。

　　12. 了解更多关于Servlet 3.0对异步处理的支持方面的内容。

　　13. Philip McCarthy的博客上的文章Comet & Java: Threaded Vs Nonblocking I/O中有着更多的内容。

　　14. 在维基百科上了解这些内容：

　　　　14.1. Ajax
　 　　14.2. Reverse Ajax
　 　　14.3 WebSockets

　　15. “Exploring Reverse AJAX”：获得一些关于反向Ajax技术的介绍说明。

　　16. “Cross-domain communications with JSONP, Part 1: Combine JSONP and jQuery to quickly build powerful mashups”（developerWorks, February 2009）：了解如何把不起眼的跨域调用技术（JSONP）和一个灵活的JavaScript库（JQuery）结合在一起，以令人惊讶的速度构建出一些功能强大的聚合应用。

　　17. “Build Ajax applications with Ext JS”（developerWorks, July 2008）：对Ext Js背后的面向对象JavaScript 设计概念做了一个概述，并说明了如何把Ext JS框架用作富互联网应用的UI元素。

　　18. “Compare JavaScript frameworks”（developerWorks, February 2010）：对极大地增强了JavaScript开发的那些框架有一个整体的了解。

　　19. “Mastering Ajax, Part 2: Make asynchronous requests with JavaScript and Ajax”（developerWorks, January 2006）：学习如何使用Ajax和XMLHttpRequest对象来创建一种永不会让用户等待服务器响应的请求/响应模型。

　　20. “Create Ajax applications for the mobile Web”（developerWorks, March 2010）：了解如何使用Ajax构建跨浏览器的智能手机Web应用。

　　21. “Where and when to use Ajax in your applications”（developerWorks, February 2008）：了解如何使用Ajax来改进网站，同时避免糟糕的用户体验。

　　22. “Improve the performance of Web 2.0 applications“（developerWorks, December 2009）：探讨不同的浏览器端缓存机制。

　　23. “Introducing JSON”（JSON.org）：获得对JSON语法的一个入门介绍。

　　24. developerWorks Web development zone：获得各种谈论基于Web的解决方案的文章。

　　25. developerWorks podcasts：收听各种与软件开发者进行的有趣的访谈和讨论。

　　26. developerWorks technical events and webcasts：随时关注developerWorks的技术事件和webcast的进展。

　　获取产品和技术

　　1. Jetty：获取Jetty，一个web服务器和javax.servlet容器，外带对WebSocket的支持。

　　2. Apache Tomcat Advanced I/O文档：获得有用的链接、用户指南、参考手册和Apache Tomcat开发说明。

　　3. Grizzly NIO Framework：帮助你使用Java NIO API。

　　4. Grizzly Comet例子：在从头开始构建一个新的应用之前，了解需要对现有应用做哪些修改。

　　5. Glassfish Application Server：获得主要的Glassfish Server的开源版本。

　　6. Socket.IO Java：获得原始的项目和最后更新的Ovea的派生版本。

　　7. Apache Maven：获取Maven，一个软件项目管理和包容工具。

　　8. Java Development Kit, Version 6：获得Java平台标准版（Java Platform, Standard Edition，Java SE），该平台允许你在台式机和服务器上，以及在当今要求苛刻的嵌入式环境上开发和部署Java应用。

　　9. 免费试用IBM软件，下载使用版，登录在线试用，在沙箱环境中使用产品，或是通过云来访问，有超过100种IBM产品试用版选择。

　　讨论

　　1. 参加论坛的讨论。

　　2. 现在就创建你的developerWorks个人资料，并设置一个关于Reverse Ajax的观看列表。与developerWorks社区建立联系并保持联系。

　　3. 找到其他在web开发方面感兴趣的developerWorks成员。

　　4. 分享你的知识：加入一个关注web专题的developerWorks组。

　　5. Roland Barcia在他的博客中谈论Web 2.0和中间件。

　　6. 关注developerWork成员的shared bookmarks on web topics。

　　7. 快速获得答案：访问Web 2.0 Apps论坛。

　　8. 快速获得答案：访问Ajax论坛。

　　关于作者

　　Mathieu Carbou是Ovea的一位提供服务和开发解决方案的Java web架构师和顾问。他是几个开源项目的提交者和领导者，也是Montreal的Java User Group的一位演讲者和领导者。Mathieu有着很强的代码设计和最佳实践背景，他是一个从客户端到后端的事件驱动的web开发方面的专家。他的工作重点是在高度可伸缩的web应用中提供事件驱动的和消息式的解决方案。你可以看一看他的博客。

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


联系
我们