kafka消费者

最新推荐文章于 2024-06-09 19:59:57 发布
最新推荐文章于 2024-06-09 19:59:57 发布
阅读量4k 收藏 8
点赞数 2
文章标签： kafka

转载地址：https://www.cnblogs.com/sodawoods-blogs/p/8969774.html

                  https://blog.csdn.net/qq_35349490/article/details/79790625

                  https://blog.csdn.net/qq_35349490/article/details/79523926

                  https://blog.csdn.net/xianzhen376/article/details/51167333

                  http://www.360doc.com/content/17/0723/21/11253639_673606100.shtml（kafka 学习 非常详细的经典教程）

目录

一、消费组和消费者

二、订阅主题

三、订阅指定分区

四、提交和偏移量

1、消费者为什么要提交偏移量

2、提交偏移量可能带来的问题

3、提交偏移量的方式

     (1) 自动提交offset

     (2)手动提交

     (3) 提交特定的偏移量

     (4) 提交具体分区具体offset

     (5) 再均衡监听器

     (6) 外部存储offset

     (7) 控制消费位置

五、SimpleConsumer查询

六、以时间戳查询消息

七、控制消费流 Consumption Flow Control

八、多线程处理模型 Multi-threaded Processing

九、从zookeeper中动态读取kafka集群中brokers

一、消费组和消费者

  1. 每个consumer客户端被创建时，会向zookeeper注册自己的信息；
  2. 此作用主要是为了"负载均衡"。
  3. 同一个Consumer Group中的Consumers，Kafka将相应Topic中的每个消息只发送给其中一个Consumer。
  4. Consumer Group中的每个Consumer读取Topic的一个或多个Partitions，并且是唯一的Consumer；
  5. 一个Consumer group的多个consumer的所有线程依次有序地消费一个topic的所有partitions，如果Consumer group中所有consumer总线程大于partitions数量，则会出现空闲情况;

     举例说明：
     kafka集群中创建一个topic为report-log   4 partitions 索引编号为0,1,2,3
     假如有目前有三个消费者node：注意-->一个consumer中一个消费线程可以消费一个或多个partition.
    如果每个consumer创建一个consumer thread线程，各个node消费情况如下，node1消费索引编号为0,1分区，node2费索引编号为2，node3费索引编号为3
     如果每个consumer创建2个consumer thread线程，各个node消费情况如下(是从consumer node先后启动状态来确定的)，node1消费索引编号为0,1分区；node2费索引编号为2,3；node3为空闲状态
     总结：
              从以上可知，Consumer Group中各个consumer是根据先后启动的顺序有序消费一个topic的所有partitions的。

              如果Consumer Group中所有consumer的总线程数大于partitions数量，则可能consumer thread或consumer会出现空闲状态。

     转载地址：https://www.cnblogs.com/qingyunzong/p/9007107.html

二、订阅主题

       在实例化一个消费者之后，我们需要为该消费者订阅主题。一个消费者可以同时订阅多个主题，通常我们可以以集合的形式指定多个主题，或者以正则表达式形式订阅特定模式的主题。

Kafka 定义了以下 3 种订阅主题方法：

  • subscribe(Collection<String> topics)方法，以集合形式指定消费者订阅的主题，通常我们用ArrayList。
  • subscribe(Collection<String> topics, ConsumerRebalanceListener listener)方法，订阅主题时指定一个监听器，用于在消费者发生平衡操作时回调进行相应的业务处理。
  • subscribe(Pattern pattern, ConsumerRebalanceListener listener)方法，以正则表达式形式指定匹配特定模式的主题。

消费端的普通实现：

    public void TestKafkaConsumer(){
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test-1");
        props.put("enable.auto.commit", "true");
        props.put("auto.commit.interval.ms", "1000");
        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("my-topic", "bar"));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                process(record);
            }
        }
    }

 在回调接口ConsumerRebalanceListener中定义了两个回调方法：

  1. onPartitionsRevoked(Collection<TopicPartition> partitions)：在这里我们可以提交偏移量操作以避免数据重复消费。
  2. onPartitionsAssigned(Collection<TopicPartition> partitions)：这个方法在平衡之后、消费者开始拉去消息之前被调用，一般在该方法中保证各消费者回滚到正确的偏移量，即重置各消费者消费偏移量。
public class JavaKafkaConsumer {
 
    static Properties props = new Properties();
 
    static {
        props.put("bootstrap.servers", "192.168.17.64:9092");
        props.put("group.id", "test");
        props.put("client.id", "test");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
 
    }
 
    public static void main(String[] args) {
        // 1.初始化消费者
        final KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
        // 2.订阅主题，指定一个监听器，用于在消费者发生平衡操作时回调响应的业务处理
        consumer.subscribe(Arrays.asList("java-topic_test"), new ConsumerRebalanceListener() {
            public void onPartitionsRevoked(Collection<TopicPartition> collection) {
                consumer.commitAsync(); // 提交偏移量
            }
 
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                // 获取该分区下已消费的偏移量
                long commitedOffset = -1;
                for (TopicPartition topicPartition : partitions) {
                    // 获取该分区下已消费的偏移量
                    commitedOffset = consumer.committed(topicPartition).offset();
                    // 重置偏移量到上一次提交的偏移量下一个位置处开始消费
                    consumer.seek(topicPartition, commitedOffset + 1);
                }
            }
        });
 
