【学习笔记】大数据技术之SparkStreaming

尚硅谷大数据Spark教程从入门到精通

思考？

SparkStreaming 的wordcount

有有状态和无状态的wordcount
基于滑动窗口的wordcount

第1章 SparkStreaming 概述

SparkSteaming 准实时（秒，分钟），微批次（时间）的数据处理框架

1.1 Spark Streaming 是什么

Spark 流使得构建可扩展的容错流应用程序变得更加容易。
Spark Streaming 用于流式数据的处理。Spark Streaming 支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ 和简单的 TCP 套接字等等。数据输入后可以用 Spark 的高度抽象原语如：map、reduce、join、window 等进行运算。而结果也能保存在很多地方，如 HDFS，数据库等。

和 Spark 基于 RDD 的概念很相似，Spark Streaming 使用离散化流(discretized stream)作为抽象表示，叫作 DStream。DStream 是随时间推移而收到的数据的序列。在内部，每个时间区间收到的数据都作为 RDD 存在，而 DStream 是由这些 RDD 所组成的序列(因此得名“离散化”)。所以简单来将，DStream 就是对 RDD 在实时数据处理场景的一种封装。

1.2 Spark Streaming 的特点

➢ 易用

➢ 容错

➢ 易整合到 Spark 体系

1.3 Spark Streaming 架构

1.3.1 架构图

➢ 整体架构图

➢ SparkStreaming 架构图

1.3.2 背压机制

Spark 1.5 以前版本，用户如果要限制 Receiver 的数据接收速率，可以通过设置静态配制参
数“spark.streaming.receiver.maxRate”的值来实现，此举虽然可以通过限制接收速率，来适配当前的处理能力，防止内存溢出，但也会引入其它问题。比如：producer 数据生产高于 maxRate，当前集群处理能力也高于 maxRate，这就会造成资源利用率下降等问题。

为了更好的协调数据接收速率与资源处理能力，1.5 版本开始 Spark Streaming 可以动态控制
数据接收速率来适配集群数据处理能力。背压机制（即 Spark Streaming Backpressure）: 根据JobScheduler 反馈作业的执行信息来动态调整 Receiver 数据接收率。

通过属性“spark.streaming.backpressure.enabled”来控制是否启用 backpressure 机制，默认值
false，即不启用。

第 2 章 Dstream 入门

2.1 WordCount 案例实操

➢ 需求：使用 netcat 工具向 9999 端口不断的发送数据，通过 SparkStreaming 读取端口数据并
统计不同单词出现的次数

1. 添加依赖

<dependency>
 <groupId>org.apache.spark</groupId>
 <artifactId>spark-streaming_2.12</artifactId>
 <version>3.0.0</version>
</dependency>

2. 编写代码

package com.wanghaha.bigdata.spark.streaming

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

object SparkStreaming01_WordCount {
   
  def main(args: Array[String]): Unit = {
   
    // TODO 创建环境对象
    // StreamingContext创建时，需要传递两个参数
    // 第一个参数 表示环境配置
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    // 第二个参数便是 批量处理的周期/时间/采集周期
    val ssc = new StreamingContext(sparkConf,Seconds(3))
    // TODO 逻辑处理
    // 获取端口数据
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
    val words = lines.flatMap(_.split(" "))
    val wordToOne = words.map((_,1))
    val wordCount: DStream[(String, Int)] = wordToOne.reduceByKey(_ + _)
    wordCount.print() // 也打印时间戳

    // 由于SparkStreming 采集器是长期执行的任务，所以不能直接关闭
    // 如果main方法执行完毕，应用程序也会自动结束。所以不能让main执行完毕。
    // ssc.stop()
    // 1. 启动采集器
    ssc.start()
    // 2. 等待采集器的关闭
    ssc.awaitTermination()
  }

}

3. 启动程序并通过 netcat 发送数据：

netcat-win32-1.12.zip
在该工具的文件夹下，进行cmd操作。需要提前关闭防火墙。

nc -lk 9999
hello spark

2.2 WordCount 解析

Discretized Stream 是 Spark Streaming 的基础抽象，代表持续性的数据流和经过各种 Spark 原语操作后的结果数据流。在内部实现上，DStream 是一系列连续的 RDD 来表示。每个 RDD 含有一段时间间隔内的数据。

对数据的操作也是按照 RDD 为单位来进行的

计算过程由 Spark Engine 来完成

第 3 章 DStream 创建

3.1 RDD 队列

3.1.1 用法及说明

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

3.1.2 案例实操

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

1. 编写代码

object RDDStream {
   
