Redis Stream做消息队列

最新推荐文章于 2024-10-01 11:12:34 发布
最新推荐文章于 2024-10-01 11:12:34 发布
阅读量679 收藏 22
点赞数 13
分类专栏： Java redis 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EzrealYi/article/details/142646344
版权

目录

Redis Stream

接上篇文章，这章说说消息队列。消息队列用于应用间通信，“消息”是两个应用间传输的数据单位。今天介绍一款轻量级、用于小型项目间、相对可靠的队列——redis stream

消息队列

当我们使用消息队列时，希望消息队列具有以下优点：

  1. 支持发布/订阅模式
  2. 消息持久化，做到消息宕机不丢失
  3. 可重复消费
  4. 可阻塞式拉取
  5. 处理消息消费失败的机制

发布/订阅和Stream的区别

redis做消息队列有多种方式，其中发布/订阅就是其中一种。发布/订阅有什么缺点呢？

发布/订阅可以做到消息的广播模式，对消费者能做到有消息就通知的能力，但有个致命缺点，即发布/订阅不能持久化消息。当redis服务出现断开、宕机等突发情况，消息就会丢失。

Stream

使用Stream数据结构，需要注意redis的版本。redis从5.0开始支持Stream能力，是对消息队列(Message Queue)的完善实现

对于队列，我们要考虑的是除了发布/订阅模式的不能持久化的缺点之外，我们还需要考虑

  • 消息的生产
  • 消息的消费
    • 单播和多播
    • 阻塞和非阻塞
  • 消息的有序性
  • 消息的重复消费
  • 消息堆积等

Stream的结构

每个stream数据都有唯一的名称，那就是redis的key，不能显示创建stream，但可以在我们首次使用XADD指令时隐式创建stream以及指定key。

在这里插入图片描述

  • stream中每一个消息都有一个唯一ID，用于区分不同消息。在stream中，entry是消息的称呼，即ID也叫entry的id

    entry ID是通过XADD指令返回的，ID的结构是<millisecondsTime>-<sequenceNumber>

  • consumer group：消费者组，使用XGROUP CREATE指令创建，一个消费者组有多个消费者，组内的消费者之间是竞争关系。

  • last_delivered_id：游标。每个消费者组有一个游标，表示消费者组读取消息的位置

  • pending_ids：待确认消息id集合。属于消费者的属性，当中记录当前消费者读取但未确认(ACK)的消息id

Stream相关操作

[官方链接](XADD | Docs (redis.io))

属于Stream本身的操作：

  • XADD：添加消息到指定Stream中，如果Stream不存在，则创建
  • XDEL：从Stream中删除指定的条目，并返回删除的条目数
  • XINFO STREAM：提供Stream信息
  • XLEN：返回Stream长度，不存在返回0
  • XRANGE：范围查看Stream中的条目数据
  • XREAD：查看指定的条目数据
  • XREVRANGE：和XRANGE相反，以反方向顺序查看条目数据
  • XTRIM：通过删除就条目来修剪Stream

属于消费者组或消费者的操作：

  • XGROUP CREATE：给Stream创建一个消费者组
  • XGROUP CREATECONSUMER：给Stream中的消费者组创建一个消费者
  • XGROUP DELCONSUMER：删除一个消费者
  • XGROUP DESTROY：完全销毁消费者组，包括消费者组、消费者、消费者的pending、last_deliver_id等
  • XGROUP SETID：为消费者组设置last delivered ID
  • XINFO GROUPS：提供消费者组信息
  • XINFO CONSUMERS：提供消费者信息
  • XPENDING：查看消费者组中读取但未确认的消息集合
  • XREADGROUP：和XREAD类似，XREADGROUP支持消费者组

项目中应用

spring启动时初始化stream

/**
 * @author zhangyi
 */
@Component
@Slf4j
@Order(1)
public class MqRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 初始化stream
        MqService mqService = SpringUtils.getBean(MqService.class);
        mqService.init();
        // 添加消费者监听
        StreamConsumerService consumerService = SpringUtils.getBean(StreamConsumerService.class);
        consumerService.startListenering();
    }
}


