kafka结合streaming的两种方式

SparkStreaming的Receiver方式和直连方式的区别？Receiver接收固定时间间隔的数据(放在内存中的)，使用kafka高级API，自动维护偏移量， 达到固定时间才能进行处理，效率低下（），并且容易丢失数据 Direct直连方式，相当于直连连接到Kafka的分区上，使用Kafka底层API，效率高，需要自己维护偏移量 Receiver方式和直连的方式： 如果说这两种方式设置的时间间隔是5秒的话，Receiver方式拉去的数据是等待5秒，然后将这5秒的数据 全部一次性拿过来进行操作，这样等待5秒的时间，如果数据量特变大的情况下，杯子容量不够，会造成数据丢失。 Direct直连方式，这种方式是直接连接到kafka对应的分区上，如果kafka中有数据的话，就直接从kafka中拉取数据， 不用等待5秒的时间才拉取数据，等到了5秒的时间才去执行一次数据。

1.Receiver方式：

这种方式的缺点在于：如果5秒钟的时间，receiver去kafka中拉数据，如果数据量小的话， 是可以接受的但是当数据量大的时候，5秒的时间可能拉取了大量的数据，receiver可能已经不能容纳下这么大量的数据，就会导致数据的丢失问题，这里数据的偏移量，既update offset 是交给zookeeper管理的，这种方式在生产过程中，已经很少有使用了，甚至在kafka0-10以后就直接吧receiver移除了。这里的receiver就相当于一个杯子，这个回去kafka的流中接收数据，杯子的容量是一定的，当kafka流中的量过大的时候，就会导致数据的丢失。接收5秒钟才进行处理 ，这样的效率比较慢。 如果在这5秒的时间拉取过来的数据量过大，因为内存中的大小是有限的，内存中的数据会溢出，就会save data to WAL 的方式将多余的数据存储在本地磁盘中，这里的WAL相当于一个大盆，Receiver相当于一个水杯，这样可以防止数据的丢失，但是，因为有一些数据是写在本地磁盘的，会造成大量的网络IO的消耗。 receiver方式：它使用的是高级API实现Offset自动管理，不需要我们去管理，那么这样的话，它的灵活性特别差，不好，而且处理数据的时候，如果某一时刻的数据量过大，那么会造成磁盘溢血的情况 ，他通过WALs来进行磁盘写入。 2.直连的方式(Direct) 直连方式：他使用的是底层API实现Offset，我们开发人员管理，这样的话，它的灵活性很好，并且可以保证数据的安全性，而且不用担心数据量过大，因为他有浴池里机制，进行提前处理，然后批次提交任务。

舍弃了WAL的方式，使用更加底层的api，偏移量需要自己去查询和管理，先通过自己维护的偏移量去读取数据，这种方式数据不会经过磁盘，这里会有一个预处理机制，相当于直接用水管插到kafka上，当拉去到数据之后就直接进行预处理机制产生结果集，然后到达到设置的时间后，把所有预处理机制产生的结果汇集起来，这样会减少数据的大小，因为每次来的数据都会进行一个预处理，这里的预处理也就是执行计算逻辑，当达到预定时间，就直接将预处理的数据进行一个汇总。 代码如下：

