使用Redis做为消息队列

使用Redis做为消息队列: (2019.12.3)

Redis做消息队列的优缺点:

• 可靠性
  redis ：没有相应的机制保证消息的可靠消费，如果发布者发布一条消息，而没有对应的订阅者的话，这条消息将丢失，不会存在内存中；
  其他消息中间件：具有消息消费确认机制，如果发布一条消息，还没有消费者消费该队列，那么这条消息将一直存放在队列中，直到有消费者消费了该条消息，以此可以保证消息的可靠消费。

• 实时性
  redis:实时性高，redis作为高效的缓存服务器，所有数据都存在内存中，所以它具有更高的实时性
  消费者负载均衡：
  其他消息中间件队列可以被多个消费者同时监控消费，但是每一条消息只能被消费一次，由于其他消息中间件的消费确认机制，因此它能够根据消费者的消费能力而调整它的负载；
  redis发布订阅模式，一个队列可以被多个消费者同时订阅，当有消息到达时，会将该消息依次发送给每个订阅者，她是一种消息的广播形式，redis本身不做消费者的负载均衡，因此消费效率存在瓶颈；

• 持久性
  redis：redis的持久化是针对于整个redis缓存的内容，它有RDB和AOF两种持久化方式（redis持久化方式，后续更新），可以将整个redis实例持久化到磁盘，以此来做数据备份，防止异常情况下导致数据丢失。
  其他消息中间件：队列，每条消息都可以选择性持久化，持久化粒度更小，更灵活；
  队列监控
  其他消息中间件实现了后台监控平台，可以在该平台上看到所有创建的队列的详细情况，良好的后台管理平台可以方面我们更好的使用；
  redis没有所谓的监控平台。

• 总结
  redis： 轻量级，低延迟，高并发，低可靠性；
  其他消息中间件：重量级，高可靠，异步，不保证实时；
  其他消息中间件是一个专门的AMQP协议队列，他的优势就在于提供可靠的队列服务，并且可做到异步，而redis主要是用于缓存的，redis的发布订阅模块，可用于实现及时性，且可靠性低的功能。

开始实现

1.导入Redis依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. application.yml

  redis:
    host: localhost
    port: 6379
    lettuce:
      pool:
        # 连接池最大连接数（使用负值表示没有限制） 默认 8
        max-active: 16
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
        max-wait: -1ms
        # 连接池中的最大空闲连接 默认 8
        max-idle: 16
        # 连接池中的最小空闲连接 默认 0
        min-idle: 0
    timeout: 10000ms

3. 写个Redis消息监听器(消费者)

import org.springframework.data.redis.connection.Message;
/**
 * Redis消息队列监听接口 (消费者)
 */
public interface MessageListeners extends MessageListener {

    /**
     *  消费者
     *
     * @param message redis消息类接口
     * @param pattern 二进制形式的消息通道
     * @return void
     * @author: zhihao
     * @date: 2019/12/3
     * {@link #}
     */
    @Override
    void onMessage(Message message, byte[] pattern);

}

该接口仅有一个onMessage(Message message, @Nullable byte[] pattern)方法，该方法便是监听到队列中消息后的回调方法。下面解释一下这两个参数：

• message：redis消息类，该类中仅有两个方法
  • byte[] getBody()以二进制形式获取消息体
  • byte[] getChannel()以二进制形式获取消息通道
• pattern：二进制形式的消息通道，和message.getChannel()返回值相同

4. 实现简单的redis队列监听器进行消费(消费者)

import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;
/**
 * @Author: zhihao
 * @Date: 2019/12/3 9:46
 * @Description:
 * @Versions 1.0
 **/
@Component
public class MessageListenerImpl implements MessageListeners {

    @Override
    public void onMessage(Message message, byte[] pattern) {
        System.out.println("接收到的元的消息"+new String(message.getBody()));
        //反序列化要和配置的序列化一致  这里使用的是Redis默认jdk提供的序列化
        RedisSerializer serializer = new JdkSerializationRedisSerializer();
        Object deserialize = serializer.deserialize(message.getBody());
        System.out.println("接收到的消息反序列化后的数据"+deserialize);
    }
}

队列监听器实现完以后，我们还需要将这个监听器添加到redis队列监听器容器中，代码如下：

	@Autowired
    private MessageListeners listener;

    /** 
     *  把监听器添加进Redis消息监听容器
     *
     * @param factory redis连接工厂
     * @return org.springframework.data.redis.listener.RedisMessageListenerContainer 
     * @author: zhihao
     * @date: 2019/12/3 
     * {@link #}
     */
    @Bean
    public RedisMessageListenerContainer getContainer(RedisConnectionFactory factory){
        //Redis消息监听容器
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        //设置连接工厂
        container.setConnectionFactory(factory);
        //添加消息监听器
        container.addMessageListener(listener,new PatternTopic("demo-queue"));
        //返回容器
        return container;
    }

这几行代码大概意思就是新建一个Redis消息监听器容器，然后将监听器和管道名想绑定，最后返回这个容器。

这里要注意的是，这个管道名和下面将要说的推送消息时的管道名要一致，不然监听器监听不到消息。

5. redis队列推送服务（生产者）

	@Autowired
    private RedisTemplate redisTemplate;
    
    @Test
    public void test() {
    	//进行100次发送消息
        for (int i = 0; i <= 100; i++) {
           final int j = i;
            pool.execute(() -> {
                redisTemplate.convertAndSend("demo-queue", "测试发送队列消息" + j);
            });
        }
    }

redis.convertAndSend()这个方法的作用为，向某个通道（参数1）推送一条消息（第二个参数）。

这里还是要注意上面所说的，生产者和消费者的通道名要相同。

至此，消息队列的生产者和消费者已经全部编写完成。