@Override
public void init() {
    log.info("init redis stream");
    try {
        StreamInfo.XInfoStream streamInfo = redisUtils.streamInfo(BIG_MODEL_STREAM_KEY);
    } catch (Exception e) {
        // 还没创建stream时
        if (e.getMessage().contains("ERR no such key")) {
            redisUtils.sendMessageByStream(BIG_MODEL_STREAM_KEY, ImmutableMap.of("init", "init"));

            // 还没创建group和consumer时
            if (redisUtils.groupInfo(BIG_MODEL_STREAM_KEY).stream().noneMatch(group -> Objects.equals(BIG_MODEL_STREAM_CONSUMER_GROUP_NAME, group.groupName()))) {
                redisUtils.createStreamGroup(BIG_MODEL_STREAM_KEY, BIG_MODEL_STREAM_CONSUMER_GROUP_NAME);
            }
        }
    }
    log.info("init redis stream success");
}

/**
 * @author zhangyi
 */
@Slf4j
@Component
public class StreamConsumerServiceImpl implements StreamConsumerService {
    @Autowired
    private RedisUtils redisUtils;

    @Override
    public void startListenering() {
        AsyncManager.me().execute(new TimerTask() {
            @Override
            public void run() {
                while (true) {
                    try {
                        // 拉取并处理消息
                        pullFromStreamAndConsume();
                    } catch (Exception e) {
                        log.error(e.getMessage(), e);
                        ThreadUtil.sleep(5, TimeUnit.MINUTES);
                    }
                }
            }
        });
    }

    private void pullFromStreamAndConsume() {
        List<MapRecord<String, String, String>> records = redisUtils.xReadGroup(BIG_MODEL_STREAM_KEY, BIG_MODEL_STREAM_CONSUMER_GROUP_NAME, BIG_MODEL_STREAM_CONSUMER_1_NAME);
        for (MapRecord<String, String, String> record : records) {
            RecordId recordId = record.getId();
            Map<String, String> recordMap = record.getValue();
            for (Map.Entry<String, String> entry : recordMap.entrySet()) {
                String value = JsonUtils.fromJson(entry.getValue(), String.class);
                if (Objects.equals("init", entry.getKey()) && Objects.equals("init", value)) {
                    redisUtils.xAck(BIG_MODEL_STREAM_KEY, BIG_MODEL_STREAM_CONSUMER_GROUP_NAME, recordId.getValue());
                    log.info("消费者消费了一条消息，recordId：{}", recordId.getValue());
                    log.info("field：{}", entry.getKey());
                    log.info("value：{}", value);
                    continue;
                }

                try {
                    // 处理消息
                    doSomething();
                    redisUtils.xAck(BIG_MODEL_STREAM_KEY, BIG_MODEL_STREAM_CONSUMER_GROUP_NAME, recordId.getValue());
                    log.info("消费者消费了一条消息，recordId：{}", recordId.getValue());
                    log.info("field：{}", entry.getKey());
                    log.info("value：{}", value);
                } catch (Exception e) {
                    log.error("无法消费消息，recordId：{}", recordId.getValue());
                    log.error(e.getMessage(), e);
                }
            }
        }

        // records为空，休眠30s
        if (records.isEmpty()) {
            ThreadUtil.sleep(30, TimeUnit.SECONDS);
        }
    }
}

/**
 * spring redis 工具类
 *
 * @author zhangyi
 **/
@Component
public class RedisUtils {
    @Autowired
    public RedisTemplate redisTemplate;

    /*
     * ------------------------------------------------------redis stream------------------------------------------------------
     */

    /**
     * 获取名为key的stream相关信息
     *
     * @param key stream key
     * @return info
     */
    public StreamInfo.XInfoStream streamInfo(String key) {
        return redisTemplate.opsForStream().info(key);
    }

    /**
     * 获取名为key的stream上的消费者组
     *
     * @param key stream key
     * @return XInfoGroups
     */
    public StreamInfo.XInfoGroups groupInfo(String key) {
        return redisTemplate.opsForStream().groups(key);
    }

    /**
     * 给消息队列发送消息，相当于生产者
     *
     * @param key     stream key
     * @param message field value 对
     * @return RecordId 消息id
     */
    public RecordId sendMessageByStream(String key, Map<String, Object> message) {
        return sendMessageByStream(key, message, 1000);
    }

