public class MessageListenerAdapter extends Object implements MessageListener, ChannelAwareMessageListener
By default, the content of incoming Rabbit messages gets extracted before being passed into the target listener
method, to let the target method operate on message content types such as String or byte array instead of the raw
Message
. Message type conversion is delegated to a Spring AMQ MessageConverter
. By default, a
SimpleMessageConverter
will be used. (If you do not want such automatic message conversion taking place, then
be sure to set the MessageConverter
to null
.)
If a target listener method returns a non-null object (typically of a message content type such as
String
or byte array), it will get wrapped in a Rabbit Message
and sent to the exchange of
the incoming message with the routingKey that comes from the Rabbit ReplyTo property or via
specified routingKey
).
Note: The sending of response messages is only available when using the ChannelAwareMessageListener
entry point (typically through a Spring message listener container). Usage as MessageListener
does not
support the generation of response messages.
Find below some examples of method signatures compliant with this adapter class. This first example handles all
Message
types and gets passed the contents of each Message
type as an argument. No
Message
will be sent back as all of these methods return void
.
public interface MessageContentsDelegate { void handleMessage(String text); void handleMessage(Map map); void handleMessage(byte[] bytes); void handleMessage(Serializable obj); }This next example handle a
Message
type and gets passed the actual (raw) Message
as an
argument. Again, no Message
will be sent back as all of these methods return void
.
public interface RawMessageDelegate { void handleMessage(Message message); }This next example illustrates a
Message
delegate that just consumes the String
contents of
Messages
. Notice also how the name of the Message
handling method is different from the
original
(this will have to be configured in the attandant bean
definition). Again, no Message
will be sent back as the method returns void
.
public interface TextMessageContentDelegate { void onMessage(String text); }This final example illustrates a
Message
delegate that just consumes the String
contents of
Messages
. Notice how the return type of this method is String
: This will result in the
configured MessageListenerAdapter
sending a Message
in response.
public interface ResponsiveTextMessageContentDelegate { String handleMessage(String text); }For further examples and discussion please do refer to the Spring reference documentation which describes this class (and its attendant XML configuration) in detail.
setDelegate(java.lang.Object)
,
setDefaultListenerMethod(java.lang.String)
,
setResponseRoutingKey(String)
,
setMessageConverter(org.springframework.amqp.support.converter.MessageConverter)
,
SimpleMessageConverter
,
ChannelAwareMessageListener
,
AbstractMessageListenerContainer.setMessageListener(java.lang.Object)
Modifier and Type | Field and Description |
---|---|
protected org.apache.commons.logging.Log |
logger
Logger available to subclasses
|
static String |
ORIGINAL_DEFAULT_LISTENER_METHOD
Out-of-the-box value for the default listener method: "handleMessage".
|
Constructor and Description |
---|
MessageListenerAdapter()
Create a new
MessageListenerAdapter with default settings. |
MessageListenerAdapter(Object delegate)
Create a new
MessageListenerAdapter for the given delegate. |
MessageListenerAdapter(Object delegate,
MessageConverter messageConverter)
Create a new
MessageListenerAdapter for the given delegate. |
MessageListenerAdapter(Object delegate,
String defaultListenerMethod)
Create a new
MessageListenerAdapter for the given delegate while also
declaring its POJO method. |
Modifier and Type | Method and Description |
---|---|
protected Object[] |
buildListenerArguments(Object extractedMessage)
Build an array of arguments to be passed into the target listener method.
|
protected Message |
buildMessage(com.rabbitmq.client.Channel session,
Object result)
Build a Rabbit message to be sent as response based on the given result object.
|
protected Object |
extractMessage(Message message)
Extract the message body from the given Rabbit message.
|
protected String |
getDefaultListenerMethod()
Return the name of the default listener method to delegate to.
|
protected Object |
getDelegate()
Return the target object to delegate message listening to.
|
protected String |
getListenerMethodName(Message originalMessage,
Object extractedMessage)
Determine the name of the listener method that is supposed to handle the given message.
|
protected MessageConverter |
getMessageConverter()
Return the converter that will convert incoming Rabbit messages to listener method arguments, and objects
returned from listener methods back to Rabbit messages.
|
protected String |
getReceivedExchange(Message request) |
protected Address |
getReplyToAddress(Message request)
Determine a reply-to Address for the given message.
|
protected void |
handleListenerException(Throwable ex)
Handle the given exception that arose during listener execution.
|
protected void |
handleResult(Object result,
Message request,
com.rabbitmq.client.Channel channel)
Handle the given result object returned from the listener method, sending a response message back.
|
protected void |
initDefaultStrategies()
Initialize the default implementations for the adapter's strategies.
|
protected Object |
invokeListenerMethod(String methodName,
Object[] arguments)
Invoke the specified listener method.
|
void |
onMessage(Message message)
Rabbit
MessageListener entry point. |
void |
onMessage(Message message,
com.rabbitmq.client.Channel channel)
Spring
ChannelAwareMessageListener entry point. |
protected void |
postProcessChannel(com.rabbitmq.client.Channel channel,
Message response)
Post-process the given message producer before using it to send the response.
|
protected void |
postProcessResponse(Message request,
Message response)
Post-process the given response message before it will be sent.
|
protected void |
sendResponse(com.rabbitmq.client.Channel channel,
Address replyTo,
Message message)
Send the given response message to the given destination.
|
void |
setDefaultListenerMethod(String defaultListenerMethod)
Specify the name of the default listener method to delegate to, for the case where no specific listener method
has been determined.
|
void |
setDelegate(Object delegate)
Set a target object to delegate message listening to.
|
void |
setEncoding(String encoding)
The encoding to use when inter-converting between byte arrays and Strings in message properties.
|
void |
setImmediatePublish(boolean immediatePublish) |
void |
setMandatoryPublish(boolean mandatoryPublish) |
void |
setMessageConverter(MessageConverter messageConverter)
Set the converter that will convert incoming Rabbit messages to listener method arguments, and objects returned
from listener methods back to Rabbit messages.
|
void |
setResponseExchange(String responseExchange)
Set the exchange to use when sending response messages.
|
void |
setResponseRoutingKey(String responseRoutingKey)
Set the routing key to use when sending response messages.
|
public static final String ORIGINAL_DEFAULT_LISTENER_METHOD
protected final org.apache.commons.logging.Log logger
public MessageListenerAdapter()
MessageListenerAdapter
with default settings.public MessageListenerAdapter(Object delegate)
MessageListenerAdapter
for the given delegate.delegate
- the delegate objectpublic MessageListenerAdapter(Object delegate, MessageConverter messageConverter)
MessageListenerAdapter
for the given delegate.delegate
- the delegate objectmessageConverter
- the message converter to usepublic MessageListenerAdapter(Object delegate, String defaultListenerMethod)
MessageListenerAdapter
for the given delegate while also
declaring its POJO method.delegate
- the delegate objectdefaultListenerMethod
- name of the POJO method to call upon message receiptpublic void setDelegate(Object delegate)
If no explicit delegate object has been specified, listener methods are expected to present on this adapter instance, that is, on a custom subclass of this adapter, defining listener methods.
protected Object getDelegate()
public void setEncoding(String encoding)
encoding
- the encoding to setpublic void setDefaultListenerMethod(String defaultListenerMethod)
"handleMessage"
.protected String getDefaultListenerMethod()
public void setResponseRoutingKey(String responseRoutingKey)
Response destinations are only relevant for listener methods that return result objects, which will be wrapped in a response message and sent to a response destination.
public void setResponseExchange(String responseExchange)
Response destinations are only relevant for listener methods that return result objects, which will be wrapped in a response message and sent to a response destination.
responseExchange
- public void setMessageConverter(MessageConverter messageConverter)
The default converter is a SimpleMessageConverter
, which is able to handle "text" content-types.
protected MessageConverter getMessageConverter()
public void setMandatoryPublish(boolean mandatoryPublish)
public void setImmediatePublish(boolean immediatePublish)
public void onMessage(Message message)
MessageListener
entry point.
Delegates the message to the target listener method, with appropriate conversion of the message argument. In case
of an exception, the handleListenerException(Throwable)
method will be invoked.
Note: Does not support sending response messages based on result objects returned from listener methods.
Use the ChannelAwareMessageListener
entry point (typically through a Spring message listener container)
for handling result objects as well.
onMessage
in interface MessageListener
message
- the incoming Rabbit messagehandleListenerException(java.lang.Throwable)
,
onMessage(Message, Channel)
public void onMessage(Message message, com.rabbitmq.client.Channel channel) throws Exception
ChannelAwareMessageListener
entry point.
Delegates the message to the target listener method, with appropriate conversion of the message argument. If the target method returns a non-null object, wrap in a Rabbit message and send it back.
onMessage
in interface ChannelAwareMessageListener
message
- the incoming Rabbit messagechannel
- the Rabbit channel to operate onException
- if thrown by Rabbit API methodsprotected void initDefaultStrategies()
protected void handleListenerException(Throwable ex)
This method only applies when using a Rabbit MessageListener
. With
ChannelAwareMessageListener
, exceptions get handled by the
caller instead.
ex
- the exception to handleonMessage(Message)
protected Object extractMessage(Message message) throws Exception
message
- the Rabbit Message
Exception
- if thrown by Rabbit API methodsprotected String getListenerMethodName(Message originalMessage, Object extractedMessage) throws Exception
The default implementation simply returns the configured default listener method, if any.
originalMessage
- the Rabbit request messageextractedMessage
- the converted Rabbit request message, to be passed into the listener method as argumentnull
)Exception
- if thrown by Rabbit API methodssetDefaultListenerMethod(java.lang.String)
protected Object[] buildListenerArguments(Object extractedMessage)
The default implementation builds an array with the given message object as sole element. This means that the extracted message will always be passed into a single method argument, even if it is an array, with the target method having a corresponding single argument of the array's type declared.
This can be overridden to treat special message content such as arrays differently, for example passing in each element of the message array as distinct method argument.
extractedMessage
- the content of the messageprotected Object invokeListenerMethod(String methodName, Object[] arguments) throws Exception
methodName
- the name of the listener methodarguments
- the message arguments to be passed inException
- if thrown by Rabbit API methodsgetListenerMethodName(org.springframework.amqp.core.Message, java.lang.Object)
,
buildListenerArguments(java.lang.Object)
protected void handleResult(Object result, Message request, com.rabbitmq.client.Channel channel) throws Exception
result
- the result object to handle (never null
)request
- the original request messagechannel
- the Rabbit channel to operate on (may be null
)Exception
- if thrown by Rabbit API methodsbuildMessage(com.rabbitmq.client.Channel, java.lang.Object)
,
postProcessResponse(org.springframework.amqp.core.Message, org.springframework.amqp.core.Message)
,
getReplyToAddress(Message)
,
sendResponse(com.rabbitmq.client.Channel, org.springframework.amqp.core.Address, org.springframework.amqp.core.Message)
protected Message buildMessage(com.rabbitmq.client.Channel session, Object result) throws Exception
session
- the Rabbit Channel to operate onresult
- the content of the message, as returned from the listener methodMessage
(never null
)Exception
- if thrown by Rabbit API methodssetMessageConverter(org.springframework.amqp.support.converter.MessageConverter)
protected void postProcessResponse(Message request, Message response) throws Exception
The default implementation sets the response's correlation id to the request message's correlation id, if any; otherwise to the request message id.
request
- the original incoming Rabbit messageresponse
- the outgoing Rabbit message about to be sentException
- if thrown by Rabbit API methodsprotected Address getReplyToAddress(Message request) throws Exception
The default implementation first checks the Rabbit Reply-To Address of the supplied request; if that is not
null
it is returned; if it is null
, then the configured default response Exchange and
routing key are used to construct a reply-to Address. If the responseExchange property is also null
,
then an AmqpException
is thrown.
request
- the original incoming Rabbit messagenull
)Exception
- if thrown by Rabbit API methodsAmqpException
- if no Address
can be determinedsetResponseExchange(String)
,
setResponseRoutingKey(String)
,
Message.getMessageProperties()
,
MessageProperties.getReplyTo()
protected void sendResponse(com.rabbitmq.client.Channel channel, Address replyTo, Message message) throws Exception
channel
- the Rabbit channel to operate onreplyTo
- the Rabbit ReplyTo string to use when sending. Currently interpreted to be the routing key.message
- the Rabbit message to sendException
- if thrown by Rabbit API methodspostProcessResponse(Message, Message)
protected void postProcessChannel(com.rabbitmq.client.Channel channel, Message response) throws Exception
The default implementation is empty.
response
- the outgoing Rabbit message about to be sentException
- if thrown by Rabbit API methods