        try {
            while (true) {
                // 长轮询拉取消息
                ConsumerRecords<String, String> records = consumer.poll(1000);
                for (ConsumerRecord<String , String> record : records) {
                    System.out.printf("partition = %d, offset = %d,key= %s value = %s%n",
                            record.partition(), record.offset(),
                            record.key(),record.value());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            consumer.close();
        }
    }
}

 

三、订阅指定分区

      可以通过subscribe()方法订阅主题，也可以某些主题的特定分区。Kafka提供了assign(Collection<TopicPartition> partitions)方法来订阅指定分区。

      例如，我们指定消费者只订阅主题“test”的编号为0和1的分区：

consumer.assign(Arrays.asList(new TopicPartition("test", 0),new TopicPartition("test", 1) ));

向特定的分区订阅消息，会失去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中混用。

 

四、提交和偏移量

1、消费者为什么要提交偏移量

       当消费者崩溃或者有新的消费者加入，那么就会触发再均衡（rebalance），完成再均衡后，每个消费者可能会分配到新的分区，而不是之前处理那个，为了能够继续之前的工作，消费者需要读取每个partition最后一次提交的偏移量，然后从偏移量指定的地方继续处理。

2、提交偏移量可能带来的问题

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

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

3、提交偏移量的方式

       Kafka消费者消费位移确认有自动提交与手动提交两种策略。在创建KafkaConsumer对象时，通过参数enable.auto.commit设定，true表示自动提交（默认）。自动提交策略由消费者协调器（ConsumerCoordinator）每隔${auto.commit.interval.ms}毫秒执行一次偏移量的提交。手动提交需要由客户端自己控制偏移量的提交。

      (1) 自动提交offset

        enable.auto.commit设置成true（默认为true），那么每过5s，消费者自动把从poll()方法接收到的最大的偏移量提交。提交的时间间隔由auto.commit.interval.ms控制，默认是5s。

        自动提交的优点是方便，但是可能会重复处理消息

        例如，我们创建一个消费者，该消费者自动提交偏移量，采用显示设置为自动。

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");
/* 设置偏移量自动提交时间间隔 */
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的情况下，如果数据从kafka集群读出，就确认，但是持久化过程失败，就会导致数据丢失。我们就需要控制offset的确认。

      Kafka 提供了异步提交（commitAsync）及同步提交（commitSync）两种手动提交的方式。两者的主要区别在于同步模式下提交失败时一直尝试提交，直到遇到无法重试的情况下才会结束，同时，同步方式下消费者线程在拉取消息时会被阻塞，直到偏移量提交操作成功或者在提交过程中发生错误。而异步方式下消费者线程不会被阻塞，可能在提交偏移量操作的结果还未返回时就开始进行下一次的拉取操作，在提交失败时也不会尝试提交。

     实现手动提交前需要在创建消费者时关闭自动提交，即设置enable.auto.commit=false。然后在业务处理成功后调用commitAsync()或commitSync()方法手动提交偏移量。由于同步提交会阻塞线程直到提交消费偏移量执行结果返回，而异步提交并不会等消费偏移量提交成功后再继续下一次拉取消息的操作，因此异步提交还提供了一个偏移量提交回调的方法commitAsync(OffsetCommitCallback callback)。当提交偏移量完成后会回调OffsetCommitCallback 接口的onComplete()方法，这样客户端根据回调结果执行不同的逻辑处理。

  • 同步提交：

