Spring指南之使用 Redis 进行消息传递(Spring Data Redis/以及自定义注解实现)

请参见官方文档Spring指南之Messaging with Redis
参见代码地址
请参见Redis菜鸟教程之Redis 发布订阅
请参见请参见Spring Data Redis官方文档之Redis 消息传递（发布/订阅）

一.简介

本指南将向您介绍如何使用Spring Data Redis发布和订阅用Redis发送的消息。

二.你将创造什么(What You Will Build)

1.您将构建一个使用StringRedisTemplate发布字符串消息的应用程序，并通过使用MessageListenerAdapter为该消息提供一个POJO订阅。

2.使用Spring Data Redis作为发布消息的手段听起来可能有些奇怪，但是，正如您将发现的，Redis不仅提供了NoSQL数据存储，还提供了消息传递系统。

三.创建项目

创建项目过程请参见Spring入门指南之创建多模块项目

1.Dependencies选择Spring Data Redis。

四.创建Redis消息接收器

1.在任何基于消息传递的应用程序中，都存在消息发布者和消息接收者。要创建消息接收器，用一个响应消息的方法实现一个接收器。

//一个自定义的消息接收器
public class MyReceiver1 {
    private static final Logger LOGGER = LoggerFactory.getLogger(MyReceiver1.class);
    private AtomicInteger counter = new AtomicInteger();
    
    public void receiveMessage(String message) {
		counter.incrementAndGet();
        LOGGER.info("Received <" + message + ">----counter=" + getCount());
    }

    public int getCount() {
        return counter.get();
    }
}

五.注册监听器并发送消息

1.Spring Data Redis提供了所有你需要用Redis发送和接收消息的组件。具体来说，你需要配置:

• A connection factory 连接工厂
• A message listener container 消息监听器容器
• A Redis template Redis模板

2.(1)您将使用Redis template发送消息，并将接收者（MyReceiver1）注册到消息监听器容器中，以便它接收消息。连接工厂（RedisConnectionFactory）驱动 template 和消息监听器容器，让它们连接到Redis服务器。这个例子使用了Spring Boot默认的RedisConnectionFactory，这是一个基于Jedis Redis库的JedisConnectionFactory实例。连接工厂被注入到消息监听器容器和Redis template中，如下例所示。
(2)listenerAdapter方法中定义的bean被注册为容器中定义的消息监听器容器中的消息监听器，并将监听有关 chat 主题的消息。
因为MyReceiver1类是一个POJO，所以需要将其包装在实现MessageListener接口的消息监听器适配器（MessageListenerAdapter）中(addMessageListener()需要这个接口)。消息监听器适配器也配置为在消息到达时调用MyReceiver1上的receiveMessage()方法。
(3)监听消息只需要连接工厂和消息监听器容器bean。要发送消息，还需要Redis模板。在这里，它是一个配置为StringRedisTemplate的bean，RedisTemplate的一个实现，其中键和值都是字符串实例。

@Configuration
public class RedisMessageListener {

    @Bean
    MyReceiver1 myReceiver1() {
        return new MyReceiver1();
    }

    //使用消息监听器容器注册Receiver，以便它将接收消息(监听receiveMessage方法)
    @Bean
    MessageListenerAdapter listenerAdapter(MyReceiver1 myReceiver1) {
        return new MessageListenerAdapter(myReceiver1, "receiveMessage");
    }

    //您将使用Redis模板发送消息
    //连接工厂被注入到 Redis模板中
    @Bean
    StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
    }

    //使用了Spring Boot默认的RedisConnectionFactory，这是一个基于Jedis Redis库的JedisConnectionFactory实例。
    //连接工厂被注入到消息侦听器容器中
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                            MessageListenerAdapter listenerAdapter) {

        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic("chat"));

        return container;
    }
}

3.在配置文件中添加redis相关配置

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=xxxx

