kafka官网示例说明--KafkaConsumer

最新推荐文章于 2025-06-26 17:28:01 发布

翻译最新推荐文章于 2025-06-26 17:28:01 发布 · 1.6w 阅读

文章标签：

#kafka #consumer #api #官网

hadoop 专栏收录该内容

19 篇文章

订阅专栏

Kafka client会消费kafka cluster中的记录。

它将透明地处理Kafka集群中的服务器故障，并透明地适应它在集群内迁移的数据分区。该客户机还与服务器交互，以允许用户组使用消费者组来负载平衡消费(如下所述)。

消费者维护TCP连接到必要的代理来获取数据。使用后未能关闭消费者会泄漏这些连接。消费者不是线程安全的。更多细节见多线程处理。

偏移量

Kafka为分区中的每个记录保留一个数值偏移量。这个偏移量充当该分区中记录的唯一标识符，并且表示该分区中的消费者的位置。也就是说，拥有5号位置的消费者使用偏移值为0到4的记录，并将使用偏移量5记录下一个记录。实际上，与使用者的使用者有关的位置有两个概念。

消费者的位置将提供下一个记录的偏移量。它将比消费者在该分区中看到的最高偏移量大一个。它在消费者每次接收数据调用poll(long)和接收消息时自动地前进。

已提交的位置是安全保存的最后一个偏移量。如果进程失败并重新启动，这将恢复到它将恢复的偏移量。消费者可以定期自动提交补偿;或者，它可以选择通过调用commitSync来手动控制这个提交的位置，它会阻塞，直到在提交过程中成功提交了补偿或致命错误，或者提交了非阻塞的commitAsync，并将触发OffsetCommitCallback，要么成功提交，要么失败。

消费者组和订阅主题

Kafka使用了消费者组（Consumer Groups）的概念来允许一个过程池来划分消费和处理记录的工作。这些进程可以在同一台机器上运行，或者，更有可能的是，它们可以分布在许多机器上，从而为处理提供额外的可伸缩性和容错。

每个Kafka消费者可以配置一个消费者团体,它属于,并且可以动态设置主题希望通过订阅订阅列表(列表,Consumer Rebalance Listener),或通过订阅订阅所有主题匹配特定的模式(模式,ConsumerRebalanceListener)。Kafka将在每个用户组中的一个流程中传递订阅主题中的每个消息。这是通过在每个组的消费者过程中平衡主题中的分区来实现的。因此，如果有一个带有四个分区的主题，以及一个有两个进程的消费者组，每个进程将从两个分区中消耗。这个组成员是动态维护的:如果进程失败，分配给它的分区将被重新分配给同一组中的其他进程，如果一个新进程加入这个组，那么分区将从现有的消费者转移到这个新的进程。

因此，如果两个进程订阅一个主题同时指定不同的组，则它们将在该主题中获得所有的记录;如果他们都指定相同的组，他们将会得到大约一半的记录。从概念上来说，您可以将消费者组看作是由多个进程组成的单个逻辑订阅者。作为一个多用户系统，Kafka自然支持在没有重复数据的情况下为给定的主题提供任意数量的用户组(额外的消费者实际上相当便宜)。这是对消息传递系统中常见的功能的轻微概括。

为了获得与传统消息传递系统中的队列相似的语义，所有流程都将是单个消费者组的一部分，因此记录交付将在组中与队列相同。与传统的消息传递系统不同，您可以拥有多个这样的组。要获得类似于传统消息传递系统中的pub-sub的语义，每个流程都有自己的消费者组，因此每个进程将订阅发布到该主题的所有记录。

此外,自动组分配时,消费者可以通过Consumer Rebalance Listener通知,这允许他们完成清理等必要的应用程序级的逻辑状态,手动抵消提交(注意,抵消总是承诺对于一个给定的消费者团体),等等的详细信息,请参阅存储抵消外部卡夫卡对消费者也可以手动指定分区分配给它分配(列表),禁用这个动态分区分配。

用法示例

1. 自动确认Offset

Properties props = new Properties();
/* 定义kakfa 服务的地址，不需要将所有broker指定上 */
props.put("bootstrap.servers", "localhost:9092");
/* 制定consumer group */
props.put("group.id", "test");
/* 是否自动确认offset */
props.put("enable.auto.commit", "true");
/* 自动确认offset的时间间隔 */
props.put("auto.commit.interval.ms", "1000");
props.put("session.timeout.ms", "30000");
/* key的序列化类 */
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
/* value的序列化类 */
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
 /* 定义consumer */
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
/* 消费者订阅的topic, 可同时订阅多个 */
consumer.subscribe(Arrays.asList("foo", "bar"));

 /* 读取数据，读取超时时间为100ms */
while (true) {
    ConsumerRecords<String, String> records = consumer.poll(100);
    for (ConsumerRecord<String, String> record : records)
        System.out.printf("offset = %d, key = %s, value = %s", record.offset(), record.key(), record.value());
}