      将enable.auto.commit设置成false，让应用程序决定何时提交偏移量。commitSync()提交由poll()方法返回的最新偏移量，所以在处理完所有消息后要确保调用commitSync，否则会有消息丢失的风险。commitSync在提交成功或碰到无法恢复的错误之前，会一直重试。如果发生了再均衡，从最近一批消息到发生再均衡之间的所有消息都会被重复处理。

不足：broker在对提交请求作出回应之前，应用程序会一直阻塞，会限制应用程序的吞吐量。

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);
        try {
            //处理完当前批次的消息，在轮询更多的消息之前，调用commitSync方法提交当前批次最新的消息
            consumer.commitSync();
            buffer.clear();
        }catch (CommitFailedException e) {
            //只要没有发生不可恢复的错误，commitSync方法会一直尝试直至提交成功。如果提交失败，我们也只能把异常记录到错误日志里
            log.error("commit failed", e);
        }
    }
}
  • 异步提交：

       异步提交的commitAsync，只管发送提交请求，无需等待broker响应。commitAsync提交之后不进行重试，假设要提交偏移量2000，这时候发生短暂的通信问题，服务器接收不到提交请求，因此也就不会作出响应。与此同时，我们处理了另外一批消息，并成功提交了偏移量3000,。如果commitAsync重新尝试提交2000，那么它有可能在3000之后提交成功，这个时候如果发生再均衡，就会出现重复消息。

Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "test");
props.put("client.id", "test");
// 为了便于测试，这里设置一次fetch 请求取得的数据最大值为1KB,默认是5MB
props.put("fetch.max.bytes", 1024);
props.put("enable.auto.commit", false);// 设置手动提交偏移量
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("test"));
try {
    int minCommitSize = 10;// 最少处理10 条消息后才进行提交
    int icount = 0 ;// 消息计算器
    while (true) {
        // 等待拉取消息
        ConsumerRecords<String, String> records = consumer.poll(1000);
        for (ConsumerRecord<String, String> record : records) {
            // 简单打印出消息内容,模拟业务处理
            System.out.printf("partition = %d, offset = %d,key= %s value = %s%n", record. partition(), record.offset(), record.key(),record.value());
            icount++;
        }
        // 在业务逻辑处理成功后提交偏移量
        if (icount >= minCommitSize){
            consumer.commitAsync(new OffsetCommitCallback() {
                @Override
                public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception exception) {
                    if (null == exception) {
                        // TODO 表示偏移量成功提交
                        System.out.println("提交成功");
                    } else {
                        // TODO 表示提交偏移量发生了异常，根据业务进行相关处理
                        System.out.println("发生了异常");
                    }
                }
            });
            icount=0; // 重置计数器
        }
    }
} catch(Exception e){
    // TODO 异常处理
    e.printStackTrace();
} finally {
    consumer.close();
  •   同步和异步组合提交

        一般情况下，针对偶尔出现的提交失败，不进行重试不会有太大的问题，因为如果提交失败是因为临时问题导致的，那么后续的提交总会有成功的。但是如果在关闭消费者或再均衡前的最后一次提交，就要确保提交成功。

       因此，在消费者关闭之前一般会组合使用commitAsync和commitSync提交偏移量。

try {
　　while (true) {
   　　 ConsumerRecords<String, String> records = consumer.poll(100);
   　　 for (ConsumerRecord<String, String> record : records) {
   　　     System.out.println("topic = %s, partition = %s, offset = %d,         
     　　   customer = %s, country = %s\n", record.topic(),         
     　　   record.partition(), record.offset(), record.key(), 
      　　  record.value());
     　　}
        //如果一切正常，我们使用commitAsync来提交，这样速度更快，而且即使这次提交失败，下次提交很可能会成功
       consumer.commitAsync();
} catch (CommitFailedException e) {
    log.error("commit failed", e);
} finally {
    try {
       //关闭消费者前，使用commitSync，直到提交成成功或者发生无法恢复的错误
　　　　consumer.commitSync();
　　 } finally {
　　　　consumer.close();
　　 }
}

     (3) 提交特定的偏移量

       消费者API允许调用commitSync()和commitAsync()方法时传入希望提交的partition和offset的map，即提交特定的偏移量。

//用于跟踪偏移量的map
private Map<TopicPartition, OffsetAndMetadata> currentOffsets = new HashMap<>();
int count = 0;
while (true) {
    ConsumerRecords<String, String> records = consumer.poll(100);
    for (ConsumerRecord<String, String> record : records) {
        System.out.println("topic = %s, partition = %s, offset = %d,         
        customer = %s, country = %s\n", record.topic(),         
        record.partition(), record.offset(), record.key(), 
        record.value());//模拟对消息的处理
        //在读取每条消息后，使用期望处理的下一个消息的偏移量更新map里的偏移量。下一次就从这里开始读取消息
        currentOffsets.put(new TopicPartition(record.topic(), record.partition()), new OffsetAndMetadata(record.offset() + 1, “no matadata”));
        if (count++ % 1000 == 0) {
            //每处理1000条消息就提交一次偏移量，在实际应用中，可以根据时间或者消息的内容进行提交
            consumer.commitAsync(currentOffsets, null);
        }
    }

}

     (4) 提交具体分区具体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。

     (5) 再均衡监听器

      在为消费者分配新的partition或者移除旧的partition时，可以通过消费者API执行一些应用程序代码，在使用subscribe()方法时传入一个ConsumerRebalanceListener实例。

     ConsumerRebalanceListener需要实现的两个方法：

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

    2) public void onPartitionAssigned(Collection<TopicPartition> partitions)方法会在重新分配partition之后和消费者开始读取消息之前被调用。

private Map<TopicPartition, OffsetAndMetadata> currentOffsets = new HashMap<>();//用于跟踪偏移量的map

      private class HandleRebalance implements ConsumerRebalanceListener {
        @Override
        public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
        }

        @Override
        public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
        //如果发生再均衡，要在即将失去partition所有权时提交偏移量。
        //注意：（1）提交的是最近处理过的偏移量，而不是批次中还在处理的最后一个偏移量。因为partition有可能在我们还在处理消息时被撤回。
        //(2)我们要提交所有分区的偏移量，而不只是即将市区所有权的分区的偏移量。因为提交的偏移量是已经处理过的，所以不会有什么问题。
        //(3)调用commitSync方法，确保在再均衡发生之前提交偏移量
            consumer.commitSync(currentOffsets);
        }
      }
      try{
          consumer.subscribe(topics, new HandleRebalance());
          while (true) {
              ConsumerRecords<String, String> records = consumer.poll(100);
              for (ConsumerRecord<String, String> record : records) {
                  System.out.println("topic = %s, partition = %s, offset = %d,         
                  customer = %s, country = %s\n", record.topic(),         
                  record.partition(), record.offset(), record.key(), 
                  record.value());//模拟对消息的处理
                  //在读取每条消息后，使用期望处理的下一个消息的偏移量更新map里的偏移量。下一次就从这里开始读取消息
                  currentOffsets.put(new TopicPartition(record.topic(), record.partition()), new OffsetAndMetadata(record.offset() + 1, “no matadata”));
              }
              consumer.commitAsync(currentOffsets, null);
      } catch(WakeupException e) {
          //忽略异常，正在关闭消费者
      } catch (Exception e) {
          log.error("unexpected error", e);
      } finally {
          try{
              consumer.commitSync(currentOffsets);
          } finally {
              consumer.close();
          }
      }
}

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

     (6) 外部存储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掉。

    (7) 控制消费位置

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

 

