消息可靠性:生产 ACK、副本与消费幂等提交

消息可靠性:生产 ACK、副本与消费幂等提交

Hello,我是小兔大白糖。 读完能按生产端、Broker、消费端三段拼出至少一次链路,并说明精确一次需幂等与事务边界。

消息可靠性要按生产 ACK、Broker 副本、消费幂等提交三段拼链路;精确一次另需事务/幂等边界。

估计阅读时间:46 分钟

生产 ACK、副本 ISR、消费提交三段合同
生产 ACK、副本 ISR、消费提交三段合同 · 点击查看 SVG 原图

一句话结论是什么?

消息可靠性是指从生产者发出消息到消费者完成处理的全链路过程中,消息既不丢失也不重复,其核心通过生产端 ACK + Broker 副本持久化 + 消费端手动提交 + 全链路幂等来实现 At-Least-Once,并通过事务与幂等生产者组合逼近 Exactly-Once。


1. 这是什么?概念怎么定义

1.1 消息可靠性的三个语义级别

分布式消息系统围绕消息投递语义,定义了三个核心级别:

语义级别含义特点适用场景
At-Most-Once消息最多投递一次,可能丢失吞吐最高,实现最简单日志采集、监控指标,可容忍少量丢失
At-Least-Once消息至少投递一次,不丢失但可能重复吞吐与可靠性平衡,需消费者幂等订单状态变更、风控事件通知
Exactly-Once消息严格只投递一次,既不丢失也不重复实现最复杂,有性能开销资金转账、库存扣减、风控资金冻结

1.2 类比说明

消息可靠性可以类比为快递物流的签收确认流程:

  • At-Most-Once:快递员把包裹放门口就走了,不发短信不打电话。快但容易丢。
  • At-Least-Once:快递员必须打电话让你签收,你没接就反复打。不会丢,但可能重复送。
  • Exactly-Once:快递员打电话,你签收后系统立刻标记"已签收",快递员再次送货时系统提示"已完成"。既不丢也不重复。

在 大型加密货币交易所 这样的金融交易场景中,风控事件的投递必须是 Exactly-Once 语义:一笔可疑交易的风控告警既不能丢失(导致漏风控),也不能重复(导致重复冻结用户资金)。

1.3 为什么需要它(解决了什么问题)

在分布式系统中,网络分区、节点宕机、磁盘故障、进程崩溃是常态。消息系统作为异步解耦的核心基础设施,其可靠性直接影响业务正确性:

  1. 消息丢失:导致状态不一致,风控事件漏处理,交易数据缺失,无法满足审计合规。
  2. 消息重复:导致重复处理,重复扣款、重复发奖、重复冻结资金,引发资损。
  3. 乱序消费:导致状态机跃迁错误,如"已取消"订单被后续"已支付"消息覆盖。

消息可靠性保障的目标,是在不可靠的基础设施上构建可靠的业务语义。


2. 核心原理是什么?

核心原理:可靠性按生产 ACK、Broker 副本、消费提交三段拼;精确一次另加幂等/事务边界。

2.1 消息可靠性全链路保障模型

消息从生产到消费,经过三个关键节点,每个节点都有对应的可靠性保障机制:

┌─────────────────────────────────────────────────────────────────────────────┐
│                        消息可靠性全链路保障                                   │
└─────────────────────────────────────────────────────────────────────────────┘

  ┌──────────────┐         ┌──────────────┐         ┌──────────────┐
  │  生产端      │  ---->  │   Broker     │  ---->  │  消费端      │
  │  Producer    │  Send   │   消息中间件  │  Pull   │  Consumer    │
  └──────────────┘         └──────────────┘         └──────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
  ┌──────────────┐         ┌──────────────┐         ┌──────────────┐
  │ ACK 确认机制  │         │ 副本复制机制  │         │ 手动提交 Offset│
  │ 重试 + 退避   │         │ ISR 同步集合  │         │ 消费确认 ACK  │
  │ 本地事务表    │         │ 刷盘策略 fsync│         │ 死信队列 DLQ  │
  │ 幂等生产者    │         │ Quorum 写入   │         │ 消费幂等校验  │
  └──────────────┘         └──────────────┘         └──────────────┘

2.2 生产端不丢失:ACK 机制与重试策略

生产端的核心风险在于:消息发出后,在到达 Broker 之前网络断开,或 Broker 接收后未持久化就宕机。

Kafka Producer 可靠性三要素:

  1. acks:

    • acks=0:不等待确认,最高吞吐,最易丢失(At-Most-Once)。
    • acks=1:等待 Leader 确认,不等待副本同步。Leader 宕机可能丢失。
    • acks=all:等待 Leader + 所有 ISR(In-Sync Replicas)确认。最可靠。
  2. retries + retry.backoff.ms:发送失败自动重试,配合指数退避避免雪崩。

  3. enable.idempotence=true:开启幂等生产者,Broker 端去重,解决重试导致的重复问题。

RabbitMQ Publisher Confirm:

RabbitMQ 通过 confirm.select 模式实现异步 ACK。Producer 发送消息后等待 Broker 返回 basic.ack 或 basic.nack。未收到确认的消息需重试或记录到本地事务表。

2.3 Broker 端不丢失:副本与持久化

Kafka 的副本机制:

  • Replication Factor:Topic 级别配置,建议生产环境 >= 3。
  • ISR(In-Sync Replicas):与 Leader 保持同步的副本集合。只有 ISR 中的副本全部确认,acks=all 才算成功。
  • min.insync.replicas:最小同步副本数。如果 ISR 数量小于该值,Producer 会收到 NOT_ENOUGH_REPLICAS 异常,拒绝写入,优先保证一致性。
  • 刷盘策略:Kafka 依赖 OS Page Cache,通过 flush.messages 和 flush.ms 控制刷盘频率。极端场景下(OS 崩溃未刷盘)可能丢失少量消息。

RabbitMQ 的镜像队列:

RabbitMQ 通过 Policy 配置镜像队列(ha-mode: all 或 exactly),消息会同步到多个节点。但镜像队列有性能代价,同步复制会增加写入延迟。

2.4 消费端不丢失:手动提交与死信队列

消费端的核心风险:消息拉取后,业务处理完成前消费者宕机,Offset 却已自动提交。

