SparkStreaming笔记(一）

最新推荐文章于 2023-12-15 11:24:25 发布

smallworldxyl

最新推荐文章于 2023-12-15 11:24:25 发布

阅读量220

点赞数

分类专栏： Spark 文章标签： spark streaming

本文链接：https://blog.csdn.net/smallworldxyl/article/details/113723949

版权

Spark 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

一.概述

1.简介

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 在实时数据处理场景的一种封装。

2.特点

➢ 易用
➢ 容错
➢ 易整合到 Spark 体系

3.架构

3.1 架构

➢ 整体架构图
在这里插入图片描述

➢ SparkStreaming 架构图
在这里插入图片描述

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，即不启用。

二. WordCount

Discretized Stream 是 Spark Streaming 的基础抽象，代表持续性的数据流和经过各种 Spark 原语操作后的结果数据流。在内部实现上，DStream 是一系列连续的 RDD 来表示。每个 RDD 含有一段时间间隔内的数据。
在这里插入图片描述对数据的操作也是按照 RDD 为单位来进行的

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

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

    // TODO 创建环境对象
    // StreamingContext创建时，需要传递两个参数
    // 第一个参数表示环境配置
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
      .set("spark.testing.memory", "2147480000")
    // 第二个参数表示批量处理的周期（采集周期）
    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 wordToCount: DStream[(String, Int)] = wordToOne.reduceByKey(_+_)

    wordToCount.print()

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

}

在9999端口输入：

[root@master xyl]# nc -lp 9999
hello scala
hello spark
aaaa sa sad
ad
asdca

输出：


Time: 1612590207000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590210000 ms
-------------------------------------------
(scala,1)
(hello,1)
-------------------------------------------
Time: 1612590213000 ms
-------------------------------------------
(spark,1)
(hello,1)
-------------------------------------------
Time: 1612590216000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590219000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590222000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590225000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590228000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590231000 ms
-------------------------------------------
(aaaa,1)
(sa,1)
(sad,1)
-------------------------------------------
Time: 1612590234000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590237000 ms
-------------------------------------------
(ad,1)
-------------------------------------------
Time: 1612590240000 ms
-------------------------------------------
(asdca,1)
-------------------------------------------
Time: 1612590243000 ms
-------------------------------------------
-------------------------------------------
Time: 1612590246000 ms
-------------------------------------------

三. DStream 创建

3.1 RDD 队列

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

val sparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
      .set("spark.testing.memory", "2147480000")
    val sc = new StreamingContext(sparkConf, Seconds(3))
    val rddQueue = new mutable.Queue[RDD[Int]]()

    val inputStream = sc.queueStream(rddQueue,oneAtATime = false)
    val mappedStream = inputStream.map((_,1))
    val reducedStream = mappedStream.reduceByKey(_ + _)
    reducedStream.print()

    sc.start()

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

    sc.awaitTermination()

输出：

Time: 1612592622000 ms
-------------------------------------------
(147,1)
(19,1)
(39,1)
(297,1)
(71,1)
(180,1)
(130,1)
(66,1)
(138,1)
(171,1)
...

[Stage 2:>                                                         (0 + 0) / 10]-------------------------------------------
Time: 1612592625000 ms
-------------------------------------------
(147,1)
(19,1)
(39,1)
(297,1)
(71,1)
(180,1)
(130,1)
(66,1)
(138,1)
(171,1)
...

-------------------------------------------
Time: 1612592628000 ms
-------------------------------------------
(147,2)
(19,2)
(39,2)
(297,2)
(71,2)
(180,2)
(130,2)
(66,2)
(138,2)
(171,2)
...

-------------------------------------------
Time: 1612592631000 ms
-------------------------------------------
(147,1)
(19,1)
(39,1)
(297,1)
(71,1)
(180,1)
(130,1)
(66,1)
(138,1)
(171,1)
...

-------------------------------------------
Time: 1612592634000 ms
-------------------------------------------

-------------------------------------------
Time: 1612592637000 ms
-------------------------------------------

3.2 自定义数据源

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

import java.util.Random

import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
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.collection.mutable

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()
    }
    /*
    自定义数据采集器
    1. 继承Receiver，定义泛型, 传递参数
    2. 重写方法
     */
    class MyReceiver extends Receiver[String](StorageLevel.MEMORY_ONLY) {
        private var flg = true
//最初启动的时候，调用该方法，作用为：读数据并将数据发送给 Spark
        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;
        }
    }
}

3.3 KafKa数据源（后续更）

四.DStream 转换

DStream 上的操作与 RDD 的类似，分为 Transformations（转换）和 Output Operations（输出）两种，此外转换操作中还有一些比较特殊的原语，如：updateStateByKey()、transform()以及各种 Window 相关的原语。

4.1 无状态转化操作

无状态转化操作就是把简单的 RDD 转化操作应用到每个批次上，也就是转化 DStream 中的每一个 RDD。部分无状态转化操作列在了下表中。注意，针对键值对的 DStream 转化操作(比如reduceByKey())要添加 import StreamingContext._才能在 Scala 中使用。
在这里插入图片描述尽管这些函数看起来像作用在整个流上一样，但事实上每个DStream 在内部是由许多 RDD（批次）组成，且无状态转化操作是分别应用到每个 RDD 上的。
例如：reduceByKey()会归约每个时间区间中的数据，但不会归约不同区间之间的数据。

