SpringBoot系列：Redis消息的发布和订阅（三）

序言

redis不但能用于对数据的CRUD，也可以作为一个消息中间件，用来进行消息的发布和订阅。在下面的demo中，配置了多个监听器，来监听不同的通道。

消息的发布

• 创建一个消息发布者类MessageSender.java，两个发送者分别向通道chatA和通道chatB发送消息：

  /**
   * 消息发布者
   */
  @EnableScheduling//开启定时器功能
  @Component//自动注入
  public class MessageSender {
  
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
  
      /**
       * 间隔4秒，通过stringRedisTemplate对象向redis消息队列chatA通道发布消息
       */
      @Scheduled(fixedDelay = 4000)
      public void sendMessage() {
          stringRedisTemplate.convertAndSend("chatA", "通道A消息"+String.valueOf(Math.random()));
      }
  
      /**
       * 间隔4秒，通过stringRedisTemplate对象向redis消息队列chatB通道发布消息
       */
      @Scheduled(fixedDelay = 4000)
      public void sendMessage2() {
          stringRedisTemplate.convertAndSend("chatB","通道B消息"+String.valueOf(Math.random()));
      }
  }
  

消息的订阅

• 首先创建一个消息处理者类MessageReceiver.java：

  /**
   * 消息处理者类
   */
  @Component
  public class MessageReceiver {
      /**
       * 接收消息方法：消费者A
       */
      public void receiverMessageA(String message) {
          System.out.println("receiverMessageA接收的消息：" + message);
      }
  
      /**
       * 接收消息方法：消费者B
       */
      public void receiverMessageB(String message) {
          System.out.println("receiverMessageB接收的消息：" + message);
      }
  }
  

  其中方法receiverMessageA相当于消费者A，方法receiverMessageB相当于消费者B。

