AtmosphereServlet (atmosphere-runtime 0.6.3 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.atmosphere.cpr
Class AtmosphereServlet

java.lang.Object
  javax.servlet.GenericServlet
      javax.servlet.http.HttpServlet
          org.eclipse.jetty.websocket.WebSocketServlet
              weblogic.servlet.http.AbstractAsyncServlet
                  org.atmosphere.cpr.AtmosphereServlet

All Implemented Interfaces:: Serializable, Servlet, ServletConfig, org.apache.catalina.CometProcessor, org.jboss.servlet.http.HttpEventServlet

Direct Known Subclasses:: MeteorServlet

public class AtmosphereServlet
extends weblogic.servlet.http.AbstractAsyncServlet
implements org.apache.catalina.CometProcessor, org.jboss.servlet.http.HttpEventServlet
extends weblogic.servlet.http.AbstractAsyncServlet
implements org.apache.catalina.CometProcessor, org.jboss.servlet.http.HttpEventServlet

The AtmosphereServlet acts as a dispatcher for AtmosphereHandler defined in META-INF/atmosphere.xml, or if atmosphere.xml is missing, all classes that implements AtmosphereHandler will be discovered and mapped using the class's name.

This Servlet can be defined inside an application's web.xml using the following:


  <servlet>
      <description>AtmosphereServlet</description>
      <servlet-name>AtmosphereServlet</servlet-name>
      <servlet-class>org.atmosphere.cpr.AtmosphereServlet</servlet-class>
      <load-on-startup>0 </load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>AtmosphereServlet</servlet-name>
      <url-pattern>/Atmosphere </url-pattern>
  </servlet-mapping>

You can force this Servlet to use native API of the Web Server instead of the Servlet 3.0 Async API you are deploying on by adding


  <init-param>
      <param-name>org.atmosphere.useNative</param-name>
      <param-value>true</param-value>
  </init-param>

You can force this Servlet to use one Thread per connection instead of native API of the Web Server you are deploying on by adding


  <init-param>
      <param-name>org.atmosphere.useBlocking</param-name>
      <param-value>true</param-value>
  </init-param>

You can also define Broadcasterby adding:


  <init-param>
      <param-name>org.atmosphere.cpr.broadcasterClass</param-name>
      <param-value>class-name</param-value>
  </init-param>

You can also for Atmosphere to use OutputStream for all write operations.


  <init-param>
      <param-name>org.atmosphere.useStream</param-name>
      <param-value>true</param-value>
  </init-param>

You can also configure BroadcasterCache that persist message when Browser is disconnected.


  <init-param>
      <param-name>org.atmosphere.cpr.broadcasterCacheClass</param-name>
      <param-value>class-name</param-value>
  </init-param>

You can also configure Atmosphere to use http session or not


  <init-param>
      <param-name>org.atmosphere.cpr.sessionSupport</param-name>
      <param-value>false</param-value>
  </init-param>

You can also configure BroadcastFilter that will be applied at all newly created Broadcaster


  <init-param>
      <param-name>org.atmosphere.cpr.broadcastFilterClasses</param-name>
      <param-value>BroadcastFilter class name separated by coma</param-value>
  </init-param>

The Atmosphere Framework can also be used as a Servlet Filter (AtmosphereFilter).

If you are planning to use JSP, Servlet or JSF, you can instead use the MeteorServlet, which allow the use of Meteor inside those components.

Author:: Jeanfrancois Arcand
See Also:: Serialized Form

Nested Class Summary
`static class`	`AtmosphereServlet.Action` Simple class/struck that hold the current state.
`class`	`AtmosphereServlet.AtmosphereConfig`
`static class`	`AtmosphereServlet.AtmosphereHandlerWrapper`

Field Summary
`static String`	`ATMOSPHERE_HANDLER`
`static String`	`ATMOSPHERE_RESOURCE`
`static String`	`ATMOSPHERE_SERVLET`
`static String`	`BROADCAST_FILTER_CLASSES`
`static String`	`BROADCASTER_CACHE`
`static String`	`BROADCASTER_CLASS`
`static String`	`BROADCASTER_FACTORY`
`protected static String`	`broadcasterClassName`
`protected CometSupport`	`cometSupport`
`protected AtmosphereServlet.AtmosphereConfig`	`config`
`static String`	`DEFAULT_NAMED_DISPATCHER`
`static String`	`DISABLE_ONSTATE_EVENT`
`static String`	`GAE_BROADCASTER`
`protected HashMap<String,String>`	`initParams`
`protected boolean`	`isBroadcasterSpecified`
`protected AtomicBoolean`	`isCometSupportConfigured`
`protected boolean`	`isCometSupportSpecified`
`protected boolean`	`isFilter`
`protected boolean`	`isSessionSupportSpecified`
`static String`	`JERSEY_BROADCASTER`
`static String`	`JERSEY_CONTAINER`
`static Logger`	`logger`
`protected ArrayList<String>`	`possibleAtmosphereHandlersCandidate`
`static String`	`PRIMEFACES_SERVLET`
`static String`	`PROPERTY_BLOCKING_COMETSUPPORT`
`static String`	`PROPERTY_COMET_SUPPORT`
`static String`	`PROPERTY_NATIVE_COMETSUPPORT`
`static String`	`PROPERTY_SERVLET_MAPPING`
`static String`	`PROPERTY_SESSION_SUPPORT`
`static String`	`PROPERTY_USE_STREAM`
`static String`	`RESUME_AND_KEEPALIVE`
`static String`	`RESUME_ON_BROADCAST`
`static String`	`RESUMED_ON_TIMEOUT`
`static String`	`SUPPORT_SESSION`
`protected boolean`	`useBlockingImplementation`
`protected boolean`	`useNativeImplementation`
`protected boolean`	`useStreamForFlushingComments`
`static String`	`WEB_INF`
`static String`	`WEBSOCKET_ATMOSPHEREHANDLER`
`static String`	`WEBSOCKET_SUPPORT`

Constructor Summary
`AtmosphereServlet()` Create an Atmosphere Servlet.
`AtmosphereServlet(boolean isFilter)` Create an Atmosphere Servlet.

Method Summary
`void`	`addAtmosphereHandler(String mapping, AtmosphereHandler h)` Add an `AtmosphereHandler` serviced by the `Servlet` This API is exposed to allow embedding an Atmosphere application.
`void`	`addAtmosphereHandler(String mapping, AtmosphereHandler h, Broadcaster broadcaster)` Add an `AtmosphereHandler` serviced by the `Servlet` This API is exposed to allow embedding an Atmosphere application.
`void`	`addAtmosphereHandler(String mapping, AtmosphereHandler h, String broadcasterId)` Add an `AtmosphereHandler` serviced by the `Servlet` This API is exposed to allow embedding an Atmosphere application.
`void`	`addInitParameter(String name, String value)` Add init-param like if they were defined in web.xml
`protected void`	`autoDetectAtmosphereHandlers(ServletContext sc, URLClassLoader c)` Auto detect instance of `AtmosphereHandler` in case META-INF/atmosphere.xml is missing.
`protected void`	`autoDetectContainer()` Auto detect the underlying Servlet Container we are running on.
`protected void`	`configureBroadcaster()`
`protected CometSupportResolver`	`createCometSupportResolver()` Returns an instance of CometSupportResolver `CometSupportResolver`
`void`	`destroy()`
`protected boolean`	`detectSupportedFramework(ServletConfig sc)` Auto-detect Jersey when no atmosphere.xml file are specified.
`protected AtmosphereServlet.Action`	`doCometSupport(HttpServletRequest req, HttpServletResponse res)` Invoke the proprietary `CometSupport`
`void`	`doDelete(HttpServletRequest req, HttpServletResponse res)` Delegate the request processing to an instance of `CometSupport`
`void`	`doGet(HttpServletRequest req, HttpServletResponse res)` Delegate the request processing to an instance of `CometSupport`
`void`	`doHead(HttpServletRequest req, HttpServletResponse res)` Delegate the request processing to an instance of `CometSupport`
`protected void`	`doInitParams(ServletConfig sc)` Read init param from web.xml and apply them.
`void`	`doOptions(HttpServletRequest req, HttpServletResponse res)` Delegate the request processing to an instance of `CometSupport`
`void`	`doPost(HttpServletRequest req, HttpServletResponse res)` Delegate the request processing to an instance of `CometSupport`
`void`	`doPut(HttpServletRequest req, HttpServletResponse res)` Delegate the request processing to an instance of `CometSupport`
`protected boolean`	`doRequest(weblogic.servlet.http.RequestResponseKey rrk)` Weblogic specific comet based implementation.
`protected void`	`doResponse(weblogic.servlet.http.RequestResponseKey rrk, Object context)` Weblogic specific comet based implementation.
`protected void`	`doTimeout(weblogic.servlet.http.RequestResponseKey rrk)` Weblogic specific comet based implementation.
`void`	`doTrace(HttpServletRequest req, HttpServletResponse res)` Delegate the request processing to an instance of `CometSupport`
`protected WebSocket`	`doWebSocketConnect(HttpServletRequest request, String protocol)` Jetty 7 and up WebSocket support.
`void`	`event(org.apache.catalina.CometEvent cometEvent)` Hack to support Tomcat AIO like other WebServer.
`void`	`event(org.jboss.servlet.http.HttpEvent httpEvent)` Hack to support JBossWeb AIO like other WebServer.
`AtmosphereServlet.AtmosphereConfig`	`getAtmosphereConfig()` Return a configured instance of `AtmosphereServlet.AtmosphereConfig`
`String`	`getBroadcasterCacheClassName()` Return the `BroadcasterCache` class name.
`static BroadcasterConfig`	`getBroadcasterConfig()` Return the `BroadcasterConfig` used by this instance.
`BroadcasterFactory`	`getBroadcasterFactory()` Get the `BroadcasterFactory` which is used by Atmosphere to construct `Broadcaster`
`CometSupport`	`getCometSupport()` Return the current `CometSupport`
`static String`	`getDefaultBroadcasterClassName()` Return the default `Broadcaster` class name.
`protected void`	`getFiles(File f)` Get the list of possible candidate to load as `AtmosphereHandler`
`void`	`init(ServletConfig sc)` Load the `AtmosphereHandler` associated with this AtmosphereServlet.
`boolean`	`isUseStreamForFlushingComments()` `true` if Atmosphere uses `ServletResponse.getOutputStream()` by default for write operation.
`protected void`	`loadAtmosphereDotXml(InputStream stream, URLClassLoader c)` Load AtmosphereHandler defined under META-INF/atmosphere.xml
`protected void`	`loadConfiguration(ServletConfig sc)`
`protected void`	`readSystemProperties()`
`void`	`removeAllAtmosphereHandler()` Remove all `AtmosphereHandler`
`void`	`removeAllInitParams()` Remove all init parameters.
`boolean`	`removeAtmosphereHandler(String mapping)` Remove an `AtmosphereHandler`
`protected void`	`sessionSupport(boolean sessionSupport)`
`void`	`setBroadcasterCacheClassName(String broadcasterCacheClassName)` Set the `BroadcasterCache` class name.
`AtmosphereServlet`	`setBroadcasterFactory(BroadcasterFactory broadcasterFactory)` Set the `BroadcasterFactory` which is used by Atmosphere to construct `Broadcaster`
`void`	`setCometSupport(CometSupport cometSupport)` Set the `CometSupport` implementation.
`static void`	`setDefaultBroadcasterClassName(String broadcasterClassName)` Set the default `Broadcaster` class name
`void`	`setUseStreamForFlushingComments(boolean useStreamForFlushingComments)` Set to `true` so Atmosphere uses `ServletResponse.getOutputStream()` by default for write operation.

Methods inherited from class weblogic.servlet.http.AbstractAsyncServlet
`notify`

Methods inherited from class org.eclipse.jetty.websocket.WebSocketServlet
`checkOrigin, init, service`

Methods inherited from class javax.servlet.http.HttpServlet
`getLastModified, service`

Methods inherited from class javax.servlet.GenericServlet
`getInitParameter, getInitParameterNames, getServletConfig, getServletContext, getServletInfo, getServletName, log, log`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface javax.servlet.Servlet
`getServletConfig, getServletInfo, service`

Field Detail

JERSEY_BROADCASTER

public static final String JERSEY_BROADCASTER

See Also:: Constant Field Values

JERSEY_CONTAINER

public static final String JERSEY_CONTAINER

See Also:: Constant Field Values

GAE_BROADCASTER

public static final String GAE_BROADCASTER

PROPERTY_SERVLET_MAPPING

public static final String PROPERTY_SERVLET_MAPPING

See Also:: Constant Field Values

PROPERTY_BLOCKING_COMETSUPPORT

public static final String PROPERTY_BLOCKING_COMETSUPPORT

See Also:: Constant Field Values

PROPERTY_NATIVE_COMETSUPPORT

public static final String PROPERTY_NATIVE_COMETSUPPORT

See Also:: Constant Field Values

WEBSOCKET_SUPPORT

public static final String WEBSOCKET_SUPPORT

See Also:: Constant Field Values

PROPERTY_USE_STREAM

public static final String PROPERTY_USE_STREAM

See Also:: Constant Field Values

BROADCASTER_FACTORY

public static final String BROADCASTER_FACTORY

See Also:: Constant Field Values

BROADCASTER_CLASS

public static final String BROADCASTER_CLASS

See Also:: Constant Field Values

BROADCASTER_CACHE

public static final String BROADCASTER_CACHE

See Also:: Constant Field Values

PROPERTY_COMET_SUPPORT

public static final String PROPERTY_COMET_SUPPORT

See Also:: Constant Field Values

PROPERTY_SESSION_SUPPORT

public static final String PROPERTY_SESSION_SUPPORT

See Also:: Constant Field Values

PRIMEFACES_SERVLET

public static final String PRIMEFACES_SERVLET

See Also:: Constant Field Values

DISABLE_ONSTATE_EVENT

public static final String DISABLE_ONSTATE_EVENT

See Also:: Constant Field Values

WEB_INF

public static final String WEB_INF

See Also:: Constant Field Values

RESUME_ON_BROADCAST

public static final String RESUME_ON_BROADCAST

See Also:: Constant Field Values

ATMOSPHERE_SERVLET

public static final String ATMOSPHERE_SERVLET

ATMOSPHERE_RESOURCE

public static final String ATMOSPHERE_RESOURCE

SUPPORT_SESSION

public static final String SUPPORT_SESSION

See Also:: Constant Field Values

ATMOSPHERE_HANDLER

public static final String ATMOSPHERE_HANDLER

WEBSOCKET_ATMOSPHEREHANDLER

public static final String WEBSOCKET_ATMOSPHEREHANDLER

logger

public static final Logger logger

RESUME_AND_KEEPALIVE

public static final String RESUME_AND_KEEPALIVE

RESUMED_ON_TIMEOUT

public static final String RESUMED_ON_TIMEOUT

DEFAULT_NAMED_DISPATCHER

public static final String DEFAULT_NAMED_DISPATCHER

See Also:: Constant Field Values

BROADCAST_FILTER_CLASSES

public static final String BROADCAST_FILTER_CLASSES

See Also:: Constant Field Values

possibleAtmosphereHandlersCandidate

protected final ArrayList<String> possibleAtmosphereHandlersCandidate

initParams

protected final HashMap<String,String> initParams

config

protected final AtmosphereServlet.AtmosphereConfig config

isCometSupportConfigured

protected final AtomicBoolean isCometSupportConfigured

isFilter

protected final boolean isFilter

useNativeImplementation

protected boolean useNativeImplementation

useBlockingImplementation

protected boolean useBlockingImplementation

useStreamForFlushingComments

protected boolean useStreamForFlushingComments

cometSupport

protected CometSupport cometSupport

broadcasterClassName

protected static String broadcasterClassName

isCometSupportSpecified

protected boolean isCometSupportSpecified

isBroadcasterSpecified

protected boolean isBroadcasterSpecified

isSessionSupportSpecified

protected boolean isSessionSupportSpecified

Constructor Detail

AtmosphereServlet

public AtmosphereServlet()

Create an Atmosphere Servlet.

AtmosphereServlet

public AtmosphereServlet(boolean isFilter)

Create an Atmosphere Servlet.

Parameters:: isFilter - true if this instance is used as an AtmosphereFilter

Method Detail

getAtmosphereConfig

public AtmosphereServlet.AtmosphereConfig getAtmosphereConfig()

Return a configured instance of AtmosphereServlet.AtmosphereConfig

Returns:: a configured instance of AtmosphereServlet.AtmosphereConfig

addAtmosphereHandler

public void addAtmosphereHandler(String mapping,
                                 AtmosphereHandler h)

Add an AtmosphereHandler serviced by the Servlet This API is exposed to allow embedding an Atmosphere application.

Parameters:: mapping - The servlet mapping (servlet path); h - implementation of an AtmosphereHandler

addAtmosphereHandler

public void addAtmosphereHandler(String mapping,
                                 AtmosphereHandler h,
                                 String broadcasterId)

Add an AtmosphereHandler serviced by the Servlet This API is exposed to allow embedding an Atmosphere application.

Parameters:: mapping - The servlet mapping (servlet path); h - implementation of an AtmosphereHandler; broadcasterId - The Broadcaster.getID() value.

addAtmosphereHandler

public void addAtmosphereHandler(String mapping,
                                 AtmosphereHandler h,
                                 Broadcaster broadcaster)

Add an AtmosphereHandler serviced by the Servlet This API is exposed to allow embedding an Atmosphere application.

Parameters:: mapping - The servlet mapping (servlet path); h - implementation of an AtmosphereHandler; broadcaster - The Broadcaster associated with AtmosphereHandler.

removeAtmosphereHandler

public boolean removeAtmosphereHandler(String mapping)

Remove an AtmosphereHandler

Parameters:: mapping - the mapping used when invoking addAtmosphereHandler(String, AtmosphereHandler);
Returns:: true if removed

removeAllAtmosphereHandler

public void removeAllAtmosphereHandler()

Remove all AtmosphereHandler

removeAllInitParams

public void removeAllInitParams()

Remove all init parameters.

addInitParameter

public void addInitParameter(String name,
                             String value)

Add init-param like if they were defined in web.xml

Parameters:: name - The name; value - The value

readSystemProperties

protected void readSystemProperties()

init

public void init(ServletConfig sc)
          throws ServletException

Load the AtmosphereHandler associated with this AtmosphereServlet.

Specified by:: init in interface Servlet
Overrides:: init in class GenericServlet

Parameters:: sc - the ServletContext
Throws:: ServletException

configureBroadcaster

protected void configureBroadcaster()
                             throws ClassNotFoundException,
                                    InstantiationException,
                                    IllegalAccessException

Throws:: ClassNotFoundException; InstantiationException; IllegalAccessException

doInitParams

protected void doInitParams(ServletConfig sc)

Read init param from web.xml and apply them.

Parameters:: sc - ServletConfig

loadConfiguration

protected void loadConfiguration(ServletConfig sc)
                          throws ServletException

Throws:: ServletException

detectSupportedFramework

protected boolean detectSupportedFramework(ServletConfig sc)
                                    throws ClassNotFoundException,
                                           IllegalAccessException,
                                           InstantiationException,
                                           NoSuchMethodException,
                                           InvocationTargetException

Auto-detect Jersey when no atmosphere.xml file are specified.

Parameters:: sc - ServletConfig
Returns:: true if Jersey classes are detected
Throws:: ClassNotFoundException; IllegalAccessException; InstantiationException; NoSuchMethodException; InvocationTargetException

sessionSupport

protected void sessionSupport(boolean sessionSupport)

destroy

public void destroy()

Specified by:: destroy in interface Servlet
Overrides:: destroy in class GenericServlet

loadAtmosphereDotXml

protected void loadAtmosphereDotXml(InputStream stream,
                                    URLClassLoader c)
                             throws IOException,
                                    ServletException

Load AtmosphereHandler defined under META-INF/atmosphere.xml

Parameters:: stream - The input stream we read from.; c - The classloader
Throws:: IOException; ServletException

setCometSupport

public void setCometSupport(CometSupport cometSupport)

Set the CometSupport implementation. Make sure you don't set an implementation that only works on some Container. See BlockingIOCometSupport for an example.

Parameters:: cometSupport -

getCometSupport

public CometSupport getCometSupport()

Return the current CometSupport

Returns:: the current CometSupport

createCometSupportResolver

protected CometSupportResolver createCometSupportResolver()

Returns an instance of CometSupportResolver CometSupportResolver

Returns:: CometSupportResolver

autoDetectContainer

protected void autoDetectContainer()

Auto detect the underlying Servlet Container we are running on.

autoDetectAtmosphereHandlers

protected void autoDetectAtmosphereHandlers(ServletContext sc,
                                            URLClassLoader c)
                                     throws MalformedURLException,
                                            URISyntaxException

Auto detect instance of AtmosphereHandler in case META-INF/atmosphere.xml is missing.

Parameters:: sc - ServletContext; c - URLClassLoader to load the class.
Throws:: MalformedURLException; URISyntaxException

getFiles

protected void getFiles(File f)

Get the list of possible candidate to load as AtmosphereHandler

Parameters:: f - the real path File