    public RecordId sendMessageByStream(String key, Map<String, Object> message, int maxLength) {
        Map<byte[], byte[]> messageMap = new HashMap<>();
        for (Map.Entry<String, Object> entry : message.entrySet()) {
            messageMap.put(entry.getKey().getBytes(), JsonUtils.toJson(entry.getValue()).getBytes());
        }
        MapRecord<byte[], byte[], byte[]> entries = StreamRecords.newRecord().in(key.getBytes()).ofMap(messageMap);
        RedisStreamCommands.XAddOptions options = RedisStreamCommands.XAddOptions.maxlen(maxLength);
        return (RecordId) redisTemplate.execute((RedisConnection connection) -> connection.xAdd(entries, options));
    }

    /**
     * 完全销毁消费者组
     *
     * @param key       stream key
     * @param groupName 消费者组名称
     */
    public void destroyGroup(String key, String groupName) {
        redisTemplate.opsForStream().destroyGroup(key, groupName);
    }

    /**
     * 创建名为key的stream的groupName的消费者组
     *
     * @param key       stream key
     * @param groupName 消费者组名称
     */
    public void createStreamGroup(String key, String groupName) {
        redisTemplate.opsForStream().createGroup(key, groupName);
    }

    /**
     * 读取消息
     *
     * @param key          stream key
     * @param groupName    消费者组名称
     * @param consumerName 消费者名称
     * @return list
     */
    public List<MapRecord<String, String, String>> xReadGroup(String key, String groupName, String consumerName) {
        List<ByteRecord> records = (List<ByteRecord>) redisTemplate.execute((RedisConnection connection) ->
                connection.xReadGroup(Consumer.from(groupName, consumerName), StreamReadOptions.empty().count(5),
                        StreamOffset.create(key.getBytes(), ReadOffset.lastConsumed())));

        ArrayList<MapRecord<String, String, String>> list = new ArrayList<>(records.size());
        for (ByteRecord record : records) {
            StringRedisSerializer serializer = new StringRedisSerializer();
            MapRecord<String, String, String> mapRecord = record.deserialize(serializer, serializer, serializer);
            list.add(mapRecord);
        }
        return list;
    }