• 其次在我们的RedisConfig.java配置类中增加以下配置：

  @EnableCaching
  @Configuration
  public class RedisConfig extends CachingConfigurerSupport {
  
      @Bean
      public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
          RedisTemplate<String, Object> template = new RedisTemplate<>();
          RedisSerializer<String> redisSerializer = new StringRedisSerializer();
          Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
          ObjectMapper om = new ObjectMapper();
          om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
          //过期方法
  //        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
          /**
           * Jackson ObjectMapper 中的 enableDefaultTyping 方法由于安全原因，
           * 从 2.10.0 开始标记为过期，建议用 activateDefaultTyping 方法代替，
           * 所以如果继续使用 enableDefaultTyping 会有警告出现，我们现在要消除这个警告，
           * 去看一下 enableDefaultTyping 源码
           */
          om.activateDefaultTyping(
                  LaissezFaireSubTypeValidator.instance,
                  ObjectMapper.DefaultTyping.NON_FINAL,
                  JsonTypeInfo.As.WRAPPER_ARRAY);
          jackson2JsonRedisSerializer.setObjectMapper(om);
  
          template.setConnectionFactory(factory);
          //序列化设置,这样为了存储操作对象时正常显示的数据,也能正常存储和获取
          //key序列化方式
          template.setKeySerializer(redisSerializer);
          //value序列化
          template.setValueSerializer(jackson2JsonRedisSerializer);
          //value hashmap序列化
          template.setHashValueSerializer(jackson2JsonRedisSerializer);
          return template;
      }
  
      @Bean
      public CacheManager cacheManager(RedisConnectionFactory factory) {
          RedisSerializer<String> redisSerializer = new StringRedisSerializer();
          Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
          //解决查询缓存转换异常的问题
          ObjectMapper om = new ObjectMapper();
          om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
          //过期方法
          //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
          //解决方法
          om.activateDefaultTyping(
                  LaissezFaireSubTypeValidator.instance,
                  ObjectMapper.DefaultTyping.NON_FINAL,
                  JsonTypeInfo.As.WRAPPER_ARRAY);
          jackson2JsonRedisSerializer.setObjectMapper(om);
          // 配置序列化（解决乱码的问题）,过期时间600秒
          RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                  .entryTtl(Duration.ofSeconds(600))
                  .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                  .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                  .disableCachingNullValues();
          RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                  .cacheDefaults(config)
                  .build();
          return cacheManager;
      }
  
      @Bean
      public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
          StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
          stringRedisTemplate.setConnectionFactory(factory);
          return stringRedisTemplate;
      }
  
      /**
       * redis消息监听器容器
       * 可以添加多个监听不同话题的redis监听器，只需要把消息监听器和相应的消息订阅处理器绑定，该消息监听器
       * 通过反射技术调用消息订阅处理器的相关方法进行一些业务处理
       * @param connectionFactory
       * @return
       */
      @Bean
      RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                              MessageListenerAdapter listenerAdapterA,
                                              MessageListenerAdapter listenerAdapterB) {
  
          RedisMessageListenerContainer container = new RedisMessageListenerContainer();
          container.setConnectionFactory(connectionFactory);
          //订阅一个叫chatA 的通道，绑定消息监听适配器listenerAdapterA
          container.addMessageListener(listenerAdapterA, new PatternTopic("chatA"));
          //订阅一个叫chatB 的通道，绑定消息监听适配器listenerAdapterB
          container.addMessageListener(listenerAdapterB, new PatternTopic("chatB"));
          return container;
      }
  
      /**
       * 消息监听器适配器listenerAdapterA，绑定消息处理器，利用反射技术调用消息处理器的业务方法
       * 这里绑定的是receiverMessageA --> 消费者A
       * @param receiver
       * @return
       */
      @Bean
      MessageListenerAdapter listenerAdapterA(MessageReceiver receiver) {
          //Receiver是一个消费者类，receiverMessageA对应MessageReceiver中的方法，相当于消费者A
          return new MessageListenerAdapter(receiver, "receiverMessageA");
      }
  
      /**
       * 消息监听器适配器listenerAdapterB，绑定消息处理器，利用反射技术调用消息处理器的业务方法
       * 这里绑定的是receiverMessageB --> 消费者B
       * @param receiver
       * @return
       */
      @Bean
      MessageListenerAdapter listenerAdapterB(MessageReceiver receiver) {
          //Receiver是一个消费者类，receiverMessageB对应MessageReceiver中的方法，相当于消费者B
          return new MessageListenerAdapter(receiver, "receiverMessageB");
      }
  }
  

  首先我们先添加消息监听适配器listenerAdapterA和listenerAdapterB，其中Receiver是一个消费者类，receiverMessageA对应MessageReceiver中的方法，相当于消费者A。（绑定消息处理器，利用反射技术调用消息处理器的业务方法）：

  @Bean
      MessageListenerAdapter listenerAdapterA(MessageReceiver receiver) {
          //Receiver是一个消费者类，receiverMessageA对应MessageReceiver中的方法，相当于消费者A
          return new MessageListenerAdapter(receiver, "receiverMessageA");
      }
  

  其次添加redis消息监听器容器，简单来说就是绑定消息监听适配器（消费者）和通道：

   @Bean
      RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                              MessageListenerAdapter listenerAdapterA,
                                              MessageListenerAdapter listenerAdapterB) {
  
          RedisMessageListenerContainer container = new RedisMessageListenerContainer();
          container.setConnectionFactory(connectionFactory);
          //订阅一个叫chatA 的通道，绑定消息监听适配器listenerAdapterA
          container.addMessageListener(listenerAdapterA, new PatternTopic("chatA"));
          //订阅一个叫chatB 的通道，绑定消息监听适配器listenerAdapterB
          container.addMessageListener(listenerAdapterB, new PatternTopic("chatB"));
          return container;
      }
  

运行测试

本文章到这里就结束了，这里纯介绍消息的发布和订阅，我们自己在学习的时候也可以结合异步线程，AOP等等