Kafka Consumer 手动提交模式:

  • 关闭 enable.auto.commit=false。
  • 业务处理完成后,调用 consumer.commitSync() 同步提交 Offset。
  • 若处理失败,不提交 Offset,消息会被重新消费(配合幂等避免重复问题)。

RabbitMQ Consumer ACK:

  • 关闭 autoAck=false,业务处理成功后发送 channel.basicAck(deliveryTag, false)。
  • 处理失败时发送 basicNack 或 basicReject,消息重回队列或进入死信队列。

死信队列(DLQ / Dead Letter Queue):

当消息多次消费失败(达到最大重试次数),将其路由到 DLQ,避免无限重试阻塞正常消费,同时保留消息用于人工排查。

2.5 Exactly-Once 实现原理

Exactly-Once 是分布式系统中最难实现的语义,因为网络超时导致"请求是否成功"本质上是不可区分的。

Kafka Exactly-Once(幂等生产者 + 事务):

message reliability pipeline · 图 2
message reliability pipeline · 图 2 · 点击查看 SVG 原图

Kafka 的 Exactly-Once 语义基于两个机制:

  1. 幂等生产者(Idempotent Producer):

    • Broker 为每个 Producer 分配唯一的 PID(Producer ID)。
    • Producer 为每个分区维护单调递增的 Sequence Number。
    • Broker 端缓存 <PID, Partition, SeqNum>,如果收到重复序号直接返回 ACK,实际不写入,从而保证单分区单会话的 Exactly-Once。
  2. 事务(Transactions):

    • Producer 通过 initTransactions() 初始化事务,获得 PID 和 Epoch。
    • beginTransaction() -> 发送消息 -> sendOffsetsToTransaction() -> commitTransaction()。
    • 事务将"消息生产"和"Offset 提交"绑定为原子操作,实现跨分区的 Exactly-Once。
    • 注意:Kafka 的 Exactly-Once 仅限于Kafka 到 Kafka的场景。如果消费端要写入外部系统(MySQL、Redis),仍需配合外部系统的幂等或两阶段提交。

RabbitMQ 的 Exactly-Once 组合方案:

RabbitMQ 本身不提供内置的 Exactly-Once 语义,需要通过组合方案实现:

  1. Publisher Confirm:确保消息到达 Exchange 并路由到 Queue。
  2. Consumer ACK + 手动确认:确保消息处理完成才确认。
  3. 业务层幂等去重表:消息处理前检查 msgId 是否已存在,存在则跳过。
  4. 可选:消息 TTL + 死信队列:处理失败的消息进入 DLQ,人工干预。

2.6 本地事务表(Outbox Pattern)

当业务数据库操作和消息发送需要强一致性时,直接先发消息再写 DB 或先写 DB 再发消息都有风险。Outbox Pattern 通过本地事务表解决:

┌────────────────────────────────────────────────────────────┐
│                        业务服务                             │
│  ┌─────────────────┐          ┌──────────────────────┐    │
│  │  业务操作        │          │  Outbox 表            │    │
│  │  UPDATE orders  │          │  (同库本地事务)        │    │
│  │  SET status='x' │  ┌─────>│  - id                │    │
│  └─────────────────┘  │       │  - aggregate_type    │    │
│         │             │       │  - aggregate_id      │    │
│         └─────────────┘       │  - event_type        │    │
│              同一事务          │  - payload           │    │
│                               │  - created_at        │    │
│                               └──────────────────────┘    │
└────────────────────────────────────────────────────────────┘
                            │
                            │  定时轮询 / CDC (Debezium)
                            ▼
                     ┌──────────────┐
                     │  Message     │
                     │  Broker      │
                     │ (Kafka/Rabbit)│
                     └──────────────┘

核心流程:

  1. 业务操作和 Outbox 记录写入在同一个本地数据库事务中,保证原子性。
  2. 后台进程轮询 Outbox 表,或通过 CDC(Change Data Capture)工具(如 Debezium)监听 Binlog。
  3. 将消息投递到 Broker,投递成功后删除或标记 Outbox 记录。

此模式解决了"业务数据更新与消息发送"的原子性问题,是金融系统中保障消息可靠性的最佳实践。


3. 怎么用?关键代码与配置

3.1 Kafka Producer 可靠性配置(Spring Boot)

@Configuration
public class KafkaProducerConfig {
 
    @Bean
    public ProducerFactory<String, RiskEvent> riskEventProducerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-1:9092,kafka-2:9092,kafka-3:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
 
        // ========== 可靠性核心配置 ==========
        // 1. acks=all: 等待所有 ISR 副本确认
        props.put(ProducerConfig.ACKS_CONFIG, "all");
 
        // 2. 失败重试机制
        props.put(ProducerConfig.RETRIES_CONFIG, Integer.MAX_VALUE); // 无限重试,由 delivery.timeout.ms 控制总超时
        props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 1000);     // 每次重试间隔 1s
        props.put(ProducerConfig.DELIVERY_TIMEOUT_MS_CONFIG, 120000); // 总超时 2 分钟
 
        // 3. 幂等生产者:Broker 端自动去重
        props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);
        // enable.idempotence=true 会自动设置:
        // retries > 0, acks=all, max.in.flight.requests.per.connection=5
 
        // 4. 事务生产者(需要 Exactly-Once 时开启)
        props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "risk-producer-tx-" + UUID.randomUUID());
 
        // 5. 缓冲与批量配置(可靠性 vs 吞吐平衡)
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        props.put(ProducerConfig.LINGER_MS_CONFIG, 5);
        props.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "lz4");
 
        return new DefaultKafkaProducerFactory<>(props);
    }
 
    @Bean
    public KafkaTemplate<String, RiskEvent> riskEventKafkaTemplate(
            ProducerFactory<String, RiskEvent> riskEventProducerFactory) {
        return new KafkaTemplate<>(riskEventProducerFactory);
    }
}

3.2 Kafka 事务生产者:订单状态变更与消息原子性

@Service
@Slf4j
public class OrderRiskService {
 
    private final KafkaTemplate<String, RiskEvent> kafkaTemplate;
    private final OrderRepository orderRepository;
    private final TransactionTemplate transactionTemplate;
 
    // 事务生产者需要在初始化时执行 initTransactions
    @PostConstruct
    public void init() {
        kafkaTemplate.initTransactions();
    }
 
