Kafka

一、偏移量提交

消费者提交偏移量的主要是消费者往一个名为_consumer_offset的特殊主题发送消息，消息中包含每个分区的偏移量。

如果消费者一直运行，偏移量的提交并不会产生任何影响。但是如果有消费者发生崩溃，或者有新的消费者加入消费者群组的时候，会触发 Kafka 的再均衡。这使得 Kafka 完成再均衡之后，每个消费者可能被会分到新分区中。为了能够继续之前的工作，消费者就需要读取每一个分区的最后一次提交的偏移量，然后从偏移量指定的地方继续处理。

但是这样可能会出现如下的问题。

1.1 提交偏移量小于客户端处理的偏移量

如果提交的偏移量小于客户端处理的最后一个消息的偏移量，那么处于两个偏移量之间的消息就会被重复处理。

1.2 提交偏移量大于客户端处理的偏移量

如果提交的偏移量大于客户端处理的最后一个消息的偏移量，那么处于两个偏移量之间的消息将会丢失。

因此，如果处理偏移量，会对客户端处理数据产生影响。KafkaConsumer API 提供了很多种方式来提交偏移量。

二、自动提交

自动提交是 Kafka 处理偏移量最简单的方式。

当 enable.auto.commit 属性被设为 true，那么每过 5s，消费者会自动把从 poll()方法接收到的最大偏移量提交上去。这是因为提交时间间隔由 auto.commit.interval.ms 控制，默认值是 5s。与消费者里的其他东西一样，自动提交也是在轮询里进行的。消费者每次在进行轮询时会检查是否该提交偏移量了，如果是，那么就会提交从上一次轮询返回的偏移量。

但是使用这种方式，容易出现提交的偏移量小于客户端处理的最后一个消息的偏移量这种情况的问题。假设我们仍然使用默认的 5s 提交时间间隔，在最近一次提交之后的 3s 发生了再均衡，再均衡之后，消费者从最后一次提交的偏移量位置开始读取消息。这个时候偏移量已经落后了 3s（因为没有达到5s的时限，并没有提交偏移量），所以在这 3s 的数据将会被重复处理。

虽然可以通过修改提交时间间隔来更频繁地提交偏移量，减小可能出现重复消息的时间窗的时间跨度，不过这种情况是无法完全避免的。

在使用自动提交时，每次调用轮询方法都会把上一次调用返回的偏移量提交上去，它并不知道具体哪些消息已经被处理了，所以在再次调用之前最好确保所有当前调用返回的消息都已经处理完毕（在调用 close() 方法之前也会进行自动提交）。一般情况下不会有什么问题，不过在处理异常或提前退出轮询时要格外小心。

三、手动提交

大部分开发者通过控制偏移量提交时间来消除丢失消息的可能性，并在发生再均衡时减少重复消息的数量。消费者 API 提供了另一种提交偏移量的方式，开发者可以在必要的时候提交当前偏移量，而不是基于时间间隔。

这是我们需要把把 auto.commit.offset 设为 false，让应用程序决定何时提交偏移量。

3.1 同步提交

使用 commitSync() 提交偏移量最简单也最可靠。这个 API 会提交由 poll() 方法返回的最新偏移量，提交成功后马上返回，如果提交失败就抛出异常。

代码示例如下：

 1 while (true) {
 2     ConsumerRecords<String, String> records = consumer.poll(100);
 3     for (ConsumerRecord<String, String> record : records)
 4     {
 5         System.out.printf("topic = %s, partition = %s, offset =
 6           %d, customer = %s, country = %s
",
 7              record.topic(), record.partition(),
 8                   record.offset(), record.key(), record.value()); 
 9         }
10         try {
11           consumer.commitSync(); 
12         } catch (CommitFailedException e) {
13             log.error("commit failed", e) 
14         }
15 }

commitSync() 将会提交由 poll() 返回的最新偏移量，所以在处理完所有记录后要确保调用了 commitSync()，否则还是会有丢失消息的风险。如果发生了再均衡，从最近一批消息到发生再均衡之间的所有消息都将被重复处理。

同时在这个程序中，只要没有发生不可恢复的错误，commitSync() 方法会一直尝试直至提交成功。如果提交失败，我们也只能把异常记录到错误日志里。

3.2 异步提交

同步提交有一个不足之处，在 broker 对提交请求作出回应之前，应用程序会一直阻塞，这样会限制应用程序的吞吐量。我们可以通过降低提交频率来提升吞吐量，但如果发生了再均衡，会增加重复消息的数量。

