无论是准备面试,还是排查线上故障,“Kafka 重复消费”都是一个绕不开的话题。很多同学对它的理解停留在“消费端做幂等”这一句话上,但被追问到“为什么 Kafka 会重复消费”“幂等方案具体怎么落地”“消息没有全局 ID 该怎么办”时,往往就回答得不够系统。
这篇文章不打算停留在概念层,而是从 Kafka 消费链路和 offset 提交原理入手,把重复消费产生的根因拆开,再结合订单、积分这类高频业务场景,给出可落地的幂等方案和 Spring Boot 代码示例。读完你会明白:Kafka 到底会不会丢消息、为什么会重复消费、手动提交 offset 能做到什么程度、以及如何用幂等表和 Redis 去重挡住重复消息。
如果你是刚接触消息队列的新手,或者准备跳槽想系统整理 Kafka 知识点,这篇文章都值得收藏漫漫看。
1. 理解 Kafka 消费机制:offset 与消费者组
在讨论“如何避免重复消费”之前,先要把 Kafka 的消息消费链路弄清楚。很多人把重复消费的原因归结为“网络抖动”“消费者宕机”,但只有理解 offset、消费者组、poll 拉取这三者的关系,才能真正理解问题出在哪里。
1.1 offset 是什么
Kafka 中的每条消息在所属分区(Partition)里都有唯一的位置标识,称为 offset(偏移量)。你可以把它理解成一个消息的编号,但这个编号不是全局唯一的,而是“分区内唯一”的。消费者读取消息后,需要告诉 Kafka“我已经处理到这个位置了”,这个动作称为提交 offset。
提交 offset 的意义在于:消费者宕机或者重启后,Kafka 能根据最后一次提交的 offset,决定从哪里继续消费。已经提交过 offset 的消息,理论上不会再次消费;而未提交 offset 的消息,在重启后就会重新拉取。这正是重复消费能够发生的根本机制。
1.2 Consumer Group 如何分配分区
Kafka 的消费端以消费者组(Consumer Group)为单位工作。同一个消费者组内,一个分区在同一时刻只允许被组内的一个消费者实例消费。这样做的目的是保证分区内的消息在组内不重复分配。
但要注意,这里保证的是“同一时刻”不重复,而不是“整个生命周期”不重复。当消费者 A 负责消费分区 0,处理完一批消息但还没提交 offset 就宕机了,此时消费者 B 会被分配接手分区 0,而 B 会从 A 上次提交的 offset 继续消费,那么 A 已经处理过但没来得及提交的那部分消息,就会被 B 再次消费。
1.3 poll 拉取模型与提交时机
Kafka 消费者并不是“来一条处理一条”,而是通过
poll()
方法批量拉取消息。每次
poll()
会返回一批消息,消费者处理完这批消息之后,再提交 offset。
这里有一个关键时间差: 消息从小到大流程上是“拉取一批 -> 处理一批 -> 提交 offset” 。如果处理完成和提交 offset 之间发生异常,就会导致“消息处理了,但 offset 没有提交”的情况。消息队列为了保证消息不丢失,下一次会从头重新消费这些未提交 offset 的消息,于是重复就出现了。
2. 重复消费产生的根因分析
重复消费不是某一个单一动作导致的,而是消费链路中多个环节共同作用的结果。下面从自动提交、消费者组再均衡、处理逻辑异常等几个角度展开。
2.1 自动提交带来的不可控窗口
在 Kafka 默认配置下,
enable.auto.commit
为
true
,消费者会每隔
auto.commit.interval.ms
(默认 5 秒)自动提交一次 offset。这个设计看起来很省事,但存在一个明显的隐患:消费者拉取消息后如果处理到一半或者已经处理完、但在 5 秒内还没到自动提交时间点,服务突然宕机或重启,那么这批消息的 offset 不会被提交。
重启后,消费者重新拉取消息,会从上一次成功提交的位置继续,于是这 5 秒窗口内处理过的消息都会被重复消费。而且自动提交的时机不由业务逻辑控制,一旦业务处理耗时较长,重复的窗口就会被拉大。
# 自动提交配置示例
enable.auto.commit=true
auto.commit.interval.ms=5000
如果生产环境对消息处理的准确性要求高,一般建议把自动提交关闭,改为在业务逻辑处理成功之后手动提交 offset。
2.2 Consumer Rebalance 导致的消息重放
消费者组内成员发生变化时,会触发分区再均衡(Rebalance)。触发场景包括:
- 消费者实例启动或关闭
-
消费者处理速度过慢,超过
max.poll.interval.ms没有发起新的 poll - 消费者与 Kafka 会话超时
- Topic 新增分区
Rebalance 本身是 Kafka 保证消费公平性的机制,但它会带来一个副作用:如果有消费者负责的分区在下一次 poll 之前没有提交 offset,那么 Rebalance 之后,新的消费者会从上次提交的位置重新消费这部分消息。这是线上重复消费最典型的原因之一。
2.3 手动提交 offset 失败与提交时机不当
很多团队为了避免自动提交的问题,会配置手动提交。但如果提交时机和方式不对,依然会重复消费。例如:
List<ConsumerRecord<String, String>> records = consumer.poll(1000);
for (ConsumerRecord<String, String> record : records) {
// 业务处理
process(record);
// 处理完立刻提交
consumer.commitAsync();
}
这里看起来是“处理完就提交”,但如果
commitAsync()
提交失败,且没有重试机制,那么这些消息依然会在下次 poll 时重新拉取。另一个常见错误是在处理业务之前就先提交 offset,比如拉取到消息后立刻提交,再去执行业务代码。这样做虽然不会重复消费,但会带来更严重的消息丢失问题:业务还没处理完,offset 已经提交了,消费者崩溃后消息无法恢复。
2.4 Producer 端重试导致的重复
除了消费端,消息重复也可能在发送端产生。当 Producer 发送消息后没有收到 Broker 的确认,会触发重试。此时 Broker 可能已经成功写入消息,只是响应丢失,那么重试时就会写入一条一模一样的消息。虽然 Kafka 的幂等 Producer(
enable.idempotence=true
)可以在 Producer 会话内解决这种重复,但它并不能解决消费端的重复问题,因为消费端的重复更多来自 offset 提交时机,而不是消息本身是否存在两份。
搞清楚这一点非常关键,因为面试官经常会故意混淆“幂等 Producer”和“消费端幂等”这两个概念。
3. 解决重复消费的总体思路
既然 Kafka 消费模式天然可能重复,那么唯一可靠的应对方式,就是在消费端实现幂等。所谓幂等,是指“同一个操作执行多次,最终产生的结果与执行一次相同”。
3.1 Kafka 的三种投递语义
- At Most Once:消息可能丢失,但不会重复。
- At Least Once:消息不会丢失,但可能重复。Kafka 默认分区多副本机制加上消费者提交策略,多数场景是这种语义。
- Exactly Once:消息既不会丢失也不会重复。这需要配合事务和幂等机制,但对大多数业务系统来说成本较高。
在业务系统中,绝大多数场景采用的还是 At Least Once。这也意味着: 消费端必须有应对重复消息的能力 。
3.2 去重方案总体分类
| 方案 | 原理 | 适用场景 |
|---|---|---|
| 手动提交 offset | 通过控制提交时机,缩短重复窗口 | 所有消费端的基础配置 |
| 幂等表 | 利用数据库唯一索引,让重复消息插入失败但不报错 | 写数据库、需要落库的批量任务 |
| Redis 去重 | 利用 SETNX 和过期时间,实现短时间窗口内的去重 | 高频轻量判断、缓存类业务 |
| 业务状态机校验 | 使用条件更新 SQL,状态只允许单向流转 | 订单状态、支付状态等强状态业务 |
后面三章会分别给出这些方案的完整代码示例。
4. 方案一:手动提交 offset,把主动权掌握在自己手中
要减少重复消费,第一步应该是关闭自动提交,改为业务处理成功后再提交。
4.1 添加依赖并创建 Spring Boot 项目
本文示例使用 Spring Boot 集成 spring-kafka。如果你的项目还没有 Kafka 依赖,在
pom.xml
中添加如下内容:
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
<version>2.9.9</version>
</dependency>
版本号需要根据你本地的 Spring Boot 版本调整,重点是理解配置思路,不要照搬版本号。
4.2 配置 Kafka 消费者
在
application.yml
中配置消费者,关闭自动提交,并设置手动提交模式:
spring:
kafka:
bootstrap-servers: localhost:9092
consumer:
group-id: order-group
enable-auto-commit: false
auto-offset-reset: earliest
key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
listener:
ack-mode: manual
配置说明:
-
enable-auto-commit: false:关闭自动提交。 -
ack-mode: manual:使用手动提交模式。 -
auto-offset-reset: earliest:如果消费者没有 offset 或 offset 失效,从最早的消息开始消费,适用于需要完整处理的场景。 -
group-id:消费者组 ID,不同业务的消费组一定要隔离。
4.3 使用 @KafkaListener 手动提交 offset
在业务代码中,通过
Acknowledgment
参数手动控制提交时机。最关键的一点是:
一定要在处理完业务逻辑之后再调用 acknowledgment.acknowledge()
。
@Service
public class OrderConsumer {
private static final Logger log = LoggerFactory.getLogger(OrderConsumer.class);
@KafkaListener(topics = "order-topic", groupId = "order-group")
public void onMessage(ConsumerRecord<String, String> record, Acknowledgment ack) {
try {
// 1. 解析消息
OrderEvent orderEvent = JSON.parseObject(record.value(), OrderEvent.class);
// 2. 执行业务逻辑:加积分、更新订单状态等
orderService.handleOrderCreated(orderEvent);
// 3. 业务处理完成后,手动提交 offset
ack.acknowledge();
} catch (Exception e) {
log.error("消费订单消息失败,topic={}, partition={}, offset={}",
record.topic(), record.partition(), record.offset(), e);
// 这里的异常处理很关键,见下方说明
}
}
}
4.4 手动提交的边界
手动提交 offset 能显著缩小重复消费的窗口,但不能完全杜绝重复。比如:业务逻辑执行成功之后,
ack.acknowledge()
调用之前服务宕机,offset 没有被提交,下次依然会重新消费这条消息。
因此, 手动提交 offset 是必要的基础配置,而不是完整的幂等方案 。真正的最终防线,是消费方在处理消息时具备天然幂等能力。
另外,catch 块中要避免无限重试导致消息积压。可以选择记录日志后人工补偿,或者结合 Spring 的重试机制最多重试两三次后放入死信队列,而不是 catch 后什么都不做。
5. 方案二:数据库唯一键与幂等表
在订单、支付、积分这类数据一致性要求高的场景,最稳妥的做法是让数据库层来保证同一业务记录不会被重复处理。
5.1 幂等表设计
假设积分系统要消费“订单创建”消息,给用户增加积分。如果重复消费,用户积分就会加两次。此时可以建立一张积分发放流水表,将消息的唯一 ID(或业务幂等键)作为唯一索引。
CREATE TABLE `points_consume_record` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`message_id` varchar(64) NOT NULL COMMENT '消息唯一ID',
`order_no` varchar(64) NOT NULL COMMENT '业务订单号',
`user_id` bigint(20) NOT NULL COMMENT '用户ID',
`points` int(11) NOT NULL COMMENT '积分数',
`status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '1-成功 0-失败',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (`id`),
UNIQUE KEY `uk_message_id` (`message_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='积分发放幂等记录表';
message_id
由 Producer 在发送消息时生成,可以是 UUID 或业务订单号 + 场景号的组合,用来代表一条消息的唯一身份。
5.2 业务处理流程
正确的处理流程是:
-
收到消息,从消息体中取出
message_id。 - 先在幂等表尝试插入记录,利用唯一索引判断这条消息是否已处理过。
- 如果插入成功,说明是第一次消费,继续执行加积分的业务逻辑。
-
如果插入失败(唯一键冲突),说明该消息已经处理过,直接
return,不再执行后续逻辑。
5.3 示例代码
@Service
public class PointsConsumer {
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void handlePointsMessage(MessagePayload message) {
String messageId = message.getMessageId();
// 核心:利用唯一索引做幂等
try {
jdbcTemplate.update(
"INSERT INTO points_consume_record(message_id, order_no, user_id, points) VALUES (?, ?, ?, ?)",
messageId, message.getOrderNo(), message.getUserId(), message.getPoints());
} catch (DuplicateKeyException e) {
// 已消费过,直接返回
return;
}
// 执行真正的业务逻辑:给用户加积分
pointsService.increasePoints(message.getUserId(), message.getPoints());
}
}
这套方案的要点在于“插入先于业务执行”,并且两个步骤放在同一个事务中。如果业务逻辑执行失败,幂等表记录应该一起回滚,否则下次新的消息会因为幂等表已有记录而被跳过,造成数据缺失。如果业务和幂等表不在同一个数据库中,则需要引入分布式事务或采用更宽容的对账机制,但那种复杂度不在本文讨论范围,面试时可以根据项目情况展开。
5.4 注意事项
幂等表方案适合“数据需要写数据库”的场景,但如果消息量极大,幂等表会变成一张超大表。实际工程中可以按日期分表,并定期清理历史数据。也可以在业务表和幂等表之间使用 Redis 做一层前置过滤,降低数据库压力。
6. 方案三:Redis 分布式去重
如果业务处理不需要落数据库,或者数据库不是主要存储,可以用 Redis 实现去重。Redis 去重适合高频、轻量的场景,例如推送通知、计数统计、缓存刷新等。
6.1 核心命令:SETNX
Redis 的
SET key value NX EX seconds
命令可以实现“不存在才设置”的原子操作。如果设置成功,说明这条消息是第一次出现;如果设置失败,说明已经处理过。
需要注意的是,应该使用 Redis 官方推荐的
SET key value NX EX
形式,而不是旧的
SETNX
命令后再单独设置过期时间,后者不是原子操作,可能在设置过期时间前服务崩溃,导致 key 永远不会过期。
6.2 Spring Boot Redis 去重示例
在 Spring Boot 中封装一个去重工具类:
@Component
public class MessageDeduplicateService {
private static final String DEDUP_KEY_PREFIX = "msg:dedup:";
@Autowired
private StringRedisTemplate redisTemplate;
/**
* 尝试标记消息已消费
*
* @param messageId 消息唯一ID
* @param ttlSeconds 去重窗口时间
* @return true-首次消费,false-重复消息
*/
public boolean tryMarkConsumed(String messageId, long ttlSeconds) {
String key = DEDUP_KEY_PREFIX + messageId;
Boolean success = redisTemplate.opsForValue()
.setIfAbsent(key, "1", Duration.ofSeconds(ttlSeconds));
return Boolean.TRUE.equals(success);
}
}
在消费端使用:
@KafkaListener(topics = "notification-topic", groupId = "notification-group")
public void onNotification(ConsumerRecord<String, String> record) {
String messageId = extractMessageId(record.value());
// 如果不是首次消费,直接跳过
if (!deduplicateService.tryMarkConsumed(messageId, 24 * 3600)) {
log.info("重复消息跳过,messageId={}", messageId);
return;
}
// 执行真正的业务逻辑
notificationService.send(record.value());
}
6.3 过期时间如何设置
Redis 的 Key 一定要设置过期时间,避免数据无限堆积。过期时间需要结合业务场景考虑:如果业务上 10 分钟内不会重复发同一消息,可以设置为 10 分钟;对于订单类场景,建议设置为 1 天甚至更久,以防隔天有补偿性重发。
但过期时间也会带来边界问题:如果消息在 Redis 的 key 过期之后才被重新消费,去重就会失败。对这种强一致性要求高的场景,应该改用数据库唯一键方案,或者 Redis 去重与数据库校验配合使用。
6.4 与数据库方案对比
| 维度 | Redis 去重 | 数据库幂等表 |
|---|---|---|
| 性能 | 高 | 较低 |
| 数据持久性 | 依赖过期时间,可能过期后失效 | 永久保存,更可靠 |
| 适用场景 | 推送、通知、缓存类 | 订单、积分、账户等核心数据 |
| 扩展性 | 需要关注 Redis 内存 | 需要分表、清理历史数据 |
7. 方案四:业务状态机校验
还有一类场景,不需要单独的幂等表,只需要利用数据库条件更新就能天然实现幂等,那就是业务系统里的状态流转。
以订单状态为例,订单从“已创建”到“已支付”是单向流转的。如果支付完成消息被重复消费两次,第二次执行“把订单从未支付改成已支付”时,会发现订单状态已经不是“未支付”,因此更新影响行数为 0,业务不再重复执行。
7.1 条件更新 SQL
UPDATE t_order
SET status = 'PAID', pay_time = NOW()
WHERE order_id = #{orderId}
AND status = 'UNPAID';
这条 SQL 的执行结果可以通过影响行数来判断:
int rows = orderMapper.updateStatusByOrderId(orderId, OrderStatusEnum.UNPAID, OrderStatusEnum.PAID);
if (rows == 0) {
// 说明订单状态不是 UNPAID,消息可能已处理过,直接返回
return;
}
这种方案的精髓在于:把“判断状态是否满足处理条件”和“状态迁移”放在同一条 SQL 中完成,避免“先查询、再更新”的并发问题。
7.2 适用场景与局限
状态机制非常适合订单、支付、退款等有明确状态流转的业务。但它有一个前提: 业务处理必须可以映射为一条条件更新 SQL ,并且状态只允许往一个方向流转。如果业务是“增加积分”“增加库存”这类累计型操作,没有状态字段可用,就应该使用幂等表或者 Redis 去重。
另外,不同状态下要执行不同逻辑,也可以配合乐观锁版本号来实现更精细的幂等:
UPDATE t_order
SET status = 'PAID', version = version + 1
WHERE order_id = #{orderId}
AND status = 'UNPAID'
AND version = #{oldVersion};
8. 高频面试问题与回答思路
这一节把面试中常见的追问总结出来,并给出回答框架。
8.1 面试官问:Kafka 如何避免重复消费?
推荐按“链路原理 -> 原因分析 -> 解决方案 -> 工程实践”四层回答。
先说明 Kafka 消费链路中 offset 提交是关键。消费者通过 poll 拉取消息,处理完成后提交 offset。如果消息处理完成但 offset 没提交,比如消费者宕机、Rebalance、或者手动提交失败,下次该分区被重新分配后,就会从上一次提交的 offset 继续消费,导致重复消息。Kafka 默认投递语义是 At Least Once,所以不丢消息和重复消费是一体两面的。要避免重复消费,核心思路是消费端幂等。常用的手段有:关闭自动提交、改为业务处理成功后手动提交 offset;在数据库中使用唯一键约束或幂等表;用 Redis SETNX 做去重;对订单等有状态流转的业务,使用条件更新 SQL 做状态机校验。项目中需要根据业务场景选择一种或叠加使用。
这个回答既表现出对原理的理解,也体现了对多种工具的掌握,分数会明显高于只说“做幂等”的候选人。
8.2 面试官追问:消息没有唯一 ID 怎么办?
如果 Producer 发送的消息体中没有携带消息 ID,可以在消费端根据已有业务字段拼接出幂等键。例如“订单号 + 操作类型”,或者对消息内容做哈希。如果能改造 Producer,更推荐从源头发送时生成一个全局唯一的 messageId,卸载消息体里。
需要注意的是,消费端拼接业务幂等键时必须保证键的稳定性,不能因为消息内容格式变化导致同一个业务事件计算出不同的键。
8.3 面试官追问:手动提交 offset 就一定能避免重复?
不能。手动提交只是将 offset 提交的时机与业务处理绑定,缩小重复窗口。从业务成功到 offset 提交成功之间,如果消费者崩溃,消息依然会被重新消费。因此手动提交是基础配置,不是完整解决方案,最终还是要靠下游业务幂等来保证。
8.4 面试官追问:幂等 Producer 能解决重复消费吗?
不能完全解决。幂等 Producer 解决的是 Producer 端因重试导致的重复写入,也就是同一个消息只往 Kafka 里写一份。但消费端是否重复消费取决于 offset 提交机制,与 Producer 无关。如果面试中能主动区分这两个概念,会显得经验更扎实。
8.5 常见报错与排查对照表
| 问题现象 | 常见原因 | 解决思路 |
|---|---|---|
| 消费一次消息后,服务重启又消费多次 | 自动提交窗口内崩溃,offset 未提交 | 关闭自动提交,改为业务处理完成后手动提交 |
| 手动提交后依然重复消费 | 提交时机早于业务处理完成,或 commitAsync 失败未处理 | 调整代码顺序,处理成功后再 acknowledge() |
| 消费组频繁 Rebalance | 单条消息处理超时,超过 max.poll.interval.ms | 增大该参数,或优化消费者处理性能,拆分批量消息 |
| 订单状态被重复覆盖 | 下游消费未判断当前状态,直接更新 | 使用条件更新 SQL,状态机流转 |
| 同一环境多个服务重复消费同一消息 | 每个实例使用不同 groupId,导致同一个分区被多组消费 | 统一 groupId,并做好环境隔离 |
9. 最佳实践与工程建议
这部分内容更多来自生产环境经验,也是面试中能体现真实项目积累的关键。
9.1 消费者组命名与环境隔离
如果生产环境和测试环境共用同一套 Kafka Broker,消费者组的命名必须包含环境信息。例如
prod-order-group
、
test-order-group
。不同环境使用相同的 groupId,会导致两个环境的消费组互相争夺分区,造成消息消费错乱。
9.2 监控与日志
每一条消费记录最好都打上三个关键信息:topic、partition、offset。这三个信息组合在一起,能唯一定位一条消息在 Kafka 中的位置。当出现重复消费时,通过日志对比两次消费的时间点和 offset,就能快速判断问题出在自动提交还是 Rebalance。
log.info("消费消息,topic={}, partition={}, offset={}, messageId={}",
record.topic(), record.partition(), record.offset(), messageId);
另外,建议对消费者组配置消费延迟(Consumer Lag)监控,一旦 lag 持续上涨,说明消费者处理能力不足,需要扩容消费者实例或优化消费逻辑。
9.3 消费者线程数和分区数匹配
Kafka 的并行消费能力取决于消费者实例数和分区数。同一个消费者组内,消费者实例数不应该超过分区总数,否则多出的消费者会闲置。例如一个 Topic 只有 3 个分区,消费者组配置 5 个实例,只有 3 个实例在消费,另外 2 个不工作,属于资源浪费。
9.4 生产环境变更前先验证
修改消费组配置、新增消费者逻辑、调整提交方式,这类变更建议先在测试环境完整验证一遍。尤其是涉及
auto-offset-reset
参数时,如果配置为
earliest
,group 第一次上线会从最早的 offset 开始消费,如果当前消费组之前没有提交过 offset,可能导致积压的历史消息全部被消费,流量瞬间暴涨,甚至拖垮下游服务。
9.5 不要把精力放在“消灭重复”上,而是“容忍重复”
对于 Kafka 这个技术栈来说,重复消费是分布式系统下的一种常见情况。与其花费巨大精力去追求绝对不重复的 Exactly Once,不如在设计系统时默认“消息可能重复”,并把重点放在下游的幂等能力上。毕竟在复杂分布式环境中,网络超时、进程宕机、消费端升级都可能发生,唯一可靠的兜底手段,始终是接收消息的一方具备处理重复消息的能力。
这套理解和代码方案,既可以作为面试回答的素材,也可以直接应用到项目开发中。建议你根据自己的业务场景选一种主力方案,在本地把 Demo 跑起来,再尝试模拟一次消费者宕机或重启,亲眼看看重复消费是如何发生的,又会如何被幂等逻辑挡住。实践过一次之后,这类问题基本就再也难不住你了。
214



被折叠的 条评论
为什么被折叠?



