Spark连接kafka官方直连方式

kafka默认提交偏移量,消费者会将偏移量默认写到特殊的topic,偏移量更新的时候,数据已经处理,但是还没有更新偏移量,再次重新启动,会重复提交偏移量,控制不够精准,无法保证数据的一致性

---所有我们不让消费者自动提交偏移量 :"enable.auto.commit" -> (false: java.lang.Boolean)

偏移量是描述信息,偏移量在Driver端生成在Driver获取

 偏移量只有在DStream中获取,一手的DStream才可以获取,如果调取rdd就不能获取偏移量

kafka的rdd是以K V形式的,我们需要的数据是V,所有调取DStream的时候需要rdd.value

window方法是将数据攒一段时间处理

如果想调第一手的DStream,我们调取transform  输入kafkardd  返回的也是kafkardd

 

 

虽然可以自己定义偏移量更新的时间,可是还是不够完美,如果执行程序成功了,可是偏移量没有成功,那么还是有问题

package cn._51doit.spark.day13

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, InputDStream, ReceiverInputDStream}
import org.apache.spark.streaming.kafka010.{CanCommitOffsets, ConsumerStrategies, HasOffsetRanges, KafkaUtils, LocationStrategies, OffsetRange}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object KafkaWordCount {

  def main(args: Array[String]): Unit = {

    //实时计算创建StreamingContext，（StreamingContext是对SparkContext的增强包装，里面持有者SparkContext的引用）
    val conf = new SparkConf().setAppName("StreamingWordCount").setMaster("local[*]")

    val ssc: StreamingContext = new StreamingContext(conf, Seconds(5))
    ssc.sparkContext.setLogLevel("WARN")

    //Kafka相关的参数
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "node-1.51doit.com:9092,node-2.51doit.com:9092,node-3.51doit.com:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "g02",
      "auto.offset.reset" -> "earliest",
      "enable.auto.commit" -> (false: java.lang.Boolean) //让消费者不用自动提交偏移量
    )

    val topics = Array("wordcount")

    //sparkStreaming跟Kafka整合，使用的是官方推荐的直连方式，使用Kafka底层的消费API，效率更高
    val kafkaDStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      ssc, //传入StreamingContext
      LocationStrategies.PreferConsistent, //位置策略
      ConsumerStrategies.Subscribe[String, String](topics, kafkaParams) //消费策略
    )

    //val reduced: DStream[(String, Int)] = kafkaDStream.map(_.value()).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _)
    //reduced.print()

    //foreachRDD既不是Transformation也不是Action
    //（foreachRDD中的函数也会定期的调用，传入到foreachRDD中的函数，是在Driver调用的）
    kafkaDStream.foreachRDD(rdd => {
      if(!rdd.isEmpty()) {
  //HasOffsetRanges返回的是数组,数组装的是offsetRanges,一个topic保存多个分区,1号分区对应OffsetRange 1号分区
            //因为Kafkardd实现了HasOffsetRanges所以能够强转
            //获取偏移量,第一手的RDD是特殊的RDD（KafkaRDD），只有KafkaRDD有偏移量(Driver端获取的)

        //获取偏移量,第一手的RDD是特殊的RDD（KafkaRDD），只有KafkaRDD有偏移量(Driver端获取的)
        val offsetRanges: Array[OffsetRange] = rdd.asInstanceOf[HasOffsetRanges].offsetRanges

        rdd.map(_.value())
          .flatMap(_.split(" "))
          .map((_, 1))
          .reduceByKey(_ + _)
          .foreach(println)
            //批次处理完此次数据然后更新偏移量,在Driver端异步更新 !!!更新偏移量,再次启动就不在重头读取了

        //（在Driver端异步的更新偏移量,将偏移量写入到Kafka特殊的Topic中，__consumer_offset）
        kafkaDStream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges) //在Driver提交的

      }
    })


    //开启
    ssc.start()
    //让程序一直运行，将Driver挂起
    ssc.awaitTermination()

  }
}