消息队列 / 系统课时

消费处理与位移原子提交

消费处理与位移原子提交

在典型的“消费一批消息 → 处理 → 写入另一个 Kafka 主题”链路中,如果结果消息和消费位移分别提交,任何一次崩溃都可能留下重复结果或错误推进位移。sendOffsetsToTransaction 的作用,就是把这两个动作纳入同一 Kafka 事务。

学习目标

  • 解释结果消息与消费位移分开提交时的故障窗口
  • 使用 sendOffsetsToTransaction 将下一消费位移加入当前生产者事务
  • 正确处理事务中止、消费者组元数据和下游隔离级别

原子边界必须覆盖两个结果

对一批已消费记录而言,真正需要原子化的不是“消费动作”本身,而是两个可持久化结果:写入输出主题的新消息,以及消费者组的下一消费位移。两者要么同时提交,要么都不提交。

Kafka 消费处理结果与位移的事务原子提交

如果先写输出消息再单独提交位移,进程可能在两者之间崩溃:输出已经存在,但旧位移仍会让输入被再次处理,于是产生重复结果。反过来,如果先提交位移再写输出,崩溃后那批输入不会重放,却可能永远没有对应结果。

Kafka 事务把这两个窗口合并成一个提交点。事务成功时,输出记录和组位移一起生效;事务中止时,位移保持原值,而事务输出对 read_committed 下游不可见。

配置消费端与事务生产者

消费端必须关闭自动位移提交,否则位移可能在业务事务之外先行推进。若输入主题本身也包含事务消息,建议同时使用 read_committed,避免把上游已中止事务的数据带进本次处理。

生产者需要设置 transactional.id 并先调用 initTransactions()。同一时刻运行的处理实例必须使用不同的事务 ID;同一个逻辑实例重启时应复用自己的稳定事务 ID,以便 Kafka 能隔离旧的僵尸生产者。

用 sendOffsetsToTransaction 完成一批处理

下面的程序从输入主题消费字符串,将值转换为大写后写入输出主题。每批输出完成后,直接把 ConsumerRecords.nextOffsets() 与 consumer.groupMetadata() 交给 sendOffsetsToTransaction,再统一提交事务。程序需要 Kafka 客户端依赖,并以 TxProcessor <bootstrapServers> <inputTopic> <outputTopic> <transactionalId> 形式传入四个参数。

java
import java.time.Duration;
import java.util.List;
import java.util.Locale;
import java.util.Properties;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;

public class TxProcessor {
    public static void main(String[] args) {
        if (args.length != 4) {
            throw new IllegalArgumentException(
                    "usage: TxProcessor <brokers> <input> <output> <transactionalId>");
        }

        String brokers = args[0];
        String inputTopic = args[1];
        String outputTopic = args[2];
        String transactionalId = args[3];

        Properties consumerProps = new Properties();
        consumerProps.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, brokers);
        consumerProps.put(ConsumerConfig.GROUP_ID_CONFIG, "tx-transformer-group");
        consumerProps.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
        consumerProps.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        consumerProps.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG, "read_committed");
        consumerProps.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());
        consumerProps.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());

        Properties producerProps = new Properties();
        producerProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, brokers);
        producerProps.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, transactionalId);
        producerProps.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, "true");
        producerProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
                StringSerializer.class.getName());
        producerProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
                StringSerializer.class.getName());

        try (KafkaConsumer<String, String> consumer =
                     new KafkaConsumer<>(consumerProps);
             KafkaProducer<String, String> producer =
                     new KafkaProducer<>(producerProps)) {

            producer.initTransactions();
            consumer.subscribe(List.of(inputTopic));

            while (true) {
                ConsumerRecords<String, String> records =
                        consumer.poll(Duration.ofSeconds(1));
                if (records.isEmpty()) {
                    continue;
                }

                producer.beginTransaction();
                try {
                    for (ConsumerRecord<String, String> record : records) {
                        String value = record.value() == null
                                ? null
                                : record.value().toUpperCase(Locale.ROOT);
                        producer.send(new ProducerRecord<>(
                                outputTopic, record.key(), value));
                    }

                    // nextOffsets 是下一次应消费的位置,不是当前记录的 offset。
                    producer.sendOffsetsToTransaction(
                            records.nextOffsets(), consumer.groupMetadata());
                    producer.commitTransaction();
                    System.out.printf(
                            "committed records=%d%n", records.count());
                } catch (RuntimeException e) {
                    // 中止后直接退出,重启会从旧的已提交位移重新处理这一批。
                    producer.abortTransaction();
                    throw e;
                }
            }
        }
    }
}

预期输出(输入主题有数据且事务成功时,批次数量会随实际数据变化):

text
committed records=<VALUE>

<VALUE> 是本批成功处理的记录数。事务提交之后,输出主题中的本批结果与消费者组位移同时生效;如果事务在提交前中止,组位移不会推进。下游若要求只观察成功事务,也必须使用 read_committed。

中止后为什么不能直接继续 poll

poll() 返回记录时,消费者进程内存中的 position 已经向前移动。若事务失败后只调用 abortTransaction(),却让同一个消费者直接进入下一次 poll(),它可能从更靠后的内存位置继续读取,而不是立刻自动回到消费者组最后一次已提交位移。

最简单可靠的处理方式是像示例一样:中止事务后终止当前处理实例,让重启后的消费者从组已提交位移恢复。若业务要求进程内继续运行,就必须显式把各分区 seek 回失败批次之前的安全位置,并正确处理可能发生的 rebalance。

原子性只覆盖 Kafka 内部状态

这套模式能为“Kafka 输入 → Kafka 处理结果”提供恰好一次可见效果,但事务边界不会自动扩展到外部数据库、HTTP 接口、邮件或文件系统。若处理过程中已经修改外部系统,随后 Kafka 事务中止,外部副作用不会跟着回滚。

因此,涉及外部副作用时还需要业务幂等键、Outbox、去重表或其他一致性方案。只要结果消息和消费位移都留在 Kafka 内部,sendOffsetsToTransaction 才能把最关键的重复与丢失窗口收敛到一个事务提交点。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

消费处理与位移原子提交

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通