Hadoop生态圈-Kafka的旧API实现生产者-消费者

　　　　　　　　　　　　　　　　　　　　Hadoop生态圈-Kafka的旧API实现生产者-消费者

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.旧API实现生产者-消费者

1>.开启kafka集群

[yinzhengjie@s101 ~]$ more `which xkafka.sh`
#!/bin/bash
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie
#EMAIL:y1053419035@qq.com

#判断用户是否传参
if [ $# -ne  ];then
    echo "无效参数，用法为: $0  {start|stop}"
    exit
fi

#获取用户输入的命令
cmd=$

for (( i= ; i<= ; i++ )) ; do
    tput setaf
    echo ========== s$i  $cmd ================
    tput setaf
    case $cmd in
        start)
            ssh s$i  "source /etc/profile ; kafka-server-start.sh -daemon /soft/kafka/config/server.properties"
            echo  s$i  "服务已启动"
            ;;
        stop)
            ssh s$i  "source /etc/profile ; kafka-server-stop.sh"
            echo s$i  "服务已停止"
            ;;
            *)
            echo "无效参数，用法为: $0  {start|stop}"
            exit
            ;;
     esac
done

[yinzhengjie@s101 ~]$ 

[yinzhengjie@s101 ~]$ more `which xkafka.sh`

[yinzhengjie@s101 ~]$ xkafka.sh start
========== s102 start ================
s102 服务已启动
========== s103 start ================
s103 服务已启动
========== s104 start ================
s104 服务已启动
[yinzhengjie@s101 ~]$ 

开启kafka集群（[yinzhengjie@s101 ~]$ xkafka.sh start）

[yinzhengjie@s101 ~]$ xcall.sh jps
============= s101 jps ============
 Jps
命令执行成功
============= s102 jps ============
 QuorumPeerMain
 Kafka
 Jps
命令执行成功
============= s103 jps ============
 Jps
 QuorumPeerMain
 Kafka
命令执行成功
============= s104 jps ============
 Jps
 QuorumPeerMain
 Kafka
命令执行成功
============= s105 jps ============
 Jps
命令执行成功
[yinzhengjie@s101 ~]$
[yinzhengjie@s101 ~]$ more `which xcall.sh`
#!/bin/bash
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie
#EMAIL:y1053419035@qq.com

