Spark Streaming（二十七）DStream的转换、输出、缓存持久化、检查点

最新推荐文章于 2022-07-20 15:23:04 发布

666呀

最新推荐文章于 2022-07-20 15:23:04 发布

阅读量3k

点赞数

分类专栏： spark 大数据专栏（一）Spark

本文链接：https://blog.csdn.net/Suubyy/article/details/82885987

版权

spark 同时被 2 个专栏收录

31 篇文章 0 订阅

订阅专栏

大数据专栏（一）Spark

27 篇文章 5 订阅

订阅专栏

定义

所谓DStream的转换其实就是对间隔时间内DStream数据流的RDD进行转换操作并返回去一个新的DStream。

DStream转换

其实DStream转换语法跟RDD的转换语法非常类似，但DStream有它自己的一些特殊的语法，如updateStateByKey()、transform()、以及各种Window语法。

转换	意思
map(func)	将DStream上的每个RDD通过func函数操作并返回一个新的DStream
flatMap(func)	和map类似，但是每个输入的元素可以映射成0个或者多个项
filter(func)	过滤出DStream上符合要求的RDD并返回新的DStream
repartiton(numPartitions)	对DStream上的RDD进行重新分区，提高并行度
union(otherDStream)	将两个DStream合并到一起
count()	返回DStream中RDD中元素的总个数，返回只包含一个Long类型的DStream
reduce(func)	通过func函数聚合DStream中每个RDD中的每个元素，返回新的DStream，该新的DStream中只有一个元素，就是聚合以后的而结果
countByValue()	计算DStream上RDD内元素出现的频次，并返回新的DStream[(K,Long)]，K是RDD元素的类型，Long是元素出现的次数
reduceByKey(func,[numPartition])	聚合DStream上（K,V）类型的RDD里元素的，根据K统计V的个数，返回新的DStream，新的DStream里的RDD元素类型也为（K,V），K为键，V为K对应值的个数
join(otherDStream,[numPartition])	将两个类型为（K,V）和（K，W）的DStream进行join连接，返回一个类型为（K,（V，W））的新的DStream
cogroup(otherDStream,[numPartition])	对两个（K，V）和（K，W）类型的DStream上调用该函数的时候，返回（K，（Seq [V]，Seq [W]））元组的新DStream。
transform(func)	通过转换函数，将DStream上的每个RDD转换成另一种RDD，这种函数的操作基本单位为RDD，所以这个函数中的操作语法就是RDD的操作语法。转换后返回新的DStream

UpdateStateByKey操作

updateStateByKey就是随着时间的流逝，在SparkStreaming中的可以对每一个Key通过checkPoint来维护state状态，通过更新函数对每一个Key的状态进行更新，在更新的时候，对于每一个批次的数据而言，SparkStreaming都会通过updateStateByKey这个函数更新已存在Key对应的State，但是如果通过更新函数对State更新以后返回的是None，那么此刻的Key对应的State就会被删除，State可以是任意类型的数据结构。

package com.lyz.streaming.transformation

import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object UpdateStateByKey {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("Streamingtest")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")

    val streaming = new StreamingContext(conf, Seconds(5))

    /**
      *
      * 在HDFS上存储state的检查点，必须设置，否则会报错，因为每次更新state的时候
      * 都需要去检查点获取上一次更新后的state
      */
    streaming.checkpoint("hdfs://xxxxx:8020/spark/checkpoint")

    val stream: InputDStream[(LongWritable, Text)] = streaming.fileStream[LongWritable, Text, TextInputFormat]("hdfs://192.168.101.187:8020/spark/data")
    val mapStream: DStream[(String, Int)] = stream.map(x => (x._2.toString, 1))

    /**
      * 定义更新函数体
      * value：就是新一批次的数据经过逻辑处理得到的结果
      * res：新一批次的数据进来之前的状态值
      */

    def func(value: Seq[Int], res: Option[Int]): Some[Int] = {
      val sum: Int = value.sum
      val per: Int = res.getOrElse(0)
      Some(sum + per)
    }

    //调用更新函数，传入更新函数体
    val res: DStream[(String, Int)] = mapStream.updateStateByKey(func)
    res.foreachRDD(rdd => {
      rdd.collect().foreach(println(_))
    })

    streaming.start()
    streaming.awaitTermination()

  }
}

Transform转换操作

transform操作允许DStream上间隔时间内里的RDD转换成另个RDD。它的作用就是应用Dstream为公开的RDD操作函数。例如DStream上一个新的批次RDD与已存在的RDD进行join连接查询的API是未公开的，所以是不能这么使用的，但是利用transform函数就可以使用DStream未公开API。

package com.lyz.streaming.transformation

import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}

object TransformTest {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("Streamingtest")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val streaming = new StreamingContext(conf, Seconds(5))

    /**
      *
      * 在HDFS上存储state的检查点，必须设置，否则会报错，因为每次更新state的时候
      * 都需要去检查点获取上一次更新后的state
      */
    streaming.checkpoint("hdfs://xxxx:8020/spark/checkpoint")
    val stream: InputDStream[(LongWritable, Text)] = streaming.fileStream[LongWritable, Text, TextInputFormat]("hdfs://192.168.101.187:8020/spark/data")
    val mapStream: DStream[(String, Int)] = stream.map(x => (x._2.toString, 1))

    //外部的RDD
    val rdd: RDD[(String, Int)] = streaming.sparkContext.makeRDD(Array(("aaaa", 1)))

    /**
      * 调用DStream的transform函数，将DStream里的RDD与外部RDD进行操作，返回新的DStream
      * transform强大的原因就是能够使用DStream为公开的一些RDD操作函数
      */
    val res: DStream[(String, (Int, Int))] = mapStream.transform(rdd1 => {
      rdd1.join(rdd)
    })

    res.foreachRDD(rdd => {
      rdd.collect().foreach(println(_))
    })

    streaming.start()
    streaming.awaitTermination()
  }
}

Window窗口操作

SparkStreaming提供了基于窗口的操作，你可以在滑动窗口内对数据进行转换。这种窗口操作就是在比SparkStreaming批处理的时间间隔更长的时间间隔内整合多个批处理的结果。
Window窗口操作需要两个参数，一个参数是窗口的时长（最近的几个批次），另一个是窗口的滑动步长（多久执行一次计算）。需要特别注意的是这两个参数一定要是批处理间隔时间的整数倍。例如我们有一个以10秒为间隔的批处理，我们想要没十秒计算一次30秒内的数据，那么我们就可以把时长窗口设置成30秒，窗口的滑动步长为10秒。

package com.lyz.streaming.transformation

import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}

object WindowTest {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("Streamingtest")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")

    val streaming = new StreamingContext(conf, Seconds(5))

    val stream: InputDStream[(LongWritable, Text)] = streaming.fileStream[LongWritable, Text, TextInputFormat]("hdfs://192.168.101.187:8020/spark/data")
    val mapStream: DStream[(String, Int)] = stream.map(x => (x._2.toString, 1))
    /**
      * 每十秒计算一次前三十秒的数据，其实也就是前6个批次的数据
      */
    val res: DStream[(String, Int)] = mapStream.reduceByKeyAndWindow((w: Int, w1: Int) => w + w1, Seconds(30), Seconds(10))
  }
}

比较常用的Window窗口函数

函数	解释
window(windowLength,slideInterval)	创建滑动窗口，并返回一个新的DStream然后自定义函数处理这个滑动窗口的数据
reduceByKeyWindow(func,windowLength.slideInterval)	对每个滑动窗口执行reduceByKey的操作
reduceByKeyAndWindow(func,invFunc,windowLength,slideInterval,[numParition])	这是一个性能更好的reduceByKeyAndWindow函数，
countByWindow(windowLength,slideInterval)	对每一个滑动窗口执行count操作，返回每个窗口里的元素个数
countByValueAndWindow(windowLength,slideInterval,[numPatition])	在每个滑动窗口内计算reduceByValue操作，统计每个键对应的值在窗口内出现的频次

DStream的操作结果输出

操作DStream的输出结果可以推送到外部数据库中或者外的文件系统中。

函数	解释
print()	在Driver端打印DStream上的前十个元素
saveAsTextFiles(prefix,[suffix])	保存DStream内容到文本文件中，每个批次产生的结果的名字为前缀为prefix，后缀为[.suffix]，所以全称为"prefix-TIME_IN_MS[.suffix]"
saveAsObjectFiles(prefix,[suffix])	保存DStream内容为Sequence文件，这文件是Java对象序列化后的，每个批次产生的结果的名字为前缀为prefix，后缀为[.suffix]，所以全称为"prefix-TIME_IN_MS[.suffix]"
saveAsHadoopFiles(prefix,[suffix])	保存DStream内容到Hadoop文件系统中，每个批次产生的结果的名字为前缀为prefix，后缀为[.suffix]，所以全称为"prefix-TIME_IN_MS[.suffix]"
foreachRDD(func)	循环DStream上的RDD，并且将函数应用到每个RDD上，并且这个函数可以将RDD推送到外部系统中，注意这个函数时在Driver端运行的。它内部的RDD的操作是在每个Woker分区上执行的

foreachRDD应用设计

foreachRDD几首一个函数，通过这个函数我可以把RDD保存到外部系统中，既然要保存到外部系统就需要与外部系统建立连接，我们都知道RDD的数据是散落在各个woker上的，处理RDD的函数也是在各个worker上进行的，我们需要将数据保存到外部数据，那么我们就必须在每个worker上都存在一个连接，因为连接是不能被序列化的，所以这个连接肯定是不能由driver发送到worker上的，而是在worker上创建出来。那么怎么样才能在worker上创建连接呢？那就是在rdd.foreach代码块里创建连接，而不是在stream.foreachRDD代码块里创建。

 res.foreachRDD(rdd => {
      rdd.foreach(r => {
        //1、创建连接
        //2、保存数据
        //3、关闭连接
      })
    })

我们都知道遍历RDD的时候其实就是在遍历每一条记录，如上代码所示我们为每一条记录都创建了连接，显然这样是非常影响系统性能的，那么我们怎么办呢？既然数据是在各个worker的分区上的，那么我们可以为每个分区创建一个连接。

dstream.foreachRDD { rdd =>
  rdd.foreachPartition { partitionOfRecords =>
    val connection = createNewConnection()
    partitionOfRecords.foreach(record => connection.send(record))
    connection.close()
  }
}

DataFrame和SQL操作DStream

在处理DStream数据流的时候，我们可以利用DataFrame和SQL操作DStream。利用DataFrame和SQL处理DStream的前提是必须利用初始化Streaming的SparkConf来创建SparkSession。例子如下

package com.lyz.streaming.transformation

import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat
import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SparkSession}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}

object DateFrameAndSqlTest {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("Streamingtest")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val streaming = new StreamingContext(conf, Seconds(5))

    /**
      *
      * 在HDFS上存储state的检查点，必须设置，否则会报错，因为每次更新state的时候
      * 都需要去检查点获取上一次更新后的state
      */
    streaming.checkpoint("hdfs://192.168.101.187:8020/spark/checkpoint")
    val stream: InputDStream[(LongWritable, Text)] = streaming.fileStream[LongWritable, Text, TextInputFormat]("hdfs://192.168.101.187:8020/spark/data")
    val mapStream: DStream[(String, Int)] = stream.map(x => (x._2.toString, 1))

    mapStream.foreachRDD(rdd => {
      //利用SparkConf来初始化SparkSession。
      val sparkSession: SparkSession = SparkSession.builder().config(conf).getOrCreate()

      //导入隐式转换来将RDD
      import sparkSession.implicits._
      //将RDD转换成DF
      val df: DataFrame = rdd.toDF("word", "count")
      df.createOrReplaceTempView("compute")
      val computeDF: DataFrame = sparkSession.sql("select * from compute")
      computeDF.show()
    })
    streaming.start()
    streaming.awaitTermination()
  }
}

DStream缓存和持久化

与RDD缓存和持久化类似，我们在程序中可以把程序中将要被多次计算的DStream缓存到内存中，也就是对相同数据进行多次计算。调用DStream的persist方法来实现DStream的缓存。对于窗口函数的操作这些底层已经对数据进行缓存了，因此窗口函数生成的DStream已经保存在了内存中，开发人员无需调用persist方法。

对于通过网络传输的的数据流，默认的持久化是将数据复制到两个节点上进行备份实现容错

注意：与RDD不同，DStream的默认持久化级别是将数据持久化保存在内存中。

DStream的检查点

由于流式处理程序需要全天不间断的运行，运行期间有很大几率会出现程序故障，为了应用程序的故障容错性，Streaming设置了检查点功能，将足够的信息保存到检查点中，以便对系统故障进行恢复。Streaming可以对两种数据进行checkPoint。

元数据检查点：将定义流式计算信息保存到检查点上（HDFS目录），用于恢复应用程序的驱动程序的故障。其中应用程序的元数据信息包含创建流式应用的配置、定义流式应用程序的操作集、部分未完成的批次
数据检查点：将生成的RDD保存到检查点上。在应用程序中跨多个批次的RDD的具有有状态的转换中，这种检查点必须设置，例如窗口操作和有状态更新。因为在多个批次组合生成一个RDD的时候，结果RDD会依赖先前批次的RDD，这样如果批次都的话，就会形成很多的依赖关系，设置RDD检查点就是为了切断依赖关系。

合适设置检查点

有状态操作的转换，如果在应用程序中只用了例如updateStateByKey侯喆是reduceByKeyAndWindow，就必须要设置RDD的检查点。

恢复故障的应用驱动程序，应用程序的元数据检查点是保存应用程序当前进度信息的，所以驱动程序故障恢复就是恢复当前应用程序执行的进度。

如何配置检查点

配置数据检查点，在执行DStream有状态的操作的时候，必须设置检查点，设置检查点只需要调用StreamingContext.checkPoint(“hdfs://hadoop001:8020/sparkStreaming/checkPoint”)并传入HDFS上的目录，这样就可以将上次执行的结果RDD保存到该目录下，供下个批次与该数据进行整合。
应用元数据信息检查点。在应用程序第一次启动的时候，会创建SparkContext，并调用start和awaitTermination方法开始流失数据的处理，当应用程序启动失败的时候，驱动程序会从检查点上恢复SparkContext。

package com.lyz.streaming.checkpoint

import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}

object MetaStoreCheckPointTest {
  def main(args: Array[String]): Unit = {
    //设置检查点目录
    val checkPointDir = "hdfs://192.168.101.187:8020/spark/checkpoint"
    //从检查点上得到StreamingContext，如果检查点上没有StreamingContext那么就创建一个新的StreamingContext。
    val streaming: StreamingContext = StreamingContext.getOrCreate(checkPointDir, () => createContext(checkPointDir))
    streaming.start()
    streaming.awaitTermination()

  }
  
  def createContext(checkPointDir: String): StreamingContext = {
    //创建SparkConf
    val conf = new SparkConf().setMaster("local[2]").setAppName("Streamingtest")
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    //创建StreamingContext
    val streaming = new StreamingContext(conf, Seconds(5))

    /**
      *
      * 在HDFS上存储state的检查点，必须设置，否则会报错，因为每次更新state的时候
      * 都需要去检查点获取上一次更新后的state
      */

    streaming.checkpoint(checkPointDir)
    val stream: InputDStream[(LongWritable, Text)] = streaming.fileStream[LongWritable, Text, TextInputFormat]("hdfs://192.168.101.187:8020/spark/data")
    val mapStream: DStream[(String, Int)] = stream.map(x => (x._2.toString, 1))
    val res: DStream[(String, Int)] = mapStream.reduceByKeyAndWindow((a: Int, b: Int) => a + b, Seconds(30), Seconds(10))
    res.foreachRDD(_.foreach(println(_)))
    streaming
  }
}

666呀

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Spark Streaming（二十七）DStream的转换、输出、缓存持久化、检查点

定义DStream的转换其实就是对间隔时间内DStream数据流的RDD进行转换操作并返回去一个新的DStream。DStream转换DStream转换语法跟RDD的转换语法非常类似，但DStream有它自己的一些特殊的语法，如updateStateByKey()、transform()、以及各种Window语法。转换意思map(func)将DStream上的每个RD...
复制链接

扫一扫