这个时候可以使用异步提交 API。我们只管发送提交请求，无需等待 broker 的响应。

 1 while (true) {
 2     ConsumerRecords<String, String> records = consumer.poll(100);
 3     for (ConsumerRecord<String, String> record : records)
 4     {
 5         System.out.printf("topic = %s, partition = %s,
 6         offset = %d, customer = %s, country = %s
",
 7         record.topic(), record.partition(), record.offset(),
 8         record.key(), record.value());
 9     }
10     consumer.commitAsync(); 
11 }

在成功提交或碰到无法恢复的错误之前，commitSync() 会一直重试，但是 commitAsync() 不会，这也是 commitAsync() 不好的一个地方。

它之所以不进行重试，是因为在它收到服务器响应的时候，可能有一个更大的偏移量已经提交成功。假设我们发出一个请求用于提交偏移量 2000，这个时候发生了短暂的通信问题，服务器收不到请求，自然也不会作出任何响应。与此同时，我们处理了另外一批消息，并成功提交了偏移量 3000。如果 commitAsync() 重新尝试提交偏移量 2000，它有可能在偏移量 3000 之后提交成功。这个时候如果发生再均衡，就会出现重复消息。

commitAsync() 也支持回调，在 broker 作出响应时会执行回调。回调经常被用于记录提交错误或生成度量指标。如果要用它来进行重试，则一定要注意提交的顺序。

 1 while (true) {
 2     ConsumerRecords<String, String> records = consumer.poll(100);
 3     for (ConsumerRecord<String, String> record : records) {
 4         System.out.printf("topic = %s, partition = %s,
 5         offset = %d, customer = %s, country = %s
",
 6         record.topic(), record.partition(), record.offset(),
 7         record.key(), record.value());
 8     }
 9     consumer.commitAsync(new OffsetCommitCallback() {
10         public void onComplete(Map<TopicPartition,
11         OffsetAndMetadata> offsets, Exception e) {
12             if (e != null)
13                 log.error("Commit failed for offsets {}", offsets, e);
14         }
15       }); 
16 }

3.3 同步和异步混合提交

一般情况下，针对偶尔出现的提交失败，不进行重试不会有太大问题，因为如果提交失败是因为临时问题导致的，那么后续的提交总会有成功的。

但如果这是发生在关闭消费者或再均衡前的最后一次提交，就要确保能够提交成功。因此在这种情况下，我们应该考虑使用混合提交的方法：

 1 try {
 2     while (true) {
 3         ConsumerRecords<String, String> records = consumer.poll(100);
 4         for (ConsumerRecord<String, String> record : records) {
 5             System.out.println("topic = %s, partition = %s, offset = %d,
 6             customer = %s, country = %s
",
 7             record.topic(), record.partition(),
 8             record.offset(), record.key(), record.value());
 9         }
10         consumer.commitAsync(); 
11     }
12 } catch (Exception e) {
13     log.error("Unexpected error", e);
14 } finally {
15     try {
16         consumer.commitSync(); 
17     } finally {
18         consumer.close();
19     }
20 }

在程序正常运行过程中，我们使用 commitAsync 方法来进行提交，这样的运行速度更快，而且就算当前提交失败，下次提交成功也可以。
如果直接关闭消费者，就没有所谓的“下一次提交”了，因为不会再调用poll()方法。使用 commitSync() 方法会一直重试，直到提交成功或发生无法恢复的错误。

3.4 提交特定的偏移量

如果 poll() 方法返回一大批数据，为了避免因再均衡引起的重复处理整批消息，想要在批次中间提交偏移量该怎么办？这种情况无法通过调用 commitSync() 或 commitAsync() 来实现，因为它们只会提交最后一个偏移量，而此时该批次里的消息还没有处理完。

这时候需要使用一下的两个方法：

 1 /**
 2  * Commit the specified offsets for the specified list of topics and partitions.
 3  */
 4 @Override
 5 public void commitSync(final Map<TopicPartition, OffsetAndMetadata> offsets)
 6 
 7 
 8 /**
 9  * Commit the specified offsets for the specified list of topics and partitions to Kafka.
10  */
11 @Override
12 public void commitAsync(final Map<TopicPartition, OffsetAndMetadata> offsets, OffsetCommitCallback callback)

消费者 API 允许在调用 commitSync() 和 commitAsync() 方法时传进去希望提交的分区和偏移量的 map。

