使用JAVA的Kafka消费者

我有一个Kafka代理，有多个主题，每个主题都有一个分区

我有一个消费者，它可以很好地使用主题中的消息

我的问题是，我需要通过增加分区的数量来提高消息队列的吞吐量，比如说，我在一个主题上有四个分区，有没有一种方法可以让我编写四个消费者，每个消费者都指向该主题上的各个分区

import java.util.*;
import kafka.consumer.Consumer;
import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;

public class KafkaConsumer {
   private ConsumerConnector consumerConnector = null;
   private final String topic = "mytopic";

   public void initialize() {
         Properties props = new Properties();
         props.put("zookeeper.connect", "localhost:2181");
         props.put("group.id", "testgroup");
         props.put("zookeeper.session.timeout.ms", "400");
         props.put("zookeeper.sync.time.ms", "300");
         props.put("auto.commit.interval.ms", "1000");
         ConsumerConfig conConfig = new ConsumerConfig(props);
         consumerConnector = Consumer.createJavaConsumerConnector(conConfig);
   }

   public void consume() {
         //Key = topic name, Value = No. of threads for topic
         Map<String, Integer> topicCount = new HashMap<String, Integer>();       
         topicCount.put(topic, new Integer(1));

         //ConsumerConnector creates the message stream for each topic
         Map<String, List<KafkaStream<byte[], byte[]>>> consumerStreams =
               consumerConnector.createMessageStreams(topicCount);         

         // Get Kafka stream for topic 'mytopic'
         List<KafkaStream<byte[], byte[]>> kStreamList =
                                              consumerStreams.get(topic);
         // Iterate stream using ConsumerIterator
         for (final KafkaStream<byte[], byte[]> kStreams : kStreamList) {
                ConsumerIterator<byte[], byte[]> consumerIte = kStreams.iterator();

                while (consumerIte.hasNext())
                       System.out.println("Message consumed from topic
                                     [" + topic + "] : "       +
                                       new String(consumerIte.next().message()));              
         }
         //Shutdown the consumer connector
         if (consumerConnector != null)   consumerConnector.shutdown();          
   }

   public static void main(String[] args) throws InterruptedException {
         KafkaConsumer kafkaConsumer = new KafkaConsumer();
         // Configure Kafka consumer
         kafkaConsumer.initialize();
         // Start consumption
         kafkaConsumer.consume();
   }

import java.util.*；
进口卡夫卡消费品；
导入kafka.consumer.ConsumerConfig；
导入kafka.consumer.ConsumerIterator；
进口kafka.consumer.KafkaStream；
导入kafka.javaapi.consumer.ConsumerConnector；
公共类卡夫卡消费者{
私有ConsumerConnector ConsumerConnector=null；
私有最终字符串topic=“mytopic”；
公共无效初始化（）{
Properties props=新属性（）；
props.put（“zookeeper.connect”，“localhost:2181”）；
props.put（“group.id”、“testgroup”）；
props.put（“zookeeper.session.timeout.ms”，“400”）；
道具放置（“zookeeper.sync.time.ms”，“300”）；
props.put（“auto.commit.interval.ms”，“1000”）；
ConsumerConfig conConfig=新的ConsumerConfig（道具）；
consumerConnector=Consumer.createJavaConsumerConnector（conConfig）；
}
公共消费（）{
//Key=主题名称，Value=主题的线程数
Map topicCount=new HashMap（）；
topicCount.put（主题，新整数（1））；
//ConsumerConnector为每个主题创建消息流
映射用户流=
consumerConnector.createMessageStreams（topicCount）；
//获取主题“mytopic”的卡夫卡流
列表kStreamList=
consumerStreams.get（主题）；
//使用ConsumerIterator迭代流
对于（最终KafkaStream kStreams:kStreamList）{
ConsumerIterator consumerIte=kStreams.iterator（）；
while（consumerIte.hasNext（））
System.out.println（“主题中使用的消息
[“+主题+”]：“+
新字符串（consumerIte.next（）.message（））；
}
//关闭耗电元件连接器
如果（consumerConnector！=null）consumerConnector.shutdown（）；
}
公共静态void main（字符串[]args）引发InterruptedException{
卡夫卡消费者卡夫卡消费者=新卡夫卡消费者（）；
//配置卡夫卡消费者
kafkaConsumer.initialize（）；
//开始消费
kafkaConsumer.consume（）；
}

---

}

本质上，您所需要做的就是启动多个消费者，这些消费者都属于同一消费者群体。如果您使用的是kafka 0.9或更高版本的新使用者，或者如果您使用的是高级使用者，kafka将负责划分分区，确保每个分区由一个使用者读取。如果分区多于使用者，则某些使用者将从多个分区接收消息，但同一使用者组中的多个使用者不会读取任何分区，以确保消息不重复。因此，您永远不希望消费者多于分区，因为有些消费者将处于空闲状态。您还可以使用简单使用者微调哪个使用者读取每个分区

您似乎正在使用卡夫卡0.8或更早版本的旧消费者。你可能想考虑转换到新的消费者。

下面是另一篇很好的文章，详细介绍了如何使用新消费者编写消费者：