五、SimpleConsumer查询

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import kafka.api.FetchRequest;
import kafka.api.FetchRequestBuilder;
import kafka.api.PartitionOffsetRequestInfo;
import kafka.common.ErrorMapping;
import kafka.common.TopicAndPartition;
import kafka.javaapi.FetchResponse;
import kafka.javaapi.OffsetResponse;
import kafka.javaapi.PartitionMetadata;
import kafka.javaapi.TopicMetadata;
import kafka.javaapi.TopicMetadataRequest;
import kafka.javaapi.consumer.SimpleConsumer;
import kafka.message.MessageAndOffset;
 
public class SimpleExample {
	private List<String> m_replicaBrokers = new ArrayList<String>();
 
	public SimpleExample() {
		m_replicaBrokers = new ArrayList<String>();
	}
 
	public static void main(String args[]) {
		SimpleExample example = new SimpleExample();
		// 最大读取消息数量
		long maxReads = Long.parseLong("3");
		// 要订阅的topic
		String topic = "mytopic";
		// 要查找的分区
		int partition = Integer.parseInt("0");
		// broker节点的ip
		List<String> seeds = new ArrayList<String>();
		seeds.add("192.168.4.30");
		seeds.add("192.168.4.31");
		seeds.add("192.168.4.32");
		// 端口
		int port = Integer.parseInt("9092");
		try {
			example.run(maxReads, topic, partition, seeds, port);
		} catch (Exception e) {
			System.out.println("Oops:" + e);
			e.printStackTrace();
		}

                /*  kafka获得partition下标，需要用到kafka的simpleconsumer
                TreeMap<Integer,PartitionMetadata> metadatas = kot.findLeader(seeds, port, topic);  
          
                int sum = 0;  
          
                for (Entry<Integer,PartitionMetadata> entry : metadatas.entrySet()) {  
                    int partition = entry.getKey();  
                    String leadBroker = entry.getValue().leader().host();  
                    String clientName = "Client_" + topic + "_" + partition;  
                    SimpleConsumer consumer = new SimpleConsumer(leadBroker, port, 100000,  
                    64 * 1024, clientName);  
                    long readOffset = getLastOffset(consumer, topic, partition,  
                                kafka.api.OffsetRequest.LatestTime(), clientName);  
                                sum += readOffset;  
                    System.out.println(partition+":"+readOffset);  
                    if(consumer!=null)consumer.close();  
                }  
                System.out.println("总和："+sum);
                */  
	}
 
