org.hawkular.bus.common

Class MessageProcessor

java.lang.Object

org.hawkular.bus.common.MessageProcessor

Direct Known Subclasses:

SimpleMessageProcessor

public class MessageProcessor
extends Object

Provides some functionality to process messages, both as a producer or consumer. Use ConnectionContextFactory to create contexts (which create destinations, sessions, and connections for you) that you then use to pass to the listen and send methods in this class.

Constructor Summary

Constructors

Constructor and Description
MessageProcessor()

Method Summary

Modifier and Type	Method and Description
protected javax.jms.Message	createMessage(ConnectionContext context, BasicMessage basicMessage) Same as createMessage(ConnectionContext, BasicMessage, Map) with null headers.
protected javax.jms.Message	createMessage(ConnectionContext context, BasicMessage basicMessage, Map<String,String> headers) Creates a text message that can be send via a producer that contains the given BasicMessage's JSON encoded data.
<T extends BasicMessage> void	listen(ConsumerConnectionContext context, AbstractBasicMessageListener<T> listener) Listens for messages.
MessageId	send(ProducerConnectionContext context, BasicMessage basicMessage) Same as send(ProducerConnectionContext, BasicMessage, Map) with null headers.
MessageId	send(ProducerConnectionContext context, BasicMessage basicMessage, Map<String,String> headers) Send the given message to its destinations across the message bus.
<T extends BasicMessage> RPCConnectionContext	sendAndListen(ProducerConnectionContext context, BasicMessage basicMessage, BasicMessageListener<T> responseListener) Same as sendAndListen(ProducerConnectionContext, BasicMessage, BasicMessageListener, Map) with null headers.
<T extends BasicMessage> RPCConnectionContext	sendAndListen(ProducerConnectionContext context, BasicMessage basicMessage, BasicMessageListener<T> responseListener, Map<String,String> headers) Send the given message to its destinations across the message bus and any response sent back will be passed to the given listener.
<R extends BasicMessage> com.google.common.util.concurrent.ListenableFuture<R>	sendRPC(ProducerConnectionContext context, BasicMessage basicMessage, Class<R> expectedResponseMessageClass) Same as sendRPC(ProducerConnectionContext, BasicMessage, Class, Map) with null headers.
<R extends BasicMessage> com.google.common.util.concurrent.ListenableFuture<R>	sendRPC(ProducerConnectionContext context, BasicMessage basicMessage, Class<R> expectedResponseMessageClass, Map<String,String> headers) Send the given message to its destinations across the message bus and returns a Future to allow the caller to retrieve the response.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MessageProcessor

public MessageProcessor()

Method Detail

listen

public <T extends BasicMessage> void listen(ConsumerConnectionContext context,
                                            AbstractBasicMessageListener<T> listener)
                                     throws javax.jms.JMSException

Listens for messages.

Parameters:

context - information that determines where to listen

listener - the listener that processes the incoming messages

Throws:

javax.jms.JMSException - any error

See Also:

ConnectionContextFactory.createConsumerConnectionContext(Endpoint)

send

public MessageId send(ProducerConnectionContext context,
                      BasicMessage basicMessage)
               throws javax.jms.JMSException

Same as send(ProducerConnectionContext, BasicMessage, Map) with null headers.

Throws:

javax.jms.JMSException

send

public MessageId send(ProducerConnectionContext context,
                      BasicMessage basicMessage,
                      Map<String,String> headers)
               throws javax.jms.JMSException

Send the given message to its destinations across the message bus. Once sent, the message will get assigned a generated message ID. That message ID will also be returned by this method. Since this is fire-and-forget - no response is expected of the remote endpoint.

Parameters:

context - information that determines where the message is sent

basicMessage - the message to send with optional headers included

headers - headers for the JMS transport that will override same-named headers in the basic message

Returns:

the message ID

Throws:

javax.jms.JMSException - any error

See Also:

ConnectionContextFactory.createProducerConnectionContext(Endpoint)

sendAndListen

