← 返回首页 📚 实战课程
📑 本篇章节导航 (共6章,点击直达)
本节目标(学完能回答的面试题)一、理论篇(30%):Kafka架构与核心概念二、实战篇(40%):Spring Boot Kafka完整代码三、面试模拟篇(20%)四、练习篇(10%)本节小结

P2-05-Kafka核心与实战

本节目标(学完能回答的面试题)

1. Kafka架构组成?Broker、Topic、Partition、Consumer Group的关系?

2. 如何保证消息不丢失?Producer、Broker、Consumer各层面怎么做?

3. 消息顺序性如何保证?

4. Consumer Group的Rebalance机制?怎么避免Rebalance风暴?

5. Kafka和RocketMQ的对比?

6. Exactly-Once语义如何实现?


一、理论篇(30%):Kafka架构与核心概念

1.1 架构总览


                    ┌──────────────┐
                    │  ZooKeeper   │ (或KRaft模式,3.x已移除ZK)
                    │  元数据管理   │
                    └──────┬───────┘
                           │
┌─────────┐    ┌───────────┴───────────┐    ┌─────────┐
│Producer │───→│    Kafka Cluster      │───→│Consumer │
└─────────┘    │  Broker0: P0(L) P1(F) │    │ Group A │
               │  Broker1: P0(F) P1(L) │    └─────────┘
               └───────────────────────┘

1.2 核心概念


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.3 ISR机制


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低于此值拒绝写入

二、实战篇(40%):Spring Boot Kafka完整代码

2.1 Producer可靠性配置


@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());
    }
}

2.2 生产者发送方式


@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;
        });
    }
}

2.3 Consumer配置


@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;
    }
}

2.4 消费者实现(手动提交 + 幂等 + 死信队列)


@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 + 告警 + 人工处理
    }
}

2.5 消息顺序性


Kafka保证:
  分区内有序:同一Partition内消息严格按写入顺序消费
  跨分区无序:不同Partition之间无法保证顺序

保证同一业务有序:相同key → 相同partition(hash(key) % numPartitions)
  同一orderId的消息 → key=orderId → 同一Partition → 有序消费

全局有序:只设1个Partition(牺牲并行度,不推荐)

2.6 Spring Boot YAML总览


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

三、面试模拟篇(20%)

Q1:如何保证消息不丢失?

层面措施配置
Produceracks=all + retries + 幂等acks=all, retries=MAX, enable.idempotence=true
BrokerISR同步 + 禁止脏选主min.insync.replicas=2, unclean.leader.election.enable=false
Consumer手动提交offsetenable.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

维度KafkaRocketMQ
单机TPS百万级十万级
顺序消息分区内有序队列有序(原生)
事务消息Kafka内部Exactly-Once半消息(跨系统)
延迟消息不支持支持(18级)
死信队列需自行实现内置
适用场景日志/大数据/Flink电商/金融/业务消息

四、练习篇(10%)


练习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同一分区
Rebalancesession.timeout、max.poll.interval、静态成员ID
Exactly-Once幂等Producer + 事务,仅限Kafka内部
Kafka vs RocketMQ大数据选Kafka、业务消息选RocketMQ