假设处理了半个批次的消息，最后一个来自主题“customers”分区 3 的消息的偏移量是 5000，你可以调用 commitSync() 方法来提交它。不过，因为消费者可能不只读取一个分区，你需要跟踪所有分区的偏移量，所以在这个层面上控制偏移量的提交会让代码变复杂。

代码如下：

 1 private Map<TopicPartition, OffsetAndMetadata> currentOffsets =
 2     new HashMap<>(); 
 3 int count = 0;
 4 
 5 ...
 6 
 7 while (true) {
 8     ConsumerRecords<String, String> records = consumer.poll(100);
 9     for (ConsumerRecord<String, String> record : records)
10     {
11         System.out.printf("topic = %s, partition = %s, offset = %d,
12         customer = %s, country = %s
",
13         record.topic(), record.partition(), record.offset(),
14         record.key(), record.value()); 
15         currentOffsets.put(new TopicPartition(record.topic(),
16         record.partition()), new
17         OffsetAndMetadata(record.offset()+1, "no metadata")); 
18         if (count % 1000 == 0) 
19             consumer.commitAsync(currentOffsets,null); 
20         count++;
21     }
22 }

这里调用的是 commitAsync()，不过调用commitSync()也是完全可以的。在提交特定偏移量时，仍然要处理可能发生的错误。

四、监听再均衡

如果 Kafka 触发了再均衡，我们需要在消费者失去对一个分区的所有权之前提交最后一个已处理记录的偏移量。如果消费者准备了一个缓冲区用于处理偶发的事件，那么在失去分区所有权之前，需要处理在缓冲区累积下来的记录。可能还需要关闭文件句柄、数据库连接等。

在为消费者分配新分区或移除旧分区时，可以通过消费者 API 执行一些应用程序代码，在调用 subscribe() 方法时传进去一个 ConsumerRebalanceListener 实例就可以了。 ConsumerRebalanceListener 有两个需要实现的方法。

public void onPartitionsRevoked(Collection partitions) 方法会在再均衡开始之前和消费者停止读取消息之后被调用。如果在这里提交偏移量，下一个接管分区的消费者就知道该从哪里开始读取了。
public void onPartitionsAssigned(Collection partitions) 方法会在重新分配分区之后和消费者开始读取消息之前被调用。

下面的例子将演示如何在失去分区所有权之前通过 onPartitionsRevoked() 方法来提交偏移量。

 1 private Map<TopicPartition, OffsetAndMetadata> currentOffsets=
 2   new HashMap<>();
 3 
 4 private class HandleRebalance implements ConsumerRebalanceListener { 
 5     public void onPartitionsAssigned(Collection<TopicPartition>
 6       partitions) { 
 7     }
 8 
 9     public void onPartitionsRevoked(Collection<TopicPartition>
10       partitions) {
11         System.out.println("Lost partitions in rebalance.
12           Committing current
13         offsets:" + currentOffsets);
14         consumer.commitSync(currentOffsets); 
15     }
16 }
17 
18 try {
19     consumer.subscribe(topics, new HandleRebalance()); 
20 
21     while (true) {
22         ConsumerRecords<String, String> records =
23           consumer.poll(100);
24         for (ConsumerRecord<String, String> record : records)
25         {
26             System.out.println("topic = %s, partition = %s, offset = %d,
27              customer = %s, country = %s
",
28              record.topic(), record.partition(), record.offset(),
29              record.key(), record.value());
30              currentOffsets.put(new TopicPartition(record.topic(),
31              record.partition()), new
32              OffsetAndMetadata(record.offset()+1, "no metadata"));
33         }
34         consumer.commitAsync(currentOffsets, null);
35     }
36 } catch (WakeupException e) {
37     // 忽略异常，正在关闭消费者
38 } catch (Exception e) {
39     log.error("Unexpected error", e);
40 } finally {
41     try {
42         consumer.commitSync(currentOffsets);
43     } finally {
44         consumer.close();
45         System.out.println("Closed consumer and we are done");
46     }
47 }

如果发生再均衡，我们要在即将失去分区所有权时提交偏移量。要注意，提交的是最近处理过的偏移量，而不是批次中还在处理的最后一个偏移量。因为分区有可能在我们还在处理消息的时候被撤回。我们要提交所有分区的偏移量，而不只是那些即将失去所有权的分区的偏移量——因为提交的偏移量是已经处理过的，所以不会有什么问题。调用 commitSync() 方法，确保在再均衡发生之前提交偏移量。