def main(args: Array[String]): Unit = {
    //指定组名
    val group = "g1"
    //创建SparkConf
    val conf = new SparkConf().setAppName("KafkaDirectWordCount").setMaster("local[2]")
    //创建SparkStreaming，并设置间隔时间
    val ssc = new StreamingContext(conf, Duration(5000))
    //指定消费的 topic 名字
    val topic = "test4"
    //指定kafka的broker地址(sparkStream的Task直连到kafka的分区上，用更加底层的API消费，效率更高)
    val brokerList = "mini4:9092,mini5:9092,mini6:9092"
    val broadcastRef: Broadcast[Array[(Long, Long, String)]] = IPUtils.broadcastIpRules(ssc, "hdfs://mini4:9000/date/ip.txt")
    //指定zk的地址，后期更新消费的偏移量时使用(以后可以使用Redis、MySQL来记录偏移量)
    val zkQuorum = "mini4:2181,mini5:2181,mini5: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(
      "metadata.broker.list" -> brokerList,
      "group.id" -> group,
      //从头开始读取数据
      "auto.offset.reset" -> kafka.api.OffsetRequest.SmallestTimeString
    )

    //zookeeper 的host 和 ip，创建一个 client,用于跟新偏移量量的
    //是zookeeper的客户端，可以从zk中读取偏移量数据，并更新偏移量
    val zkClient = new ZkClient(zkQuorum)

    //查询该路径下是否字节点（默认有字节点为我们自己保存不同 partition 时生成的）
    // /g001/offsets/wordcount/0/10001"
    // /g001/offsets/wordcount/1/30001"
    // /g001/offsets/wordcount/2/10001"
    //zkTopicPath  -> /g001/offsets/wordcount/
    val children = zkClient.countChildren(zkTopicPath)

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

    //如果 zookeeper 中有保存 offset，我们会利用这个 offset 作为 kafkaStream 的起始位置
    var fromOffsets: Map[TopicAndPartition, Long] = Map()

    //如果保存过 offset
    if (children > 0) {
      for (i <- 0 until children) {
        // /g001/offsets/wordcount/0/10001

        // /g001/offsets/wordcount/0
        val partitionOffset = zkClient.readData[String](s"$zkTopicPath/${i}")
        // wordcount/0
        val tp = TopicAndPartition(topic, i)
        //将不同 partition 对应的 offset 增加到 fromOffsets 中
        // wordcount/0 -> 10001
        fromOffsets += (tp -> partitionOffset.toLong)
      }
      //Key: kafka的key   values: "hello tom hello jerry"
      //这个会将 kafka 的消息进行 transform，最终 kafak 的数据都会变成 (kafka的key, message) 这样的 tuple
      val messageHandler = (mmd: MessageAndMetadata[String, String]) => (mmd.key(), mmd.message())

      //通过KafkaUtils创建直连的DStream（fromOffsets参数的作用是:按照前面计算好了的偏移量继续消费数据）
      //[String, String, StringDecoder, StringDecoder,     (String, String)]
      //  key    value    key的解码方式   value的解码方式
      kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder, (String, String)](ssc, kafkaParams, fromOffsets, messageHandler)
    } else {
      //如果未保存，根据 kafkaParam 的配置使用最新(largest)或者最旧的（smallest） offset
      kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)
    }

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

    //直连方式只有在KafkaDStream的RDD中才能获取偏移量，那么就不能到调用DStream的Transformation
    //所以只能子在kafkaStream调用foreachRDD，获取RDD的偏移量，然后就是对RDD进行操作了
    //依次迭代KafkaDStream中的KafkaRDD
    kafkaStream.foreachRDD { kafkaRDD =>
      if (!kafkaRDD.isEmpty()) {
        //只有KafkaRDD可以强转成HasOffsetRanges，并获取到偏移量
        offsetRanges = kafkaRDD.asInstanceOf[HasOffsetRanges].offsetRanges
        //拿到一个rdd
        val lines: RDD[String] = kafkaRDD.map(_._2)
        //这里的lines就是RDD了。
        //对RDD进行操作，触发Action
        val lineRDD: RDD[Array[String]] = lines.map(_.split(" "))
        //计算成交总金额
        CalculateUtil.calculateIncome(lineRDD)
        //计算商品分类金额
        CalculateUtil.calculateItem(lineRDD)
        //计算区域总和
        CalculateUtil.calculateZone(lineRDD,broadcastRef)
        for (o <- offsetRanges) {
          //  /g001/offsets/wordcount/0
          val zkPath = s"${topicDirs.consumerOffsetDir}/${o.partition}"
          //将该 partition 的 offset 保存到 zookeeper
          //  /g001/offsets/wordcount/0/20000
          ZkUtils.updatePersistentPath(zkClient, zkPath, o.untilOffset.toString)
        }
      }
    }

    ssc.start()
    ssc.awaitTermination()
  }