	public void run(long a_maxReads, String a_topic, int a_partition, List<String> a_seedBrokers, int a_port) throws Exception {
		// 获取指定Topic partition的元数据
		PartitionMetadata metadata = findLeader(a_seedBrokers, a_port, a_topic, a_partition);
		if (metadata == null) {
			System.out.println("Can't find metadata for Topic and Partition. Exiting");
			return;
		}
		if (metadata.leader() == null) {
			System.out.println("Can't find Leader for Topic and Partition. Exiting");
			return;
		}
		String leadBroker = metadata.leader().host();
		String clientName = "Client_" + a_topic + "_" + a_partition;
 
		SimpleConsumer consumer = new SimpleConsumer(leadBroker, a_port, 100000, 64 * 1024, clientName);
		long readOffset = getLastOffset(consumer, a_topic, a_partition, kafka.api.OffsetRequest.EarliestTime(), clientName);
		int numErrors = 0;
		while (a_maxReads > 0) {
			if (consumer == null) {
				consumer = new SimpleConsumer(leadBroker, a_port, 100000, 64 * 1024, clientName);
			}
			FetchRequest req = new FetchRequestBuilder().clientId(clientName).addFetch(a_topic, a_partition, readOffset, 100000).build();
			FetchResponse fetchResponse = consumer.fetch(req);
 
			if (fetchResponse.hasError()) {
				numErrors++;
				// Something went wrong!
				short code = fetchResponse.errorCode(a_topic, a_partition);
				System.out.println("Error fetching data from the Broker:" + leadBroker + " Reason: " + code);
				if (numErrors > 5)
					break;
				if (code == ErrorMapping.OffsetOutOfRangeCode()) {
					// We asked for an invalid offset. For simple case ask for
					// the last element to reset
					readOffset = getLastOffset(consumer, a_topic, a_partition, kafka.api.OffsetRequest.LatestTime(), clientName);
					continue;
				}
				consumer.close();
				consumer = null;
				leadBroker = findNewLeader(leadBroker, a_topic, a_partition, a_port);
				continue;
			}
			numErrors = 0;
 
			long numRead = 0;
			for (MessageAndOffset messageAndOffset : fetchResponse.messageSet(a_topic, a_partition)) {
				long currentOffset = messageAndOffset.offset();
				if (currentOffset < readOffset) {
					System.out.println("Found an old offset: " + currentOffset + " Expecting: " + readOffset);
					continue;
				}
 
				readOffset = messageAndOffset.nextOffset();
				ByteBuffer payload = messageAndOffset.message().payload();
 
				byte[] bytes = new byte[payload.limit()];
				payload.get(bytes);
				System.out.println(String.valueOf(messageAndOffset.offset()) + ": " + new String(bytes, "UTF-8"));
				numRead++;
				a_maxReads--;
			}
 
			if (numRead == 0) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException ie) {
				}
			}
		}
		if (consumer != null)
			consumer.close();
	}
 
	public static long getLastOffset(SimpleConsumer consumer, String topic, int partition, long whichTime, String clientName) {
		TopicAndPartition topicAndPartition = new TopicAndPartition(topic, partition);
		Map<TopicAndPartition, PartitionOffsetRequestInfo> requestInfo = new HashMap<TopicAndPartition, PartitionOffsetRequestInfo>();
		requestInfo.put(topicAndPartition, new PartitionOffsetRequestInfo(whichTime, 1));
		kafka.javaapi.OffsetRequest request = new kafka.javaapi.OffsetRequest(requestInfo, kafka.api.OffsetRequest.CurrentVersion(), clientName);
		OffsetResponse response = consumer.getOffsetsBefore(request);
 
		if (response.hasError()) {
			System.out.println("Error fetching data Offset Data the Broker. Reason: " + response.errorCode(topic, partition));
			return 0;
		}
		long[] offsets = response.offsets(topic, partition);
                // long[] offsets2 = response.offsets(topic, 3);  
		return offsets[0];
	}
 
	/**
	 * @param a_oldLeader
	 * @param a_topic
	 * @param a_partition
	 * @param a_port
	 * @return String
	 * @throws Exception
	 *             找一个leader broker
	 */
	private String findNewLeader(String a_oldLeader, String a_topic, int a_partition, int a_port) throws Exception {
		for (int i = 0; i < 3; i++) {
			boolean goToSleep = false;
			PartitionMetadata metadata = findLeader(m_replicaBrokers, a_port, a_topic, a_partition);
			if (metadata == null) {
				goToSleep = true;
			} else if (metadata.leader() == null) {
				goToSleep = true;
			} else if (a_oldLeader.equalsIgnoreCase(metadata.leader().host()) && i == 0) {
				// first time through if the leader hasn't changed give
				// ZooKeeper a second to recover
				// second time, assume the broker did recover before failover,
				// or it was a non-Broker issue
				//
				goToSleep = true;
			} else {
				return metadata.leader().host();
			}
			if (goToSleep) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException ie) {
				}
			}
		}
		System.out.println("Unable to find new leader after Broker failure. Exiting");
		throw new Exception("Unable to find new leader after Broker failure. Exiting");
	}
 
	private PartitionMetadata findLeader(List<String> a_seedBrokers, int a_port, String a_topic, int a_partition) {
                //TreeMap<Integer, PartitionMetadata> map = new TreeMap<Integer, PartitionMetadata>();
		PartitionMetadata returnMetaData = null;
		loop: for (String seed : a_seedBrokers) {
			SimpleConsumer consumer = null;
			try {
				consumer = new SimpleConsumer(seed, a_port, 100000, 64 * 1024, "leaderLookup");
				List<String> topics = Collections.singletonList(a_topic);
				TopicMetadataRequest req = new TopicMetadataRequest(topics);
				kafka.javaapi.TopicMetadataResponse resp = consumer.send(req);
 
				List<TopicMetadata> metaData = resp.topicsMetadata();
				for (TopicMetadata item : metaData) {
					for (PartitionMetadata part : item.partitionsMetadata()) {
                                                //map.put(part.partitionId(), part);  
						if (part.partitionId() == a_partition) {
							returnMetaData = part;
							break loop;
						}
					}
				}
			} catch (Exception e) {
				System.out.println("Error communicating with Broker [" + seed + "] to find Leader for [" + a_topic + ", " + a_partition + "] Reason: " + e);
			} finally {
				if (consumer != null)
					consumer.close();
			}
		}
		if (returnMetaData != null) {
			m_replicaBrokers.clear();
			for (kafka.cluster.Broker replica : returnMetaData.replicas()) {
				m_replicaBrokers.add(replica.host());
			}
		}
		return returnMetaData;
                // return map;
	}
}

      67行调用的getLastOffset方法，方法中有一个kafka.api.OffsetRequest.EarliestTime()这样的参数，用这个参数的时候不能及时的返回offset，总是返回0。换成kafka.api.OffsetRequest.LatestTime()，就可以及时的取到offset值了！（https://blog.csdn.net/zhouyu7373/article/details/39025691、http://blackproof.iteye.com/blog/2217388）