4.在启动类中创建 Spring 应用程序上下文（Spring application context）。应用程序上下文启动消息监听器容器，消息监听器容器bean开始监听消息。从应用程序上下文中检索StringRedisTemplate bean，并使用它从Redis发送关于 chat 主题的消息。运行启动类开始测试。

@SpringBootApplication
public class GsMessagingRedisApplication {
    public static void main(String[] args) throws InterruptedException {
        ApplicationContext ac = SpringApplication.run(GsMessagingRedisApplication.class, args);
        StringRedisTemplate template = ac.getBean(StringRedisTemplate.class);
        MyReceiver1 receiver = ac.getBean(MyReceiver1.class);
        while (true) {
            template.convertAndSend("chat", "Hello World!");
            Thread.sleep(500L);
        }
    }
}

六.使用redis客户端工具订阅消息

七.问题

实际上我们不需要再去配置StringRedisTemplate bean–>因为Spring boot自动配置了

八.自己扩展自定义注解实现(模仿@RabbitListener)

1.创建一个注解类RedisListener

/**
 * 模仿@RabbitListener
 */
@Target({ElementType.METHOD})   //作用于方法上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisListener {
	//消息订阅的主题
    String topic() default "";
}

2.创建一个自定义消息监听器

//一个自定义的消息接收器
@Component
public class MyReceiver2 {
    private static final Logger LOGGER = LoggerFactory.getLogger(MyReceiver2.class);

    @RedisListener(topic = "chat2")
    public void receiveMessage(String message) {
        LOGGER.info("MyReceiver2 Received <" + message + ">");
    }
}

3.编写一个初始化的类中完成我们之前注册监听器的步骤!!!

请请参看spring-boot-starter-amqp启动器的RabbitListenerAnnotationBeanPostProcessor类和RabbitListenerEndpointRegistrar类和RabbitListenerEndpointRegistry类源码

@Component
public class RedisListenerAnnotationBeanPostProcessor implements BeanPostProcessor {
    @Autowired
    private ApplicationContext applicationContext;

    /**
     * 注册MessageListenerAdapter bean--->等价于RedisMessageListener类的listenerAdapter(xx)方法
     */
    @Nullable
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Method[] declaredMethods = bean.getClass().getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            if (declaredMethod.isAnnotationPresent(RedisListener.class)) {
                String topic = declaredMethod.getAnnotation(RedisListener.class).topic();
                DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
                //多个MessageListenerAdapter的beanName加topic区分
                String messageListenerAdapterBeanName = String.format("%s_%s", topic, MessageListenerAdapter.class.getName());
                //注册MessageListenerAdapter bean
                MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(bean, declaredMethod.getName());
                //这里需要手动调用一下初始化回调,不然messageListenerAdapter.onMessage会报错空指针异常
                messageListenerAdapter.afterPropertiesSet();
                defaultListableBeanFactory.registerSingleton(messageListenerAdapterBeanName, messageListenerAdapter);
            }
        }
        return bean;
    }

    @Nullable
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

    //向RedisMessageListenerContainer添加MessageListenerAdapte
    @Bean
    CommandLineRunner init() {
        return new CommandLineRunner() {
            @Override
            public void run(String... args) throws Exception {
                RedisMessageListenerContainer redisMessageListenerContainer = applicationContext.getBean(RedisMessageListenerContainer.class);
                Map<String, MessageListenerAdapter> beansOfType = applicationContext.getBeansOfType(MessageListenerAdapter.class);
                for (String messageListenerAdapterBeanName : beansOfType.keySet()) {
                    //排除一下MyReceiver1
                    if(messageListenerAdapterBeanName.contains("_")){
                        String topic = messageListenerAdapterBeanName.substring(0, messageListenerAdapterBeanName.indexOf("_"));
                        redisMessageListenerContainer.addMessageListener((MessageListenerAdapter) applicationContext.getBean(messageListenerAdapterBeanName), new PatternTopic(topic));
                    }
                }
            }
        };
    }