Spark Streaming（05）——Spark Streaming与kafka整合

在Spark1.3版本后，KafkaUtils里面提供了两个创建dstream的方法，一种为KafkaUtils.createDstream，另一种为KafkaUtils.createDirectStream。

KafkaUtils.createDstream方式

KafkaUtils.createDstream(ssc, [zk], [group id], [per-topic,partitions] ) 使用了receivers接收器来接收数据，利用的是Kafka高层次的消费者api，对于所有的receivers接收到的数据将会保存在Spark executors中，然后通过Spark Streaming启动job来处理这些数据，可能会丢失，可启用WAL日志，它同步将接受到数据保存到分布式文件系统上比如HDFS。 所以数据在出错的情况下可以恢复出来 。

步骤：

A、创建一个receiver接收器来对kafka进行定时拉取数据
B、对于不同的group和topic可以使用多个receivers创建不同的DStream
C、如果启用了WAL(spark.streaming.receiver.writeAheadLog.enable=true)，同时需要设置存储级别(默认StorageLevel.MEMORY_AND_DISK_SER_2)，

开发流程：

添加依赖

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
    <version>2.1.3</version>
</dependency>

启动集群
启动zookeeper，kafka集群

kafka创建topic

kafka-topics.sh --create --zookeeper node01:2181,node02:2181,node03:2181 --replication-factor 2 --partitions 3 --topic kafka_spark

开发spark Streaming代码

package com.fgm.streaming_kafka

import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.immutable

/**
  *利用sparkSteaming整合kafka
  *
  * @Auther: fgm
  */
object SparkStreamingKafkaReceiver {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setAppName("kafkaReceiver").setMaster("local[4]").set("spark.streaming.receiver.writeAheadLog.enable","true")
    val sc: SparkContext = new SparkContext(sparkConf)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))
    //设置checkpoint目录，保证最原始的数据安全性
    ssc.checkpoint("./sparkReceiver")
    //指定zk服务地址
    val zkQuorum="node01:2181,node02:2181,node03:2181"
    //指定消费者组
    val groupId="spark-receiver"
    //指定topic相关信息
    val topics=Map("kafkaSpark"->1)
    //实现多个receiver接收器接收数据，加快数据接收的速度
    val dstreamList: immutable.IndexedSeq[ReceiverInputDStream[(String, String)]] = (1 to 3).map(x => {
      val createStream: ReceiverInputDStream[(String, String)] = KafkaUtils.createStream(ssc, zkQuorum, groupId, topics)
      createStream
    })
    val unionKafkaDstream: DStream[(String, String)] = ssc.union(dstreamList)
    //获取kafka中topic中的数据
    val data: DStream[String] = unionKafkaDstream.map(_._2)
    //切分
    val words: DStream[String] = data.flatMap(_.split(" "))
    val wordAndOne: DStream[(String, Int)] = words.map((_,1))
    val result: DStream[(String, Int)] = wordAndOne.reduceByKey(_+_)
    result.print()
    ssc.start()
    ssc.awaitTermination()
    
  }

}

向topic中生产数据
通过shell命令向topic发送消息
kafka-console-producer.sh --broker-list node01:9092 --topic kafka_spark

运行sparkstreaming代码，向topic中发送数据，查看IDEA控制台的输出结果

通过这种方式实现，如果系统异常重新启动sparkstreaming程序后，程序会重复处理已经处理过的数据，
这种基于receiver的方式，是使用Kafka的高级API，topic的offset偏移量在ZooKeeper中。这是消费Kafka数据的传统方式。这种方式配合着WAL机制可以保证数据零丢失的高可靠性，但是却无法保证数据只被处理一次，可能会处理两次。因为Spark和ZooKeeper之间可能是不同步的。
官方现在也已经不推荐这种整合方式，我们使用官网推荐的第二种方式kafkaUtils的createDirectStream()方式。
在后续的kafka jar包中，已经不支持这种方式。

KafkaUtils.createDirectStream方式

它定期地从kafka的topic下对应的partition中查询最新的偏移量，再根据偏移量范围在每个batch里面处理数据，Spark通过调用kafka简单的消费者Api（低级api）读取一定范围的数据。

createDirectStream相比基于Receiver方式有几个优点：

简化并行
不需要创建多个kafka输入流，然后union它们，sparkStreaming将会创建和kafka分区数相同的rdd的分区数，而且会从kafka中并行读取数据，spark中RDD的分区数和kafka中的topic分区数是一一对应的关系。
高效
第一种实现数据的零丢失是将数据预先保存在WAL中，会复制一遍数据，会导致数据被拷贝两次，第一次是接受kafka中topic的数据，另一次是写到WAL中。而没有receiver的这种方式消除了这个问题。
恰好一次语义(Exactly-once-semantics)
Receiver读取kafka数据是通过kafka高层次api把偏移量写入zookeeper中，虽然这种方法可以通过数据保存在WAL中保证数据不丢失，但是可能会因为sparkStreaming和ZK中保存的偏移量不一致而导致数据被消费了多次。EOS通过实现kafka低层次api，偏移量仅仅被ssc保存在checkpoint中，消除了zk和ssc偏移量不一致的问题。缺点是无法使用基于zookeeper的kafka监控工具。

依赖同上
代码开发

package com.fgm.streaming_kafka

import kafka.serializer.StringDecoder
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**
  *利用sparkStreaming整合kafka，不再有zk去维护消息的偏移量，由客户端程序自己去维护
  * @Auther: fgm
  */
object SparkStreamingKafkaDirect {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setAppName("kafkaDirect").setMaster("local[2]")
    val sc = new SparkContext(sparkConf)
    sc.setLogLevel("WARN")
    //创建streamingContext
    val ssc: StreamingContext = new StreamingContext(sc,Seconds(5))
    ssc.checkpoint("/sparkDirect")
    val kafkaParams = Map("bootstrap.servers"->"node01:9092,node02:9092,node03:9092","group.id"->"spark-direct")
    val topics=Set("kafkaSpark")
    val kafkaDstream: InputDStream[(String, String)] = KafkaUtils.createDirectStream[String,String,StringDecoder,StringDecoder](ssc,kafkaParams,topics)
    //获取topic的内容
    val data: DStream[String] = kafkaDstream.map(_._2)
    val result: DStream[(String, Int)] = data.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)
    result.print()
    ssc.start()
    ssc.awaitTermination()
  }

}

测试同上