使用Redis做为消息队列

7 篇文章 0 订阅

使用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接口
GenericFastJsonRedisSerializerjson序列化,使用fastjson序列化方式序列化对象
GenericJackson2JsonRedisSerializerjson序列化,使用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

  • 2
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

懵懵懂懂程序员

如果节省了你的时间, 请鼓励

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值