    /**
     * 订单风控标记:更新订单状态 + 发送风控事件,保证原子性
     */
    public void flagOrderAsRisky(String orderId, RiskLevel level) {
        RiskEvent event = RiskEvent.builder()
                .eventId(UUID.randomUUID().toString())
                .orderId(orderId)
                .riskLevel(level)
                .timestamp(Instant.now())
                .build();
 
        kafkaTemplate.executeInTransaction(operations -> {
            // 1. 先发送消息(在事务中)
            operations.send("risk.events", orderId, event);
 
            // 2. 再更新数据库(在同一事务中)
            transactionTemplate.execute(status -> {
                orderRepository.updateRiskStatus(orderId, level, event.getEventId());
                return null;
            });
 
            return true;
        });
    }
}

3.3 Kafka Consumer 手动提交 + 幂等消费

@Configuration
public class KafkaConsumerConfig {
 
    @Bean
    public ConsumerFactory<String, RiskEvent> riskEventConsumerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-1:9092,kafka-2:9092,kafka-3:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "risk-processor-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
        props.put(JsonDeserializer.TRUSTED_PACKAGES, "com.大型加密货币交易所.risk.event");
 
        // ========== 消费端可靠性配置 ==========
        // 关闭自动提交,业务处理完再手动提交
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        // 手动控制每次拉取数量,避免一次拉取太多处理不完导致 Rebalance
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 50);
        // 心跳间隔,避免处理耗时导致 Session 超时
        props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 3000);
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10000);
 
        return new DefaultKafkaConsumerFactory<>(props);
    }
 
    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, RiskEvent> kafkaListenerContainerFactory(
            ConsumerFactory<String, RiskEvent> consumerFactory) {
        ConcurrentKafkaListenerContainerFactory<String, RiskEvent> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        // 手动确认模式
        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
        return factory;
    }
}
 
@Service
@Slf4j
public class RiskEventProcessor {
 
    private final RiskRuleEngine ruleEngine;
    private final IdempotencyService idempotencyService;
 
    @KafkaListener(topics = "risk.events", groupId = "risk-processor-group",
                   containerFactory = "kafkaListenerContainerFactory")
    public void onRiskEvent(ConsumerRecord<String, RiskEvent> record, Acknowledgment ack) {
        RiskEvent event = record.value();
        String msgId = event.getEventId();
 
        try {
            // 1. 幂等校验:检查该消息是否已处理
            if (idempotencyService.isProcessed(msgId)) {
                log.warn("Duplicate message detected, skipping. msgId={}", msgId);
                ack.acknowledge(); // 重复消息也要提交 Offset,避免阻塞
                return;
            }
 
            // 2. 业务处理:执行风控规则引擎
            ruleEngine.evaluate(event);
 
            // 3. 标记消息已处理(幂等表写入)
            idempotencyService.markAsProcessed(msgId, event.getOrderId());
 
            // 4. 业务成功,手动提交 Offset
            ack.acknowledge();
            log.info("Risk event processed successfully. msgId={}, partition={}, offset={}",
                    msgId, record.partition(), record.offset());
 
        } catch (Exception e) {
            log.error("Failed to process risk event. msgId={}, will retry", msgId, e);
            // 不调用 ack.acknowledge(),消息会被重新投递
            // 配合死信队列策略,超过重试次数后进入 DLQ
            throw e;
        }
    }
}

3.4 RabbitMQ Publisher Confirm + Consumer ACK + DLX 配置

@Configuration
@Slf4j
public class RabbitRiskConfig {
 
    public static final String RISK_EXCHANGE = "risk.exchange";
    public static final String RISK_QUEUE = "risk.queue";
    public static final String RISK_DLX_EXCHANGE = "risk.dlx.exchange";
    public static final String RISK_DLQ = "risk.dlq";
    public static final String RISK_ROUTING_KEY = "risk.event";
 
    @Bean
    public DirectExchange riskExchange() {
        return new DirectExchange(RISK_EXCHANGE, true, false);
    }
 
    @Bean
    public DirectExchange riskDlxExchange() {
        return new DirectExchange(RISK_DLX_EXCHANGE, true, false);
    }
 
    @Bean
    public Queue riskQueue() {
        return QueueBuilder.durable(RISK_QUEUE)
                // 死信交换机配置
                .withArgument("x-dead-letter-exchange", RISK_DLX_EXCHANGE)
                .withArgument("x-dead-letter-routing-key", "risk.failed")
                // 队列消息 TTL(可选)
                .withArgument("x-message-ttl", 300000) // 5 分钟未消费则进入死信
                .build();
    }
 
    @Bean
    public Queue riskDlq() {
        return QueueBuilder.durable(RISK_DLQ).build();
    }
 
    @Bean
    public Binding riskBinding() {
        return BindingBuilder.bind(riskQueue()).to(riskExchange()).with(RISK_ROUTING_KEY);
    }
 
    @Bean
    public Binding riskDlqBinding() {
        return BindingBuilder.bind(riskDlq()).to(riskDlxExchange()).with("risk.failed");
    }
 
    // ========== Publisher Confirm 配置 ==========
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        template.setExchange(RISK_EXCHANGE);
        template.setRoutingKey(RISK_ROUTING_KEY);
        template.setMessageConverter(new Jackson2JsonMessageConverter());
 
        // 开启 Publisher Confirm
        template.setConfirmCallback((correlationData, ack, cause) -> {
            if (ack) {
                log.debug("Message confirmed by broker. id={}",
                        correlationData != null ? correlationData.getId() : "N/A");
            } else {
                log.error("Message NACK by broker. id={}, cause={}",
                        correlationData != null ? correlationData.getId() : "N/A", cause);
                // 进入补偿流程:写入本地重试表或告警
            }
        });
 
        // 开启 Return 回调(消息不可路由时触发)
        template.setReturnsCallback(returned -> {
            log.error("Message returned. exchange={}, routingKey={}, replyCode={}, replyText={}",
                    returned.getExchange(), returned.getRoutingKey(),
                    returned.getReplyCode(), returned.getReplyText());
        });
 
        // mandatory=true 确保不可路由时触发 ReturnCallback,而不是静默丢弃
        template.setMandatory(true);
 
