Redis Streams
Redis Streams 以一种抽象的方式对日志数据结构建模。日志通常是只追加(append-only)的数据结构,可以从头开始消费、从某个随机位置消费,或者通过流式方式消费新消息。
在 Redis 参考文档中进一步了解 Redis Streams。
Redis Streams 大致可分为两大功能领域:
- 追加记录
- 消费记录
虽然这种模式与发布/订阅有相似之处,但主要区别在于消息的持久化方式以及消息的消费方式。
Pub/Sub 依赖于瞬态消息的广播(也就是说,如果你不在监听,就会错过一条消息),而 Redis Stream 使用一种持久的、只追加的数据类型,它会保留消息直到流被修剪。消费方式上的另一个区别是,Pub/Sub 注册的是服务端订阅。Redis 把到达的消息推送给客户端,而 Redis Streams 则需要主动轮询。
org.springframework.data.redis.connection 和 org.springframework.data.redis.stream 包提供了 Redis Streams 的核心功能。
追加记录
要发送一条记录,与其他操作一样,你既可以使用低层的 RedisConnection,也可以使用高层的 StreamOperations。两者都提供了 add(即 xAdd)方法,该方法接受记录和目标流作为参数。RedisConnection 需要原始数据(字节数组),而 StreamOperations 则允许把任意对象作为记录传入,如下例所示:
// append message through connection
RedisConnection con = …
byte[] stream = …
ByteRecord record = StreamRecords.rawBytes(…).withStreamKey(stream);
con.xAdd(record);
// append message through RedisTemplate
RedisTemplate template = …
StringRecord record = StreamRecords.string(…).withStreamKey("my-stream");
template.opsForStream().add(record);
流记录携带一个 Map(键值元组)作为其载荷。向流追加一条记录会返回 RecordId,可作为后续引用。
消费
在消费端,可以消费一个或多个流。Redis Streams 提供读取命令,允许从已知流内容中的任意位置(随机访问)消费流,也可以从流末尾之后消费新的流记录。
在低层,RedisConnection 提供了 xRead 和 xReadGroup 方法,分别映射为读取命令和在消费者组内读取的命令。请注意,可以把多个流作为参数。
Redis 中的订阅命令可能是阻塞的。也就是说,在一个连接上调用 xRead 会导致当前线程阻塞,因为它开始等待消息。只有当读命令超时或收到一条消息时,线程才会被释放。
要消费流消息,你既可以在应用代码中轮询消息,也可以使用两种通过消息监听器容器异步接收方式之一:命令式或响应式。每当新记录到达时,容器就会通知应用代码。
同步接收
虽然流消费通常与异步处理相关联,但也可以同步地消费消息。重载的 StreamOperations.read(…) 方法提供了这一功能。在同步接收期间,调用线程可能会阻塞直到有消息可用。StreamReadOptions.block 属性指定接收方在放弃等待消息之前应等待多久。
// Read message through RedisTemplate
RedisTemplate template = …
List<MapRecord<K, HK, HV>> messages = template.opsForStream().read(StreamReadOptions.empty().count(2),
StreamOffset.latest("my-stream"));
List<MapRecord<K, HK, HV>> messages = template.opsForStream().read(Consumer.from("my-group", "my-consumer"),
StreamReadOptions.empty().count(2),
StreamOffset.create("my-stream", ReadOffset.lastConsumed()))
通过消息监听器容器异步接收
由于其阻塞特性,低层轮询并不理想,因为它需要为每一个消费者管理连接和线程。为缓解这个问题,Spring Data 提供了消息监听器,它承担所有繁重的工作。如果你熟悉 EJB 和 JMS,应该会觉得这些概念很熟悉,因为它的设计尽可能贴近 Spring Framework 中的支持及其消息驱动 POJO(MDP)。
Spring Data 自带两种实现,分别针对所使用的编程模型:
- StreamMessageListenerContainer 充当命令式编程模型的消息监听器容器。它用于从 Redis Stream 消费记录,并驱动注入其中的 StreamListener 实例。
- StreamReceiver 提供消息监听器的响应式变体。它用于把 Redis Stream 作为潜在无限的流来消费,并通过一个
Flux发出流消息。
StreamMessageListenerContainer 和 StreamReceiver 负责消息接收的全部线程调度,并把消息分发给监听器进行处理。消息监听器容器/接收器是 MDP 与消息提供者之间的中介,负责注册接收消息、获取与释放资源、异常转换等。这让你作为应用开发者可以编写与接收消息(并对其作出反应)相关的(可能复杂的)业务逻辑,而把样板化的 Redis 基础架构事务委托给框架。
两个容器都允许运行时配置变更,这样你可以在应用运行时添加或移除订阅,而无需重启。另外,容器采用延迟订阅方式,只在需要时才使用 RedisConnection。如果所有监听器都取消订阅,会自动执行清理并释放线程。
命令式 StreamMessageListenerContainer
以一种类似于 EJB 世界中消息驱动 Bean(MDB)的方式,Stream 驱动 POJO(SDP)充当 Stream 消息的接收方。SDP 的唯一约束是它必须实现 StreamListener 接口。还请注意,如果你的 POJO 在多个线程上接收消息,重要的是确保你的实现是线程安全的。
class ExampleStreamListener implements StreamListener<String, MapRecord<String, String, String>> {
@Override
public void onMessage(MapRecord<String, String, String> message) {
System.out.println("MessageId: " + message.getId());
System.out.println("Stream: " + message.getStream());
System.out.println("Body: " + message.getValue());
}
}
StreamListener 代表一个函数式接口,因此实现可以改写为 Lambda 形式:
message -> {
System.out.println("MessageId: " + message.getId());
System.out.println("Stream: " + message.getStream());
System.out.println("Body: " + message.getValue());
};
实现好 StreamListener 之后,就该创建消息监听器容器并注册订阅了:
RedisConnectionFactory connectionFactory = …
StreamListener<String, MapRecord<String, String, String>> streamListener = …
StreamMessageListenerContainerOptions<String, MapRecord<String, String, String>> containerOptions = StreamMessageListenerContainerOptions
.builder().pollTimeout(Duration.ofMillis(100)).build();
StreamMessageListenerContainer<String, MapRecord<String, String, String>> container = StreamMessageListenerContainer.create(connectionFactory,
containerOptions);
Subscription subscription = container.receive(StreamOffset.fromStart("my-stream"), streamListener);
关于各实现所支持特性的完整说明,请参阅各个消息监听器容器的 Javadoc。
响应式 StreamReceiver
对流式数据源的响应式消费通常通过事件或消息的 Flux 来进行。响应式接收方实现由 StreamReceiver 及其重载的 receive(…) 方法提供。与 StreamMessageListenerContainer 相比,响应式方式所需的基础架构资源(如线程)更少,因为它利用了驱动提供的线程资源。接收流是一个需求驱动的 StreamMessage publisher:
Flux<MapRecord<String, String, String>> messages = …
return messages.doOnNext(it -> {
System.out.println("MessageId: " + message.getId());
System.out.println("Stream: " + message.getStream());
System.out.println("Body: " + message.getValue());
});
现在我们需要创建 StreamReceiver 并注册一个订阅来消费流消息:
ReactiveRedisConnectionFactory connectionFactory = …
StreamReceiverOptions<String, MapRecord<String, String, String>> options = StreamReceiverOptions.builder().pollTimeout(Duration.ofMillis(100))
.build();
StreamReceiver<String, MapRecord<String, String, String>> receiver = StreamReceiver.create(connectionFactory, options);
Flux<MapRecord<String, String, String>> messages = receiver.receive(StreamOffset.fromStart("my-stream"));
关于各实现所支持特性的完整说明,请参阅各个消息监听器容器的 Javadoc。
需求驱动的消费使用背压信号来激活和停用轮询。如果需求已满足,StreamReceiver 订阅会暂停轮询,直到订阅者发出进一步需求的信号。根据 ReadOffset 策略的不同,这可能导致消息被跳过。
Acknowledge 策略
当你通过消费者组读取消息时,服务器会记住某条给定消息已被投递,并把它加入待处理条目列表(PEL)——即已投递但尚未确认的消息列表。必须通过 StreamOperations.acknowledge 确认消息,才能将其从待处理条目列表中移除,如下方代码片段所示。
StreamMessageListenerContainer<String, MapRecord<String, String, String>> container = ...
container.receive(Consumer.from("my-group", "my-consumer"), 1
StreamOffset.create("my-stream", ReadOffset.lastConsumed()),
msg -> {
// ...
redisTemplate.opsForStream().acknowledge("my-group", msg); 2
});
以 my-consumer 的身份从 my-group 组读取。收到的消息不被确认。
在处理完消息后确认该消息。
要在接收时自动确认消息,请使用 receiveAutoAck 而非 receive。
ReadOffset 策略
流读取操作接受一个读取偏移规范,用于从给定偏移开始消费消息。ReadOffset 表示读取偏移规范。Redis 支持 3 种偏移变体,具体取决于你是独立消费流还是在消费者组内消费:
ReadOffset.latest()– 读取最新消息。ReadOffset.from(…)– 在特定消息 Id 之后读取。ReadOffset.lastConsumed()– 在上一个已消费的消息 Id 之后读取(仅限消费者组)。
在基于消息容器的消费场景中,我们需要在消费一条消息时推进(或递增)读取偏移。推进方式取决于所请求的 ReadOffset 和消费模式(有/无消费者组)。下表说明容器如何推进 ReadOffset:
表 1. ReadOffset 的推进
| 读取偏移 | 独立模式 | 消费者组 |
|---|---|---|
| 最新 | 读取最新消息 | 读取最新消息 |
| 特定消息 Id | 把最后看到的消息用作下一个 MessageId | 把最后看到的消息用作下一个 MessageId |
从特定消息 id 和上一个已消费消息读取可被视为安全操作,它们确保消费追加到流中的所有消息。使用最新消息进行读取可能会跳过在轮询操作处于停顿状态期间被添加到流的消息。轮询会引入一段停顿时间,在这段时间内消息可能在各条轮询命令之间到达。流消费不是线性连续读取,而是被拆分为重复的 XREAD 调用。
序列化
发送到流的任何 Record 都需要被序列化为其二进制格式。由于流与哈希数据结构关系紧密,流键、字段名和值使用在 RedisTemplate 上配置的相应序列化器。
表 2. Stream 序列化
| Stream 属性 | 序列化器 | 说明 |
|---|---|---|
| key | keySerializer | 用于 Record#getStream() |
| field | hashKeySerializer | 用于载荷中的每个 map 键 |
请务必检查所使用的 RedisSerializer,并注意,如果你决定不使用任何序列化器,就需要确保那些值已经是二进制形式。
对象映射
简单值
StreamOperations 允许通过 ObjectRecord 把简单值直接追加到流,而无需把这些值放入 Map 结构。该值随后会被赋给一个 payload 字段,并在读回该值时可以被提取。
ObjectRecord<String, String> record = StreamRecords.newRecord()
.in("my-stream")
.ofObject("my-value");
redisTemplate()
.opsForStream()
.add(record); 1
List<ObjectRecord<String, String>> records = redisTemplate()
.opsForStream()
.read(String.class, StreamOffset.fromStart("my-stream"));
XADD my-stream * "_class" "java.lang.String" "_raw" "my-value"
ObjectRecord 与所有其他记录经过完全相同的序列化过程,因此也可以使用返回 MapRecord 的无类型读取操作来获取该 Record。
复杂值
向流添加复杂值可以通过 3 种方式完成:
- 转换为简单值,例如使用 String JSON 表示。
- 用合适的
RedisSerializer序列化该值。 - 使用 HashMapper 把该值转换为适合序列化的
Map。
第一种变体最直接,但它忽略了流结构所提供的字段值能力,不过流中的值仍可供其他消费者读取。第二种选项与第一种具有相同的优点,但可能导致非常特定的消费者限制,因为所有消费者都必须实现完全相同的序列化机制。HashMapper 方式要稍微复杂一些,它利用了流的哈希结构,但会把来源扁平化。只要选择合适的序列化器组合,其他消费者仍然能够读取这些记录。
HashMapper 把载荷转换为具有特定类型的 Map。请务必使用能够(反)序列化哈希的 Hash-Key 和 Hash-Value 序列化器。
ObjectRecord<String, User> record = StreamRecords.newRecord()
.in("user-logon")
.ofObject(new User("night", "angel"));
redisTemplate()
.opsForStream()
.add(record); 1
List<ObjectRecord<String, User>> records = redisTemplate()
.opsForStream()
.read(User.class, StreamOffset.fromStart("user-logon"));
XADD user-logon * "_class" "com.example.User" "firstname" "night" "lastname" "angel"
StreamOperations 默认使用 ObjectHashMapper。在获取 StreamOperations 时,你可以提供一个适合你需求的 HashMapper。
redisTemplate()
.opsForStream(new JacksonHashMapper(true))
.add(record); 1
XADD user-logon * "firstname" "night" "@class" "com.example.User" "lastname" "angel"
StreamMessageListenerContainer 可能并不知道领域类型上使用的任何 @TypeAlias,因为那些需要通过 MappingContext 解析。请务必用一个 initialEntitySet 初始化 RedisMappingContext。
@Bean
RedisMappingContext redisMappingContext() {
RedisMappingContext ctx = new RedisMappingContext();
ctx.setInitialEntitySet(Collections.singleton(Person.class));
return ctx;
}
@Bean
RedisConverter redisConverter(RedisMappingContext mappingContext) {
return new MappingRedisConverter(mappingContext);
}
@Bean
ObjectHashMapper hashMapper(RedisConverter converter) {
return new ObjectHashMapper(converter);
}
@Bean
StreamMessageListenerContainer streamMessageListenerContainer(RedisConnectionFactory connectionFactory, ObjectHashMapper hashMapper) {
StreamMessageListenerContainerOptions<String, ObjectRecord<String, Object>> options = StreamMessageListenerContainerOptions.builder()
.objectMapper(hashMapper)
.build();
return StreamMessageListenerContainer.create(connectionFactory, options);
}
:::