Refine configuration and annotation model.

Make RedisListener repeatable and accept a single topic instead of a pattern and channel mix. Introduce TopicResolver for configurable resolution of the topic (channel or pattern), align configuration infrastructure with JMS endpoint config model.

Refine bean methods by adding a distinct bean name, introduce PubSubHeaders for well-known header names. Extend Javadoc. Add tests for converted payload and header value injection.
Register converter for byte array to String conversion.

Author: mp911de

pom.xml

@@ -91,6 +91,13 @@
 			<artifactId>spring-context-support</artifactId>
 		</dependency>
 
+		<!-- Messaging for @EnableRedisListeners -->
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-messaging</artifactId>
+			<optional>true</optional>
+		</dependency>
+
 		<!-- Redis Drivers -->
 
 		<dependency>
@@ -222,13 +229,6 @@
 			<scope>test</scope>
 		</dependency>
 
-		<!-- Messaging -->
-		<dependency>
-			<groupId>org.springframework</groupId>
-			<artifactId>spring-messaging</artifactId>
-			<optional>true</optional>
-		</dependency>
-
 		<!-- CDI -->
 		<!-- Dependency order required to build against CDI 1.0 and test with CDI 2.0 -->
 

src/main/java/org/springframework/data/redis/annotation/EnableRedisListeners.java

@@ -15,23 +15,113 @@
  */
 package org.springframework.data.redis.annotation;
 
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
 import org.springframework.context.annotation.Import;
 import org.springframework.data.redis.config.RedisListenerBootstrapConfiguration;
-
-import java.lang.annotation.*;
+import org.springframework.data.redis.config.RedisListenerEndpointRegistry;
 
 /**
- * Enable Redis listener annotated endpoints that are created under the cover by a
- * {@link org.springframework.data.redis.config.RedisListenerBootstrapConfiguration}.
+ * Enable Redis Pub/Sub listener annotated endpoints that are created under the cover by a
+ * {@link RedisListenerAnnotationBeanPostProcessor}. To be used on
+ * {@link org.springframework.context.annotation.Configuration @Configuration} classes as follows:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * &#064;EnableRedisListeners
+ * public class AppConfig {
+ *
+ * 	&#064;Bean
+ * 	public RedisMessageListenerContainer myRedisListenerContainer() {
+ * 		RedisMessageListenerContainer factory = new RedisMessageListenerContainer();
+ * 		factory.setConnectionFactory(connectionFactory());
+ * 		return factory;
+ * 	}
+ *
+ * 	// other &#064;Bean definitions
+ * }
+ * </pre>
+ * <p>
+ * The {@code RedisListenerAnnotationBeanPostProcessor} is responsible for creating endpoints.
+ * <p>
+ * {@code @EnableRedisListeners} enables detection of {@link RedisListener @RedisListener} annotations on any
+ * Spring-managed bean in the container. For example, given a class {@code MyService}:
+ *
+ * <pre class="code">
+ * package com.acme.foo;
+ *
+ * public class MyService {
+ *
+ * 	&#064;RedisListener(container = "myRedisListenerContainer", topic = "myChannel")
+ * 	public void process(String msg) {
+ * 		// process incoming message
+ * 	}
+ * }
+ * </pre>
+ * <p>
+ * The container to use is identified by the {@link RedisListener#container() container} attribute defining the name of
+ * the {@code RedisMessageListenerContainer} bean to use. When none is set a default
+ * {@code RedisMessageListenerContainer} bean is assumed to be present.
+ * <p>
+ * The following configuration would ensure that every time a Pub/Sub is received on the topic channel named
+ * "myChannel", {@code MyService.process()} is invoked with the content of the message:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * &#064;EnableRedisListeners
+ * public class AppConfig {
+ *
+ * 	&#064;Bean
+ * 	public MyService myService() {
+ * 		return new MyService();
+ * 	}
+ *
+ * 	// Redis infrastructure setup
+ * }
+ * </pre>
+ * <p>
+ * Alternatively, if {@code MyService} were annotated with {@code @Component}, the following configuration would ensure
+ * that its {@code @EnableRedisListeners} annotated method is invoked with a matching incoming message:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * &#064;EnableRedisListeners
+ * &#064;ComponentScan(basePackages = "com.acme.foo")
+ * public class AppConfig {}
+ * </pre>
+ * <p>
+ * Annotated methods can use flexible signature; in particular, it is possible to use the
+ * {@link org.springframework.messaging.Message Message} abstraction and related annotations, see {@link RedisListener}
+ * Javadoc for more details. For instance, the following would inject the content of the message and the "channel" name
+ * header:
+ *
+ * <pre class="code">
+ * &#064;RedisListener(container = "myRedisListenerContainer", topic = "myChannel")
+ * public void process(String msg, @Header("channel") String channel) {
+ * 	// process incoming message
+ * }
+ * </pre>
+ * <p>
+ * These features are abstracted by the
+ * {@link org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory} that is responsible for
+ * building the necessary invoker to process the annotated method. By default,
+ * {@link org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory} is used.
+ * <p>
  *
  * @author Ilyass Bougati
+ * @since 4.1
  * @see RedisListener
  * @see RedisListenerAnnotationBeanPostProcessor
+ * @see RedisListenerEndpointRegistry
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Import(RedisListenerBootstrapConfiguration.class)
 public @interface EnableRedisListeners {
-    // Standard enable annotation attributes can be added here
+
 }

src/main/java/org/springframework/data/redis/annotation/RedisListener.java

@@ -15,39 +15,77 @@
  */
 package org.springframework.data.redis.annotation;
 
