1. Kafka架构组成?Broker、Topic、Partition、Consumer Group的关系?
2. 如何保证消息不丢失?Producer、Broker、Consumer各层面怎么做?
3. 消息顺序性如何保证?
4. Consumer Group的Rebalance机制?怎么避免Rebalance风暴?
5. Kafka和RocketMQ的对比?
6. Exactly-Once语义如何实现?
┌──────────────┐
│ ZooKeeper │ (或KRaft模式,3.x已移除ZK)
│ 元数据管理 │
└──────┬───────┘
│
┌─────────┐ ┌───────────┴───────────┐ ┌─────────┐
│Producer │───→│ Kafka Cluster │───→│Consumer │
└─────────┘ │ Broker0: P0(L) P1(F) │ │ Group A │
│ Broker1: P0(F) P1(L) │ └─────────┘
└───────────────────────┘
Broker:Kafka服务节点,每个Broker存储部分Partition
Topic:消息逻辑分类(如order、payment),物理上由多个Partition组成
Partition:Topic的物理分片,每个Partition是一个有序日志
- 每个Partition有多个副本(Replica):Leader(读写) + Follower(同步)
- ISR(In-Sync Replicas):与Leader保持同步的副本集合
Consumer Group:消费者组
- 同组Consumer共同消费Topic所有Partition
- 每个Partition只被组内一个Consumer消费
- 不同组之间互不影响(广播消费)
1. Follower持续从Leader Fetch数据
2. 落后超过replica.lag.time.max.ms(默认10s) → 被踢出ISR
3. Leader故障时只从ISR选举新Leader
4. acks=all = 等待所有ISR副本确认
5. min.insync.replicas=2 → ISR低于此值拒绝写入
@Configuration
public class KafkaProducerConfig {
@Bean
public ProducerFactory<String, String> producerFactory() {
Map<String, Object> props = new HashMap<>();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
"192.168.1.100:9092,192.168.1.101:9092,192.168.1.102:9092");
// === 可靠性三件套 ===
props.put(ProducerConfig.ACKS_CONFIG, "all"); // 等所有ISR确认
props.put(ProducerConfig.RETRIES_CONFIG, Integer.MAX_VALUE); // 无限重试
props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true); // 幂等ProducerID+SeqNo去重
// === 性能优化 ===
props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); // 批量发送16KB
props.put(ProducerConfig.LINGER_MS_CONFIG, 10); // 等待10ms凑批
props.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "lz4"); // lz4压缩
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
return new DefaultKafkaProducerFactory<>(props);
}
@Bean
public KafkaTemplate<String, String> kafkaTemplate() {
return new KafkaTemplate<>(producerFactory());
}
}
@Service
@Slf4j
public class OrderMessageProducer {
@Autowired private KafkaTemplate<String, String> kafkaTemplate;
// 方式1:异步发送(推荐,性能最好)
public void sendAsync(OrderEvent event) {
kafkaTemplate.send("topic-order", String.valueOf(event.getOrderId()),
JSON.toJSONString(event))
.addCallback(
result -> log.info("发送成功: partition={}, offset={}",
result.getRecordMetadata().partition(),
result.getRecordMetadata().getOffset()),
ex -> log.error("发送失败: orderId={}", event.getOrderId(), ex)
);
}
// 方式2:同步发送(金融/订单等关键业务)
public void sendSync(OrderEvent event) throws Exception {
SendResult<String, String> result = kafkaTemplate
.send("topic-order", String.valueOf(event.getOrderId()),
JSON.toJSONString(event))
.get(5, TimeUnit.SECONDS);
log.info("同步发送成功: offset={}", result.getRecordMetadata().getOffset());
}
// 方式3:事务发送(Exactly-Once)
public void sendInTransaction(OrderEvent event) {
kafkaTemplate.executeInTransaction(ops -> {
ops.send("topic-order", String.valueOf(event.getOrderId()),
JSON.toJSONString(event));
ops.send("topic-order-audit", String.valueOf(event.getOrderId()),
JSON.toJSONString(new AuditEvent(event)));
return true;
});
}
}
@Configuration
@EnableKafka
public class KafkaConsumerConfig {
@Bean
public ConsumerFactory<String, String> consumerFactory() {
Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
"192.168.1.100:9092,192.168.1.101:9092,192.168.1.102:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG, "order-service-group");
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
// 手动提交offset(生产必须关闭自动提交)
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
// Rebalance防护
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 25000); // 心跳超时
props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 8000); // 心跳间隔
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 300000); // 两次poll最大间隔
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 50); // 每次poll最大条数
// 静态成员ID(重启不触发Rebalance)
props.put("group.instance.id", System.getenv().getOrDefault("HOSTNAME", "c-1"));
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
return new DefaultKafkaConsumerFactory<>(props);
}
@Bean
public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
factory.setConcurrency(3); // 并发数=Partition数
return factory;
}
}
@Service
@Slf4j
public class OrderMessageConsumer {
@Autowired private OrderService orderService;
@KafkaListener(topics = "topic-order", groupId = "order-service-group")
public void consumeOrder(ConsumerRecord<String, String> record, Acknowledgment ack) {
String key = record.key();
long offset = record.offset();
log.info("收到消息: key={}, partition={}, offset={}", key, record.partition(), offset);
try {
OrderEvent event = JSON.parseObject(record.value(), OrderEvent.class);
// 幂等检查:根据orderId+eventType判断是否已处理
String dedupKey = event.getOrderId() + ":" + event.getType();
if (orderService.isProcessed(dedupKey)) {
log.info("消息已处理,跳过: orderId={}", event.getOrderId());
ack.acknowledge();
return;
}
orderService.processOrder(event); // 业务处理
ack.acknowledge(); // 处理成功后提交offset
log.info("消息处理完成: orderId={}", event.getOrderId());
} catch (Exception e) {
log.error("消息处理失败: key={}, offset={}", key, offset, e);
// 不提交offset → 下次重新消费
// 连续失败应由重试机制发到死信队列 topic-order.DLT
}
}
@KafkaListener(topics = "topic-order.DLT", groupId = "order-dlt-group")
public void consumeDeadLetter(ConsumerRecord<String, String> record) {
log.error("死信消息: key={}, value={}, offset={}",
record.key(), record.value(), record.offset());
// 记录DB + 告警 + 人工处理
}
}
Kafka保证:
分区内有序:同一Partition内消息严格按写入顺序消费
跨分区无序:不同Partition之间无法保证顺序
保证同一业务有序:相同key → 相同partition(hash(key) % numPartitions)
同一orderId的消息 → key=orderId → 同一Partition → 有序消费
全局有序:只设1个Partition(牺牲并行度,不推荐)
spring:
kafka:
bootstrap-servers: 192.168.1.100:9092,192.168.1.101:9092,192.168.1.102:9092
producer:
acks: all
retries: 3
properties:
enable.idempotence: true
compression.type: lz4
batch.size: 16384
linger.ms: 10
consumer:
group-id: order-service-group
auto-offset-reset: earliest
enable-auto-commit: false
properties:
session.timeout.ms: 25000
heartbeat.interval.ms: 8000
max.poll.interval.ms: 300000
max.poll.records: 50
group.instance.id: ${HOSTNAME:consumer-1}
listener:
ack-mode: manual_immediate
concurrency: 3
Q1:如何保证消息不丢失?
| 层面 | 措施 | 配置 |
|---|---|---|
| Producer | acks=all + retries + 幂等 | acks=all, retries=MAX, enable.idempotence=true |
| Broker | ISR同步 + 禁止脏选主 | min.insync.replicas=2, unclean.leader.election.enable=false |
| Consumer | 手动提交offset | enable.auto.commit=false + acknowledge() |
Q2:消息顺序性如何保证?
分区内有序,跨分区无序。相同Key → 相同Partition → 分区内有序(推荐)。全局有序需单分区(不推荐)。
Q3:消息重复消费怎么处理?
Kafka只保证at-least-once。处理方案:消费端幂等(去重表/唯一约束/Redis SETNX)| Kafka事务 | 业务层唯一索引。
Q4:如何处理消息积压?
紧急扩容Partition+Consumer | 临时转发到更多分区的Topic | 排查Consumer(GC/死锁/慢SQL)| 临时降级消费逻辑 | 监控Consumer Lag。
Q5:Exactly-Once怎么实现?
幂等Producer + 事务:消费-处理-发送在同一事务中。Consumer设isolation.level=read_committed。限制:只在Kafka内部有效,外部系统需自行幂等。
Q6:Kafka为什么快?
顺序写磁盘 + 零拷贝(sendfile) + 页缓存 + 批量操作 + 分区并行 + 数据压缩(lz4/snappy)。
Q7:Kafka vs RocketMQ
| 维度 | Kafka | RocketMQ |
|---|---|---|
| 单机TPS | 百万级 | 十万级 |
| 顺序消息 | 分区内有序 | 队列有序(原生) |
| 事务消息 | Kafka内部Exactly-Once | 半消息(跨系统) |
| 延迟消息 | 不支持 | 支持(18级) |
| 死信队列 | 需自行实现 | 内置 |
| 适用场景 | 日志/大数据/Flink | 电商/金融/业务消息 |
练习1:Kafka集群搭建
kafka-topics.sh --create --topic topic-order --partitions 3 --replication-factor 2
--bootstrap-server 192.168.1.100:9092
命令行生产者和消费者测试
练习2:Spring Boot Kafka完整实践
配置Producer(acks=all+幂能+lz4)和Consumer(手动提交+静态成员ID)
实现订单消息生产-消费 → 测试相同key顺序性 → 模拟Consumer下线观察Rebalance
练习3:可靠性验证
acks=all + min.insync.replicas=2 → 杀Leader验证不丢失
关闭自动提交 → 不ack重启Consumer验证重新消费
开启幂等Producer → 重试发送验证去重
| 知识点 | 关键内容 |
|---|---|
| 架构 | Broker、Topic、Partition、Replica、ISR、Consumer Group |
| Producer可靠性 | acks=all、retries=MAX、幂等性、lz4压缩 |
| Consumer可靠性 | 手动提交offset、幂等消费、死信队列 |
| 顺序性 | 分区内有序、相同Key同一分区 |
| Rebalance | session.timeout、max.poll.interval、静态成员ID |
| Exactly-Once | 幂等Producer + 事务,仅限Kafka内部 |
| Kafka vs RocketMQ | 大数据选Kafka、业务消息选RocketMQ |