        return template;
    }
 
    // ========== Consumer 配置(手动 ACK) ==========
    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
            ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        // 手动 ACK 模式
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        // 预取数量,避免单个消费者堆积过多未确认消息
        factory.setPrefetchCount(10);
        // 失败重试:本地重试 3 次后进入 DLQ
        factory.setRetryTemplate(new RetryTemplate());
        factory.setDefaultRequeueRejected(false);
        return factory;
    }
}
@Service
@Slf4j
public class RabbitRiskConsumer {
 
    private final RiskRuleEngine ruleEngine;
    private final IdempotencyService idempotencyService;
 
    @RabbitListener(queues = RabbitRiskConfig.RISK_QUEUE,
                    containerFactory = "rabbitListenerContainerFactory")
    public void onRiskEvent(RiskEvent event, Message message, Channel channel) throws IOException {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        String msgId = message.getMessageProperties().getMessageId();
        if (msgId == null) {
            msgId = event.getEventId(); // fallback
        }
 
        try {
            // 幂等校验
            if (idempotencyService.isProcessed(msgId)) {
                log.warn("Duplicate RabbitMQ message, acking. msgId={}", msgId);
                channel.basicAck(deliveryTag, false);
                return;
            }
 
            // 业务处理
            ruleEngine.evaluate(event);
 
            // 标记已处理
            idempotencyService.markAsProcessed(msgId, event.getOrderId());
 
            // 手动确认
            channel.basicAck(deliveryTag, false);
            log.info("RabbitMQ message processed. msgId={}", msgId);
 
        } catch (Exception e) {
            log.error("Failed to process RabbitMQ message. msgId={}, deliveryTag={}", msgId, deliveryTag, e);
 
            // 拒绝消息,不重新入队,直接进入死信队列
            channel.basicNack(deliveryTag, false, false);
        }
    }
}

3.5 幂等去重表实现(MySQL + Redis 双保险)

@Service
@Slf4j
public class IdempotencyService {
 
    private final StringRedisTemplate redisTemplate;
    private final IdempotencyRepository idempotencyRepository;
 
    private static final String IDEMPOTENCY_KEY_PREFIX = "idempotency:";
    private static final long REDIS_TTL_HOURS = 48; // Redis 保留 48 小时
 
    /**
     * 检查消息是否已处理
     * 先查 Redis(高性能),再查 MySQL(持久化兜底)
     */
    public boolean isProcessed(String msgId) {
        String redisKey = IDEMPOTENCY_KEY_PREFIX + msgId;
 
        // 1. 查 Redis
        String cached = redisTemplate.opsForValue().get(redisKey);
        if ("1".equals(cached)) {
            return true;
        }
 
        // 2. 查 MySQL(冷数据或 Redis 过期)
        boolean exists = idempotencyRepository.existsByMsgId(msgId);
        if (exists) {
            // 回填 Redis
            redisTemplate.opsForValue().set(redisKey, "1", REDIS_TTL_HOURS, TimeUnit.HOURS);
        }
        return exists;
    }
 
