大数据生态系统基础:Apache Kafka基础(三):最新kafka编程入门:Consumer

 生产者将信息输入到集群中, 那么消费者就要能从集群中取出所需要的信息。

        主要的类就是: KafkaConsumer

一、原理

       Kafka的一个分区的每一个记录保持一个数值偏移。这个偏移量作为该分区内记录的惟一标识符,并表示该分区中的使用者的位置。例如,处于位置5的消费者使用偏移量0到4的记录,然后将使用偏移量5来接收记录。

    消费者api提供了覆盖各种消费用例的灵活性。

二、自动位移提交

     以下是完成的程序案例

[java]  view plain  copy
  1. package wangxn.testConsumer;  
  2.   
  3.   
  4. import java.util.Collections;  
  5. import java.util.Properties;  
  6.   
  7.   
  8. import org.apache.kafka.clients.consumer.ConsumerRecord;  
  9. import org.apache.kafka.clients.consumer.ConsumerRecords;  
  10. import org.apache.kafka.clients.consumer.KafkaConsumer;  
  11. import org.apache.kafka.clients.consumer.ConsumerConfig;  
  12. public class autoConsumer {  
  13. "white-space:pre;"private static KafkaConsumer consumer;  
  14. "white-space:pre;"  
  15. "white-space:pre;"public static void main(String[] args) {  
  16. "white-space:pre;">     // TODO Auto-generated method stub  
  17. "white-space:pre;">     Properties props = new Properties();  
  18. "white-space:pre;"     props.put("bootstrap.servers""mymac:9092");  
  19. "white-space:pre;"     props.put("group.id""DemoConsumer");  
  20. "white-space:pre;"     props.put("enable.auto.commit""true");  
  21. "white-space:pre;"     props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");  
  22. "white-space:pre;"     props.put("auto.commit.interval.ms""30000");  
  23. "white-space:pre;"     props.put("key.deserializer""org.apache.kafka.common.serialization.StringDeserializer");  
  24. "white-space:pre;"     props.put("value.deserializer""org.apache.kafka.common.serialization.StringDeserializer");  
  25. "white-space:pre;"       
  26. "white-space:pre;"     //consumer.subscribe(Arrays.asList("foo", "bar"));  
  27. "white-space:pre;"     consumer = new KafkaConsumer<>(props);  
  28. "white-space:pre;"    
  29. "white-space:pre;"       
  30. "white-space:pre;"     while (true) {  
  31. "white-space:pre;"    "white-space:pre;">          
  32. "white-space:pre;"    "white-space:pre;">         consumer.subscribe(Collections.singletonList("my-topic"));  
  33. "white-space:pre;"         ConsumerRecords records = consumer.poll(1000);  
  34. "white-space:pre;"         for (ConsumerRecord record : records)   
  35. "white-space:pre;"             System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());  
  36. "white-space:pre;"         //consumer.close();  
  37. "white-space:pre;"     }  
  38. "white-space:pre;"          
  39. "white-space:pre;"}  
  40.   
  41.   
  42. }  
       其中,设置   enable.auto.commit  为 true, 就是偏移量可以按照一定的频率自动提交。 auto.commit.interval.ms  就是用来设置频率的。

        程序是不断运行的。运行结果就是:

         producer 端发送消息:

$ kafka-console-producer.sh --broker-list mymac:9092 --topic my-topic

>dajia
>ceshi
>ok, quickly
>

本程序将接收消息:

大数据生态系统基础:Apache Kafka基础(三):最新kafka编程入门:Consumer_第1张图片

 三、手动偏移量控制

          这将设置 enable.auto.commit 为 false

         用户不必依赖于使用者定期提交消耗的偏移量,还可以控制记录何时被视为消耗,从而提交他们的偏移量。当消息的消费与某些处理逻辑结合在一起时,这是很有用的,因此在完成处理之前,不应该将消息视为消费。

[java]  view plain  copy
  1. Properties props = new Properties();  
  2. props.put("bootstrap.servers""localhost:9092");  
  3. props.put("group.id""test");  
  4. props.put("enable.auto.commit""false");  
  5. props.put("key.deserializer""org.apache.kafka.common.serialization.StringDeserializer");  
  6. props.put("value.deserializer""org.apache.kafka.common.serialization.StringDeserializer");  
  7. KafkaConsumer consumer = new KafkaConsumer<>(props);  
  8. consumer.subscribe(Arrays.asList("foo""bar"));  
  9. final int minBatchSize = 200;  
  10. List> buffer = new ArrayList<>();  
  11. while (true) {  
  12.     ConsumerRecords records = consumer.poll(100);  
  13.     for (ConsumerRecord record : records) {  
  14.         buffer.add(record);  
  15.     }  
  16.     if (buffer.size() >= minBatchSize) {  
  17.         insertIntoDb(buffer);  
  18.         consumer.commitSync();  
  19.         buffer.clear();  
  20.     }  
  21. }  

       在本例中,我们将使用一批记录,并在内存中对它们进行批处理。当我们有足够的记录时,我们将把它们插入到一个数据库中。如果我们允许在前面的示例中使用补偿来进行自动提交,那么在Poll 中返回给用户之后,记录将被认为是消耗的。这样,我们的进程在批处理记录之后可能会失败,但是在它们被插入到数据库之前。
