漫遊Kafka實戰篇之客戶端API

原文地址：http://blog.csdn.net/honglei915/article/details/37697655

Kafka Producer APIs

舊版的Procuder API有兩種：kafka.producer.SyncProducer和kafka.producer.async.AsyncProducer.它們都實現了同一個接口：

 

[java] view plaincopy

1. class Producer {  
2.       
3.   /* 將消息發送到指定分區 */    
4.   public void send(kafka.javaapi.producer.ProducerData<K,V> producerData);  
5.   
6.   /* 批量發送一批消息 */    
7.   public void send(java.util.List<kafka.javaapi.producer.ProducerData<K,V>> producerData);  
8.   
9.   /* 關閉producer */    
10.   public void close();  
11.   
12. }  

 

新版的Producer API提供了以下功能：

 

1. 可以將多個消息緩存到本地隊列裏，然後異步的批量發送到broker，可以通過參數producer.type=async做到。緩存的大小可以通過一些參數指定：queue.time和batch.size。一個後臺線程（(kafka.producer.async.ProducerSendThread）從隊列中取出數據並讓kafka.producer.EventHandler將消息發送到broker，也可以通過參數event.handler定製handler，在producer端處理數據的不同的階段註冊處理器，比如可以對這一過程進行日誌追蹤，或進行一些監控。只需實現kafka.producer.async.CallbackHandler接口，並在callback.handler中配置。
2. 自己編寫Encoder來序列化消息，只需實現下面這個接口。默認的Encoder是kafka.serializer.DefaultEncoder。

   [java] view plaincopy

   1. interface Encoder<T> {  
   2.   public Message toMessage(T data);  
   3. }  
3. 提供了基於Zookeeper的broker自動感知能力，可以通過參數zk.connect實現。如果不使用Zookeeper，也可以使用broker.list參數指定一個靜態的brokers列表，這樣消息將被隨機的發送到一個broker上，一旦選中的broker失敗了，消息發送也就失敗了。
4. 通過分區函數kafka.producer.Partitioner類對消息分區。

   [java] view plaincopy

   1. interface Partitioner<T> {  
   2.    int partition(T key, int numPartitions);  
   3. }  
   分區函數有兩個參數：key和可用的分區數量，從分區列表中選擇一個分區並返回id。默認的分區策略是hash(key)%numPartitions.如果key是null,就隨機的選擇一個。可以通過參數partitioner.class定製分區函數。

 

新的api完整實例如下：

 

[java] view plaincopy

1. import java.util.*;  
2.    
3. import kafka.javaapi.producer.Producer;  
4. import kafka.producer.KeyedMessage;  
5. import kafka.producer.ProducerConfig;  
6.    
7. public class TestProducer {  
8.     public static void main(String[] args) {  
9.         long events = Long.parseLong(args[0]);  
10.         Random rnd = new Random();  
11.    
12.         Properties props = new Properties();  
13.         props.put("metadata.broker.list", "broker1:9092,broker2:9092 ");  
14.         props.put("serializer.class", "kafka.serializer.StringEncoder");  
15.         props.put("partitioner.class", "example.producer.SimplePartitioner");  
16.         props.put("request.required.acks", "1");  
17.    
18.         ProducerConfig config = new ProducerConfig(props);  
19.    
20.         Producer<String, String> producer = new Producer<String, String>(config);  
21.    
22.         for (long nEvents = 0; nEvents < events; nEvents++) {   
23.                long runtime = new Date().getTime();    
24.                String ip = “192.168.2.” + rnd.nextInt(255);   
25.                String msg = runtime + “,www.example.com,” + ip;   
26.                KeyedMessage<String, String> data = new KeyedMessage<String, String>("page_visits", ip, msg);  
27.                producer.send(data);  
28.         }  
29.         producer.close();  
30.     }  
31. }  

下面這個是用到的分區函數：

 

 

[java] view plaincopy

1. import kafka.producer.Partitioner;  
2. import kafka.utils.VerifiableProperties;  
3.    
4. public class SimplePartitioner implements Partitioner<String> {  
5.     public SimplePartitioner (VerifiableProperties props) {  
6.    
7.     }  
8.    
9.     public int partition(String key, int a_numPartitions) {  
10.         int partition = 0;  
11.         int offset = key.lastIndexOf('.');  
12.         if (offset > 0) {  
13.            partition = Integer.parseInt( key.substring(offset+1)) % a_numPartitions;  
14.         }  
15.        return partition;  
16.   }  
17.    
18. }  

 

 

 

 

 

KafKa Consumer APIs

Consumer API有兩個級別。低級別的和一個指定的broker保持連接，並在接收完消息後關閉連接，這個級別是無狀態的，每次讀取消息都帶着offset。

高級別的API隱藏了和brokers連接的細節，在不必關心服務端架構的情況下和服務端通信。還可以自己維護消費狀態，並可以通過一些條件指定訂閱特定的topic,比如白名單黑名單或者正則表達式。

低級別的API

 

[java] view plaincopy

1. class SimpleConsumer {  
2.       
3.   /*向一個broker發送讀取請求並得到消息集 */   
4.   public ByteBufferMessageSet fetch(FetchRequest request);  
5.   
6.   /*向一個broker發送讀取請求並得到一個相應集 */   
7.   public MultiFetchResponse multifetch(List<FetchRequest> fetches);  
8.   
9.   /** 
10.    * 得到指定時間之前的offsets 
11.    * 返回值是offsets列表，以倒序排序 
12.    * @param time: 時間，毫秒, 
13.    *              如果指定爲OffsetRequest$.MODULE$.LATIEST_TIME(), 得到最新的offset. 
14.    *              如果指定爲OffsetRequest$.MODULE$.EARLIEST_TIME(),得到最老的offset. 
15.    */  
16.   public long[] getOffsetsBefore(String topic, int partition, long time, int maxNumOffsets);  
17. }  

低級別的API是高級別API實現的基礎，也是爲了一些對維持消費狀態有特殊需求的場景，比如Hadoop consumer這樣的離線consumer。

 

 

 

高級別的API

 

[java] view plaincopy

1. /* 創建連接 */   
2. ConsumerConnector connector = Consumer.create(consumerConfig);  
3.   
4. interface ConsumerConnector {  
5.       
6.   /** 
7.    * 這個方法可以得到一個流的列表，每個流都是MessageAndMetadata的迭代，通過MessageAndMetadata可以拿到消息和其他的元數據（目前之後topic）   
8.    *  Input: a map of <topic, #streams> 
9.    *  Output: a map of <topic, list of message streams> 
10.    */  
11.   public Map<String,List<KafkaStream>> createMessageStreams(Map<String,Int> topicCountMap);   
12.   
13.   /**     
14.    * 你也可以得到一個流的列表，它包含了符合TopicFiler的消息的迭代， 
15.    * 一個TopicFilter是一個封裝了白名單或黑名單的正則表達式。 
16.    */  
17.   public List<KafkaStream> createMessageStreamsByFilter(  
18.       TopicFilter topicFilter, int numStreams);  
19.   
20.   /* 提交目前消費到的offset */  
21.   public commitOffsets()  
22.     
23.   /* 關閉連接 */  
24.   public shutdown()  
25. }  

 

這個API圍繞着由KafkaStream實現的迭代器展開，每個流代表一系列從一個或多個分區多和broker上匯聚來的消息，每個流由一個線程處理，所以客戶端可以在創建的時候通過參數指定想要幾個流。一個流是多個分區多個broker的合併，但是每個分區的消息只會流向一個流。

每調用一次createMessageStreams都會將consumer註冊到topic上，這樣consumer和brokers之間的負載均衡就會進行調整。API鼓勵每次調用創建更多的topic流以減少這種調整。createMessageStreamsByFilter方法註冊監聽可以感知新的符合filter的tipic。