六、以时间戳查询消息

       Kafka 在0.10.1.1 版本增加了时间戳索引文件，因此我们除了直接根据偏移量索引文件查询消息之外，还可以根据时间戳来访问消息。consumer-API 提供了一个offsetsForTimes(Map<TopicPartition, Long> timestampsToSearch)方法，该方法入参为一个Map 对象，Key 为待查询的分区，Value 为待查询的时间戳，该方法会返回时间戳大于等于待查询时间的第一条消息对应的偏移量和时间戳。需要注意的是，若待查询的分区不存在，则该方法会被一直阻塞。

        假设我们希望从某个时间段开始消费，那们就可以用offsetsForTimes()方法定位到离这个时间最近的第一条消息的偏移量，在查到偏移量之后调用seek(TopicPartition partition, long offset)方法将消费偏移量重置到所查询的偏移量位置，然后调用poll()方法长轮询拉取消息。例如，我们希望从主题“stock-quotation”第0 分区距离当前时间相差12 小时之前的位置开始拉取消息。

Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "test");
props.put("client.id", "test");
props.put("enable.auto.commit", true);// 显示设置偏移量自动提交
props.put("auto.commit.interval.ms", 1000);// 设置偏移量提交时间间隔
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.assign(Arrays.asList(new TopicPartition("test", 0)));
try {
    Map<TopicPartition, Long> timestampsToSearch = new HashMap<TopicPartition,Long>();
    // 构造待查询的分区
    TopicPartition partition = new TopicPartition("stock-quotation", 0);
    // 设置查询12 小时之前消息的偏移量
    timestampsToSearch.put(partition, (System.currentTimeMillis() - 12 * 3600 * 1000));
    // 会返回时间大于等于查找时间的第一个偏移量
    Map<TopicPartition, OffsetAndTimestamp> offsetMap = consumer.offsetsForTimes (timestampsToSearch);
    OffsetAndTimestamp offsetTimestamp = null;
    // 这里依然用for 轮询，当然由于本例是查询的一个分区，因此也可以用if 处理
    for (Map.Entry<TopicPartition, OffsetAndTimestamp> entry : offsetMap.entrySet()) {
        // 若查询时间大于时间戳索引文件中最大记录索引时间，
        // 此时value 为空,即待查询时间点之后没有新消息生成
        offsetTimestamp = entry.getValue();
        if (null != offsetTimestamp) {
        // 重置消费起始偏移量
        consumer.seek(partition, entry.getValue().offset());
        }
    }
    while (true) {
        // 等待拉取消息
        ConsumerRecords<String, String> records = consumer.poll(1000);
        for (ConsumerRecord<String, String> record : records){
            // 简单打印出消息内容
            System.out.printf("partition = %d, offset = %d,key= %s value = %s%n", record.partition(), record.offset(), record.key(),record.value());
        }
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    consumer.close();
}

 

七、控制消费流 Consumption Flow Control

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

      调控的手段：让某个分区消费先暂停，时机到了再恢复，然后接着poll。提供 pause(Collection<TopicPartition> partitions)和resume(Collection<TopicPartition>
partitions)方法，分别用来暂停某些分区在拉取操作时返回数据给客户端和恢复某些分区向客户端返回数据操作。通过这两个方法可以对消费速度加以控制，结合业务使用。

 

八、多线程处理模型 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();
    }
}

说明： 
1. KafkaConsumerRunner是runnable的，请自觉补脑多线程运行； 
2. 外部线程控制KafkaConsumerRunner线程的停止； 
3. 主要说的是多线程消费同一topic，而不是消费同一分区；

比较一下两种模型：

Consumer单线程模型

优点：实现容易； 
优点：没有线程之间的协作。通常比下面的那种更快； 
优点：单分区数据的顺序处理； 
缺点：多个TCP连接，但是关系不大，kafka对自己的server自信满满； 
缺点：太多的Request可能导致server的吞吐降低一丢丢； 
缺点：consumer数量受到分区数量限制，一个consumer一个分区；

Consumer多线程模型

优点：一个consumer任意多的线程，线程数不用受到分区数限制； 
缺点：如果有保序需求，自己要加控制逻辑； 
缺点：该模型中如果手动offset，自己要加控制逻辑； 
一种可行的解决办法：为每个分区分配独立的存储，获取的数据根据数据所在分区进行hash存储。这样可以解决顺序消费，和offset的确认问题。

疑问：

对比两种线程模型时，应该是有隐藏地图的。 
1. 单线程模型中，多分区情况下，应该说的是每个Consumer独立去消费一个分区； 
2. 多线程模型中，单Consumer消费一个Topic。如果多个线程同时消费同一分区，也就是要公用连接了，各个线程之间要做好同步； 
3. 对于多线程模型下提出的客户端分区数据分开存储，各个分区之间是如何保序的？ 

（转载地址：https://blog.csdn.net/xianzhen376/article/details/51167742）

 

