漫游Kafka实战篇之客户端编程实例

新版的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 plain  copy

   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 plain  copy

   1. interface Partitioner<T> {  
   2.    int partition(T key, int numPartitions);  
   3. }  
   分区函数有两个参数：key和可用的分区数量，从分区列表中选择一个分区并返回id。默认的分区策略是hash(key)%numPartitions.如果key是null,就随机的选择一个。可以通过参数partitioner.class定制分区函数。
   

新的api完整实例如下：

[java]  view plain  copy

1. package com.cuicui.kafkademon;  
2.   
3.   
4. import java.util.ArrayList;  
5. import java.util.List;  
6. import java.util.Properties;  
7.   
8.   
9. import kafka.javaapi.producer.Producer;  
10. import kafka.producer.KeyedMessage;  
11. import kafka.producer.ProducerConfig;  
12.   
13.   
14. /** 
15.  * @author <a href="mailto:leicui001@126.com">崔磊</a> 
16.  * @date 2015年11月4日 上午11:44:15 
17.  */  
18. public class MyProducer {  
19.   
20.   
21.     public static void main(String[] args) throws InterruptedException {  
22.   
23.   
24.         Properties props = new Properties();  
25.         props.put("serializer.class", "kafka.serializer.StringEncoder");  
26.         props.put("metadata.broker.list", KafkaProperties.BROKER_CONNECT);  
27.         props.put("partitioner.class", "com.cuicui.kafkademon.MyPartitioner");  
28.         props.put("request.required.acks", "1");  
29.         ProducerConfig config = new ProducerConfig(props);  
30.         Producer<String, String> producer = new Producer<String, String>(config);  
31.   
32.   
33.         // 单个发送  
34.         for (int i = 0; i <= 1000000; i++) {  
35.             KeyedMessage<String, String> message =  
36.                     new KeyedMessage<String, String>(KafkaProperties.TOPIC, i + "", "Message" + i);  
37.             producer.send(message);  
38.             Thread.sleep(5000);  
39.         }  
40.   
41.   
42.         // 批量发送  
43.         List<KeyedMessage<String, String>> messages = new ArrayList<KeyedMessage<String, String>>(100);  
44.         for (int i = 0; i <= 10000; i++) {  
45.             KeyedMessage<String, String> message =  
46.                     new KeyedMessage<String, String>(KafkaProperties.TOPIC, i + "", "Message" + i);  
47.             messages.add(message);  
48.             if (i % 100 == 0) {  
49.                 producer.send(messages);  
50.                 messages.clear();  
51.             }  
52.         }  
53.         producer.send(messages);  
54.     }  
55. }  

下面这个是用到的分区函数：

[java]  view plain  copy

1. import kafka.producer.Partitioner;  
2. import kafka.utils.VerifiableProperties;  
3.   
4.   
5. public class MyPartitioner implements Partitioner {  
6.     public MyPartitioner(VerifiableProperties props) {  
7.   
8.   
9.     }  
10.   
11.   
12.     /* 
13.      * @see kafka.producer.Partitioner#partition(java.lang.Object, int) 
14.      */  
15.     @Override  
16.     public int partition(Object key, int partitionCount) {  
17.         return Integer.valueOf((String) key) % partitionCount;  
18.     }  
19. }  

KafKa Consumer APIs

Consumer API有两个级别。低级别的和一个指定的broker保持连接，并在接收完消息后关闭连接，这个级别是无状态的，每次读取消息都带着offset。

高级别的API隐藏了和brokers连接的细节，在不必关心服务端架构的情况下和服务端通信。还可以自己维护消费状态，并可以通过一些条件指定订阅特定的topic,比如白名单黑名单或者正则表达式。

低级别的API

[java]  view plain  copy