说明:
1. bootstrap.servers 只是代表kafka的连接入口，只需要指定集群中的某一broker；
2. 一旦consumer和kakfa集群建立连接，consumer会以心跳的方式来高速集群自己还活着，如果session.timeout.ms 内心跳未到达服务器，服务器认为心跳丢失，会做rebalence。

2. 手工控制Offset

如果consumer在获得数据后需要加入处理，数据完毕后才确认offset，需要程序来控制offset的确认。举个栗子：
consumer获得数据后，需要将数据持久化到DB中。自动确认offset的情况下，如果数据从kafka集群读出，就确认，但是持久化过程失败，就会导致数据丢失。我们就需要控制offset的确认。

Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
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);
    }
    /* 数据达到批量要求，就写入DB，同步确认offset */
    if (buffer.size() >= minBatchSize) {
        insertIntoDb(buffer);
        consumer.commitSync();
        buffer.clear();
    }
}

还可以精细的控制对具体分区具体offset数据的确认：

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());
            }
            /* 同步确认某个分区的特定offset */
            long lastOffset = partitionRecords.get(partitionRecords.size() - 1).offset();
            consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));
        }
    }
} finally {
  consumer.close();
}

说明：确认的offset为已接受数据最大offset+1。

3. 分区订阅

可以向特定的分区订阅消息。但是会失去partion的负载分担。有几种场景可能会这么玩：
1. 只需要获取本机磁盘的分区数据；
2. 程序自己或者外部程序能够自己实现负载和错误处理。例如YARN/Mesos的介入，当consumer挂掉后，再启动一个consumer。

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

说明：
1. 此种情况用了consumer Group，也不会做负载均衡。
2. topic的订阅和分区订阅不可以在同一consumer中混用。

4. 外部存储offset

消费者可以自定义kafka的offset存储位置。该设计的主要目的是让消费者将数据和offset进行原子性的存储。这样可以避免上面提到的重复消费问题。举栗说明：
订阅特定分区。存储所获得的记录时，将每条记录的offset一起存储。保证数据和offset的存储是原子性的。当异步存储被异常打断时，凡已经存储的数据，都有有相应的offset记录。这种方式可以保证不会有数据丢失，也不会重复的从服务端读取。
如何配置实现：
1. 去使能offset自动确认：enable.auto.commit=false；
2. 从ConsumerRecord中获取offset，保存下来;
3. Consumer重启时，调用seek(TopicPartition, long)重置在服务端的消费记录。

如果消费分区也是自定义的，这种方式用起来会很爽。如果分区是自动分配的，当分区发生reblance的时候，就要考虑清楚了。如果因为升级等原因，分区漂移到一个不会更新offset的consumer上，那就日了狗了。
该情况下：
1. 原consumer需要监听分区撤销事件，并在撤销时确认好offset。接口:ConsumerRebalanceListener.onPartitionsRevoked(Collection)；
2. 新consumer监听分区分配事件，获取当前分区消费的offset。接口：ConsumerRebalanceListener.onPartitionsAssigned(Collection)；
3. consumer监听到 ConsumerRebalance事件，还没有处理或者持久化的缓存数据flush掉。

5. 控制消费位置

大多数情况下，服务端的Consumer的消费位置都是由客户端间歇性的确认。Kafka允许Consumer自己设置消费起点，达到的效果：
1. 可以消费已经消费过的数据；
2. 可以跳跃性的消费数据；
看下这样做的一些场景：
1. 对Consumer来说，数据具备时效性，只需要获取最近一段时间内的数据，就可以进行跳跃性的获取数据；
2. 上面自己存offset的场景，重启后就需要从指定的位置开始消费。
接口上面已经提到过了，用seek(TopicPartition, long)。、
麻蛋，说指针不就好了，这一小节就是多余的叨叨。

6. 控制消费流Consumption Flow Control

如果一个consumer同时消费多个分区，默认情况下，这多个分区的优先级是一样的，同时消费。Kafka提供机制，可以让暂停某些分区的消费，先获取其他分区的内容。场景举栗：
1. 流式计算，consumer同时消费两个Topic，然后对两个Topic的数据做Join操作。但是这两个Topic里面的数据产生速率差距较大。Consumer就需要控制下获取逻辑，先获取慢的Topic，慢的读到数据后再去读快的。
2. 同样多个Topic同时消费，但是Consumer启动是，本地已经存有了大量某些Topic数据。此时就可以优先去消费下其他的Topic。

调控的手段：让某个分区消费先暂停，时机到了再恢复，然后接着poll。接口：pause(TopicPartition…)，resume(TopicPartition…)

7. 多线程处理模型 Multi-threaded Processing

Kafka的Consumer的接口为非线程安全的。多线程共用IO，Consumer线程需要自己做好线程同步。
如果想立即终止consumer，唯一办法是用调用接口：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();
    }
}