九、从zookeeper中动态读取kafka集群中brokers

      kafka集群中producer和consumer都依赖于zookeeper来保证系统可用性集群保存一些meta信息。

public class KafkaBrokerInfoFetcher {
 
    public static void main(String[] args) throws Exception {
        ZooKeeper zk = new ZooKeeper("localhost:2181", 10000, null);
        List<String> ids = zk.getChildren("/brokers/ids", false);
        for (String id : ids) {
            String brokerInfo = new String(zk.getData("/brokers/ids/" + id, false, null));
            System.out.println(id + ": " + brokerInfo);
        }
    }
}

结果如下：

1: {"jmx_port":-1,"timestamp":"1428512949385","host":"192.168.0.11","version":1,"port":9093}
2: {"jmx_port":-1,"timestamp":"1428512955512","host":"192.168.0.11","version":1,"port":9094}
3: {"jmx_port":-1,"timestamp":"1428512961043","host":"192.168.0.11","version":1,"port":9095}

转载地址：https://blog.csdn.net/qq_25827845/article/details/56049022

learn_tech
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kafka - 新消费者
用时间去蜕变
04-20 1065
Kafka - 新消费者 一、数据来源 数据使用上一个博文所配置的 Flume，将文本数据写入到 Kafka中。不过这次有所改变，数据的监控目录 有所改变，写入的Kafka的主题名也变更为A25。 这里我们可以看到 Flume 对于新传上去的 A91 数据已经完成消费。 二、消费者代码 2.1 创建消费者 创建消费者所使用的属性和生产者使用的属性差距不是很大： ...
Kafka实践之Consumer
【逸辰杳】的博客
01-01 2341
本文设计的所有代码详见Github 上手Kafka Consumer是比较容易的，这里以原生的Java API为例，通常的实现逻辑如下所示： public void consumer() { String brokers = &amp;quot;localhost:9092&amp;quot;; String group = &amp;quot;group_test&amp;quot;; String topic...
kafka消费者之seek方法
杜海的博客
10-26 4475
继续kafka学习之旅。今天学习的还是<深入理解kafka-核心设计与实践原理>一书。上一篇博客，学习了消费者，今天继续学习消费者。 auto.offset.reset。这个参数的意思是：当kafka消费者在_consumer_offset主题中找不到所属分区的offset时，该参数就派上用场了，改参数有三个可选值，latest、earilst、none。第一个取值是说，当消费者找不到偏移量时，就从日志尾部开始消费，earilst是从日志头部开始消费。none是既不从头也不从尾，而是抛出NoOf
kafka生产消费流程
最新发布
m0_62645012的博客
06-09 1265
1.生产者先从zookeeper的"/brokers/topic/主题名/partitions/分区名/state"节点找到该partition的leader。比如，消费者可以重置到旧的偏移量，重新处理之前已经消费过的消息；或者直接跳到最近的位置，从当前的时刻开始消费。kafka采用拉取模型，由消费者自己记录消费状态，每个消费者相互独立的顺序拉取消息。leader接收到所有的ISR中的Replica的ACK中，并向生产者返回ACK。broker进程上的leader将消息写入到本地log中。
kafka新版本的消费者与生产者
weixin_44928340的博客
08-28 270
kafka新版本的生产者与消费者 0.11后的版本 生产者：KafkaProducer import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; import java.util.Properties; import java.util.concurrent.TimeUnit; import org.apache.kafka.client
kafka 从指定位置消费 seek
mhbsoft的博客
11-28 3030
KafkaContext.java public class KafkaContext { public static String brokerList = "192.168.131.130:9092"; public static String topic = "heilu"; public static String groupId = "group.heilu"; ...
go-kafka-example:Golang Kafka消费者和生产者示例
05-06
示例Golang Kafka消费者和生产者 设置 制片人 go run cmd/producer/main.go 消费者 标志： brokerList 话题 分区（默认值：0） offsetType messageCountStart（默认值：0） go run cmd/consumer/main.go ...
erlang-kafka:Erlang 的 Kafka 消费者协议
06-23
EKC 是的 Erlang 客户端，目前提供的消费者 API，是一个高吞吐量的分布式消息传递系统。 建造 EKC 使用 。 要构建运行make 。 客户 Kafka 协议客户端作为 OTP gen_server运行。 范围 描述 默认 笔记 主持人 要连接...
kafka-consumer:简单的 Scala Kafka 消费者
06-13
在本文中，我们将深入探讨如何使用 Scala 创建一个简单的 Kafka 消费者，以便与 Kafka 集群进行交互。Kafka 是一个分布式流处理平台，广泛用于实时数据处理和消息传递。而 Scala 是一种功能丰富的编程语言，它与 ...
Java实现Kafka生产者消费者代码实例
08-19
主要介绍了Java实现Kafka生产者消费者代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Kafka实战：KafkaConsumer#seek方法不生效
foureyes
01-28 1839
文章目录1. 背景2. 示例3. 结论 1. 背景 现需要在Kafka管理平台中加入数据预览功能，浏览topic最新的10条数据，我们需要用startOffset = HighWatermark - 10公式求出起始startOffset，从startOffset开始查询分区中的数据。 但是，在使用KafkaConsumer#seek方法设置offset时不生效，KafkaConsumer#poll始终无法拉取到历史数据，更精确地说，始终只能拉取到最新插入的数据。 环境： CDH 6.3.2 Kafka
kafka seek方法
杜海的博客
10-29 3706
我们知道消息的拉取是根据poll（）方法中的逻辑来处理的，这个poll（）方法中的逻辑对于普通的开发人员而言是一个黑盒，无法精确地掌控其消费的起始位置。提供的auto.offset.reset 参数也只能在找不到消费位移或位移越界的情况下粗粒度地从开头或 末尾开始消费。有些时候，我们需要一种更细粒度的掌控，可以让我们从特定的位移处开始拉取消息，而KafkaConsumer 中的seek（）方法正好提供了这个功能，让我们得以追前消费或回溯消费。seek（）方法的具体定义如下： public void se
《Kafka权威指南》——问题1——onParitionsAssigned
kennyJ的博客
01-05 1328
四、Kafka消费者——从Kafka读取数据 4.8 从特定偏移量处开始处理数据 4.7节中说到，在调用subcribe()方法时传进去一个ConsumerRebalanceListener实例，可以在为消费者分配新分区或移除分区时，可以调用执行一些代码。 onPartitionsRevoked 方法会在再均衡开始之前和消费者读取消息之后被调用 onParitionsAssigned 方法会在重新分配分区之后和消费者开始读取消息之前被调用 4.8节中，使用seek()方法，并在消费者启动或分配到新分区时
kafka之消费者进阶
Qynwang的博客
05-13 909
消费者组：一个消费者组包含多个消费者。同一个消费组的消费者，分别消费不同的partition，便于加快消费。kafka约定在一个消费者组中，对于同一个topic，每个consumer会分配不同partition，即topic下的一个patition只能被同一个消费者组的一个消费者消费，所以当消费组中的消费者个数大于partition个数时，会存在消费者闲置的情况，因为分不到partition.
一文读懂kafka消息拉取机制｜线程拉取模型
weixin_42179304的博客
03-31 483
又是一年求职季，在这里，我为各位准备了一套Java程序员精选高频面试笔试真题，来帮助大家攻下BAT的offer，题目范围从初级的Java基础到高级的分布式架构等等一系列的面试题和答案，用于给大家作为参考以下是部分内容截图《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！试题和答案，用于给大家作为参考以下是部分内容截图[外链图片转存中…(img-onpAMIUb-1711868214199)]
Kafka的assign和subscribe订阅模式和手动提交偏移量(单个分区、多分区)
weixin_42409103的博客
06-21 1580
kafka 消费 单个分区 多个分区
Kafka的生产者和消费者的线程模型是怎样的？Kafka的数据压缩算法有哪些？Kafka如何处理消费者的故障？Kafka如何处理生产者的故障？
luoluoal的博客
07-07 262
自动均衡：当消费者加入或离开消费者组时，Kafka会自动重新分配分区，以确保每个消费者组中的消费者数量均衡。这样可以确保当一个消费者故障时，其他消费者可以接管故障消费者的分区。需要注意的是，生产者和消费者的线程模型是基于Java客户端实现的，其他语言的客户端可能有不同的设计。消息持久化：Kafka使用磁盘存储消息，即使生产者故障或重启，消息仍然可以被消费者读取。总的来说，Kafka通过数据持久化、数据复制、ISR机制、消息重试、心跳检测和容错机制等多种方式来处理生产者的故障，确保数据的可靠性和持久性。
Kafka的分区分配问题
从此一心向前，别无它念
08-28 1966
Kafka的分区分配主要包括三点：生产者的分区分配，消费者的分区分配，broker端的分区分配。 1、生产者的分区分配 Producer调用send方法发送消息到broker时，中间可能会经过拦截器、序列化器、分区器，当消息ProducerRecord指定了partition字段，则就不需要分区器的作用，会直接发送到指定的partition中，如果没有指定partition字段，那么就会采用分区器...
kafka消费者负载
02-23
Kafka消费者负载是指将消息从Kafka主题中读取并处理的过程。Kafka的消费者负载可以通过以下几个方面来进行优化和管理： 1. 分区分配策略：Kafka提供了多种分区分配策略，用于将主题的分区分配给消费者组中的消费者。常见的策略有RoundRobin、Range和Sticky等。这些策略可以根据消费者的数量和负载情况来进行选择，以实现负载均衡。 2. 消费者组管理：Kafka使用消费者组来管理消费者，每个消费者组可以有多个消费者。消费者组内的消费者可以共同消费一个主题的消息，并且每个分区只能由一个消费者来消费。通过合理管理和配置消费者组，可以实现消费者负载的均衡。 3. 并行处理：Kafka允许多个消费者并行地处理消息，以提高处理能力和吞吐量。通过增加消费者的数量，可以将负载分散到多个消费者上，从而提高整体的处理效率。 4. 监控和调优：监控消费者的负载情况是优化和管理的关键。可以通过监控指标如消费速率、延迟、偏移量等来评估消费者的负载情况，并根据需要进行调整和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值