为了避免这种情况,我们将在将相应的记录插入到数据库之后手工提交补偿。这使我们精确地控制了记录被认为是消耗的时间。这就产生了相反的可能性:在插入到数据库之后,进程可能会失败,但是在提交之前(尽管可能只有几毫秒,但这是有可能的)。在这种情况下,接管消费的过程将消耗最后一次提交的偏移量,并将重复最后一批数据的插入。使用这种方式,Kafka提供了通常被称为“最少一次”的交付保证,因为每一次记录都可能被交付一次,但在失败案例中可能会被重复。

     注意:使用自动偏移量提交也可以给您“至少一次”的交付,但是需求是您必须在任何后续调用之前,或者在关闭客户之前,使用从每个调用返回的所有数据(给 Poll)。如果您没有执行这两种操作,那么就有可能被提交的偏移量超出所消耗的位置,从而导致丢失的记录。使用手动补偿控制的优点是,当记录被认为是“消耗”时,您可以直接控制。

             上面的例子是用 CommitSync 去标记所有已经提交的接收记录。在某些情况下,您可能希望通过显式地指定偏移量来更好地控制哪些记录被提交。在下面的例子中,我们在处理完每个分区中的记录之后,提交了偏移量。

    

[java]  view plain  copy
  1. try {  
  2.         while(running) {  
  3.             ConsumerRecords records = consumer.poll(Long.MAX_VALUE);  
  4.             for (TopicPartition partition : records.partitions()) {  
  5.                 List> partitionRecords = records.records(partition);  
  6.                 for (ConsumerRecord record : partitionRecords) {  
  7.                     System.out.println(record.offset() + ": " + record.value());  
  8.                 }  
  9.                 long lastOffset = partitionRecords.get(partitionRecords.size() - 1).offset();  
  10.                 consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));  
  11.             }  
  12.         }  
  13.     } finally {  
  14.       consumer.close();  
  15.     }  
注意:提交的偏移量应该始终是应用程序将要读取的下一条消息的偏移量。因此,当调用   commitSync(offsets)   时,您应该将一个添加到处理的最后一条消息的偏移量。


四、手动分配 Partition

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

五、采用多线程来进行处理

         下面是完整的程序,不解释。

        

[java]  view plain  copy
  1. package wangxn.testkafka;  
  2.   
  3. import kafka.utils.ShutdownableThread;  
  4.   
  5.   
  6. import org.apache.kafka.clients.consumer.ConsumerConfig;  
  7. import org.apache.kafka.clients.consumer.ConsumerRecord;  
  8. import org.apache.kafka.clients.consumer.ConsumerRecords;  
  9. import org.apache.kafka.clients.consumer.KafkaConsumer;  
  10.   
  11. import java.util.Collections;  
  12. import java.util.Properties;  
  13.   
  14. public class myConsumer extends ShutdownableThread {  
  15.   
  16.   
  17.     private final KafkaConsumer consumer;  
  18.         private final String topic;  
  19.   
  20.         public myConsumer(String topic) {  
  21.             super("KafkaConsumerExample"false);  
  22.             Properties props = new Properties();  
  23.             props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "mymac:9092");  
  24.             props.put(ConsumerConfig.GROUP_ID_CONFIG, "DemoConsumer");  
  25.             props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");  
  26.             props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");  
  27.             props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "30000");  
  28.             props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.IntegerDeserializer");  
  29.             props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");  
  30.   
  31.             consumer = new KafkaConsumer(props);  
  32.             this.topic = topic;  
  33.           
  34.         }  
  35.   
  36.         @Override  
  37.         public void doWork() {  
  38.           
  39.             consumer.subscribe(Collections.singletonList(this.topic));  
  40.            // System.err.println("consumer.subscribe!");  
  41.             ConsumerRecords records = consumer.poll(3000);  
  42.             
  43.             for (ConsumerRecord record : records)   
  44.                 System.out.println("Received message: (" + record.key() + ", " + record.value() + ") at offset " + record.offset());  
  45.               
  46.         }  
  47.   
  48.         @Override  
  49.         public String name() {  
  50.             return null;  
  51.         }  
  52.   
  53.         @Override  
  54.         public boolean isInterruptible() {  
  55.             return false;  
  56.         }  
  57.   
  58. }  

你可能感兴趣的:(大数据生态系统基础:Apache Kafka基础(三):最新kafka编程入门:Consumer)