在分布式系统架构演进过程中,java使用redis做消息队列已成为一种轻量级、高吞吐、低延迟的消息中间件替代方案。相比传统MQ(如RabbitMQ、Kafka),java使用redis做消息队列具有部署简单、运维成本低、与现有技术栈高度兼容等显著优势,尤其适用于中低并发场景下的异步解耦、任务分发、日志采集等业务场景。
近年来,随着Redis 5.0引入Stream数据结构,配合XADD、XREADGROUP、XACK等命令,真正实现了具备持久化、消费组、ACK确认机制的生产者-消费者模型,为java使用redis做消息队列提供了原生、可靠的底层支持。
appendfsync everysec策略可保障99.99%消息不丢失• 消息量级:建议单队列日均消息量≤500万条
• 顺序要求:仅支持单消费者有序消费(多消费者需业务层补偿)
• 消费能力:单消费者处理能力受限于Redis单线程模型,建议≤2000 QPS/消费者
• 延迟容忍:不适合毫秒级严格延迟场景(需考虑DelayQueue+Redis SortedSet组合方案)
LPUSH入队 + BRPOP阻塞出队)XADD:向流追加消息(自动生成唯一ID:1638421200000-0)XREADGROUP:消费组读取消息(支持阻塞等待)XACK:标记消息已处理(从Pending List移除)[生产者] XADD mystream * msg "order-created" → ID: 1638421200000-0 [消费者组创建] XGROUP CREATE mystream orders-group $ MKSTREAM → 创建消费组"orders-group",起始ID为新消息 [消费者注册] XREADGROUP GROUP orders-group consumer-01 COUNT 10 BLOCK 5000 STREAMS mystream > → 从mystream读取最多10条未确认消息,阻塞5秒 [消费确认] XACK mystream orders-group 1638421200000-0 → 标记消息已处理,从Pending List移除 [异常重试] XPENDING mystream orders-group → 查看未确认消息列表 XCLAIM mystream orders-group consumer-02 3600000 1638421200000-0 → 超时30分钟未ACK的消息转由consumer-02接管
java使用redis做消息队列时,消息重复消费是高频故障点。推荐采用以下三层幂等保障:
SADD原子操作记录已消费消息ID,失败则跳过message_id唯一索引,数据库层兜底| 方案 | 实现复杂度 | 可靠性 | 吞吐量 | 适用场景 |
|---|---|---|---|---|
| Redis List | ★☆☆☆☆(低) | ★☆☆☆☆(低) | ★★★☆☆(中) | 简单任务分发、日志采集 |
| Redis Stream | ★★★☆☆(中) | ★★★★☆(高) | ★★★★★(高) | java使用redis做消息队列首选方案 |
| Redis + Spring Cloud Stream | ★★★★☆(高) | ★★★★★(高) | ★★★★☆(高) | 微服务架构统一消息抽象 |
timestamp-sequence(如1638421200000-0)GROUP:消费组名称(建议业务命名,如order-notif-group)consumer:消费者实例ID(建议UUID+服务名,如order-service-01)count:单次拉取条数(建议10~50,根据处理耗时调整)block:阻塞超时(建议5000ms,避免空轮询)<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
</dependency> <!-- 非必需,用于兼容迁移 -->
</dependencies>
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
// 使用String序列化key
template.setKeySerializer(new StringRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
// 使用JSON序列化value
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
@Service
public class MessageProducer {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public void sendOrderMessage(OrderEvent event) {
String streamKey = "order:stream";
// 构造消息内容
Map<String, Object> message = new HashMap<>();
message.put("orderId", event.getOrderId());
message.put("eventType", event.getType().name());
message.put("timestamp", System.currentTimeMillis());
// 使用StreamOperations追加消息
redisTemplate.opsForStream()
.add(RedisStreamOptions.defaultOptions()
.autoCreateStream(true))
.add(streamKey, message);
}
}
@Service
public class OrderConsumer {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@PostConstruct
public void init() {
// 初始化消费组(仅需执行一次)
String streamKey = "order:stream";
String group = "order-notif-group";
try {
redisTemplate.opsForStream()
.createGroup(streamKey, ReadOffset.from("0-0"), group);
} catch (Exception e) {
// 消费组已存在时忽略
}
}
@Scheduled(fixedDelay = 100)
public void consume() {
String streamKey = "order:stream";
String group = "order-notif-group";
String consumer = "order-service-01";
// 读取未确认消息( pending)
Map<String, List<Record<String, Object>>> records =
redisTemplate.opsForStream()
.read(Consumer.from(group, consumer),
StreamReadOptions.empty().count(50).block(Duration.ofMillis(5000)),
StreamOffset.fromLast(streamKey));
if (!records.isEmpty()) {
List<Record<String, Object>> recordList =
records.values().stream()
.flatMap(List::stream)
.collect(Collectors.toList());
for (Record<String, Object> record : recordList) {
try {
// 处理消息
handleOrderEvent(record.getValue());
// 确认消息
redisTemplate.opsForStream()
.acknowledge(group, record.getId());
} catch (Exception e) {
// 异常重试:延迟10秒后重新入队
redisTemplate.opsForStream()
.claim(streamKey, group, consumer,
Duration.ofSeconds(10).toMillis(), record.getId());
}
}
}
}
private void handleOrderEvent(Map<String, Object> event) {
// 业务逻辑处理(幂等性检查)
String orderId = (String) event.get("orderId");
if (orderService.isProcessed(orderId)) {
return; // 跳过重复消息
}
// 执行核心业务
orderService.processEvent(event);
}
}
XCLAIM立即重试(延迟1秒)order:stream:dlq供人工介入// 死信队列处理
public void handleDLQ() {
String dlqKey = "order:stream:dlq";
Map<String, List<Record<String, Object>>> dlqRecords =
redisTemplate.opsForStream()
.read(Consumer.from("dlq-group", "dlq-consumer"),
StreamReadOptions.empty().count(10),
StreamOffset.fromLast(dlqKey));
dlqRecords.values().stream()
.flatMap(List::stream)
.forEach(record -> {
// 记录监控日志
log.error("DLQ message: {}", record.getValue());
// 可选:发送告警邮件
alertService.send("死信消息积压", record.getId());
});
}
当单次消费处理耗时>50ms时,建议启用批量确认:
XACK(减少网络往返)// 批量确认实现
public void batchAck(String group, List<StreamOffset> offsets) {
String streamKey = "order:stream";
redisTemplate.executePipelined((RedisConnection connection) -> {
offsets.forEach(offset -> {
connection.streamCommands()
.acknowledge(StreamOffset.fromLast(streamKey),
group, offset.getOffset());
});
return null;
});
}
| 序列化方式 | 消息大小 | 序列化耗时 | 适用场景 |
|---|---|---|---|
| Jackson(默认) | 100% | 100% | 通用场景 |
| Gzip + Jackson | 40%~60% | 180%~220% | 大消息体(>5KB) |
| Protobuf | 20%~30% | 150% | 强类型服务间通信 |
同一订单被多次处理,导致库存超卖
XACK,超时重试idle-timeout:设置XSETID后的IDLE时间≤30秒MINSLAVES参数保障数据不丢失XREAD指定ID范围,跳过旧消息DEL命令),重启服务重建消费Redis内部Pending List由服务端管理,手动操作可能导致状态不一致。正确做法:
XCLAIM转移消息所有权XGROUP SETID重置消费组起始位置主节点未持久化即崩溃,从节点无最新消息
appendfsync everysec(性能与可靠性平衡)no-appendfsync-on-rewrite: yes(避免重写期间丢失)repl-diskless-sync: no(使用磁盘中间层保障同步可靠性)min-slaves-to-write 1(至少1个从节点在线才接受写)MASTERDOWN事件自动重连| 指标 | 监控方式 | 告警阈值 | 优化动作 |
|---|---|---|---|
| Stream长度 | INFO stats:total_commands_processed | >10万条 | 触发扩容 |
| Pending消息数 | XPENDING key group | >5000条 | 告警+自动扩容 |
| 消费者延迟 | Redis Exporter: redis_stream_pending_time_seconds | >5秒 | 检查消费者健康状态 |
| 消息丢失率 | 对比生产/消费总数 | >0.01% | 检查主从同步状态 |
# Redis Exporter配置
- job_name: 'redis-stream'
static_configs:
- targets: ['redis-exporter:9121']
metric_relabel_configs:
- source_labels: [__name__]
regex: 'redis_stream_pending.*'
action: keep
# 创建主题
XADD topic:order:* msg "order-created"
XADD topic:payment:* msg "payment-success"
# 消费组绑定多个主题
XREADGROUP GROUP user-service consumer-01 COUNT 10
STREAMS topic:order: topic:payment: >
topic:order:*相关消息route_key字段Pattern匹配| 优先级 | Stream Key | 处理逻辑 |
|---|---|---|
| 高 | order:stream:pri-1 | 优先消费,阻塞等待超时100ms |
| 中 | order:stream:pri-2 | 主队列,阻塞等待超时5000ms |
| 低 | order:stream:pri-3 | 后台处理,阻塞等待超时30000ms |
@Scheduled(fixedDelay = 50)
public void consumePriority() {
// 先处理高优先级队列
readAndProcess("order:stream:pri-1", Duration.ofMillis(100));
// 再处理中优先级队列
readAndProcess("order:stream:pri-2", Duration.ofMillis(5000));
// 最后处理低优先级队列
readAndProcess("order:stream:pri-3", Duration.ofMillis(30000));
}
traceId:abc123)trace:abc123键值对,记录各阶段时间戳XINFO STREAM获取完整消费路径// 消息轨迹记录
public void traceMessage(String traceId, String stage, String detail) {
String key = "trace:" + traceId;
Map<String, Object> data = new HashMap<>();
data.put("timestamp", System.currentTimeMillis());
data.put("stage", stage);
data.put("detail", detail);
redisTemplate.opsForStream()
.add(key, data, StreamAddOptions.builder().maxLen(100).build());
}
// 消费端调用
traceService.traceMessage(traceId, "CONSUMED", "order-123 processed");
A:Redis Stream本身不支持分布式事务,但可通过以下方式保障消息一致性:
SETEX同步状态到RedisA:推荐使用Redis SortedSet实现延迟队列:
ZRANGEBYSCORE当前时间戳前的消息A:根据Redis版本和配置差异:
io-threads、关闭no-appendfsync-on-rewriteA:通过XGROUP CREATE指定起始ID:
$:仅消费新消息(推荐生产环境)0:从头开始消费(仅用于测试)last_id:从上次确认ID之后开始(需持久化last_id)A:严格顺序消费需满足:
MAXLEN ~截断导致ID不连续)lazyfree-lazy-expire(避免异步删除导致顺序错乱)| 测试环境 | 消息大小 | 吞吐量(QPS) | 平均延迟 |
|---|---|---|---|
| 单机Redis 6.2 | 1KB | 82,000 | 0.8ms |
| 单机Redis 6.2 | 10KB | 45,000 | 1.2ms |
| 集群(3主3从) | 1KB | 210,000 | 0.5ms |