消息队列 / 系统课时
消费处理与位移原子提交
消费处理与位移原子提交
在典型的“消费一批消息 → 处理 → 写入另一个 Kafka 主题”链路中,如果结果消息和消费位移分别提交,任何一次崩溃都可能留下重复结果或错误推进位移。sendOffsetsToTransaction 的作用,就是把这两个动作纳入同一 Kafka 事务。
学习目标
- 解释结果消息与消费位移分开提交时的故障窗口
- 使用
sendOffsetsToTransaction将下一消费位移加入当前生产者事务 - 正确处理事务中止、消费者组元数据和下游隔离级别
原子边界必须覆盖两个结果
对一批已消费记录而言,真正需要原子化的不是“消费动作”本身,而是两个可持久化结果:写入输出主题的新消息,以及消费者组的下一消费位移。两者要么同时提交,要么都不提交。

如果先写输出消息再单独提交位移,进程可能在两者之间崩溃:输出已经存在,但旧位移仍会让输入被再次处理,于是产生重复结果。反过来,如果先提交位移再写输出,崩溃后那批输入不会重放,却可能永远没有对应结果。
Kafka 事务把这两个窗口合并成一个提交点。事务成功时,输出记录和组位移一起生效;事务中止时,位移保持原值,而事务输出对 read_committed 下游不可见。
配置消费端与事务生产者
消费端必须关闭自动位移提交,否则位移可能在业务事务之外先行推进。若输入主题本身也包含事务消息,建议同时使用 read_committed,避免把上游已中止事务的数据带进本次处理。
生产者需要设置 transactional.id 并先调用 initTransactions()。同一时刻运行的处理实例必须使用不同的事务 ID;同一个逻辑实例重启时应复用自己的稳定事务 ID,以便 Kafka 能隔离旧的僵尸生产者。
用 sendOffsetsToTransaction 完成一批处理
下面的程序从输入主题消费字符串,将值转换为大写后写入输出主题。每批输出完成后,直接把 ConsumerRecords.nextOffsets() 与 consumer.groupMetadata() 交给 sendOffsetsToTransaction,再统一提交事务。程序需要 Kafka 客户端依赖,并以 TxProcessor <bootstrapServers> <inputTopic> <outputTopic> <transactionalId> 形式传入四个参数。
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;
}
}
}
}
}预期输出(输入主题有数据且事务成功时,批次数量会随实际数据变化):
committed records=<VALUE><VALUE> 是本批成功处理的记录数。事务提交之后,输出主题中的本批结果与消费者组位移同时生效;如果事务在提交前中止,组位移不会推进。下游若要求只观察成功事务,也必须使用 read_committed。
中止后为什么不能直接继续 poll
poll() 返回记录时,消费者进程内存中的 position 已经向前移动。若事务失败后只调用 abortTransaction(),却让同一个消费者直接进入下一次 poll(),它可能从更靠后的内存位置继续读取,而不是立刻自动回到消费者组最后一次已提交位移。
最简单可靠的处理方式是像示例一样:中止事务后终止当前处理实例,让重启后的消费者从组已提交位移恢复。若业务要求进程内继续运行,就必须显式把各分区 seek 回失败批次之前的安全位置,并正确处理可能发生的 rebalance。
原子性只覆盖 Kafka 内部状态
这套模式能为“Kafka 输入 → Kafka 处理结果”提供恰好一次可见效果,但事务边界不会自动扩展到外部数据库、HTTP 接口、邮件或文件系统。若处理过程中已经修改外部系统,随后 Kafka 事务中止,外部副作用不会跟着回滚。
因此,涉及外部副作用时还需要业务幂等键、Outbox、去重表或其他一致性方案。只要结果消息和消费位移都留在 Kafka 内部,sendOffsetsToTransaction 才能把最关键的重复与丢失窗口收敛到一个事务提交点。