0
0

SparkStreaming---DStream

文章目录

1.DStream是什么

参考博文SparkStreaming入门

2.DStream创建

2.1 RDD队列

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

  1.   def main(args: Array[String]): Unit = {
  2.     //1.初始化 Spark 配置信息
  3.     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
  4.     //2.初始化 SparkStreamingContext
  5.     //处理区间为3s一次
  6.     val ssc = new StreamingContext(sparkConf, Seconds(3))
  8.     //创建RDD队列
  9.     val rddQueue = new mutable.Queue[RDD[Int]]()
  11.     //创建QueueInputDStream
  12.     //oneAtTime=false表示同时处理队列中所有的RDD
  13.     val inputStream: InputDStream[Int] = ssc.queueStream(rddQueue, oneAtATime = false)
  15.     //对DStream处理
  16.     val mapStream: DStream[(Int, Int)] = inputStream.map((_, 1))
  17.     val resDStream: DStream[(Int, Int)] = mapStream.reduceByKey(_ + _)
  19.     resDStream.print()
  21.     //启动SparkStreamingContext
  22.     ssc.start()
  24.     //向RDD队列中放入RDD
  25.     for(i <- 1 to 5) {
  26.     rddQueue+=ssc.sparkContext.makeRDD(List(1,2,3,4))
  27.     Thread.sleep(2000)
  28.     }
  29.     //等待接收数据
  30.     ssc.awaitTermination()
  31.   }

在这里插入图片描述

2.2 自定义数据源

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

  1. class MyReceiver(host:String,port:Int) extends Receiver[String](StorageLevel.MEMORY_ONLY)
  2. {
  3.   //最初启动的时候，调用该方法，读数据并将数据发送给 Spark
  4.   override def onStart(): Unit = {
  5.     new Thread("Receiver"){
  6.       override def run(){
  7.         receive()
  8.       }
  9.     }.start()
  10.   }
  12.   ///读数据并将数据发送给 Spark
  13.   def receive(): Unit = {
  14.     //创建Socket
  15.     val socket: Socket = new Socket(host,port)
  16.     //创建变量用于接收端口穿过来的数据
  17.     var input:String=null
  18.     //创建BufferedReader用于读取端口传来的数据
  19.     val reader: BufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream, StandardCharsets.UTF_8))
  21.     //读取数据
  22.     input=reader.readLine()
  23.     //当 receiver 没有关闭并且输入数据不为空
  24.     while(!isStopped() && input != null){
  25.       //循环发送数据给 Spark
  26.       store(input)
  27.       input=reader.readLine()
  28.     }
  30.     //跳出循环则关闭资源
  31.     reader.close()
  32.     socket.close()
  34.     //重启任务
  35.     restart("restart")
  36.   }
  38.   override def onStop(): Unit = {
  40.   }
  41. }

使用自定义数据源采集数据

  1.   def main(args: Array[String]): Unit = {
  2.     //1.初始化 Spark 配置信息
  3.     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
  4.     //2.初始化 SparkStreamingContext
  5.     //处理区间为3s一次
  6.     val ssc = new StreamingContext(sparkConf, Seconds(3))
  8.     //3.创建自定义 receiver 的 Streaming
  9.     val lineStream = ssc.receiverStream(new MyReceiver("localhost", 9999))
  11.     //4.处理接收的数据
  12.     val words: DStream[String] = lineStream.flatMap(_.split(" "))
  13.     val wordMap: DStream[(String, Int)] = words.map((_, 1))
  14.     val res = wordMap.reduceByKey(_ + _)
  16.     res.print()
  18.     //启动SparkStreamingContext
  19.     ssc.start()
  21.     //等待接收数据
  22.     ssc.awaitTermination()
  23.   }

在这里插入图片描述

3.DStream转换

在SparkStreaming中，各个DStream之间是相互独立的，互不干扰的。

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

3.1 无状态转换

无状态转化操作就是把简单的 RDD 转化操作应用到每个批次上，也就是转化 DStream 中的每一个 RDD。即一次对一个批次的RDD执行转换操作。

3.1.1 Transformations

在Spark Streaming中，transform操作是一个强大的功能，允许你将一个DStream转换成一个新的DStream。 它类似于Spark Core中的flatMap和map操作。你可以使用它来执行各种转换操作，例如过滤、分组、连接等。原RDD保持不变。

  1.   def main(args: Array[String]): Unit = {
  2.     //1.初始化 Spark 配置信息
  3.     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
  4.     //2.初始化 SparkStreamingContext
  5.     //处理区间为3s一次
  6.     val ssc = new StreamingContext(sparkConf, Seconds(3))
  8.     //3.通过监控端口创建 DStream，读进来的数据为一行行
  9.     val lines = ssc.socketTextStream("localhost", 9999)
  11.     //4.使用transform来转换
  12.     val resTransform = lines.transform(rdd => {
  13.       val words = rdd.flatMap(_.split(" "))
  14.       val wordMap = words.map((_, 1))
  15.       val res = wordMap.reduceByKey(_ + _)
  16.       res
  17.     })
  19.     //打印
  20.     resTransform.print()
  22.     //启动SparkStreamingContext
  23.     ssc.start()
  25.     //等待接收数据
  26.     ssc.awaitTermination()
  27.   }

在这里插入图片描述

3.1.2 join

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

  1.   def main(args: Array[String]): Unit = {
  2.     //1.初始化 Spark 配置信息
  3.     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
  4.     //2.初始化 SparkStreamingContext
  5.     //处理区间为3s一次
  6.     val ssc = new StreamingContext(sparkConf, Seconds(3))
  8.     //3.通过监控端口创建 DStream，读进来的数据为一行行
  9.     val line9999: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
  10.     val line8888: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 8888)
  12.     //4.将两个流转换为K,V类型
  13.     val lines1: DStream[(String, Int)] = line8888.flatMap(_.split(" ")).map((_,1))
  14.     val lines2: DStream[(String, Int)] = line9999.flatMap(_.split(" ")).map((_,11))
  16.     //5.使用join来对两个DStream进行连接
  17.     var resTransform: DStream[(String, (Int, Int))] =lines1.join(lines2)
  19.     //打印
  20.     resTransform.print()
  22.     //启动SparkStreamingContext
  23.     ssc.start()
  25.     //等待接收数据
  26.     ssc.awaitTermination()
  27.   }

在这里插入图片描述

3.2 有状态转换操作

在Spark Streaming中，有状态转换操作是指那些需要依赖之前批次数据或中间结果来计算当前批次数据的操作。这些操作在处理数据时，会在跨时间区间内跟踪数据的状态变化。在有状态转换的过程中，需要借助检查点(checkpoint)来完成转换。

3.2.1 UpdateStateByKey

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

  1.   def main(args: Array[String]): Unit = {
  3.     //定义状态更新方法:参数 seq 为当前批次单词数量，state 为以往批次单词数量
  4.     val updateFuc = (seq:Seq[Int],state:Option[Int])=>{
  5.       //当前批次的单词数量
  6.       val updateSeq: Int = seq.foldLeft(0)((x, y) => x + y)
  7.       //以往批次的单词数量
  8.       val updateState:Int = state.getOrElse(0)
  9.       Some(updateSeq+updateState)
  10.     }
  12.     //1.初始化 Spark 配置信息
  13.     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
  14.     //2.初始化 SparkStreamingContext
  15.     //处理区间为3s一次
  16.     val ssc = new StreamingContext(sparkConf, Seconds(3))
  18.     ssc.checkpoint("./ck")
  20.     val line9999: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
  22.     val wordMap: DStream[(String, Int)] = line9999.flatMap(_.split(" ")).map((_,1))
  24.     val res = wordMap.updateStateByKey[Int](updateFuc)
  26.     //打印
  27.     res.print()
  29.     //启动SparkStreamingContext
  30.     ssc.start()
  32.     //等待接收数据
  33.     ssc.awaitTermination()
  34.   }

3.2.2 WindowOperations

Window Operations 可以设置窗口的大小和滑动窗口的间隔来动态的获取当前 Steaming 的允许状态。所有基于窗口的操作都需要两个参数，分别为窗口时长以及滑动步长。

注意：窗口时长和滑动步长这两者都必须为采集周期大小的整数倍。

实现需求：WordCount案例：3 秒一个批次，窗口 12 秒，滑步 6 秒。

  1.   def main(args: Array[String]): Unit = {
  3.     //1.初始化 Spark 配置信息
  4.     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
  5.     //2.初始化 SparkStreamingContext
  6.     //处理区间为3s一次
  7.     val ssc = new StreamingContext(sparkConf, Seconds(3))
  9.     ssc.checkpoint("./ck")
  11.     val lines = ssc.socketTextStream("localhost", 9999)
  12.     val dataMap: DStream[(String, Int)] = lines.flatMap(_.split(" ")).map((_, 1))
  14.     //窗口 12 秒，滑步 6 秒
  15.     val wordCountByWindows = dataMap.reduceByKeyAndWindow((a: Int, b: Int) => {
  16.       a + b
  17.     }, Seconds(12), Seconds(6))
  19.     wordCountByWindows.print()
  21.     //启动SparkStreamingContext
  22.     ssc.start()
  23.     //等待接收数据
  24.     ssc.awaitTermination()
  25.   }

reduceByKeyAndWindow(func, windowLength, slideInterval, [numTasks]):
当在一个(K,V)对的DStream上调用此函数，会返回一个新(K,V)对的DStream，此处通过对滑动窗口中批次数据使用
reduce 函数来整合每个 key 的 value 值。
参数解答：

windowLength 是滑动窗口的大小。
slideInterval 是滑动窗口的滑动间隔。这意味着每6秒，窗口会向前滑动一次。

关于 Window 的操作还有如下方法：

（1）window(windowLength, slideInterval): 基于对源 DStream 窗化的批次进行计算返回一个新的 Dstream；
（2）countByWindow(windowLength, slideInterval): 返回一个滑动窗口计数流中的元素个数；
（3）reduceByWindow(func, windowLength, slideInterval): 通过使用自定义函数整合滑动区间流元素来创建>一个新的单元素流；
（4）reduceByKeyAndWindow(func, invFunc, windowLength, slideInterval, [numTasks]): 这个函数是上述函数的变化版本，每个窗口的 reduce 值都是通过用前一个窗的 reduce 值来递增计算。通过 reduce 进入到滑动窗口数据并”反向 reduce”离开窗口的旧数据来实现这个操作。一个例子是随着窗口滑动对 keys 的“加”“减”计数。当窗口较大而滑动步数较小时，可以使用该函数来避免重复计算。

4.DStream输出

输出操作指定了对流数据经转化操作得到的数据所要执行的操作(例如把结果推入外部数据库或输出到屏幕上)。与 RDD 中的惰性求值类似，如果一个 DStream 及其派生出的 DStream 都没有被执行输出操作，那么这些 DStream 就都不会被求值。 如果 StreamingContext 中没有设定输出操作，整个 context 就都不会启动。
在这里插入图片描述

标签： spark scala sql
本文转载自: https://blog.csdn.net/weixin_47109902/article/details/135955833
版权归原作者 肥大毛 所有， 如有侵权，请联系我们删除。
登录后发布评论

“SparkStreaming---DStream”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？