    /**
     * XACK操作
     *
     * @param key       stream key
     * @param groupName 消费者组名称
     * @param recordId  recordId
     */
    public void xAck(String key, String groupName, String recordId) {
        redisTemplate.opsForStream().acknowledge(key, groupName, recordId);
    }
}
雨路行人
关注
专栏目录
基于 Redis Stream 的消息队列
蛮吉是魁拔的博客
08-23 1421
Redis Stream 消息队列
redis stream消息队列的使用
Libigtong的博客
09-01 833
redis stream是redis5.0以后出现的新的数据类型，它主要是一个可以附加的数据结构可以在一定程度上完善之前redis的订阅发布功能存在的缺陷。
Redis 消息队列 Stream
激流丶的博客
06-10 3724
Stream 是 Redis 5.0 版本中新增的一种数据结构，它是一个高性能、持久化的消息队列，可以用于实现消息的发布和订阅。Stream 可以看作是一个有序的消息队列，每个消息都有一个唯一的 ID，可以根据 ID 进行消息的查找、删除和确认。在 Stream 中，消息以键值对的形式存储，可以存储任意类型的数据。Stream 还支持多个消费者组，每个消费者组可以独立消费消息，避免消息重复消费。Stream 的引入使得 Redis 在消息队列领域更具竞争力，同时也为开发者提供了一种高效、可靠的消息处理方式。
基于Redis的Stream类型的完美消息队列解决方案（全）
红牛编程
03-26 4509
文章目录1 概述2 追加新消息，XADD，生产消息3 从消息队列中获取消息，XREAD，消费消息4 消息ID说明5 消费者组模式，consumer group6 Pending 等待列表7 消息转移8 坏消息问题，Dead Letter，死信问题9 信息监控，XINFO10 命令一览11 Stream数据结构，RadixTree，基数树12 相关产品 1 概述 Redis5.0带来了Stream类...
redis stream 实现消息队列
爱码猿的博客
04-07 8329
redis stream 实现消息队列 Redis5.0带来了Stream类型。从字面上看是流类型，但其实从功能上看，应该是Redis对消息队列（MQ，Message Queue）的完善实现。 基于redis实现消息队列的方式有很多： PUB/SUB，订阅/发布模式 基于List的 LPUSH+BRPOP 的实现 redis 实现消息对列4中方法 发布订阅 发布订阅优点： 典型的一对的，所有消费者都能同时消费到消息。主动通知订阅者而不是订阅者轮询去读。 发布订阅缺点： 不支持多个消费者公平消费消息，消息
Redis Stream应用案例
weixin_34072458的博客
06-26 792
摘要： Redis Stream Redis最新的大版本5.0已经RC1了，其中最重要的Feature莫过于Redis Stream了，关于Redis Stream的基本使用介绍和设计理念可以看我之前的一篇文章（Redis Stream简介）。Redis StreamRedis最新的大版本5.0已经RC1了，其中最重要的Feature莫过于Redis Stream了，关于Redis Stream的...
【redis】stream消息队列
王佑辉的博客
06-29 1832
***/@Slf4j@Override//TODO 消费异常时处理逻辑log.error("发生了异常", e);/*** 消息队列自定义注解*//*** 消息队列的 key* @return*//*** 消费者组* @return*//*** 消息反序列化类型* @return*//*** 是否自动 acknowledge* @return*//*** 每次拉取的消息数,线程池每秒拉取一次* @return*//**
SpringBoot+Redis stream实现消息队列
doupengzp的博客
06-15 6823
Springboot+Redis stream实现消息队列
Spring中基于redis stream 的消息队列实现方法
xingyuemengjin的博客
09-02 2100
本文主要介绍了消息队列的概念性质和应用场景，介绍了kafka、rabbitMq常用消息队列中间件的应用模型及消息队列的实现方式，并实战了在Spring中基于redis stream 的消息队列实现方法。
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
利用redis rightPop 和 redis stream 实现消息队列
03-15
在本主题中，我们将深入探讨如何利用Redis的`rightPop`操作以及`Stream`数据类型来构建一个高效的消息队列。 消息队列是分布式系统中不可或缺的组件，它允许不同组件之间异步通信，提高系统的可扩展性和可靠性。...
Redis-持久化
qq_74812898的博客
09-28 877
redis持久化
Redission · 可重入锁（Reentrant Lock）
不惑
09-29 913
下面的代码是单节点 Redis 的配置。/*** 对 Redisson 的使用都是通过 RedissonClient 对象* @return*/@Bean(destroyMethod="shutdown") // 服务停止后调用 shutdown 方法。// 创建配置// 集群模式。
Redis-持久化机制
最新发布
qq_39007838的博客
10-01 629
配置文件redis 6.0.16 及其以下补充一张来自于的图片写回策略，对应图中的 3 也即上面个图的 fsync 策略。
Redis篇（环境搭建）
wlcass zhengge blog
09-26 777
Windows系统中启动Redis，直接双击redis-server.exe即可启动Redis服务，redis服务默认端口号为6379。双击 redis-cli.exe 即可启动Redis客户端，默认连接的是本地的Redis服务，而且不需要认证即可连接成功。前面我们已经启动了Redis服务，默认情况下Redis启动后是在前台运行，而且客户端不需要密码就可以连接到。如果没有指定，就说明可以接受。通过 redis-cli 可以连接到本地的Redis服务，默认情况下不需要认证即可连接成功。
Python对数据库（MySQL，redis、MongoDB）的操作
wu73guang5jian的博客
09-27 1428
python对MySQL、Redis，MongoDB的操作
【Redis】主从复制（下）--主从复制原理和流程
2301_78320637的博客
09-27 910
存在数据则直接发送给从节点,这样就可以保持主从节点复制的一致性.补发的这部分数据一般远远小于全量数据,所以减少了开销.,默认大小是1MB,当主节点连接从节点的时候被创建,这时主节点响应写命令时,不但会把命令发送给从节点,还会写入。的方式,源源不断的输给从节点.从节点就会根据这些请求来同时修改自身的数据,从而保证和主节点数据的一致性.:主节点的复制id,主节点重新启动,或者从节点晋级成主节点,都会生成一个。在网络传输的时间,从节点清空旧数据的时间,从节点加载。的时间,主节点就会认为从节点故障并中断复制连接。
【Redis】安装redis-plus-plus
lzb_kkk的博客
09-27 1133
在ubuntu或者centos系统下redis-plus-plus的安装方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雨路行人

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值