public <T extends BasicMessage> RPCConnectionContext sendAndListen(ProducerConnectionContext context,
                                                                   BasicMessage basicMessage,
                                                                   BasicMessageListener<T> responseListener)
                                                            throws javax.jms.JMSException

Same as sendAndListen(ProducerConnectionContext, BasicMessage, BasicMessageListener, Map) with null headers.

Throws:

javax.jms.JMSException

sendAndListen

public <T extends BasicMessage> RPCConnectionContext sendAndListen(ProducerConnectionContext context,
                                                                   BasicMessage basicMessage,
                                                                   BasicMessageListener<T> responseListener,
                                                                   Map<String,String> headers)
                                                            throws javax.jms.JMSException

Send the given message to its destinations across the message bus and any response sent back will be passed to the given listener. Use this for request-response messages where you expect to get a non-void response back. The response listener should close its associated consumer since typically there is only a single response that is expected. This is left to the listener to do in case there are special circumstances where the listener does expect multiple response messages. If the caller merely wants to wait for a single response and obtain the response message to process it further, consider using instead the method sendRPC(org.hawkular.bus.common.producer.ProducerConnectionContext, org.hawkular.bus.common.BasicMessage, java.lang.Class<R>) and use its returned Future to wait for the response, rather than having to supply your own response listener.

Parameters:

context - information that determines where the message is sent

basicMessage - the request message to send with optional headers included

responseListener - The listener that will process the response of the request. This listener should close its associated consumer when appropriate.

headers - headers for the JMS transport that will override same-named headers in the basic message

Returns:

the RPC context which includes information about the handling of the expected response

Throws:

javax.jms.JMSException - any error

See Also:

ConnectionContextFactory.createProducerConnectionContext(Endpoint)

sendRPC

public <R extends BasicMessage> com.google.common.util.concurrent.ListenableFuture<R> sendRPC(ProducerConnectionContext context,
                                                                                              BasicMessage basicMessage,
                                                                                              Class<R> expectedResponseMessageClass)
                                                                                       throws javax.jms.JMSException

Same as sendRPC(ProducerConnectionContext, BasicMessage, Class, Map) with null headers.

Throws:

javax.jms.JMSException

sendRPC

public <R extends BasicMessage> com.google.common.util.concurrent.ListenableFuture<R> sendRPC(ProducerConnectionContext context,
                                                                                              BasicMessage basicMessage,
                                                                                              Class<R> expectedResponseMessageClass,
                                                                                              Map<String,String> headers)
                                                                                       throws javax.jms.JMSException

Send the given message to its destinations across the message bus and returns a Future to allow the caller to retrieve the response. This is intended to mimic an RPC-like request-response workflow. It is assumed the request will trigger a single response message to be sent back. This method returns a Future that will provide you with the response message that is received back.

Parameters:

context - information that determines where the message is sent

basicMessage - the request message to send with optional headers included

expectedResponseMessageClass - this is the message class of the expected response object.

headers - headers for the JMS transport that will override same-named headers in the basic message

Returns:

a future that allows you to wait for and get the response of the given response type

Throws:

javax.jms.JMSException - any error

See Also:

ConnectionContextFactory.createProducerConnectionContext(Endpoint)

createMessage

protected javax.jms.Message createMessage(ConnectionContext context,
                                          BasicMessage basicMessage)
                                   throws javax.jms.JMSException

Same as createMessage(ConnectionContext, BasicMessage, Map) with null headers.

Throws:

javax.jms.JMSException

createMessage

protected javax.jms.Message createMessage(ConnectionContext context,
                                          BasicMessage basicMessage,
                                          Map<String,String> headers)
                                   throws javax.jms.JMSException

Creates a text message that can be send via a producer that contains the given BasicMessage's JSON encoded data.

Parameters:

context - the context whose session is used to create the message

basicMessage - contains the data that will be JSON-encoded and encapsulated in the created message, with optional headers included

headers - headers for the Message that will override same-named headers in the basic message

Returns:

the message that can be produced

Throws:

javax.jms.JMSException - any error

NullPointerException - if the context is null or the context's session is null