-import java.lang.annotation.*;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.messaging.handler.annotation.MessageMapping;
 
 /**
- * Annotation that marks a method to be the target of a Redis message listener on the specified {@link #channels() topics}
- * (or {@link #patterns() patterns}).
+ * Annotation that marks a method to be the target of a Redis Pub/Sub message listener on the specified {@link #topic}.
+ * The {@link #container()} identifies the {@link org.springframework.data.redis.listener.RedisMessageListenerContainer}
+ * to subscribe with. If not set, a <em>default</em> container is assumed to be available.
+ * <p>
+ * Processing of {@code @RedisListener} annotations is performed by registering a
+ * {@link RedisListenerAnnotationBeanPostProcessor}. This can be done manually or, more conveniently, through the
+ * {@link EnableRedisListeners @EnableRedisListeners} annotation.
+ * <p>
+ * Annotated Redis listener methods are allowed to have flexible signatures similar to what {@link MessageMapping}
+ * provides:
+ * <ul>
+ * <li>{@link org.springframework.data.redis.listener.Topic} to get access to the Redis topic</li>
+ * <li>{@link org.springframework.messaging.Message} to use Spring's messaging abstraction</li>
+ * <li>{@link org.springframework.messaging.handler.annotation.Payload @Payload}-annotated method arguments, including
+ * support for validation</li>
+ * <li>{@link org.springframework.messaging.handler.annotation.Header @Header}-annotated method arguments to extract
+ * specific header values, including Redis headers defined by
+ * {@link org.springframework.data.redis.listener.support.PubSubHeaders}</li>
+ * <li>{@link org.springframework.messaging.handler.annotation.Headers @Headers}-annotated method argument that must
+ * also be assignable to {@link java.util.Map} for obtaining access to all headers</li>
+ * <li>{@link org.springframework.messaging.MessageHeaders} arguments for obtaining access to all headers</li>
+ * <li>{@link org.springframework.messaging.support.MessageHeaderAccessor} for convenient access to all method
+ * arguments</li>
+ * </ul>
+ * <p>
+ * This annotation can be used as a <em>{@linkplain Repeatable repeatable}</em> annotation.
+ * <p>
+ * This annotation may be used as a <em>meta-annotation</em> to create custom <em>composed annotations</em> with
+ * attribute overrides.
  *
  * @author Ilyass Bougati
+ * @author Mark Paluch
+ * @since 4.1
  * @see EnableRedisListeners
+ * @see RedisListenerAnnotationBeanPostProcessor
+ * @see RedisListeners
  */
 @Target({ ElementType.METHOD, ElementType.ANNOTATION_TYPE })
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
+@Repeatable(RedisListeners.class)
+@MessageMapping
 public @interface RedisListener {
 
 	/**
 	 * The unique identifier of the container managing this endpoint.
+	 * <p>
+	 * If none is specified, an auto-generated one is provided.
 	 */
 	String id() default "";
 
 	/**
-	 * The bean name of the {@link org.springframework.data.redis.listener.RedisMessageListenerContainer} to use.
-	 * If empty, the default 'redisMessageListenerContainer'
-	 * bean will be used
+	 * The bean name of the {@link org.springframework.data.redis.listener.RedisMessageListenerContainer} to subscribe
+	 * with. If empty, the default {@code RedisMessageListenerContainer} bean will be used.
 	 */
-	String container() default "redisMessageListenerContainer";
+	String container() default "";
 
 	/**
-	 * The topics for this listener.
+	 * The destination name for this listener, resolved through a
+	 * {@link org.springframework.data.redis.listener.support.TopicResolver} strategy.
 	 */
-	String[] channels() default {};
+	String topic() default "";
 
-	/**
-	 * The topic patterns for this listener.
-	 */
-	String[] patterns() default {};
 }