扩展资料:

RedisTemplate几种序列化方式的简要介绍

序列化方式	介绍
StringRedisSerializer	将对象序列化为字符串，但是经测试，无法序列化对象，一般用在key上
OxmSerializer	将对象序列化为xml性质，本质上是字符串
ByteArrayRedisSerializer	默认序列化方式，将对象序列化为二进制字节，但是需要对象实现Serializable接口
GenericFastJsonRedisSerializer	json序列化，使用fastjson序列化方式序列化对象
GenericJackson2JsonRedisSerializer	json序列化，使用jackson序列化方式序列化对象

redis队列监听器线程安全问题

redis队列监听器的监听机制是：使用一个线程监听队列，队列有未消费的消息则取出消息并生成一个新的线程来消费消息。如果你还记得，我开头说的是由于redis单线程特性，因此我们用它来做消息队列，但是如果监听器每次接受一个消息就生成新的线程来消费信息的话，这样就完全没有使用到redis的单线程特性，同时还会产生线程安全问题。

单一消费者（一个通道只有一个消费者）的解决办法

最简单的办法莫过于为onMessage()方法加锁，这样简单粗暴却很有用，不过这种方式无法控制队列监听的速率，且无限制的创造线程最终会导致系统资源被占光。

那如何解决这种情况呢？线程池。

在将监听器添加到容器的配置的时候，RedisMessageListenerContainer类中有一个方法setTaskExecutor(Executor taskExecutor)可以为监听容器配置线程池。配置线程池以后，所有的线程都会由该线程池产生，由此，我们可以通过调节线程池来控制队列监听的速率。

多个消费者（一个通道有多个消费者）的解决办法

单一消费者的问题相比于多个消费者来说还是较为简单，因为Java内置的锁都是只能控制自己程序的运行，不能干扰其他的程序的运行；然而现在很多时候我们都是在分布式环境下进行开发，这时处理多个消费者的情况就很有意义了。

那么这种问题如何解决呢？分布式锁。

下面来简要科普一下什么是分布式锁：

分布式锁是指在分布式环境下，同一时间只有一个客户端能够从某个共享环境中（例如redis）获取到锁，只有获取到锁的客户端才能执行程序。

然后分布式锁一般要满足：排他性（即同一时间只有一个客户端能够获取到锁）、避免死锁（即超时后自动释放）、高可用（即获取或释放锁的机制必须高可用且性能佳）

上面讲依赖的时候，我们导入了一个spring-integration-redis依赖，这个依赖里面包含了很多实用的工具类，而我们接下来要讲的分布式锁就是这个依赖下面的一个工具包RedisLockRegistry。

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-redis</artifactId>
</dependency>

首先讲一下如何使用，导入了依赖以后，首先配置一个Bean

@Bean
public RedisLockRegistry redisLockRegistry(RedisConnectionFactory factory) {
    return new RedisLockRegistry(factory, "demo-lock",60);
}

RedisLockRegistry的构造函数，第一个参数是redis连接池，第二个参数是锁的前缀，即取出的锁，键名为“demo-lock:KEY_NAME”，第三个参数为锁的过期时间（秒），默认为60秒，当持有锁超过该时间后自动过期。

使用锁的方法，下面是对监听器的修改

@Component
public class RedisListener implement MessageListener{
    @Autowrite
    private RedisLockRegistry redisLockRegistry;

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisListener.class);

    @Override
    public void onMessage(Message message,byte[] pattern){
        Lock lock=redisLockRegistry.obtain("lock");
        try{
            lock.lock(); //上锁
            LOGGER.debug("从消息通道={}监听到消息",new String(pattern));
            LOGGER.debug("从消息通道={}监听到消息",new String(message.getChannel()));
            LOGGER.debug("元消息={}",new String(message.getBody()));
            // 新建一个用于反序列化的对象，注意这里的对象要和前面配置的一样
            // 因为我前面设置的默认序列化方式为GenericJackson2JsonRedisSerializer
            // 所以这里的实现方式为GenericJackson2JsonRedisSerializer
            RedisSerializer serializer=new GenericJackson2JsonRedisSerializer();
            LOGGER.debug("反序列化后的消息={}",serializer.deserialize(message.getBody()));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁
        }
    }
}

上面代码的代码比起前面的监听器代码，只是多了一个注入的RedisLockRegistry，一个通过redisLockRegistry.obtain()方法获取锁，一个加锁一个解锁，然后这就完成了分布式锁的使用。

注意这个获取锁的方法redisLockRegistry.obtain()，其返回的是一个名为RedisLock的锁，这是一个私有内部类，它实现了Lock接口，因此我们不能从代码外部创建一个他的实例，只能通过obtian()方法来获取这个锁。

配置RedisTemplate

配置RedisTemplate的主要目的是配置序列化方式以解决乱码问题，同时合理配置序列化方式还能降低一点性能开销。

/**
 * 配置RedisTemplate，解决乱码问题
 */
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    LOGGER.debug("redis序列化配置开始");
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // string序列化方式
    RedisSerializer serializer = new GenericJackson2JsonRedisSerializer();
    // 设置默认序列化方式
    template.setDefaultSerializer(serializer);
    template.setKeySerializer(new StringRedisSerializer());
    template.setHashValueSerializer(serializer);
    LOGGER.debug("redis序列化配置结束");
    return template;
}

代码第12行，我们配置默认的序列化方式为GenericJackson2JsonRedisSerializer

代码第13行，我们配置键的序列化方式为StringRedisSerializer

代码第14行，我们配置哈希表的值的序列化方式为GenericJackson2JsonRedisSerializer

资料参考了: https://juejin.im/post/5de46d63f265da060b381fa2?utm_source=gold_browser_extension#heading-5