  def main(args: Array[String]) {
   
    //1.初始化 Spark 配置信息
    val conf = new SparkConf().setMaster("local[*]").setAppName("RDDStream")
    //2.初始化 SparkStreamingContext
    val ssc = new StreamingContext(conf, Seconds(4))
    //3.创建 RDD 队列
    val rddQueue = new mutable.Queue[RDD[Int]]()
    //4.创建 QueueInputDStream
    val inputStream = ssc.queueStream(rddQueue,oneAtATime = false)
    //5.处理队列中的 RDD 数据
    val mappedStream = inputStream.map((_,1))
    val reducedStream = mappedStream.reduceByKey(_ + _)
    //6.打印结果
    reducedStream.print()
    //7.启动任务
    ssc.start()
    //8.循环创建并向 RDD 队列中放入 RDD
    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)
(6,60)
(8,60)
(2,60)
(1,60)
(3,60)
(7,60)
(9,60)
(5,60)
-------------------------------------------
Time: 1539075284000 ms
-------------------------------------------
(4,60)
(0,60)
(6,60)
(8,60)
(2,60)
(1,60)
(3,60)
(7,60)
(9,60)
(5,60)
-------------------------------------------
Time: 1539075288000 ms
-------------------------------------------
(4,30)
(0,30)
(6,30)
(8,30)
(2,30)
(1,30)
(3,30)
(7,30)
(9,30)
(5,30)
-------------------------------------------
Time: 1539075292000 ms
-------------------------------------------

3.2 自定义数据源

3.2.1 用法及说明

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

3.2.2 案例实操

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

1. 自定义数据源

class CustomerReceiver(host: String, port: Int) extends
  Receiver[String](StorageLevel.MEMORY_ONLY) {
   

  //最初启动的时候，调用该方法，作用为：读数据并将数据发送给 Spark
  override def onStart(): Unit = {
   
    new Thread("Socket Receiver") {
   
      override def run() {
   
        receive()
      }
    }.start()
  }

  //读数据并将数据发送给 Spark
  def receive(): Unit = {
   
    //创建一个 Socket
    var socket: Socket = new Socket(host, port)
    //定义一个变量，用来接收端口传过来的数据
    var input: String = null
    //创建一个 BufferedReader 用于读取端口传来的数据
    val reader = new BufferedReader(new InputStreamReader(socket.getInputStream,
      StandardCharsets.UTF_8))
    //读取数据
    input = reader.readLine()
    //当 receiver 没有关闭并且输入数据不为空，则循环发送数据给 Spark
    while (!isStopped() && input != null) {
   
      store(input)
      input = reader.readLine()
    }
    //跳出循环则关闭资源
    reader.close()
    socket.close()
    //重启任务
    restart("restart")
  }

  override def onStop(): Unit = {
   }
}

自定义数据采集器

package com.wanghaha.bigdata.spark.streaming

import org.apache.spark.SparkConf
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.receiver.Receiver
import org.apache.spark.streaming.{
   Seconds, StreamingContext}

import scala.util.Random

object SparkStreaming03_DIY {
   
  def main(args: Array[String]): Unit = {
   
    // TODO 创建环境对象
    // StreamingContext创建时，需要传递两个参数
    // 第一个参数 表示环境配置
    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()
  }


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

      override def onStart(): Unit = {
   
        new Thread(new Runnable {
   
          override def run(): Unit = {
   
            while (flg) {
   
              val message = "采集的数据是：" + new Random().nextInt(10).toString
              store(message)
              Thread.sleep(500)
            }
          }
        }).start()
      }

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

2. 使用自定义的数据源采集数据

object FileStream {
   
 def main(args: Array[String]): Unit = {
   
 //1.初始化 Spark 配置信息
val sparkConf = new SparkConf().setMaster("local[*]")
.setAppName("StreamWordCount")
 //2.初始化 SparkStreamingContext
 val ssc = new StreamingContext(sparkConf, Seconds(5))
//3.创建自定义 receiver 的 Streaming
val lineStream = ssc.receiverStream(new CustomerReceiver("hadoop102", 9999))
 //4.将每一行数据做切分，形成一个个单词
 val wordStream = lineStream.flatMap(_.split("\t"))
 //5.将单词映射成元组（word,1）
val wordAndOneStream = wordStream.map((_, 1))
 //6.将相同的单词次数做统计
 val wordAndCountStream = wordAndOneStream.reduceByKey(_ + _)
 //7.打印
 wordAndCountStream.print()
 //8.启动 SparkStreamingContext
 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-8 Receiver 模式（当前版本不适用）

1） 需求：通过 SparkStreaming 从 Kafka 读取数据，并将读取过来的数据做简单计算，最终打印
到控制台。
2）导入依赖

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

3）编写代码

package com.atguigu.kafka
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{
   Seconds, StreamingContext}
object ReceiverAPI {
   
 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 数据创建 DStream(基于 Receive 方式)
 val kafkaDStream: ReceiverInputDStream[(String, String)] = 
KafkaUtils.createStream(ssc,
 "linux1:2181,linux2:2181,linux3:2181",
 "atguigu",
 Map[String, Int]("atguigu" -> 1))
 //4.计算 WordCount
 kafkaDStream.map {
    case (_, value) =>
 (value, 1)
 }.reduceByKey(_ + _)
 .print()
 //5.开启任务
 ssc.start()
 ssc.awaitTermination()
 }
}

3.3.3 Kafka 0-8 Direct 模式（当前版本不适用）

1）需求：通过 SparkStreaming 从 Kafka 读取数据，并将读取过来的数据做简单计算，最终打印到控制台。
2）导入依赖

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

3）编写代码（自动维护 offset）

import kafka.serializer.StringDecoder
import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.InputDStream
import org