    /**
     * 标记消息已处理
     * 先写 MySQL(持久化),再写 Redis(加速查询)
     */
    @Transactional
    public void markAsProcessed(String msgId, String bizId) {
        try {
            IdempotencyRecord record = IdempotencyRecord.builder()
                    .msgId(msgId)
                    .bizId(bizId)
                    .createdAt(LocalDateTime.now())
                    .build();
            idempotencyRepository.save(record);
 
            // 异步写入 Redis,失败不影响主流程
            String redisKey = IDEMPOTENCY_KEY_PREFIX + msgId;
            redisTemplate.opsForValue().set(redisKey, "1", REDIS_TTL_HOURS, TimeUnit.HOURS);
 
        } catch (DuplicateKeyException e) {
            // 唯一索引冲突,说明已处理,忽略
            log.warn("Idempotency key conflict, msgId already processed. msgId={}", msgId);
        }
    }
}
-- 幂等去重表 DDL
CREATE TABLE idempotency_record (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    msg_id VARCHAR(64) NOT NULL COMMENT '消息唯一标识',
    biz_id VARCHAR(64) NOT NULL COMMENT '业务单号,便于排查',
    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    UNIQUE KEY uk_msg_id (msg_id),
    KEY idx_biz_id (biz_id),
    KEY idx_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='消息幂等去重表';

3.6 本地事务表(Outbox Pattern)实现

@Entity
@Table(name = "outbox_event")
@Data
@Builder
public class OutboxEvent {
    @Id
    private String id;
    private String aggregateType; // 如 "Order"
    private String aggregateId;   // 如订单号
    private String eventType;     // 如 "OrderRiskFlagged"
    @Column(columnDefinition = "JSON")
    private String payload;       // 事件 JSON  payload
    private LocalDateTime createdAt;
    private boolean published;    // 是否已发布
    private LocalDateTime publishedAt;
}
 
@Service
@Slf4j
public class OrderService {
 
    private final OrderRepository orderRepository;
    private final OutboxRepository outboxRepository;
 
    /**
     * 订单风控标记:使用 Outbox Pattern 保证 DB 更新和消息原子性
     */
    @Transactional
    public void flagOrderRisky(String orderId, RiskLevel level) {
        // 1. 更新订单状态
        orderRepository.updateRiskStatus(orderId, level);
 
        // 2. 构造事件
        RiskEvent event = RiskEvent.builder()
                .eventId(UUID.randomUUID().toString())
                .orderId(orderId)
                .riskLevel(level)
                .timestamp(Instant.now())
                .build();
 
        // 3. 写入 Outbox 表(与订单更新在同一事务中)
        OutboxEvent outbox = OutboxEvent.builder()
                .id(event.getEventId())
                .aggregateType("Order")
                .aggregateId(orderId)
                .eventType("OrderRiskFlagged")
                .payload(JsonUtils.toJson(event))
                .createdAt(LocalDateTime.now())
                .published(false)
                .build();
        outboxRepository.save(outbox);
    }
}
 
@Component
@Slf4j
public class OutboxPoller {
 
    private final OutboxRepository outboxRepository;
    private final KafkaTemplate<String, String> kafkaTemplate;
 
    /**
     * 每 5 秒轮询一次 Outbox 表,投递未发布的消息
     */
    @Scheduled(fixedDelay = 5000)
    public void pollAndPublish() {
        List<OutboxEvent> unpublished = outboxRepository.findTop100ByPublishedFalseOrderByCreatedAtAsc();
 
        for (OutboxEvent event : unpublished) {
            try {
                kafkaTemplate.send("risk.events", event.getAggregateId(), event.getPayload())
                        .whenComplete((result, ex) -> {
                            if (ex == null) {
                                // 投递成功,标记为已发布
                                outboxRepository.markAsPublished(event.getId());
                                log.info("Outbox event published. id={}", event.getId());
                            } else {
                                log.error("Failed to publish outbox event. id={}", event.getId(), ex);
                                // 下次轮询重试
                            }
                        });
            } catch (Exception e) {
                log.error("Exception publishing outbox event. id={}", event.getId(), e);
            }
        }
    }
}

3.7 完整可运行的 Demo:资金变动消息全链路保障

/**
 * 场景:用户提现后,需要发送资金变动消息到风控系统。
 * 要求:
 * 1. 提现记录更新和消息发送原子性(Outbox)
 * 2. 消息不丢失(Kafka acks=all + 重试)
 * 3. 消息不重复(消费端幂等表)
 * 4. 消费失败可追踪(DLQ)
 */
 
// ============ 生产端 ============
@Service
public class WithdrawalService {
 
    @Transactional
    public void processWithdrawal(String userId, BigDecimal amount) {
        String withdrawalId = UUID.randomUUID().toString();
 
        // 1. 创建提现记录
        withdrawalRepository.insert(Withdrawal.builder()
                .id(withdrawalId)
                .userId(userId)
                .amount(amount)
                .status("PROCESSING")
                .build());
 
        // 2. 写入 Outbox(保证原子性)
        FundChangeEvent event = FundChangeEvent.builder()
                .eventId(UUID.randomUUID().toString())
                .withdrawalId(withdrawalId)
                .userId(userId)
                .amount(amount)
                .type("WITHDRAWAL")
                .timestamp(Instant.now())
                .build();
 
        outboxRepository.save(OutboxEvent.builder()
                .id(event.getEventId())
                .aggregateType("Withdrawal")
                .aggregateId(withdrawalId)
                .eventType("FundChange")
                .payload(JsonUtils.toJson(event))
                .createdAt(LocalDateTime.now())
                .published(false)
                .build());
    }
}
 
// ============ 消费端 ============
@Service
public class FundChangeProcessor {
 
    private final RiskAlertService riskAlertService;
    private final IdempotencyService idempotencyService;
 
    @KafkaListener(topics = "fund.change", groupId = "risk-group")
    public void onFundChange(ConsumerRecord<String, FundChangeEvent> record, Acknowledgment ack) {
        FundChangeEvent event = record.value();
 
        try {
            if (idempotencyService.isProcessed(event.getEventId())) {
                ack.acknowledge();
                return;
            }
 
            // 风控检测:大额提现触发人工审核
            if (event.getAmount().compareTo(new BigDecimal("100000")) > 0) {
                riskAlertService.triggerManualReview(event);
            }
 
            idempotencyService.markAsProcessed(event.getEventId(), event.getWithdrawalId());
            ack.acknowledge();
 
        } catch (Exception e) {
            log.error("Fund change processing failed. eventId={}", event.getEventId(), e);
            throw e; // 不提交 Offset,进入重试/DLQ
        }
    }
}

4. 业界怎么做?

4.1 阿里巴巴:电商交易消息可靠性保障

阿里巴巴的电商核心链路(下单、支付、履约)对消息可靠性要求极高。他们在 Kafka 的基础上构建了名为MetaQ / RocketMQ的消息中间件,并发展出一整套消息可靠性方案:

技术实现:

  1. 同步双写 + 异步复制:Broker 主从同步复制,消息写入 Master 后同步到 Slave 才返回成功。
  2. 事务消息(Half Message):RocketMQ 的事务消息机制是 Outbox Pattern 的中间件级实现:
    • Producer 先发送 Half Message(对消费者不可见)。
    • 执行本地事务(如创建订单)。
    • 根据本地事务结果提交或回滚 Half Message。
    • Broker 提供回查机制,若 Producer 本地事务状态未知,Broker 主动回查 Producer。
  3. 消费端幂等:所有消费端必须实现幂等,通过 uniq_msg_id + 业务主键去重。
  4. 消息轨迹(Message Trace):全链路追踪消息从生产到消费的每个节点,用于排查消息丢失。

踩过的坑:

  • 2015 年双 11:某集群因磁盘故障导致部分消息丢失,后续引入同步刷盘选项(flushDiskType=SYNC_FLUSH),牺牲部分写入性能换取更高可靠性。
  • 消费堆积导致 Rebalance 雪崩:消费者处理慢导致频繁 Rebalance,进一步降低消费速度。后续优化为增量 Rebalance + 静态成员(Static Membership),减少不必要的分区重分配。

4.2 LinkedIn:Kafka 的诞生与 Exactly-Once 演进

LinkedIn 是 Kafka 的诞生地,其日志聚合、用户行为追踪、实时推荐系统都重度依赖 Kafka。他们对消息可靠性的实践直接塑造了 Kafka 的核心设计:

技术实现:

  1. 日志持久化(Log Compaction):LinkedIn 的用户画像更新、配置变更等场景使用 Log Compaction Topic,保留每个 Key 的最新值,确保即使消费者重启也能恢复到正确状态。
  2. Exactly-Once Stream Processing:LinkedIn 开发了 Kafka Streams,并在 0.11 版本中推动 Kafka 引入了幂等生产者 + 事务 API。其流处理作业通过事务保证"消费-处理-生产"的原子性:
    • 从输入 Topic 消费消息。
    • 处理并生成输出到下游 Topic。
    • 将消费 Offset 和输出消息在同一事务中提交。
  3. Multi-DC Replication(MirrorMaker 2):LinkedIn 跨数据中心复制使用 MirrorMaker 2,基于 Kafka Connect 框架,支持 Exactly-Once 语义的数据同步。

踩过的坑:

  • Producer 重试导致数据重复:早期 Kafka 缺乏幂等机制,Producer 重试会导致消息重复写入。LinkedIn 的实时推荐系统曾因重复消息导致用户推荐结果异常膨胀,后推动社区实现了幂等生产者(PID + Sequence Number)。
  • 事务超时导致消费者停滞:Kafka 事务有超时时间(transaction.timeout.ms),如果一个事务迟迟不提交,其他消费者无法读取该事务生成的消息(消费者隔离级别 read_committed)。LinkedIn 的某实时报表作业因处理逻辑死循环导致事务超时,下游消费者长时间无数据,后引入事务超时监控和自动中断机制。

5. 业务场景怎么对照?

5.1 风控 / Risk 场景如何应用

在 大型加密货币交易所 这类加密货币交易所的风控系统中,消息可靠性直接关系到资金安全与合规审计:

场景一:交易流水消息绝不能丢失(审计合规)

  • 要求:每笔交易的流水必须发送到审计系统,满足监管要求。
  • 方案:Kafka acks=all + min.insync.replicas=2 + Outbox Pattern + 消费端幂等表。
  • 关键:不允许使用 acks=1 或异步无确认发送。Broker 必须配置至少 3 副本,最小同步副本为 2。

场景二:风控规则触发消息不能重复执行(避免重复冻结资金)

  • 要求:同一笔可疑交易的风控告警只能触发一次资金冻结。
  • 方案:消费端幂等去重表(Redis + MySQL 双保险)+ 风控动作本身的幂等设计(如"已冻结则跳过")。
  • 关键:不能仅靠消息系统的 Exactly-Once,因为 Kafka 的 Exactly-Once 只覆盖 Kafka 内部。写入外部系统(如冻结用户账户的 API)必须业务层幂等。

场景三:告警通知必须 Exactly-Once(避免漏报或误报)

  • 要求:重大风险事件(如大额异常转账)的告警既不能漏发,也不能重复轰炸值班人员。
  • 方案:RabbitMQ Publisher Confirm + Consumer ACK + 业务层去重表 + 告警系统的"同事件合并窗口"(如 5 分钟内同一事件只发一次)。
  • 关键:消息层面保证 At-Least-Once,告警系统层面通过时间窗口和事件 ID 去重实现 Exactly-Once 体验。

场景四:资金变动消息的全链路追踪与对账

  • 要求:资金变动消息从生产到消费的全链路可追踪,且能与数据库状态对账。
  • 方案:
    1. 消息中携带全局 Trace ID(如 OpenTelemetry Trace ID)。
    2. 生产端将消息 ID 写入业务表(如 withdrawal.msg_id)。
    3. 消费端将处理结果写入对账表。
    4. 每日对账任务扫描:业务表中有 msg_id 但对账表无记录的消息,判定为丢失或处理失败。

5.2 常见误区 vs 正确做法

误区正确做法
开启 enable.auto.commit=true,依赖自动提交保证不丢失关闭自动提交,业务处理成功后手动提交。自动提交可能在处理失败前提交 Offset,导致消息丢失。
认为 Kafka 的 Exactly-Once 可以覆盖外部系统Kafka Exactly-Only 仅保证 Kafka 内部语义。消费端写入 MySQL / Redis 仍需业务层幂等。
消息重试时不限制重试次数,导致无限循环设置最大重试次数(如 5 次),超限后进入 DLQ,避免阻塞正常消费。
只用 Redis 做幂等,不持久化到数据库Redis 可能丢数据或过期,关键业务(资金类)必须持久化到数据库。
认为 acks=all 就万事大吉acks=all 配合 min.insync.replicas 才有效。如果 ISR 只剩 Leader,acks=all 退化为 acks=1。
消息堆积时直接扩容消费者先分析堆积原因(消费慢 / 生产突增 / 分区不足)。盲目扩容可能因 Rebalance 加剧问题。

5.3 选型建议

When to use Kafka:

  • 高吞吐日志采集、用户行为追踪(百万级 TPS)。
  • 需要长时间消息保留(数天到数周)用于回放和回溯。
  • 流处理场景(Kafka Streams / Flink),需要 Exactly-Once 语义。
  • 团队有运维 Kafka 集群的能力。

When to use RabbitMQ:

  • 需要复杂路由(Topic、Header、Fanout)。
  • 需要延迟队列、优先级队列、死信队列等高级特性。
  • 消息量中等(万级 TPS),但对可靠性要求极高。
  • 需要快速上手,运维成本低。

When NOT to use 消息队列:

  • 要求强实时一致性(< 10ms):消息队列有天然延迟,考虑 RPC 或共享内存。
  • 消息体过大(> 10MB):消息队列不适合传输大文件,考虑对象存储 + 消息通知。
  • 简单的点对点通知:考虑 WebSocket 或 SSE。

6. 高频问题怎么答?

Q1: Kafka 的 Exactly-Once 是如何实现的?有没有局限性?

答:Kafka 的 Exactly-Once 由两部分组成:

  1. 幂等生产者:Broker 为每个 Producer 分配 PID,Producer 为每个分区维护 Sequence Number。Broker 端缓存已接收的 <PID, Partition, SeqNum>,拒绝重复写入。
  2. 事务 API:通过 initTransactions() 获取 PID 和 Epoch,将消息生产和 Offset 提交绑定为原子事务。

局限性:

  • 仅覆盖 Kafka 内部语义(Producer -> Broker -> Consumer within Kafka)。
  • 消费端如果写入外部系统(MySQL、Redis),需要配合外部系统的幂等或两阶段提交。
  • 事务有性能开销(约 10-20% 吞吐下降)。
  • 跨分区的 Exactly-Once 依赖事务协调器,可能因协调器故障导致事务挂起。

Q2: RabbitMQ 的镜像队列有什么缺点?什么场景下不适合使用?

答:RabbitMQ 镜像队列(Mirrored Queues)将所有消息同步复制到多个节点,提高了可用性但带来以下问题:

  1. 写入性能下降:所有镜像节点确认后才返回 ACK,同步复制增加延迟。在跨机房部署时尤其明显。
  2. 脑裂风险:网络分区时,RabbitMQ 可能选择错误的 Master,导致消息不一致。
  3. 扩展性受限:镜像队列的所有镜像都存储完整数据,无法像 Kafka 的分区那样水平扩展。

不适合场景:

  • 超高吞吐(> 数万 TPS)的日志采集。
  • 跨地域多活部署,同步复制延迟不可接受。
  • 消息体很大,复制开销高。

RabbitMQ 3.8+ 引入了Quorum Queues作为替代,基于 Raft 共识算法,在一致性和性能之间取得更好平衡。

Q3: 消费端幂等的最佳实践是什么?如何防止幂等表无限膨胀?

答:

最佳实践:

  1. 唯一标识:消息必须携带全局唯一 ID(如 UUID),由生产端生成。
  2. 去重表:数据库表以 msg_id 为唯一索引,INSERT IGNORE 或 ON DUPLICATE KEY UPDATE。
  3. Redis 加速:热数据查 Redis,冷数据查数据库,Redis 设置合理 TTL。
  4. 业务层兜底:即使消息重复,业务操作本身也应该是幂等的(如 UPDATE balance SET frozen=frozen+100 WHERE order_id='x' AND frozen_status='unfrozen')。

防止幂等表膨胀:

  1. 定期归档:将超过 30 天的记录迁移到冷存储(如 Hive / S3)。
  2. 分表分库:按时间或 Hash 分片,避免单表过大。
  3. TTL + 压缩:若使用 Redis 集群,配置合理的过期策略;若使用 Cassandra / TiDB,利用 TTL 自动过期。

Q4: 本地事务表(Outbox Pattern)和 Kafka 事务有什么区别?什么时候用哪个?

答:

维度Outbox PatternKafka 事务(Transaction API)
一致性范围业务 DB 和 Outbox 表(同一数据库)Kafka 内部(Producer + Consumer Offset)
外部系统支持天然支持写入外部 DB不支持外部系统
复杂度需额外开发轮询或 CDC中间件原生支持
延迟取决于轮询间隔(秒级)毫秒级
适用场景微服务架构,业务数据在 MySQL/PostgreSQL纯 Kafka 生态内的流处理

选型建议:

  • 如果业务状态存储在 MySQL,且需要通知其他服务 -> Outbox Pattern。
  • 如果是 Kafka Streams 作业,消费 Kafka Topic 处理后产出到另一个 Kafka Topic -> Kafka 事务。
  • 也可以组合使用:Outbox 写入 Kafka,下游 Kafka 作业使用 Kafka 事务。

Q5: 消息堆积时如何保证不丢失?除了扩容还有什么手段?

答:消息堆积时的处理策略:

  1. 定位根因:

    • 生产端突增?检查是否有流量异常或活动峰值。
    • 消费端变慢?检查下游依赖(DB、API)是否响应延迟。
    • 消费者数量不足?检查分区数与消费者数的比例。
  2. 紧急消费加速:

    • 临时增加消费者:确保消费者数 <= 分区数,否则多余的消费者空闲。
    • 降级处理:非核心消息直接 ACK 跳过,后续离线补偿。
    • 批量处理:增大 max.poll.records,减少网络往返。
  3. 防止堆积导致丢失:

    • Kafka:调整 retention.ms 和 retention.bytes,确保消息保留时间足够。若磁盘满,Broker 可能拒绝写入或删除旧消息。
    • RabbitMQ:设置 max-length 或 max-length-bytes 超限策略为 reject-publish(拒绝新消息)而非 drop-head(丢弃队头)。
  4. 监控与告警:

    • 监控 consumer lag(Kafka)或 ready / unacked 消息数(RabbitMQ)。
    • 设置 Lag 阈值告警,在堆积初期介入。

Q6: 如果 Kafka Broker 的 Leader 和 Follower 都挂了,消息会丢失吗?

答:取决于配置:

  • 若 acks=all 且 min.insync.replicas=2(假设副本数=3),当 ISR 中只剩一个节点且该节点也挂了,Producer 会收到 NOT_ENOUGH_REPLICAS 异常,拒绝写入,消息不会丢失(但可用性下降)。
  • 若 acks=1,Leader 确认后未同步到 Follower 就挂了,消息丢失。
  • 若 acks=all 但 unclean.leader.election.enable=true(允许非 ISR 节点成为 Leader),可能选举一个落后的副本为 Leader,导致已确认的消息丢失(生产环境必须关闭此选项)。

Q7: 在跨机房部署时,如何保障消息可靠性?

答:

  1. Kafka:

    • 使用 MirrorMaker 2 或 Confluent Replicator 进行跨集群复制。
    • 生产端优先写入本地机房集群,异步复制到异地。
    • 避免跨机房同步写入(延迟高),采用异步复制 + 冲突检测。
  2. RabbitMQ:

    • 使用 Federation 或 Shovel 插件进行跨机房消息路由。
    • 镜像队列不推荐跨机房(同步复制延迟不可接受)。
  3. 通用:

    • 消息携带数据中心标识,避免循环复制。
    • 消费端实现幂等,应对可能的重复复制。

Q8: 消息系统的可靠性测试应该怎么做?

答:

  1. 故障注入(Chaos Engineering):

    • 随机 Kill Broker 节点,验证副本切换和消息不丢失。
    • 网络分区测试:隔离 Leader 与 Follower,验证是否拒绝写入或正确选举。
  2. 压力测试:

    • 持续高吞吐写入,观察磁盘、内存、网络瓶颈。
    • 消费端故意减速,验证堆积后是否正常恢复。
  3. 数据一致性校验:

    • 生产端记录所有发送消息的 ID。
    • 消费端记录所有处理消息的 ID。
    • 对账:发送集合 vs 处理集合,差集即为丢失或重复。
  4. 灰度验证:

    • 新配置(如调整 min.insync.replicas)先在灰度集群验证,再全量推广。

Q9: 为什么金融场景的消息可靠性不能仅靠消息中间件,必须业务层配合?

答:消息中间件(Kafka、RabbitMQ)的可靠性是有边界的:

  1. 边界在于中间件自身:Kafka Exactly-Once 只保证 Kafka 内部。一旦消息离开 Kafka,进入业务代码、写入 MySQL、调用外部 API,中间件无法约束。
  2. 网络超时不可区分:发送方不知道消息是成功但未收到 ACK,还是真的失败了。重试必然导致重复的可能性。
  3. 业务语义复杂:"扣款一次"的业务幂等不等于"消息消费一次"。例如,消息消费成功但扣款接口超时,业务上需要重试扣款,但不应重复发送通知。
  4. 端到端原则:可靠性必须由发送端、传输层、接收端、业务层共同保障,任何单一层次都无法独立完成。

Q10: Kafka 的 min.insync.replicas 和 acks=all 配合使用有什么陷阱?

答:

  • acks=all 要求所有 ISR 副本确认,但"所有"的数量由 ISR 集合大小决定。
  • 若 min.insync.replicas=2,正常情况下 ISR 有 3 个节点,需要 2 个确认。
  • 但如果 2 个 Follower 落后被踢出 ISR,ISR 只剩 Leader(1 个节点),此时 acks=all 只需 Leader 确认就返回成功,退化为 acks=1。
  • 陷阱:设置 min.insync.replicas 但不监控 ISR 大小,可能在 ISR 缩小时意外降低可靠性。
  • 正确做法:监控 UnderReplicatedPartitions 和 ISR Shrinks 指标,配合告警。关键业务设置 min.insync.replicas=2 + 副本数=3,并确保 Broker 故障时快速恢复副本同步。

一、生产者端 丢消息 / 重复 应对

1. 丢消息场景

  • acks=0:发完直接返回,不管 Broker 是否落盘,极易丢

  • acks=1:只写到 leader 就返回,leader 宕机未同步副本就丢

  • 异步发送无回调、无重试,异常直接吞掉

  • 网络闪断、缓冲区满、拦截器异常未捕获

解决方案

  1. 事务业务场景(风控 / 订单)

    spring.kafka.producer.acks=all
    spring.kafka.producer.retries=3
    spring.kafka.producer.transaction-id-prefix=tx-
    1. acks=all:等待所有 ISR 副本落盘成功才返回

    2. 开启重试,网络抖动自动重发

  2. 发送方式规范

    1. 重要业务:同步发送 + get () 阻塞等待结果,失败主动抛异常

    2. 普通业务:异步发送必须加回调监听,失败本地落库重试

  3. 本地消息表兜底 业务入库 + 写入本地消息状态表 → 发送 Kafka → 回调更新状态 定时任务扫描发送失败状态重推,彻底杜绝生产者丢消息

2. 生产者重复投递

  • 原因:重试发送、事务回滚重发、业务重试

  • 应对:

    • 业务生成全局唯一业务 ID(orderId/eventId)

    • 消费端做幂等(Redis 判重、数据库唯一索引)


二、Broker 集群端 丢消息应对

1. 丢失原因

  • 副本数 = 1、ISR 集合只剩 leader,leader 宕机数据丢失

  • 磁盘故障、日志刷盘策略不合理

  • 集群扩容 / 缩容、分区迁移丢数据

最优配置防丢

  1. 分区副本数至少 2,生产建议 replication-factor=2~3

  2. 保证 ISR 列表至少 2 个节点在线

  3. 刷盘策略调优(高可靠)

    # 每条消息立即刷盘(极致可靠,性能略降)
    log.flush.interval.messages=1
  4. 禁用不安全集群配置 关闭 unclean.leader.election.enable=false 杜绝从非 ISR 副本选主导致数据丢失

核心结论

acks=all + 副本≥2 + ISR 正常 = Broker 层面几乎不可能丢消息


三、消费者端 丢消息 / 重复消费 应对

1. 消费端丢消息根源

先提交 Offset,后执行业务

  • 自动提交 offset、批量定时提交

  • 业务还没处理完,offset 已经提交,重启直接跳过消息

杜绝丢消息方案

  1. 关闭自动提交

    enable-auto-commit: false
  2. 统一流程: 拉取消息 → 执行业务逻辑成功 → 手动提交 offset

  3. 消费失败不提交 offset,下次重启自动重新消费

2. 消费端重复投递根源

  • 业务处理成功,提交 offset 时网络异常,Broker 没收到 ack

  • 消费者重平衡、宕机重启,未提交 offset 重新拉取

  • 生产者重试、事务重试

去重幂等方案

  1. 唯一 ID 幂等(最通用) 以 eventId/orderId 为 key 存入 Redis,处理前判断是否已消费

  2. 数据库唯一约束 业务表用业务唯一键,重复插入直接报错忽略

  3. 状态机控制 消息状态:待处理→处理中→处理完成,防止重复执行


四、全链路防丢防重总结

环节丢失原因解决手段
生产者acks 低、无重试、异步无回调acks=all + 重试 + 本地消息表 + 同步等待结果
Broker副本少、ISR 不足、非法选主副本≥2、关闭脏选主、合理刷盘
消费者先提交 offset 后业务手动提交 offset、业务成功再 ack

重复统一解决:全局唯一 ID + 消费端幂等


五、死信队列 DLQ 通俗讲解

1. 什么是死信队列

正常消息:正常消费 → 成功提交 offset 死信消息: 一条消息多次重试消费一直失败(数据异常、格式错误、业务报错、脏数据),不再继续重试,直接转发到专门存放异常消息的 Topic,这个 Topic 就是死信队列。

2. 出现场景

  • 消息体格式错乱、JSON 解析失败

  • 业务参数非法、不存在数据

  • 依赖第三方服务一直超时报错

  • 脏数据、测试垃圾消息

3. 工作流程

  1. 正常消费失败 → 进入重试队列重试 N 次

  2. 重试全部失败 → 自动投递到 死信队列 dlq_topic

  3. 正常业务消费不再阻塞卡在这条坏消息

  4. 运维 / 开发单独消费死信队列,排查修复数据后重放

4. 作用

  1. 避免一条脏消息卡死整个分区消费(最核心)

  2. 异常消息统一归档、排查、统计

  3. 不影响正常业务流量,提升消费稳定性

  4. 线上问题快速溯源

5. Spring Kafka 标准用法

配置重试次数、死信目的地:

  • 消费异常 → 本地重试 3 次

  • 仍失败 → 转发死信 Topic

  • 主消费线程继续跑正常消息


六、极简面试背诵版

  1. 生产者防丢:acks=all + 开启重试 + 重要业务同步发送 + 本地消息表

  2. Broker 防丢:副本数≥2、关闭脏主选举、保证 ISR 健康

  3. 消费者防丢:关闭自动提交,业务成功再手动 ACK

  4. 防重复:业务唯一 ID + Redis / 数据库做幂等

  5. 死信队列:消费重试失败的异常消息单独存放,防阻塞、便于排查修复重放