## org.mortbay.cometd
Class BayeuxService

    java.lang.Object
      org.mortbay.cometd.BayeuxService

Direct Known Subclasses:
  ChatService, CometdDemoServlet.EchoRPC, CometdDemoServlet.Monitor

    public abstract class BayeuxService

extends java.lang.Object

Abstract Bayeux Service class. This is a base class to assist with the creation of server side @ link Bayeux} clients that provide services to remote Bayeux clients. The class provides a Bayeux `Client` and `Listener` together with convenience methods to map subscriptions to methods on the derived class and to send responses to those methods.

If a `setThreadPool(ThreadPool)` is set, then messages are handled in their own threads. This is desirable if the handling of a message can take considerable time and it is desired not to hold up the delivering thread (typically a HTTP request handling thread).

If the BayeuxService is constructed asynchronously (the default), then messages are delivered unsynchronized and multiple simultaneous calls to handling methods may occur.

If the BayeuxService is constructed as a synchronous service, then message delivery is synchronized on the internal `Client` instances used and only a single call will be made to the handler method (unless a thread pool is used).

Author:
  gregw
See Also:
  `MessageListener`

Constructor Summary
`BayeuxService(org.cometd.Bayeux bayeux, java.lang.String name)` Instantiate the service.
`BayeuxService(org.cometd.Bayeux bayeux, java.lang.String name, int maxThreads)` Instantiate the service.
`BayeuxService(org.cometd.Bayeux bayeux, java.lang.String name, int maxThreads, boolean synchronous)` Instantiate the service.

Method Summary
`protected void` `asyncDoInvoke(java.lang.reflect.Method method, org.cometd.Client fromClient, org.cometd.Client toClient, org.cometd.Message msg)`
`protected void` `exception(org.cometd.Client fromClient, org.cometd.Client toClient, java.util.Map<java.lang.String,java.lang.Object> msg, java.lang.Throwable th)` Handle Exception.
`org.cometd.Bayeux` `getBayeux()`
`org.cometd.Client` `getClient()`
`ThreadPool` `getThreadPool()`
`boolean` `isSeeOwnPublishes()`
`protected void` `send(org.cometd.Client toClient, java.lang.String onChannel, java.lang.Object data, java.lang.String id)` Send data to a individual client.
`void` `setSeeOwnPublishes(boolean own)`
`void` `setThreadPool(ThreadPool pool)` Set the threadpool.
`protected void` `subscribe(java.lang.String channelId, java.lang.String methodName)` Subscribe to a channel.

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

Constructor Detail

### BayeuxService

    public BayeuxService(org.cometd.Bayeux bayeux,
                         java.lang.String name)

  Instantiate the service. Typically the derived constructor will call @ #subscribe(String, String)} to map subscriptions to methods.

  Parameters:
    `bayeux` - The bayeux instance.
    `name` - The name of the service (used as client ID prefix).

### BayeuxService

    public BayeuxService(org.cometd.Bayeux bayeux,
                         java.lang.String name,
                         int maxThreads)

  Instantiate the service. Typically the derived constructor will call @ #subscribe(String, String)} to map subscriptions to methods.

  Parameters:
    `bayeux` - The bayeux instance.
    `name` - The name of the service (used as client ID prefix).
    `maxThreads` - The size of a ThreadPool to create to handle messages.

### BayeuxService

    public BayeuxService(org.cometd.Bayeux bayeux,
                         java.lang.String name,
                         int maxThreads,
                         boolean synchronous)

  Instantiate the service. Typically the derived constructor will call @ #subscribe(String, String)} to map subscriptions to methods.

  Parameters:
    `bayeux` - The bayeux instance.
    `name` - The name of the service (used as client ID prefix).
    `maxThreads` - The size of a ThreadPool to create to handle messages.
    `synchronous` - True if message delivery will be synchronized on the client.

Method Detail

### getBayeux

    public org.cometd.Bayeux getBayeux()

### getClient

    public org.cometd.Client getClient()

### getThreadPool

    public ThreadPool getThreadPool()

### setThreadPool

    public void setThreadPool(ThreadPool pool)

  Set the threadpool. If the `ThreadPool` is a `LifeCycle`, then it is started by this method.

  Parameters:
    `pool` -

### isSeeOwnPublishes

    public boolean isSeeOwnPublishes()

### setSeeOwnPublishes

    public void setSeeOwnPublishes(boolean own)

### subscribe

    protected void subscribe(java.lang.String channelId,
                             java.lang.String methodName)

  Subscribe to a channel. Subscribe to channel and map a method to handle received messages. The method must have a unique name and one of the following signatures:
  - `myMethod(Client fromClient,Object data)`
  - `myMethod(Client fromClient,Object data,String id)`
  - `myMethod(Client fromClient,String channel,Object data,String id)`
  The data parameter can be typed if the type of the data object published by the client is known (typically Map<String,Object>). If the type of the data parameter is `Message` then the message object itself is passed rather than just the data.

  Typically a service will subscribe to a channel in the "/service/**" space which is not a broadcast channel. Messages published to these channels are only delivered to server side clients like this service.

  Any object returned by a mapped subscription method is delivered to the calling client and not broadcast. If the method returns void or null, then no response is sent. A mapped subscription method may also call `send(Client, String, Object, String)` to deliver a response message(s) to different clients and/or channels. It may also publish methods via the normal `Bayeux` API.

  Parameters:
    `channelId` - The channel to subscribe to
    `methodName` - The name of the method on this object to call when messages are recieved.

### send

    protected void send(org.cometd.Client toClient,
                        java.lang.String onChannel,
                        java.lang.Object data,
                        java.lang.String id)

  Send data to a individual client. The data passed is sent to the client as the "data" member of a message with the given channel and id. The message is not published on the channel and is thus not broadcast to all channel subscribers. However to the target client, the message appears as if it was broadcast.

  Typcially this method is only required if a service method sends response(s) to channels other than the subscribed channel. If the response is to be sent to the subscribed channel, then the data can simply be returned from the subscription method.

  Parameters:
    `toClient` - The target client
    `onChannel` - The channel the message is for
    `data` - The data of the message
    `id` - The id of the message (or null for a random id).

### exception

    protected void exception(org.cometd.Client fromClient,
                             org.cometd.Client toClient,
                             java.util.Map<java.lang.String,java.lang.Object> msg,
                             java.lang.Throwable th)

  Handle Exception. This method is called when a mapped subscription method throws and exception while handling a message.

  Parameters:
    `fromClient` - The remote client
    `toClient` - The client associated with this BayeuxService
    `msg` - The message
    `th` - The exception thrown by the mapped subscription method

### asyncDoInvoke

    protected void asyncDoInvoke(java.lang.reflect.Method method,
                                 org.cometd.Client fromClient,
                                 org.cometd.Client toClient,
                                 org.cometd.Message msg)

Copyright © 1995-2010 Mort Bay Consulting. All Rights Reserved.