1. package com.cuicui.kafkademon;  
2.   
3.   
4. import java.nio.ByteBuffer;  
5. import java.util.Collections;  
6. import java.util.HashMap;  
7. import java.util.List;  
8. import java.util.Map;  
9.   
10.   
11. import kafka.api.FetchRequest;  
12. import kafka.api.FetchRequestBuilder;  
13. import kafka.api.PartitionOffsetRequestInfo;  
14. import kafka.cluster.Broker;  
15. import kafka.common.TopicAndPartition;  
16. import kafka.javaapi.FetchResponse;  
17. import kafka.javaapi.OffsetRequest;  
18. import kafka.javaapi.OffsetResponse;  
19. import kafka.javaapi.PartitionMetadata;  
20. import kafka.javaapi.TopicMetadata;  
21. import kafka.javaapi.TopicMetadataRequest;  
22. import kafka.javaapi.TopicMetadataResponse;  
23. import kafka.javaapi.consumer.SimpleConsumer;  
24. import kafka.javaapi.message.ByteBufferMessageSet;  
25. import kafka.message.Message;  
26. import kafka.message.MessageAndOffset;  
27.   
28.   
29. /** 
30.  * offset自己维护 目标topic、partition均由自己分配 
31.  *  
32.  * @author <a href="mailto:leicui001@126.com">崔磊</a> 
33.  * @date 2015年11月4日 上午11:44:15 
34.  * 
35.  */  
36. public class MySimpleConsumer {  
37.   
38.   
39.     public static void main(String[] args) {  
40.         new MySimpleConsumer().consume();  
41.     }  
42.   
43.   
44.     /** 
45.      * 消费消息 
46.      */  
47.     public void consume() {  
48.         int partition = 0;  
49.   
50.   
51.         // 找到leader  
52.         Broker leaderBroker = findLeader(KafkaProperties.BROKER_CONNECT, KafkaProperties.TOPIC, partition);  
53.   
54.   
55.         // 从leader消费  
56.         SimpleConsumer simpleConsumer =  
57.                 new SimpleConsumer(leaderBroker.host(), leaderBroker.port(), 20000, 10000, "mySimpleConsumer");  
58.         long startOffet = 1;  
59.         int fetchSize = 1000;  
60.   
61.   
62.         while (true) {  
63.             long offset = startOffet;  
64.             // 添加fetch指定目标tipic，分区，起始offset及fetchSize(字节)，可以添加多个fetch  
65.             FetchRequest req =  
66.                     new FetchRequestBuilder().addFetch(KafkaProperties.TOPIC, 0, startOffet, fetchSize).build();  
67.   
68.   
69.             // 拉取消息  
70.             FetchResponse fetchResponse = simpleConsumer.fetch(req);  
71.   
72.   
73.             ByteBufferMessageSet messageSet = fetchResponse.messageSet(KafkaProperties.TOPIC, partition);  
74.             for (MessageAndOffset messageAndOffset : messageSet) {  
75.                 Message mess = messageAndOffset.message();  
76.                 ByteBuffer payload = mess.payload();  
77.                 byte[] bytes = new byte[payload.limit()];  
78.                 payload.get(bytes);  
79.                 String msg = new String(bytes);  
80.   
81.   
82.                 offset = messageAndOffset.offset();  
83.                 System.out.println("partition : " + 3 + ", offset : " + offset + "  mess : " + msg);  
84.             }  
85.             // 继续消费下一批  
86.             startOffet = offset + 1;  
87.         }  
88.     }  
89.   
90.   
91.     /** 
92.      * 找到制定分区的leader broker 
93.      *  
94.      * @param brokerHosts broker地址，格式为：“host1:port1,host2:port2,host3:port3” 
95.      * @param topic topic 
96.      * @param partition 分区 
97.      * @return 
98.      */  
99.     public Broker findLeader(String brokerHosts, String topic, int partition) {  
100.         Broker leader = findPartitionMetadata(brokerHosts, topic, partition).leader();  
101.         System.out.println(String.format("Leader tor topic %s, partition %d is %s:%d", topic, partition, leader.host(),  
102.                 leader.port()));  
103.         return leader;  
104.     }  
105.   
106.   
107.     /** 
108.      * 找到指定分区的元数据 
109.      *  
110.      * @param brokerHosts broker地址，格式为：“host1:port1,host2:port2,host3:port3” 
111.      * @param topic topic 
112.      * @param partition 分区 
113.      * @return 元数据 
114.      */  
115.     private PartitionMetadata findPartitionMetadata(String brokerHosts, String topic, int partition) {  
116.         PartitionMetadata returnMetaData = null;  
117.         for (String brokerHost : brokerHosts.split(",")) {  
118.             SimpleConsumer consumer = null;  
119.             String[] splits = brokerHost.split(":");  
120.             consumer = new SimpleConsumer(splits[0], Integer.valueOf(splits[1]), 100000, 64 * 1024, "leaderLookup");  
121.             List<String> topics = Collections.singletonList(topic);  
122.             TopicMetadataRequest request = new TopicMetadataRequest(topics);  
123.             TopicMetadataResponse response = consumer.send(request);  
124.             List<TopicMetadata> topicMetadatas = response.topicsMetadata();  
125.             for (TopicMetadata topicMetadata : topicMetadatas) {  
126.                 for (PartitionMetadata PartitionMetadata : topicMetadata.partitionsMetadata()) {  
127.                     if (PartitionMetadata.partitionId() == partition) {  
128.                         returnMetaData = PartitionMetadata;  
129.                     }  
130.                 }  
131.             }  
132.             if (consumer != null)  
133.                 consumer.close();  
134.         }  
135.         return returnMetaData;  
136.     }  
137.   
138.   
139.     /** 
140.      * 根据时间戳找到某个客户端消费的offset 
141.      *  
142.      * @param consumer SimpleConsumer 
143.      * @param topic topic 
144.      * @param partition 分区 
145.      * @param clientID 客户端的ID 
146.      * @param whichTime 时间戳 
147.      * @return offset 
148.      */  
149.     public long getLastOffset(SimpleConsumer consumer, String topic, int partition, String clientID, long whichTime) {  
150.         TopicAndPartition topicAndPartition = new TopicAndPartition(topic, partition);  
151.         Map<TopicAndPartition, PartitionOffsetRequestInfo> requestInfo =  
152.                 new HashMap<TopicAndPartition, PartitionOffsetRequestInfo>();  
153.         requestInfo.put(topicAndPartition, new PartitionOffsetRequestInfo(whichTime, 1));  
154.         OffsetRequest request = new OffsetRequest(requestInfo, kafka.api.OffsetRequest.CurrentVersion(), clientID);  
155.         OffsetResponse response = consumer.getOffsetsBefore(request);  
156.         long[] offsets = response.offsets(topic, partition);  
157.         return offsets[0];  
158.     }  
159. }  

