Go最新Kafka学习 — 3 kafka消费者客户端(3)，干货满满

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

 props.put("group.id", "test");
 props.put("enable.auto.commit", "false");
 props.put("auto.commit.interval.ms", "1000");
 props.put("session.timeout.ms", "30000");
 props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
 props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
 KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
 consumer.subscribe(Arrays.asList("foo", "bar"));
 final int minBatchSize = 200;
 List<ConsumerRecord<String, String>> buffer = new ArrayList<>();
 while (true) {
     ConsumerRecords<String, String> records = consumer.poll(100);
     for (ConsumerRecord<String, String> record : records) {
         buffer.add(record);
     }
     if (buffer.size() >= minBatchSize) {
         insertIntoDb(buffer);
         consumer.commitSync();
         buffer.clear();
     }
 }

在这个示例中，当接收的消息达到一定数量后将它们批量插入到数据库中。如果我们设置offset自动提交（之前说的例子），默认认为消费已消费完成这批消息。但有可能在批处理记录之后，插入到数据库之前失败了，因为已经自动提交，这样就没法再继续获取之前的消息。


为了避免这种情况，我们应该再记录插入数据库之后再手动提交偏移量。这样可以准确控制消息是成功消费的。提出一个相反的可能性：在插入数据库之后，但是在提交之前，这个过程可能会失败（即使这可能只是几毫秒，这是一种可能性）。在这种情况下，进程将获取到已提交的偏移量，并会重复插入的最后一批数据。这种方式就是所谓的“至少一次”保证，在故障情况下，可以重复。


使用手动偏移控制的优点是可以直接控制消息何时被视为“已消费”。


### 3.2 精细控制提交的偏移量


在某些情况下，你可以希望更精细的控制，通过指定一个明确消息的偏移量为“已提交”。在下面，我们的例子中，我们处理完每个分区中的消息后，提交偏移量。

try {
while(running) {
ConsumerRecords<String, String> records = consumer.poll(Long.MAX_VALUE);
for (TopicPartition partition : records.partitions()) {
List<ConsumerRecord<String, String>> partitionRecords = records.records(partition);
for (ConsumerRecord<String, String> record : partitionRecords) {
System.out.println(record.offset() + ": " + record.value());
}
long lastOffset = partitionRecords.get(partitionRecords.size() - 1).offset();
consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));
}
}
} finally {
consumer.close();
}

## 四、订阅指定的分区


在前面的例子中，我们订阅我们感兴趣的topic，让kafka提供给我们平分后的topic分区。但是，在有些情况下，你可能需要自己来控制分配指定分区，例如：


4.1 如果这个消费者进程与该分区保存了某种本地状态（如本地磁盘的键值存储），则它应该只能获取这个分区的消息。


4.2 如果消费者进程本身具有高可用性，运行失败后会自动重新启动（可能使用集群管理框架如YARN，Mesos，或者AWS设施，或作为一个流处理框架的一部分）。 在这种情况下，不需要Kafka检测故障，重新分配分区，因为消费者进程将在另一台机器上重新启动。  
 要使用此模式，你只需调用assign（Collection）消费指定的分区即可：

 String topic = "foo";
 TopicPartition partition0 = new TopicPartition(topic, 0);
 TopicPartition partition1 = new TopicPartition(topic, 1);
 consumer.assign(Arrays.asList(partition0, partition1));

一旦手动分配分区，你可以在循环中调用poll（跟前面的例子一样）。消费者分组仍需要提交offset，只是现在分区的设置只能通过调用assign修改，因为手动分配分区后不会进行分组协调，因此消费者故障不会引发分区重新平衡。每一个消费者是独立工作的（即使和其他的消费者共享GroupId）。为了避免offset提交冲突，通常你需要确认每一个consumer实例的gorupId都是唯一的。  
 **注意**：手动分配分区（即，assgin）和动态分区分配的订阅topic模式（即，subcribe）不能混合使用。


## 五、offset的存储地方


消费者可以不使用kafka内置的offset仓库。可以选择自己来存储offset。


### 5.1 消费结果（数据）和offset存储在数据库中


如果消费的结果和offset存储在关系数据库中，需要将提交结果和offset在单个事务中。这样，事物成功，则offset存储和更新。如果offset没有存储，那么偏移量也不会被更新。


### 5.2 每个消费者都有自己的offset，所以要管理自己的偏移，你只需要做到以下几点：


5.2.1配置 enable.auto.commit=false；  
 5.2.2使用提供的 ConsumerRecord 来保存你的位置。  
 5.2.3在重启时用 seek(TopicPartition, long) 恢复消费者的位置。


## 六、消费者控制消费的位置


大多数情况下，消费者只是简单的从头到尾的消费消息，周期性的提交位置（自动或手动）。kafka也支持消费者去手动的控制消费的位置，可以消费之前的消息也可以跳过最近的消息。


**有几种情况，消费者手动控制消费的位置可能是有用的：**  
 6.1、一种场景是对于时间敏感的消费者处理程序，对足够落后的消息，直接跳过，从最近的消息开始消费。  
 6.2、另一个使用场景是本地状态存储系统（上一节说的）。在这样的系统中，消费者将要在启动时初始化它的位置（无论本地存储是否包含）。同样，如果本地状态已被破坏（假设因为磁盘丢失），则可以通过重新消费所有数据并重新创建状态（假设kafka保留了足够的历史）在新的机器上重新创建。  
 6.3、 kafka使用**seek**(TopicPartition, long)指定新的消费位置。  
 用于查找kafka服务器保留的最早和最新的消息可用（seekToBeginning(Collection) 和 seekToEnd(Collection)）。


## 七、消费者控制流量


如果消费者分配了多个分区，并同时消费所有的分区，这些分区具有相同的优先级。在一些情况下，消费者需要首先消费一些指定的分区，当指定的分区有少量或者已经没有可消费的数据时，则开始消费其他分区。


**例如流处理**，当处理器从2个topic获取消息并把这两个topic的消息合并，当其中一个topic长时间落后另一个，则暂停消费，以便落后的赶上来。


kafka支持动态控制流量，分别在future的poll(long)中使用**pause**(Collection) 来暂停消费指定分配的分区，和 **resume**(Collection) 重新开始消费指定暂停的分区。


## 八、多线程处理


**Kafka消费者不是线程安全的**。所有网络I/O都发生在进行调用应用程序的线程中。用户的责任是确保多线程访问正确同步的。非同步访问将导致ConcurrentModificationException。


此规则唯一的例外是**wakeup()**，它可以安全地从外部线程来中断活动操作。在这种情况下，将从操作的线程阻塞并抛出一个WakeupException。这可用于从其他线程来关闭消费者。 以下代码段显示了典型模式：

public class KafkaConsumerRunner implements Runnable {
private final AtomicBoolean closed = new AtomicBoolean(false);
private final KafkaConsumer consumer;

 public void run() {
     try {
         consumer.subscribe(Arrays.asList("topic"));
         while (!closed.get()) {
             ConsumerRecords records = consumer.poll(10000);
             // Handle new records
         }
     } catch (WakeupException e) {
         // Ignore exception if closing
         if (!closed.get()) throw e;
     } finally {
         consumer.close();
     }
 }

 // Shutdown hook which can be called from a separate thread
 public void shutdown() {
     closed.set(true);
     consumer.wakeup();
 }

}

![img](https://img-blog.csdnimg.cn/img_convert/a01b28147a2499ddae28296eb25fe609.png)
![img](https://img-blog.csdnimg.cn/img_convert/4fcffa518e46da36ce7d4d7a842eb4b5.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**