#判断用户是否传参
if [ $# -lt  ];then
        echo "请输入参数"
        exit
fi

#获取用户输入的命令
cmd=$@

for (( i=;i<=;i++ ))
do
        #使终端变绿色
        tput setaf
        echo ============= s$i $cmd ============
        #使终端变回原来的颜色，即白灰色
        tput setaf
        #远程执行命令
        ssh s$i $cmd
        #判断命令是否执行成功
        if [ $? ==  ];then
                echo "命令执行成功"
        fi
done
[yinzhengjie@s101 ~]$ 

检查kafka是否正常启动（[yinzhengjie@s101 ~]$ xcall.sh jps）

2>.编写生产者端代码

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E7%94%9F%E6%80%81%E5%9C%88/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.kafka;

 import kafka.javaapi.producer.Producer;
 import kafka.producer.KeyedMessage;
 import kafka.producer.ProducerConfig;
 import java.util.Properties;

 public class TestProducer {

     public static void main(String[] args) throws Exception {
         //初始化Java的Properties属性
         Properties props = new Properties();
         //通过metadata.broker.list参数设置代理，其value对应的kafka服务器地址，如果有多个就用逗号（"，"）分隔。
         props.put("metadata.broker.list", "s102:9092, s103:9092, s104:9092");
         //指定message的数据类型，将传输的数据都序列化成字符串（String），当然还有很多序列化方式（LongEncoder,NullEncoder,DefalutEmcoder,IntegerEncoder），比如默认为字节类型等等。
         props.put("serializer.class", "kafka.serializer.StringEncoder");
         //包装java的prop，包装成ProducerConfig
         ProducerConfig config = new ProducerConfig(props);
         //使用producerConfig初始化producer
         //<String, String> 中第一个为key类型(未接触到)，第二个是value类型，真实数据
         Producer<String, String> producer = new Producer<String, String>(config);
         //定义kafka的主题
         String topic = "yinzhengjie";
         for (int i = 1000; i < 2000; i++) {
             KeyedMessage<String, String> data = new KeyedMessage<String, String>(topic, "BigData" + i);
             producer.send(data);
             Thread.sleep(500);
         }
         producer.close();
     }
 }    

　　运行以上代码，并在Linux中断启用KafKa的消费者,截图如下：

3>.编写消费者端代码

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E7%94%9F%E6%80%81%E5%9C%88/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.kafka;

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import kafka.consumer.ConsumerConfig;
 import kafka.consumer.ConsumerIterator;
 import kafka.consumer.KafkaStream;
 import kafka.javaapi.consumer.ConsumerConnector;

 public class TestConsumer {
     public static void main(String[] args) {
         Properties props = new Properties();
         props.put("zookeeper.connect", "s102:2181,s103:2181,s104:2181");
         //设置组id名称
         props.put("group.id", "yzj");
         //ZooKeeper的最大超时时间，就是心跳的间隔，若是没有反映，那么认为已经死了，不易过大
         props.put("zookeeper.session.timeout.ms", "500");
         //定义ZooKeeper集群中leader和follower之间的同步时间
         props.put("zookeeper.sync.time.ms", "250");
         //consumer向zookeeper提交offset的频率，单位是毫秒
         props.put("auto.commit.interval.ms", "1000");
         //把props封装成一个ConsumerConfig对象
         ConsumerConfig conf = new ConsumerConfig(props);
         //创建出一个ConsumerConnector实例
         ConsumerConnector consumer = kafka.consumer.Consumer.createJavaConsumerConnector(conf);
         //定义一个集合，这个集合最终被被传入到consumer.createMessageStreams()方法中。
         Map<String, Integer> topicMap = new HashMap<String, Integer>();
         //topicMap中指定第一个参数是主题，第二个参数是指定线程个数。
         topicMap.put("yinzhengjie", new Integer(1));
         //通过consumer和topic获取到数据流，在Map中的第一个参数是：topic，第二个参数是：消息列表
         Map<String, List<KafkaStream<byte[], byte[]>>> consumerStreamsMap = consumer.createMessageStreams(topicMap);
         //通过topic返回所有消息列表
         List<KafkaStream<byte[], byte[]>> streamList = consumerStreamsMap.get("yinzhengjie");
         //迭代所有list，通过迭代器获取消息流中的k-v
         for (final KafkaStream<byte[], byte[]> stream : streamList) {
             ConsumerIterator<byte[], byte[]> consumerIte = stream.iterator();
             while (consumerIte.hasNext())
                 System.out.println("Message from Single Topic :: "+ new String(consumerIte.next().message()));
         }
     }
 }

　　在Linux端启动生产者并运行以上代码，输出结果如下：

二.kafka的producer和Consumer配置（实战重点，调优手段）

1>.kafka的producer配置

>.metadata.broker.list
    答：kafka服务器地址，如果有多个就用逗号（"，"）分隔。
>.serializer.class
    答：指定message的数据类型。
>.key.serializer.class
    答：指定key的数据类型，key的作用，用作选择分区。默认kafka.serializer.DefaultEncoder(byte[]),常用的还有
"kafka.serializer.NullEncoder","kafka.serializer.NullEncoder","kafka.serializer.StringEncoder","kafka.serializer.IntegerEncoder"
"kafka.serializer.LongEncoder"。

>.producer.type
    答：指定消息应该如何发送。比如async和sync。
            //async    异步，将数据发在缓冲区，一并发送给broker，无序    100000条数据：3792
            //sync    同步，正常发送，有序    100000条数据：31939ms

>.batch.num.messages
    答：指定异步发送中一个批次含有多少条数据，默认200，超过此值就会发送。
>.queue.buffer.max.ms
    答：队列的毫秒数，到达此值数据也会发送。

>.request.required.acks
    答：获取回值，有三种回值方式(并对着三种方式处理100000条数据的所用时间):
            //0意味着 producer不等待broker的回执，适用于最低延迟，不保证数据的完整性(3559)
            //1意味着 只接收分区中的leader回执(4421)
            //-1意味着 接收所有in-sync状态下的节点回执(6792)

>.partitioner.class
    答：指定分区函数类。

>.compression.codec
    答：指定压缩编解码器none, gzip, and snappy.

2>.kafka的Consumer配置

重复消费的手段：
    设置从头消费        //--from-beginning
                //auto.offset.reset = smallest
    手动控制消费偏移量    //通过修改zk数据 consumer/groupid/offsets/topic/partition

>.group.id
    答：指定消费者组id，没有指定会自动创建。

>.consumer.id
    答：指定消费者的id，没有指定会自动创建。

>.zookeeper.connect
    答：指定zookeeper客户端地址。

>.client.id
    答：指定自己的客户端id，没有指定会和group.id一样。

>.zookeeper.session.timeout.ms
    答：zk会话超时则抛异常。

>.zookeeper.connection.timeout.ms
    答：zk连接超时则抛异常。

>.zookeeper.sync.time.ms
    答：控制zk同步数据的时间。

>.auto.commit.enable
    答：自动提交消息的偏移量到zk。
>.auto.commit.interval.ms
    答：自动提交偏移量的间隔。

>.auto.offset.reset
    答：设置从哪里读取数据
                //largest    读取最新数据
                //smallest    读取zk中偏移量的数据

>.consumer.timeout.ms
    答：consumer超时抛异常，并关闭连接

3>.以上部分参数测试代码如下

 

三.