低级别的API是高级别API实现的基础，也是为了一些对维持消费状态有特殊需求的场景，比如Hadoop consumer这样的离线consumer。

高级别的API

[java]  view plain  copy

1. package com.cuicui.kafkademon;  
2.   
3. import java.util.HashMap;  
4. import java.util.List;  
5. import java.util.Map;  
6. import java.util.Properties;  
7.   
8. import kafka.consumer.Consumer;  
9. import kafka.consumer.ConsumerConfig;  
10. import kafka.consumer.ConsumerIterator;  
11. import kafka.consumer.KafkaStream;  
12. import kafka.javaapi.consumer.ConsumerConnector;  
13. import kafka.message.MessageAndMetadata;  
14.   
15.   
16. /** 
17.  * offset在zookeeper中记录，以group.id为key 分区和customer的对应关系由Kafka维护 
18.  *  
19.  * @author <a href="mailto:leicui001@126.com">崔磊</a> 
20.  * @date 2015年11月4日 上午11:44:15 
21.  */  
22. public class MyHighLevelConsumer {  
23.   
24.     /** 
25.      * 该consumer所属的组ID 
26.      */  
27.     private String groupid;  
28.   
29.     /** 
30.      * 该consumer的ID 
31.      */  
32.     private String consumerid;  
33.   
34.     /** 
35.      * 每个topic开几个线程？ 
36.      */  
37.     private int threadPerTopic;  
38.   
39.     public MyHighLevelConsumer(String groupid, String consumerid, int threadPerTopic) {  
40.         super();  
41.         this.groupid = groupid;  
42.         this.consumerid = consumerid;  
43.         this.threadPerTopic = threadPerTopic;  
44.     }  
45.   
46.     public void consume() {  
47.         Properties props = new Properties();  
48.         props.put("group.id", groupid);  
49.         props.put("consumer.id", consumerid);  
50.         props.put("zookeeper.connect", KafkaProperties.ZK_CONNECT);  
51.         props.put("zookeeper.session.timeout.ms", "60000");  
52.         props.put("zookeeper.sync.time.ms", "2000");  
53.         // props.put("auto.commit.interval.ms", "1000");  
54.   
55.         ConsumerConfig config = new ConsumerConfig(props);  
56.         ConsumerConnector connector = Consumer.createJavaConsumerConnector(config);  
57.   
58.         Map<String, Integer> topicCountMap = new HashMap<String, Integer>();  
59.   
60.         // 设置每个topic开几个线程  
61.         topicCountMap.put(KafkaProperties.TOPIC, threadPerTopic);  
62.   
63.         // 获取stream  
64.         Map<String, List<KafkaStream<byte[], byte[]>>> streams = connector.createMessageStreams(topicCountMap);  
65.   
66.         // 为每个stream启动一个线程消费消息  
67.         for (KafkaStream<byte[], byte[]> stream : streams.get(KafkaProperties.TOPIC)) {  
68.             new MyStreamThread(stream).start();  
69.         }  
70.     }  
71.   
72.     /** 
73.      * 每个consumer的内部线程 
74.      *  
75.      * @author cuilei05 
76.      * 
77.      */  
78.     private class MyStreamThread extends Thread {  
79.         private KafkaStream<byte[], byte[]> stream;  
80.   
81.         public MyStreamThread(KafkaStream<byte[], byte[]> stream) {  
82.             super();  
83.             this.stream = stream;  
84.         }  
85.   
86.         @Override  
87.         public void run() {  
88.             ConsumerIterator<byte[], byte[]> streamIterator = stream.iterator();  
89.   
90.             // 逐条处理消息  
91.             while (streamIterator.hasNext()) {  
92.                 MessageAndMetadata<byte[], byte[]> message = streamIterator.next();  
93.                 String topic = message.topic();  
94.                 int partition = message.partition();  
95.                 long offset = message.offset();  
96.                 String key = new String(message.key());  
97.                 String msg = new String(message.message());  
98.                 // 在这里处理消息,这里仅简单的输出  
99.                 // 如果消息消费失败，可以将已上信息打印到日志中，活着发送到报警短信和邮件中，以便后续处理  
100.                 System.out.println("consumerid:" + consumerid + ", thread : " + Thread.currentThread().getName()  
101.                         + ", topic : " + topic + ", partition : " + partition + ", offset : " + offset + " , key : "  
102.                         + key + " , mess : " + msg);  
103.             }  
104.         }  
105.     }  
106.   
107.     public static void main(String[] args) {  
108.         String groupid = "myconsumergroup";  
109.         MyHighLevelConsumer consumer1 = new MyHighLevelConsumer(groupid, "myconsumer1", 3);  
110.         MyHighLevelConsumer consumer2 = new MyHighLevelConsumer(groupid, "myconsumer2", 3);  
111.   
112.         consumer1.consume();  
113.         consumer2.consume();  
114.     }  
115. }  

这个API围绕着由KafkaStream实现的迭代器展开，每个流代表一系列从一个或多个分区多和broker上汇聚来的消息，每个流由一个线程处理，所以客户端可以在创建的时候通过参数指定想要几个流。一个流是多个分区多个broker的合并，但是每个分区的消息只会流向一个流。

每调用一次createMessageStreams都会将consumer注册到topic上，这样consumer和brokers之间的负载均衡就会进行调整。API鼓励每次调用创建更多的topic流以减少这种调整。createMessageStreamsByFilter方法注册监听可以感知新的符合filter的tipic。