====Kafka消费者模型
参考博客：http://www.tuicool.com/articles/fI7J3m
--分区消费模型
分区消费架构图
图中kafka集群有两台服务器（Server），每台服务器有2个分区（Patition），共4个分区。
由四个消费者实例（Consumer）来消费4个分区。
当然，Consumer1不一定对应Patition1，但是必须建立1对1的对应关系。
分区消费伪代码描述
--组（Group）消费模型
组消费架构图
途中有两个服务器Server1和Server2，每个服务器上有2个Patiton分区。
有两个组（Consumer Group）。其中，
Consumer Group A中用2个Consumer实例来消费集群当前主题（Topic）中的4个Patition。
Consumer Group B中用4个Consumer实例来消费集群当前主题（Topic）中的4个Patition。
两个Group都可以拿到当前主题（Topic）的全量数据（这点很重要）。
--按组（Group）消费伪代码描述
*流数N：即每个Consumer Group组里面有多少个Consumer实例。
Consumer分配方法
--Java客户端参数调优
（1）FetchSize：从服务器获取单包大小
（2）bufferSize：kafka客户端缓冲区大小
（3）group.id：分区组消费时分组名
--两种消费模型对比
分区消费模型更加灵活，但是：
（1）需要自己处理各种异常情况
（2）需要自己管理offset（以实现消息传递的其他语义）
组消费模型更加简单，但是不灵活
（1）不需要自己处理异常情况，不需要自己管理offset
（2）只能实现kafka默认的最少一次消息传递语义
*消息传递语义有三种：至少一次、最多一次、有且只有一次
====kafka生产者模型
--同步生产模型
使用同步生产模型时，提供“至少一次”的语义。
--异步生产模型
--两种生产模型的伪代码描述
*kafka默认负载均衡算法有：哈希、轮训、随机
*根据设置生产者参数来决定是同步/异步生产模型。
--Java客户端参数调优
（1）message.sen.max.retries：发送失败重试次数；
（2）retry.backoff.ms：未接到确认，认为发送失败的时间；
（3）producer.type：同步发送或者异步发送；
（4）batch.num.messages：异步发送时，累计最大消息数；
（5）queue.buffering.max.ms：异步发送时，累计最大时间；
--两种生产模型对比
同步生产模型：
（1）低消息丢失率
（2）高消息重复率（由于网络原因，回复确认未收到）
（3）高延迟、低吞吐量
异步生产模型：
（1）低延迟
（2）高发送性能
（3）高消息丢失率（无确认机制，发送端队列满）
====kafka中关键参数配置
参考博客：http://debugo.com/kafka-params/
（1）Broker（集群总的节点）配置
•broker.id：唯一确定的一个int 类型数字
•log.dirs：存储kafka数据，默认路径为/tmp/kafka-logs
•port：comsumer连接的端口号
•zookeeper.conect：zookeeper的链接字符串，定义的格式如下hostname1:port1,hostname2:port2,hostname3
•num.partitions：一个topic可以被分成多个paritions管道，每个partiions中的message有序，但是多个paritions中的顺序不能保证
（2）Consumer 配置
•group.id：string类型，决定该Consumer归属的唯一组ID。
•zookeeper.connect：对于zookeeper集群的指定，必须和broker使用同样的zk配置。host1:port1,host2:port2。
•zookeeper.session.timeout.ms：zookeeper的心跳超时时间，查过这个时间就认为是无效的消费者
•zookeeper.sync.time.ms：zookeeper的等待连接时间
•auto.commit.interval.ms：自动提交的时间间隔
（3）Producer配置
•metadata.book.list：消费者获取消息元信息，格式为host1:port1,host2:port2
•serializer.class：message的序列化类。默认编码器处理类型都是byte[]类型
•partitioner.class：分区的策略，默认是取模
•producer.type：确定messages是否同步提交
•request.required.acks：消息的确认模式。
#0：不保证消息的到达确认，只管发送，低延迟但是会出现消息的丢失，在某个server失败的情况下，有点像TCP
#1：发送消息，并会等待leader 收到确认后，一定的可靠性
#-1：发送消息，等待leader收到确认，并进行复制操作后，才返回，最高的可靠性
====kafka客户端API
--Kafka Producer APIs
Procuder API有两种：
•kafka.producer.SyncProducer
•kafka.producer.async.AsyncProducer
它们都实现了同一个接口：
class Producer {
/* 将消息发送到指定分区 */
publicvoid send(kafka.javaapi.producer.ProducerData<K,V> producerData);
/* 批量发送一批消息 */
publicvoid send(java.util.List<kafka.javaapi.producer.ProducerData<K,V>> producerData);
/* 关闭producer */
publicvoid close();
}
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。
interface Encoder<T> {
public Message toMessage(T data);
}
（3）提供了基于Zookeeper的broker自动感知能力，可以通过参数zk.connect实现。
如果不使用Zookeeper，也可以使用broker.list参数指定一个静态的brokers列表，
这样消息将被随机的发送到一个broker上，一旦选中的broker失败了，消息发送也就失败了。
（4）通过分区函数kafka.producer.Partitioner类对消息分区。
interface Partitioner<T> {
int partition(T key, int numPartitions);
}
分区函数有两个参数：key和可用的分区数量，从分区列表中选择一个分区并返回id。
默认的分区策略是hash(key)%numPartitions.如果key是null,就随机的选择一个。
可以通过参数partitioner.class定制分区函数。
--KafKa Consumer APIs
Consumer API有两个级别。
低级别的和一个指定的broker保持连接，并在接收完消息后关闭连接，这个级别是无状态的，每次读取消息都带着offset。
高级别的API隐藏了和brokers连接的细节，在不必关心服务端架构的情况下和服务端通信。还可以自己维护消费状态，并可以通过一些条件指定订阅特定的topic,比如白名单黑名单或者正则表达式。
（1）低级别的API
低级别的API是高级别API实现的基础，也是为了一些对维持消费状态有特殊需求的场景，比如Hadoop consumer这样的离线consumer。
-----------------
class SimpleConsumer {
/* 向一个broker发送读取请求并得到消息集 */
public ByteBufferMessageSet fetch(FetchRequest request);
/* 向一个broker发送读取请求并得到一个相应集 */
public MultiFetchResponse multifetch(List<FetchRequest> fetches);
/**
* 得到指定时间之前的offsets
* 返回值是offsets列表，以倒序排序
* @param time: 时间，毫秒,
* 如果指定为OffsetRequest$.MODULE$.LATIEST_TIME(), 得到最新的offset.
* 如果指定为OffsetRequest$.MODULE$.EARLIEST_TIME(),得到最老的offset.
*/
publiclong[] getOffsetsBefore(String topic, int partition, long time, int maxNumOffsets);
}
-----------------
（2）高级别的API
这个API围绕着由KafkaStream实现的迭代器展开，每个流代表一系列从一个或多个分区多和broker上汇聚来的消息，
每个流由一个线程处理，所以客户端可以在创建的时候通过参数指定想要几个流。
一个流是多个分区多个broker的合并，但是每个分区的消息只会流向一个流。
每调用一次createMessageStreams都会将consumer注册到topic上，这样consumer和brokers之间的负载均衡就会进行调整。
API鼓励每次调用创建更多的topic流以减少这种调整。
createMessageStreamsByFilter方法注册监听可以感知新的符合filter的topic。
-----------------
/* 创建连接 */
ConsumerConnector connector = Consumer.create(consumerConfig);
interface ConsumerConnector {
/**
* 这个方法可以得到一个流的列表，每个流都是MessageAndMetadata的迭代，通过MessageAndMetadata可以拿到消息和其他的元数据（目前之后topic）
* Input: a map of <topic, #streams>
* Output: a map of <topic, list of message streams>
*/
public Map<String,List<KafkaStream>> createMessageStreams(Map<String,Int> topicCountMap);
/**
* 你也可以得到一个流的列表，它包含了符合TopicFiler的消息的迭代，
* 一个TopicFilter是一个封装了白名单或黑名单的正则表达式。
*/
public List<KafkaStream> createMessageStreamsByFilter(TopicFilter topicFilter, int numStreams);
/* 提交目前消费到的offset */
public commitOffsets()
/* 关闭连接 */
public shutdown()
}
-----------------
====kafka消息组织原理
--磁盘重认识
当需要从磁盘读取数据时，要确定读的数据在哪个磁道，哪个扇区：
（1）首先必须找到柱面，即磁头需要移动对准相应磁道，这个过程叫寻道，所需时间叫寻道时间。
（2）然后目标扇区旋转到次投下，这个过程消费的时间叫旋转时间
一次访问请求（读/写）完成过程由三个动作组成
（1）寻道（时间）：磁头移动定位到指定磁道
（2）旋转延迟（时间）：等待指定扇区从磁头下旋转经过
（3）数据传输（时间）：数据在磁盘、内存与网络之间的实际传输
由于存储介质的特性，磁盘本身存取就比主存慢，再加上机械运动耗费，磁盘存取速度往往是主存的几百分之一甚至几千分之一。
--怎样才能提高磁盘的读写效率呢？
根据数据的局部性原理，有以下两种方法
（1）预读或者提前读
（2）合并写--将多个逻辑上的写操作合并成一个大的物理写操作中。
即采用磁盘顺序读写（不需要寻道时间，只需要很少的旋转时间）。
实验结果：在一个67200rpm SATA RAID-5的磁盘真累上线性写的速度大概是300M/秒，
但是随机写的速度只有50K/秒，两者相差奖金10000倍。
--kafka消息的写入原理
一般的将数据从文件传到套接字的路径：
（1）操作系统将数据从磁盘读到内核空间的页缓存区
（2）应用将数据从内核空间读到用户空间的缓存中
（3）应用将数据写会内存空间的套接字缓存中
（4）操作系统将数据从套接字缓存写到网卡缓存中，以便将数据经网络发出
这样做明显是抵消的，这里有四次拷贝，两次系统调用。
如果使用sendfile（Java为：FileChannel.transferTo api），两次拷贝可以被避免：
允许操作系统将数据直接从页缓存发送到网络上。优化后，只有最后一步将数据拷贝到网卡缓存中。
kafka的内部设计有两个重要的知识点：
（1）基于磁盘的顺序写
（2）基于数据的0字节拷贝（Byte Zero Copy）
====生产者消费者代码例子