Implementing Asynchronous Web Application using Grizzly's Comet. Jeanfrancois Arcand Staff Engineer Java WebTier

Transcription

1 Implementing Asynchronous Web Application using Grizzly's Comet. Jeanfrancois Arcand Staff Engineer Java WebTier

2 Agenda Introduction > What is Grizzly > What is Comet Request Processing Comet support in Grizzly > Definitions > How it works > Comet implementation What's next Questions 2

3 What is Grizzly Grizzly is a generic NIO framework for building scalable server application. Grizzly support blocking and non blocking socket operations, over plain or ssl connection. Grizzly extensions currently used by several internal projects (Alaska, GlassFish, Tango, etc.) and external projects (Jetty 6.1) Grizzly v2 is targetted for GlassFish 9.1, and will be used by the ORB, MQ and possibly JAX-WS. 3

4 What is Comet Request Processing Definition from Wikipedia: Comet is a programming technique that enables web servers to send data to the client without having any need for the client to request for it. It allows creation of event-driven web applications which are hosted in the browser. 4

5 What makes Comet Application different from traditional application (from Fundamentally, they all use long-lived HTTP connections to reduce the latency with which messages are passed to the server. In essence, they do not poll the server occasionally. Instead the server has an open line of communication with which it can push data to the client. 5

6 What makes Comet Application different from traditional application? (from Comet applications can deliver data to the client at any time, not only in response to user input. The data is delivered over a single, previously-opened connection. This approach reduces the latency for data delivery significantly. 6

7 Comet support in Grizzly: Details Implemented on top of the Grizzly Asynchronous Request Processing extension [1]. Hide the complexity of NIO/Asynchronous Request Processing. Support clean and ssl connection. Make it available to JSF, JSP, Servlet, POJO, JavaScript (Phobos) Main Goal: Make it simple! 7

8 The Grizzly Comet: Definitions CometContext: A shareable space applications can subscribe and get updated when the context is updated. CometEvent: An object containing the state of the Comet Context (content updated, client connected/disconnected, etc.). CometHandler: The interface an application must implement in order to be part of one or several CometContext. 8

9 First, the application creates a new Comet context (or register to an existing one) Application (server side) register create Shareable Comet Context Shareable Comet Context 9

10 Next, add your Comet request to the context. You usually create one per connection (not mandatory). Application (server side) add Shareable Comet Context ** The can be created during the first request. Persistent HTTP connections 10

11 Next, clients open a single connection to a shareable context. client client client client Shareable Comet Context Persistent HTTP connections 11

12 When one client push data, all other clients are updated. client client client client Shareable Comet Context 12

13 When something change on the context clients are updated. client client client client Shareable Comet Context Database update 13

14 Implementing Comet: Four simple steps Adding Comet support to an existing application is simple (no big refactoring). The next four slides will describe how to do it. More details can be found in [2]. 14

15 Step 1 - Registration First, register to a new or existing Comet context. The context are usually created using a context path (but not mandatory) CometEngine cometengine = CometEngine.getEngine(); CometContext context = cometengine.register(contextpath); 15

16 Step 2- Define your Comet The Comet interface is simple: public void attach(e attachment); public void onevent(cometevent event) public void oninitialize(cometevent event) public void onterminate(cometevent event) public void oninterrupt(cometevent event) 16

17 Step 3- Adding Comet to the context Next, instantiate your Comet request and add it to the context MyCometHandler = new MyCometHandler(); cometcontext.addcomethandler() 17

18 Step 4 Advertise changes. Once the Comet has been added to the Context, you can start pushing events. You can notify the context when the client push data or when something external has changed (ex: a database): cometcontext.notify( Comet is cool ); 18

19 Comet example. For a Servlet, you will most probably implement the CometHandler using the HttpServletResponse: public class CometResponseHandler implements CometHandler{ public void attach(httpservletresponse httpservletresponse){ this.httpservletresponse = httpservletresponse; 19

20 Comet example. And the onevent method will most probably looks like: public void onevent(cometevent event) throws IOException{ try{ PrintWriter printwriter = httpservletresponse.getwriter(); printwriter.println(event.attachment()); printwriter.flush(); } catch (Throwable t){ t.printstacktrace(); } 20

21 What's next. Ship a common set of s applications can re-use: > One for Servlet/Jsp/Jsf > One for Phobos > One for POJO Ship an AJAX JMaki re-usable client component. Add cometd support (consists of a protocol spec called Bayeux, javacript libraries (dojo toolkit), and an event server (Grizzly)) An external team is working on it right now. 21

22 What's next. Publish some performance numbers. Improve current implementation in order to compete with Jetty and Tomcat Comet support. 22

23 References [1] rt_ii.html [2] com.html 23

24 Help Improve This Presentation The copyright of this speech is licensed under a creative commons license. Some rights are reserved JeanFrancois Arcand See If you want to contribute, keep attribution and maintain license. We would also appreciate notifying us of the changes. More related presentations are kept at the Presentations page of the GlassFish Wiki. 24

25 Implementing Asynchronous Web Application using Grizzly's Comet.