4.1.1 Transform

Transform 允许 DStream 上执行任意的 RDD-to-RDD 函数。即使这些函数并没有在 DStream的 API 中暴露出来，通过该函数可以方便的扩展 Spark API。该函数每一批次调度一次。其实也就是对 DStream 中的 RDD 应用转换。

object Transform {
 def main(args: Array[String]): Unit = {
 //创建 SparkConf
val sparkConf: SparkConf = new 
SparkConf().setMaster("local[*]").setAppName("WordCount")
 //创建 StreamingContext
 val ssc = new StreamingContext(sparkConf, Seconds(3))
 //创建 DStream
 val lineDStream: ReceiverInputDStream[String] = ssc.socketTextStream("linux1", 
9999)
 //转换为 RDD 操作
 val wordAndCountDStream: DStream[(String, Int)] = lineDStream.transform(rdd => 
{
 val words: RDD[String] = rdd.flatMap(_.split(" "))
 val wordAndOne: RDD[(String, Int)] = words.map((_, 1))
 val value: RDD[(String, Int)] = wordAndOne.reduceByKey(_ + _)
 value
 })
 //打印
 wordAndCountDStream.print
 //启动
 ssc.start()
 ssc.awaitTermination()
 } }

4.1.2 join

两个流之间的 join 需要两个流的批次大小一致，这样才能做到同时触发计算。计算过程就是对当前批次的两个流中各自的 RDD 进行 join，与两个 RDD 的 join 效果相同。

import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
object JoinTest {
 def main(args: Array[String]): Unit = {
 //1.创建 SparkConf
 val sparkConf: SparkConf = new 
SparkConf().setMaster("local[*]").setAppName("JoinTest")
 //2.创建 StreamingContext
 val ssc = new StreamingContext(sparkConf, Seconds(5))
 //3.从端口获取数据创建流
 val lineDStream1: ReceiverInputDStream[String] = 
ssc.socketTextStream("linux1", 9999)
 val lineDStream2: ReceiverInputDStream[String] = 
ssc.socketTextStream("linux2", 8888)
 //4.将两个流转换为 KV 类型
 val wordToOneDStream: DStream[(String, Int)] = lineDStream1.flatMap(_.split(" ")).map((_, 1))
 val wordToADStream: DStream[(String, String)] = lineDStream2.flatMap(_.split(" ")).map((_, "a"))
 //5.流的 JOIN
 val joinDStream: DStream[(String, (Int, String))] = 
wordToOneDStream.join(wordToADStream)
 //6.打印
 joinDStream.print()
 //7.启动任务
 ssc.start()
 ssc.awaitTermination()
 } }

向8888端口输入：

[root@master xyl]# nc -lp 8888
a
a
a
a
a
a

向9999端口输入：

[root@master xyl]# nc -lp 9999
a
a
a
a
a
a

输出：

-------------------------------------------
Time: 1612592631000 ms
-------------------------------------------
(a,(1,a))
(a,(1,a))
(a,(1,a))
(a,(1,a))
(a,(1,a))
(a,(1,a))

4.2 有状态转化操作

4.2.1 UpdateStateByKey

UpdateStateByKey 原语用于记录历史记录，有时，我们需要在 DStream 中跨批次维护状态(例如流计算中累加 wordcount)。针对这种情况，updateStateByKey()为我们提供了对一个状态变量的访问，用于键值对形式的 DStream。给定一个由(键，事件)对构成的 DStream，并传递一个指定如何根据新的事件更新每个键对应状态的函数，它可以构建出一个新的 DStream，其内部数据为(键，状态) 对。
updateStateByKey() 的结果会是一个新的 DStream，其内部的 RDD 序列是由每个时间区间对应的(键，状态)对组成的。
updateStateByKey 操作使得我们可以在用新信息进行更新时保持任意的状态。为使用这个功能，需要做下面两步：

定义状态，状态可以是一个任意的数据类型。
定义状态更新函数，用此函数阐明如何使用之前的状态和来自输入流的新值对状态进行更新。

使用 updateStateByKey 需要对检查点目录进行配置，会使用检查点来保存状态。

原版的WordCount输出:（只对当前的采集周期内的数据进行处理）

[root@master conf]# nc -lp 9999
a 
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a

Time: 1612596114000 ms
-------------------------------------------
(a,9)

-------------------------------------------
Time: 1612596117000 ms
-------------------------------------------
(a,7)

更新的WordCount输出:（保留数据统计结果）

val sparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    .set("spark.testing.memory", "2147480000")

  val ssc = new StreamingContext(sparkConf, Seconds(3))
  ssc.checkpoint("file:///home/xyl/IdeaProjects/sparktest/cp")

  // 无状态数据操作，只对当前的采集周期内的数据进行处理
  // 在某些场合下，需要保留数据统计结果（状态），实现数据的汇总
  // 使用有状态操作时，需要设定检查点路径
  val datas = ssc.socketTextStream("localhost", 9999)

  val wordToOne = datas.map((_,1))

  //val wordToCount = wordToOne.reduceByKey(_+_)

  // updateStateByKey：根据key对数据的状态进行更新
  // 传递的参数中含有两个值
  // 第一个值表示相同的key的value数据
  // 第二个值表示缓存区相同key的value数据
  val state = wordToOne.updateStateByKey(
    ( seq:Seq[Int], buff:Option[Int] ) => {
      val newCount = buff.getOrElse(0) + seq.sum
      Option(newCount)
    }
  )

  state.print()

  ssc.start()
  ssc.awaitTermination()

输出：

-------------------------------------------
Time: 1612597860000 ms
-------------------------------------------
(a,6)

-------------------------------------------
Time: 1612597863000 ms
-------------------------------------------
(a,10)

-------------------------------------------
Time: 1612597866000 ms
-------------------------------------------
(a,13)

-------------------------------------------
Time: 1612597869000 ms
-------------------------------------------
(a,16)

-------------------------------------------
Time: 1612597872000 ms
-------------------------------------------
(a,16)

4.2.2 WindowOperations

Window Operations 可以设置窗口的大小和滑动窗口的间隔来动态的获取当前 Steaming 的允许状态。所有基于窗口的操作都需要两个参数，分别为窗口时长以及滑动步长。
➢ 窗口时长：计算内容的时间范围；
➢ 滑动步长：隔多久触发一次计算。
注意：这两者都必须为采集周期大小的整数倍。

WordCount 第三版：3 秒一个批次，窗口 12 秒，滑步 6 秒。

object WorldCount {
 def main(args: Array[String]) {
 val conf = new 
SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")
 val ssc = new StreamingContext(conf, Seconds(3))
 ssc.checkpoint("./ck")
 // Create a DStream that will connect to hostname:port, like localhost:9999
 val lines = ssc.socketTextStream("linux1", 9999)
 // Split each line into words
 val words = lines.flatMap(_.split(" "))
// Count each word in each batch
 val pairs = words.map(word => (word, 1))
 val wordCounts = pairs.reduceByKeyAndWindow((a:Int,b:Int) => (a + 
b),Seconds(12), Seconds(6))
 // Print the first ten elements of each RDD generated in this DStream to the 
console
 wordCounts.print()
 ssc.start() // Start the computation
 ssc.awaitTermination() // Wait for the computation to terminate
 } }

关于 Window 的操作还有如下方法：
（1）window(windowLength, slideInterval): 基于对源 DStream 窗化的批次进行计算返回一个新的 Dstream；
（2）countByWindow(windowLength, slideInterval): 返回一个滑动窗口计数流中的元素个数；
（3）reduceByWindow(func, windowLength, slideInterval): 通过使用自定义函数整合滑动区间流元素来创建一个新的单元素流；
（4）reduceByKeyAndWindow(func, windowLength, slideInterval, [numTasks]): 当在一个(K,V)对的 DStream 上调用此函数，会返回一个新(K,V)对的 DStream，此处通过对滑动窗口中批次数据使用 reduce 函数来整合每个 key 的 value 值。
（5）reduceByKeyAndWindow(func, invFunc, windowLength, slideInterval, [numTasks]): 这个函数是上述函数的变化版本，每个窗口的 reduce 值都是通过用前一个窗的 reduce 值来递增计算。通过 reduce 进入到滑动窗口数据并”反向 reduce”离开窗口的旧数据来实现这个操作。一个例子是随着窗口滑动对 keys 的“加”“减”计数。通过前边介绍可以想到，这个函数只适用于”可逆的 reduce 函数”，也就是这些 reduce 函数有相应的”反 reduce”函数(以参数 invFunc 形式传入)。如前述函数，reduce 任务的数量通过可选参数来配置。

val ipDStream = accessLogsDStream.map(logEntry => (logEntry.getIpAddress(), 1))
val ipCountDStream = ipDStream.reduceByKeyAndWindow(
 {(x, y) => x + y},
 {(x, y) => x - y},
 Seconds(30),
 Seconds(10))
 //加上新进入窗口的批次中的元素 //移除离开窗口的老批次中的元素 //窗口时长// 滑动步长

在这里插入图片描述

countByWindow()和 countByValueAndWindow()作为对数据进行计数操作的简写。
countByWindow()返回一个表示每个窗口中元素个数的 DStream，而 countByValueAndWindow()返回的 DStream 则包含窗口中每个值的个数。

val ipDStream = accessLogsDStream.map{entry => entry.getIpAddress()}
val ipAddressRequestCount = ipDStream.countByValueAndWindow(Seconds(30), 
Seconds(10)) 
val requestCount = accessLogsDStream.countByWindow(Seconds(30), Seconds(10))

smallworldxyl

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SparkStreaming笔记(一）

package org.xylimport org.apache.spark.SparkConfimport org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}import org.apache.spark.streaming.{Seconds, StreamingContext}object SparkStreaming_01 { def main(args: Array[String]): Unit = {
复制链接

扫一扫