2.Spark Streaming基础—DStream 创建—RDD 队列、自定义数据源、Kafka 数据源

第3章 DStream 创建

3.1 RDD 队列

3.1.1 用法及说明

测试过程中，可以通过使用 ssc.queueStream(queueOfRDDs) 来创建 DStream，每一个推送到这个队列中的 RDD，都会作为一个 DStream 处理。

3.1.2 案例实操

需求：循环创建几个 RDD，将 RDD 放入队列。通过 SparkStream 创建 Dstream，计算WordCount。

• (1) 编写代码

import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.{Seconds, StreamingContext}

import scala.collection.mutable

object SparkStreaming02_Queue {

  def main(args: Array[String]): Unit = {
    // TODO 创建环境对象
    // StreamingContext创建时, 需要传递两个参数第一个参数表示环境配置
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName ("SparkStreaming")
    // 第二个参数表示批量处理的周期（采集周期)
    val ssc = new StreamingContext(sparkConf, Seconds(3))

    val rddQueue = new mutable.Queue[RDD[Int]]()
    val inputStream = ssc.queueStream(rddQueue, oneAtATime = false)
    val mappedStream = inputStream.map((_, 1))
    val reducedStream = mappedStream.reduceByKey(_ + _)
    reducedStream.print()

    ssc.start()

    for (i <- 1 to 5) {
      rddQueue += ssc.sparkContext.makeRDD(1 to 300, 10)
      Thread.sleep(2000)
    }

    ssc.awaitTermination()
  }
}

• (2) 结果展示

-------------------------------------------
Time: 1539075280000 ms
-------------------------------------------
(4,60)
(0,60)
...
-------------------------------------------
Time: 1539075284000 ms
-------------------------------------------
(4,60)
(0,60)
...

---

3.2 自定义数据源

3.2.1 用法及说明

• 需要继承 Receiver，并实现 onStart、onStop 方法来自定义数据源采集。

3.2.2 案例实操

需求：自定义数据源，实现监控某个端口号，获取该端口号内容。

• (1) 自定义数据源

/**
 * 自定义数据采集器
 *    1.继承Receiver, 定义泛型, 传递参数
 *    2.重写方法
 */
class MyReceiver extends Receiver[String](StorageLevel.MEMORY_ONLY) {
  private var flag = true

  //最初启动的时候，调用该方法，作用为：读数据并将数据发送给 Spark
  override def onStart(): Unit = {
    new Thread(new Runnable {
      override def run(): Unit = {
        while ( flag ) {
          val message ="采集的数据为:" + new Random().nextInt(10).toString
          store(message)
          Thread.sleep(500)
        }
      }
    }).start()
  }

  override def onStop(): Unit = {
    flag = false
  }
}

• (2) 使用自定义的数据源采集数据

object SparkStreaming03_DIY {

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName ("SparkStreaming")
    val ssc = new StreamingContext(sparkConf, Seconds(3))

    val messageDS: ReceiverInputDStream[String] = ssc.receiverStream(new MyReceiver())
    messageDS.print()

    ssc.start()
    ssc.awaitTermination()
  }
}

---

3.3 Kafka 数据源（面试、开发重点）

3.3.1 版本选型

• ReceiverAPI：需要一个专门的 Executor 去接收数据，然后发送给其他的 Executor 做计算。存在的问题，接收数据的 Executor 和计算的 Executor 速度会有所不同，特别在接收数据的 Executor 速度大于计算的 Executor 速度，会导致计算数据的节点内存溢出。早期版本中提供此方式，当前版本不适用。
• DirectAPI：是由计算的 Executor 来主动消费 Kafka 的数据，速度由自身控制。

3.3.2 Kafka 0-10 Direct 模式

需求：通过 Spark Streaming 从 Kafka 读取数据，并将读取过来的数据做简单计算，最终打印
到控制台。

• (1) 导入依赖

<dependency>
	<groupId>org.apache.sparkgroupId>
	<artifactId>spark-streaming-kafka-0-10_2.12artifactId>
	<version>3.0.0version>
dependency>
<dependency>
	<groupId>com.fasterxml.jackson.coregroupId>
	<artifactId>jackson-coreartifactId>
	<version>2.10.1version>
 dependency>

• (2) 编写代码

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, 
LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
object DirectAPI {
 def main(args: Array[String]): Unit = {
 //1.创建 SparkConf
 val sparkConf: SparkConf = new 
SparkConf().setAppName("ReceiverWordCount").setMaster("local[*]")
 //2.创建 StreamingContext
 val ssc = new StreamingContext(sparkConf, Seconds(3))
 //3.定义 Kafka 参数
 val kafkaPara: Map[String, Object] = Map[String, Object](
 ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> 
"linux1:9092,linux2:9092,linux3:9092",
 ConsumerConfig.GROUP_ID_CONFIG -> "atguigu",
 "key.deserializer" -> 
"org.apache.kafka.common.serialization.StringDeserializer",
 "value.deserializer" -> 
"org.apache.kafka.common.serialization.StringDeserializer"
 )
 //4.读取 Kafka 数据创建 DStream
 val kafkaDStream: InputDStream[ConsumerRecord[String, String]] = 
KafkaUtils.createDirectStream[String, String](ssc,
 LocationStrategies.PreferConsistent,
 ConsumerStrategies.Subscribe[String, String](Set("atguigu"), kafkaPara))
 //5.将每条消息的 KV 取出
 val valueDStream: DStream[String] = kafkaDStream.map(record => record.value())
 //6.计算 WordCount
 valueDStream.flatMap(_.split(" "))
 .map((_, 1))
 .reduceByKey(_ + _)
 .print()
 //7.开启任务
 ssc.start()
 ssc.awaitTermination()
 }
}

查看 Kafka 消费进度

bin/kafka-consumer-groups.sh --describe --bootstrap-server linux1:9092 --group 
atguigu

---

声明：本文是学习时记录的笔记，如有侵权请告知删除！
原视频地址:https://www.bilibili.com/video/BV11A411L7CK