redis Stream流（2）-如何在运行中动态监听stream流

在实际生产中，有这样一种需求：
A创建stream流，B要监听流中的数据。但是A是根据需求逐渐建立的，不是在一开始就完全知道要建立的流，B要动态的添加要监听的流。

被这个问题困扰了一下午，查找了网上的一些资料，发现质量确实混杂。
遂又去翻阅redis官方文档，找到一个XCLAIM命令，但是只适用于同一个流下有两个以上的消费者组成的消费者组的情况，不能跨组监听。
后来自己研究发现解决办法很简单，开贴记录一下。

配置

这是原配置文件：

 @Bean(initMethod = "start", destroyMethod = "stop")
    public StreamMessageListenerContainer<String, ObjectRecord<String, Object>> streamMessageListenerContainer() {
        AtomicInteger index = new AtomicInteger(1);
        int processors = Runtime.getRuntime().availableProcessors();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(processors, processors, 0, TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(), r -> {
            Thread thread = new Thread(r);
            thread.setName("async-stream-consumer-" + index.getAndIncrement());
            thread.setDaemon(true);
            return thread;
        });

        StreamMessageListenerContainer.StreamMessageListenerContainerOptions<String, ObjectRecord<String, Object>> options =
                StreamMessageListenerContainer.StreamMessageListenerContainerOptions
                        .builder()
                        // 一次最多获取多少条消息
                        .batchSize(10)
                        // 运行 Stream 的 poll task
                        .executor(executor)
                        // 可以理解为 Stream Key 的序列化方式
                        .keySerializer(RedisSerializer.string())
                        // 可以理解为 Stream 后方的字段的 key 的序列化方式
                        .hashKeySerializer(RedisSerializer.string())
                        // 可以理解为 Stream 后方的字段的 value 的序列化方式
                        .hashValueSerializer(new GenericFastJsonRedisSerializer())//RedisSerializer.string()
                        // Stream 中没有消息时，阻塞多长时间，需要比 `spring.redis.timeout` 的时间小
                        .pollTimeout(Duration.ofSeconds(1))
	                        // ObjectRecord 时，将 对象的 filed 和 value 转换成一个 Map 比如：将Object对象转换成map
                        .objectMapper(new ObjectHashMapper())
                        // 获取消息的过程或获取到消息给具体的消息者处理的过程中，发生了异常的处理
                        .errorHandler(new CustomErrorHandler())
                        // 将发送到Stream中的Record转换成ObjectRecord，转换成具体的类型是这个地方指定的类型
                        .targetType(Object.class)
                        .build();
        streamMessageListenerContainer =
                StreamMessageListenerContainer.create(redisConnectionFactory, options);
        String streamKey = Constants.STREAM_KEY;
        //加入多个消费者对应多个key
        RedisConnection connection = redisConnectionFactory.getConnection();
        Set<byte[]> keys = connection.keyCommands().keys(streamKey.getBytes());
        for (byte[] key : keys) {
            StreamInfo.XInfoGroups xInfoGroups = connection.xInfoGroups(key);
            if (xInfoGroups == null || xInfoGroups.groupCount() == 0) {
                connection.xGroupCreate(key, "group-1", ReadOffset.from("0"));
            }
            Consumer from = Consumer.from("group-1", "consumer-"+key);
            StreamOffset<String> streamOffset = StreamOffset.create(new String(key), ReadOffset.lastConsumed());
            streamMessageListenerContainer.receive(from, streamOffset, listener);
            System.out.println(new String(key));
        }
        connection.close();
        return streamMessageListenerContainer;
    }

修改

为了解决标题问题，增加一个动态监听方法：

public void addStreamListener(String streamKey) {
        RedisConnection connection = redisConnectionFactory.getConnection();
        StreamInfo.XInfoGroups xInfoGroups = connection.xInfoGroups(streamKey.getBytes());
        if (xInfoGroups == null || xInfoGroups.groupCount() == 0) {
            connection.xGroupCreate(streamKey.getBytes(), "group-1", ReadOffset.from("0"));
        }
        Consumer consumer = Consumer.from("group-1", "consumer-" + streamKey);
        StreamOffset<String> streamOffset = StreamOffset.create(streamKey, ReadOffset.lastConsumed());
        streamMessageListenerContainer.receive(consumer, streamOffset, listener);
        connection.close();
    }

问题解决。