SparkStreaming 之整合kafka0.8

直接贴代码，注释内都有详细解释：
pom依赖：

<!--SparkStreaming 整合kafka0.8版本-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
            <version>2.1.3</version>
        </dependency>

package cn.spark.direct

import kafka.common.TopicAndPartition
import kafka.message.MessageAndMetadata
import kafka.serializer.StringDecoder
import kafka.utils.{ZKGroupTopicDirs, ZkUtils}
import org.I0Itec.zkclient.ZkClient
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka.{HasOffsetRanges, KafkaUtils, OffsetRange}
import org.apache.spark.streaming.{Duration, StreamingContext}

/**
  * 使用直连方式 SparkStreaming连接kafka0.8获取数据 将偏移量数据保存到zookeeper中
  *
  * @Author xiaohuli
  * @CreateDate 2019/2/17
  */
object Kafaka8Direct {
    def main(args: Array[String]): Unit = {
        //指定组名
        val group = "g001"
        //创建SparkConf 提交到集群中运行 不要设置master参数
        val conf = new SparkConf().setAppName("KafakaDirect8").setMaster("local[4]")
        //设置SparkStreaming，并设定间隔时间
        val ssc = new StreamingContext(conf, Duration(5000))
        //指定消费者的topic名字
        val topic = "wordcount"
        //指定kafka的broker地址(SparkStreaming的Task直接连接到kafka的分区上，用更加底层的API消费，效率更高)
        val brokerList = "master:9092,slave1:9092,slave2:9092"

        //指定zookeeper的地址，用来存放数据偏移量数据，也可以使用Redis MySQL等
        val zkQuorum = "master:2181,slave1:2181,slave2:2181"
        //创建Stream时使用的topic名字集合，SparkStreaming可同时消费多个topic
        val topics: Set[String] = Set(topic)

        //创建一个 ZKGroupTopicDirs 对象，就是用来指定在zk中的存储目录，用来保存数据偏移量
        val topicDirs = new ZKGroupTopicDirs(group, topic)
        //获取 zookeeper 中的路径 "/g001/offsets/wordcount/"
        val zkTopicPath = s"${topicDirs.consumerOffsetDir}"

        //准备kafka的参数
        val kafkaParams = Map(
            //"key.deserializer" -> classOf[StringDeserializer], //key的数据类型
            //"value.deserializer" -> classOf[StringDeserializer], //value的数据类型
            //"deserializer.encoding" -> "GB2312", //配置读取Kafka中数据的编码
            "metadata.broker.list" -> brokerList,
            "group.id" -> group,
            //SmallestTimeString 从头开始读取数据
            //LargestTimeString 表示从启动后开始
            "auto.offset.reset" -> kafka.api.OffsetRequest.SmallestTimeString
        )

        //构造一个zookeeper的客户端 用来读写偏移量数据
        val zkClient = new ZkClient(zkQuorum)

        //查询该路径下是否有子节点，即是否有分区读取数据记录的读取的偏移量
        // /g001/offsets/wordcount/0/1001
        // /g001/offsets/wordcount/1/1001
        // /g001/offsets/wordcount/2/1001
        val children: Int = zkClient.countChildren(zkTopicPath)

        var kafkaStream: InputDStream[(String, String)] = null

        //构造一个map集合用来存放数据偏移量信息
        var fromOffsets: Map[TopicAndPartition, Long] = Map()

        //判断是否保存过数据 根据子节点的数量是否为0
        if (children > 0) {
            //保存过offset
            //遍历子节点
            for (i <- 0 until (children)) {

                //获取子节点 /g001/offsets/wordcount/0/1001
                val partitionOffset: String = zkClient.readData[String](s"$topicDirs/$i")
                // /wordcount/0
                val tp = TopicAndPartition(topic, i)
                //获取数据偏移量  将不同分区内的数据偏移量保存到map集合中
                //  wordcount/0 -> 1001
                fromOffsets += (tp -> partitionOffset.toLong)
            }
            // 泛型中 key：kafka中的key   value：hello tom hello jerry
            //创建函数 解析数据 转换为（topic_name, message）的元组
            val messageHandler = (mmd: MessageAndMetadata[String, String]) => (mmd.topic, mmd.message())
            //利用底层的API创建DStream 采用直连的方式
            //[String, String, StringDecoder, StringDecoder, (String, String)]
            // key      value   key的解码器     value的解码器   解析函数的返回值类型
            kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder, (String, String)](ssc, kafkaParams, fromOffsets, messageHandler)
        } else {
            //zk中没有子节点数据 就是第一次读取数据 直接创建直连对象
            kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)
        }

        //偏移量的范围
        var offsetRanges = Array[OffsetRange]()

        //直接操作kafkaStream
        //依次迭代DStream中的kafkaRDD 只有kafkaRDD才可以强转为HasOffsetRanges  从中获取数据偏移量信息
        //之后是操作的RDD 不能够直接操作DStream 因为调用Transformation方法之后就不是kafkaRDD了获取不了偏移量信息
        kafkaStream.foreachRDD(kafkaRDD => {

            //强转为HasOffsetRanges 获取offset偏移量数据
            offsetRanges = kafkaRDD.asInstanceOf[HasOffsetRanges].offsetRanges

            //获取数据
            val lines: RDD[String] =kafkaRDD.map(_._2)
            //todo
            //val results = yourCalculation(rdd)
            //接下来就是对RDD进行操作 触发action
            lines.foreachPartition(patition => {
                patition.foreach(x => println(x))
            })

            for (o <- offsetRanges) {
                //拼接zk路径  /g001/offsets/wordcount/0
                val zkPath = s"${topicDirs.consumerOffsetDir}/${o.partition}"
                //将 partition 的偏移量数据 offset 保存到zookeeper中
                ZkUtils.updatePersistentPath(zkClient, zkPath, o.untilOffset.toString)
            }
        })

        //开启SparkStreaming 并等待退出
        ssc.start()
        ssc.awaitTermination()

    }
}