序言

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;
    }

运行测试

redis消息订阅 redis消息订阅与发布 ajax_监听器


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