Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.data.redis.listener.adapter
Class MessageListenerAdapter

    java.lang.Object
      org.springframework.data.redis.listener.adapter.MessageListenerAdapter

All Implemented Interfaces:
  InitializingBean, MessageListener

    public class MessageListenerAdapter

extends Object
implements InitializingBean, MessageListener

Message listener adapter that delegates the handling of messages to target listener methods via reflection, with flexible message type conversion. Allows listener methods to operate on message content types, completely independent from the Redis API.

Make sure to call `afterPropertiesSet()` after setting all the parameters on the adapter.

Note that if the underlying "delegate" is implementing `MessageListener`, the adapter will delegate to it and allow an invalid method to be specified. However if it is not, the method becomes mandatory. This lenient behavior allows the adapter to be used uniformly across existing listeners and message POJOs.

Modeled as much as possible after the JMS MessageListenerAdapter in Spring Framework.

By default, the content of incoming Redis 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 Data `RedisSerializer`. By default, the `JdkSerializationRedisSerializer` will be used. (If you do not want such automatic message conversion taking place, then be sure to set the `Serializer` to `null`.)

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.

     public interface MessageContentsDelegate {
            void handleMessage(String text);

            void handleMessage(byte[] bytes);

            void handleMessage(Person obj);
     }

In addition, the channel or pattern to which a message is sent can be passed in to the method as a second argument of type String:

     public interface MessageContentsDelegate {
            void handleMessage(String text, String channel);

            void handleMessage(byte[] bytes, String pattern);
     }

For further examples and discussion please do refer to the Spring Data reference documentation which describes this class (and its attendant configuration) in detail. Important: Due to the nature of messages, the default serializer used by the adapter is `StringRedisSerializer`. If the messages are of a different type, change them accordingly through `setSerializer(RedisSerializer)`.

See Also:
  `MessageListenerAdapter`

Field Summary
`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 Summary
`MessageListenerAdapter()` Create a new `MessageListenerAdapter` with default settings.
`MessageListenerAdapter(Object delegate)` Create a new `MessageListenerAdapter` for the given delegate.
`MessageListenerAdapter(Object delegate, String defaultListenerMethod)` Create a new `MessageListenerAdapter` for the given delegate.

Method Summary
`void` | `afterPropertiesSet()`
`protected Object` | `extractMessage(Message message)` Extract the message body from the given Redis message.
`protected String` | `getDefaultListenerMethod()` Return the name of the default listener method to delegate to.
`Object` | `getDelegate()` Returns 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 void` | `handleListenerException(Throwable ex)` Handle the given exception that arose during listener execution.
`protected void` | `initDefaultStrategies()` Initialize the default implementations for the adapter's strategies.
`protected void` | `invokeListenerMethod(String methodName, Object[] arguments)` Invoke the specified listener method.
`void` | `onMessage(Message message, byte[] pattern)` Standard Redis `MessageListener` entry point.
`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` | `setSerializer(RedisSerializer<?> serializer)` Set the serializer that will convert incoming raw Redis messages to listener method arguments.
`void` | `setStringSerializer(RedisSerializer<String> serializer)` Sets the serializer used for converting the channel/pattern to a String.

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

Field Detail

### ORIGINAL_DEFAULT_LISTENER_METHOD

    public static final String ORIGINAL_DEFAULT_LISTENER_METHOD

  Out-of-the-box value for the default listener method: "handleMessage".

  See Also:
    Constant Field Values

### logger

    protected final org.apache.commons.logging.Log logger

  Logger available to subclasses

Constructor Detail

### MessageListenerAdapter

    public MessageListenerAdapter()

  Create a new `MessageListenerAdapter` with default settings.

### MessageListenerAdapter

    public MessageListenerAdapter(Object delegate)

  Create a new `MessageListenerAdapter` for the given delegate.

  Parameters:
    `delegate` - the delegate object

### MessageListenerAdapter

    public MessageListenerAdapter(Object delegate,
                                  String defaultListenerMethod)

  Create a new `MessageListenerAdapter` for the given delegate.

  Parameters:
    `delegate` - the delegate object
    `defaultListenerMethod` - method to call when a message comes
  See Also:
    `getListenerMethodName(org.springframework.data.redis.connection.Message, java.lang.Object)`

Method Detail

### setDelegate

    public void setDelegate(Object delegate)

  Set a target object to delegate message listening to. Specified listener methods have to be present on this target object.

  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.

  Parameters:
    `delegate` - delegate object

### getDelegate

    public Object getDelegate()

  Returns the target object to delegate message listening to.

  Returns:
    message listening delegation

### setDefaultListenerMethod

    public 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. Out-of-the-box value is `"handleMessage"`.

  See Also:
    `getListenerMethodName(org.springframework.data.redis.connection.Message, java.lang.Object)`

### getDefaultListenerMethod

    protected String getDefaultListenerMethod()

  Return the name of the default listener method to delegate to.

### setSerializer

    public void setSerializer(RedisSerializer<?> serializer)

  Set the serializer that will convert incoming raw Redis messages to listener method arguments.

  The default converter is a `StringRedisSerializer`.

  Parameters:
    `serializer` -

### setStringSerializer

    public void setStringSerializer(RedisSerializer<String> serializer)

  Sets the serializer used for converting the channel/pattern to a String.

  The default converter is a `StringRedisSerializer`.

  Parameters:
    `serializer` -

### afterPropertiesSet

    public void afterPropertiesSet()

  Specified by:
    `afterPropertiesSet` in interface `InitializingBean`

### onMessage

    public void onMessage(Message message,
                          byte[] pattern)

  Standard Redis `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.

  Specified by:
    `onMessage` in interface `MessageListener`
  Parameters:
    `message` - the incoming Redis message
    `pattern` - pattern matching the channel (if specified) - can be null
  See Also:
    `handleListenerException(java.lang.Throwable)`

### initDefaultStrategies

    protected void initDefaultStrategies()

  Initialize the default implementations for the adapter's strategies.

  See Also:
    `setSerializer(RedisSerializer)`, `JdkSerializationRedisSerializer`

### handleListenerException

    protected void handleListenerException(Throwable ex)

  Handle the given exception that arose during listener execution. The default implementation logs the exception at error level.

  Parameters:
    `ex` - the exception to handle

### extractMessage

    protected Object extractMessage(Message message)

  Extract the message body from the given Redis message.

  Parameters:
    `message` - the Redis `Message`
  Returns:
    the content of the message, to be passed into the listener method as argument

### getListenerMethodName

    protected String getListenerMethodName(Message originalMessage,
                                           Object extractedMessage)

  Determine the name of the listener method that is supposed to handle the given message.

  The default implementation simply returns the configured default listener method, if any.

  Parameters:
    `originalMessage` - the Redis request message
    `extractedMessage` - the converted Redis request message, to be passed into the listener method as argument
  Returns:
    the name of the listener method (never `null`)
  See Also:
    `setDefaultListenerMethod(java.lang.String)`

### invokeListenerMethod

    protected void invokeListenerMethod(String methodName,
                                        Object[] arguments)

  Invoke the specified listener method.

  Parameters:
    `methodName` - the name of the listener method
    `arguments` - the message arguments to be passed in
  See Also:
    `getListenerMethodName(org.springframework.data.redis.connection.Message, java.lang.Object)`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD