大数据——Spark Streaming中的Window（窗口）操作和Spark Streaming结合SparkSQL

最新推荐文章于 2022-01-07 13:12:19 发布
最新推荐文章于 2022-01-07 13:12:19 发布
阅读量444 收藏 1
点赞数
文章标签： 大数据 spark Streaming java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsjia2970727/article/details/111565241
版权

Spark Streaming中的Window（窗口）操作

窗口函数

窗口函数，就是在DStream流上，以一个可配置的长度为窗口，以一个可配置的速率向前移动窗口，根据窗口函数的具体内容，分别对当前窗口中的这一波数据采取某个对应的操作算子。

需要注意的是窗口长度和窗口移动速率需要是batch time的整数倍。
在这里插入图片描述

Window（windowLength, slideInterval）

该操作由一个DStream对象调用，传入一个窗口长度参数，一个窗口移动速率参数，然后将当前时刻当前长度窗口中的元素取出形成一个新的DStream。

//输入
-------
java 
scala
-------
java
scala
-------

//输出
-------
java
scala
-------
java
scala
java
scala
-------

代码展示：

package nj.zb.kb09.window

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}

//该操作由一个DStream对象调用，传入一个窗口长度参数，一个窗口移动速率参数，然后将当前时刻当前长度窗口中的元素取出形成一个新的DStream。
object SparkWindowDemo1 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(2))

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup2")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

    val numStream: DStream[(String, Int)] = kafkaStream.flatMap(line=>line.value().toString.split("\\s+")).map((_,1)).window(Seconds(8),Seconds(4))

    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

结果展示：

-------------------------------------------
Time: 1608637736000 ms
-------------------------------------------

-------------------------------------------
Time: 1608637740000 ms
-------------------------------------------

-------------------------------------------
Time: 1608637744000 ms
-------------------------------------------
(java,1)
(scala,1)

-------------------------------------------
Time: 1608637748000 ms
-------------------------------------------
(java,1)
(scala,1)
(java,1)
(scala,1)

-------------------------------------------
Time: 1608637752000 ms
-------------------------------------------
(java,1)
(scala,1)

-------------------------------------------
Time: 1608637756000 ms
-------------------------------------------

countByWindow（windowLength,slideInterval）

返回指定长度窗口中的元素个数
注：需要设置checkpoint

//输入
-------
java
-------
java
scala
-------

//输出
------
1
------
3
------

代码展示：

package nj.zb.kb09.window

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}

//返回指定长度窗口中的元素个数。
object SparkWindowDemo2 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(2))

    streamingContext.checkpoint("checkpoint2")

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup3")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

     val numStream: DStream[Long] = kafkaStream.flatMap(line=>line.value().toString.split("\\s+")).map((_,1)).countByWindow(Seconds(8),Seconds(4))

    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

结果展示：

-------------------------------------------
Time: 1608639456000 ms
-------------------------------------------

-------------------------------------------
Time: 1608639460000 ms
-------------------------------------------
1

-------------------------------------------
Time: 1608639464000 ms
-------------------------------------------
3

-------------------------------------------
Time: 1608639468000 ms
-------------------------------------------
2

-------------------------------------------
Time: 1608639472000 ms
-------------------------------------------
0

-------------------------------------------
Time: 1608639476000 ms
-------------------------------------------
0

countByValueAndWindow（windowLength,slideInterval, [numTasks]）

统计当前时间窗口中元素值相同的元素的个数（wordcount）
注：需要设置checkpoint

//输入
-----------
java
-----------
java
scala
-----------

//输出
---------
(java,1)
---------
(java,2)
(scala,1)
---------

代码展示：

package nj.zb.kb09.window

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}

//统计当前时间窗口中元素值相同的元素的个数
object SparkWindowDemo3 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(2))

    streamingContext.checkpoint("checkpoint3")

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup4")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

   val numStream: DStream[(String, Long)] = kafkaStream.flatMap(line=>line.value().toString.split("\\s+")).countByValueAndWindow(Seconds(8),Seconds(4))

    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

结果展示：

-------------------------------------------
Time: 1608639846000 ms
-------------------------------------------

-------------------------------------------
Time: 1608639850000 ms
-------------------------------------------
(java,1)

-------------------------------------------
Time: 1608639854000 ms
-------------------------------------------
(java,2)
(scala,1)

-------------------------------------------
Time: 1608639858000 ms
-------------------------------------------
(java,1)
(scala,1)

-------------------------------------------
Time: 1608639862000 ms
-------------------------------------------

reduceByWindow（func, windowLength,slideInterval）

在调用DStream上首先去窗口函数的元素形成新的DStream，然后在窗口元素形成的DStream上进行reduce

//输入
----------
java
----------
java
spark
----------

//输出
----------
java
----------
java:java:spark
----------

代码展示：

package nj.zb.kb09.window

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}


object SparkWindowDemo4 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(2))

    streamingContext.checkpoint("checkpoint4")

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup5")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

    val numStream: DStream[String] = kafkaStream.flatMap(line=>line.value().toString.split("\\s+")).reduceByWindow(_+":"+_,Seconds(8),Seconds(4))

    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

结果展示：

-------------------------------------------
Time: 1608720860000 ms
-------------------------------------------

-------------------------------------------
Time: 1608720864000 ms
-------------------------------------------
java

-------------------------------------------
Time: 1608720868000 ms
-------------------------------------------
java:java:spark

-------------------------------------------
Time: 1608720872000 ms
-------------------------------------------
java:spark
-------------------------------------------
Time: 1608720876000 ms
-------------------------------------------

reduceByKeyAndWindow（func,windowLength, slideInterval, [numTasks]）

reduceByKeyAndWindow的数据源是基于该DStream的窗口长度汇总的所有数据进行计算。该操作有一个可选的并发数参数

//输入
----------
java
-----------
java
scala
----------- 

//输出
-----------
(java,1)
-----------
(java,2)
(scala,1)
-----------

代码展示：

package nj.zb.kb09.window

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}


object SparkWindowDemo5 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(2))

    streamingContext.checkpoint("checkpoint5")

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup6")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

     val numStream: DStream[(String, Int)] = kafkaStream.flatMap(line=>line.value().toString.split("\\s+")).map((_,1)).reduceByKeyAndWindow((a:Int,b:Int)=>a+b,Seconds(8),Seconds(4))

    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

结果展示：

-------------------------------------------
Time: 1608721078000 ms
-------------------------------------------

-------------------------------------------
Time: 1608721082000 ms
-------------------------------------------
(java,1)

-------------------------------------------
Time: 1608721086000 ms
-------------------------------------------
(java,2)
(scala,1)

-------------------------------------------
Time: 1608721090000 ms
-------------------------------------------
(java,1)
(scala,1)

-------------------------------------------
Time: 1608721094000 ms
-------------------------------------------

reduceByKeyAndWindow（func, invFunc,windowLength, slideInterval, [numTasks]）

这个窗口操作和上一个的区别是多传入一个函数invFunc。前面的func作用和上一个reduceByKeyAndWindow相同，后面的invFunc是用于处理流出rdd的

//输入
----------
java
-----------
java
spark
----------- 

//输出
----------
(java,1)
----------
(java,2)
(spark,1)
----------
(java,0)
(spark,0)
----------

代码展示：

package nj.zb.kb09.window

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}


object SparkWindowDemo6 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(2))

    streamingContext.checkpoint("checkpoint6")

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup7")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

    val numStream: DStream[(String, Int)] = kafkaStream.flatMap(line=>line.value().toString.split("\\s+")).map((_,1)).reduceByKeyAndWindow((a:Int,b:Int)=>a+b,(a:Int,b:Int)=>a-b,Seconds(8),Seconds(4))

    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

结果展示：

-------------------------------------------
Time: 1608722110000 ms
-------------------------------------------

-------------------------------------------
Time: 1608722114000 ms
-------------------------------------------
(java,1)

-------------------------------------------
Time: 1608722118000 ms
-------------------------------------------
(java,2)
(spark,1)

-------------------------------------------
Time: 1608722122000 ms
-------------------------------------------
(java,1)
(spark,1)

-------------------------------------------
Time: 1608722126000 ms
-------------------------------------------
(java,0)
(spark,0)

-------------------------------------------
Time: 1608722130000 ms
-------------------------------------------
(java,0)
(spark,0)

transform

Transform操作是返回一个新的RDD的操作,比如map()和filter().调用转换操作时,不会立即执行.Spark会在内部记录下索要求执行的操作的相关信息,直到action操作触发时,才开始执行真正的计算

//输入
----------
java scala spark scala java
----------
java spark hello world java
----------

//输出
----------
((scala,20201223 19:51:00),2)
((java,20201223 19:51:00),2)
((spark,20201223 19:51:00),1)
----------
((java,20201223 19:51:10),2)
((world,20201223 19:51:10),1)
((spark,20201223 19:51:10),1)
((hello,20201223 19:51:10),1)
----------

代码展示：

package nj.zb.kb09.window

import java.text.SimpleDateFormat

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
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}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}


object SparkWindowDemo7 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(10))

    streamingContext.checkpoint("checkpoint7")

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup8")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

    val numStream: DStream[((String, String), Int)] = kafkaStream.transform((rdd, timestamp) => {
      val format = new SimpleDateFormat("yyyyMMdd HH:mm:ss")
      val time: String = format.format(timestamp.milliseconds)
      val value: RDD[((String, String), Int)] = rdd.flatMap(x => x.value().split("\\s+")).map(x => ((x, time), 1)).reduceByKey((x,y)=>x+y).sortBy(x=>x._2,false)
      value
    })

    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

结果展示：

-------------------------------------------
Time: 1608724250000 ms
-------------------------------------------

-------------------------------------------
Time: 1608724260000 ms
-------------------------------------------
((scala,20201223 19:51:00),2)
((java,20201223 19:51:00),2)
((spark,20201223 19:51:00),1)

-------------------------------------------
Time: 1608724270000 ms
-------------------------------------------
((java,20201223 19:51:10),2)
((world,20201223 19:51:10),1)
((spark,20201223 19:51:10),1)
((hello,20201223 19:51:10),1)

-------------------------------------------
Time: 1608724280000 ms
-------------------------------------------

SparkStreaming结合SparkSQL结合使用

Flume+Kafka+SparkStreaming已经发展为一个比较成熟的实时日志收集与计算架构，利用Kafka，既可以支持将用于离线分析的数据流到HDFS，又可以同时支撑多个消费者实时消费数据，包括SparkStreaming。然而，在SparkStreaming程序中如果有复杂业务逻辑的统计，使用Scala代码实现起来比较困难，也不易于别人理解。但如果在SparkStreaming中也是用SQL来做统计分析，是不是就简单很多呢。

//输入
----------
hello java scala java spark scala
----------
java java scala hello world spark spark spark
----------

//输出
----------
[hello,1]
[scala,2]
[spark,1]
[java,2]
----------
[hello,1]
[scala,1]
[spark,3]
[world,1]
[java,2]
----------

代码展示：

package nj.zb.kb09.window

import java.text.SimpleDateFormat

import nj.zb.kb09.window.SQLContextSingleton.instance
import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Dataset, Row, SQLContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}


object SparkWindowDemo8 {
  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamKafkaSource")

    val streamingContext = new StreamingContext(sparkConf,Seconds(10))

    streamingContext.checkpoint("checkpoint8")

    val kafkaParams: Map[String, String] = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.136.100:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG, "kafkaGroup9")
    )
    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(streamingContext,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe(Set("sparkKafkaDemo"),kafkaParams))

    val numStream: DStream[Row] = kafkaStream.transform(rdd => {
      val sqlContext: SQLContext = SQLContextSingleton.getInstance(rdd.sparkContext)
      import sqlContext.implicits._
      val words: RDD[String] = rdd.flatMap(_.value().toString.split("\\s+"))
      val tuple2RDD: RDD[(String, Int)] = words.map((_, 1))
      tuple2RDD.toDF("name", "cn").createOrReplaceTempView("tbwordcount")
      val frame: DataFrame = sqlContext.sql("select name,count(cn) from tbwordcount group by name")

      /*val dataSet: Dataset[Unit] = frame.map(row => {
        val name: String = row.getAs[String]("name")
        val count: Long = row.getAs[Long]("cn")

      })
      dataSet.rdd*/

      frame.rdd
    })


    numStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

object SQLContextSingleton{
  @transient private var instance:SQLContext=_

  def getInstance(sparkContext: SparkContext):SQLContext={
    synchronized(if(instance==null){
      instance= new SQLContext(sparkContext)
    }
      )
    instance
  }
}

结果展示：

-------------------------------------------
Time: 1608724910000 ms
-------------------------------------------

-------------------------------------------
Time: 1608724920000 ms
-------------------------------------------
[hello,1]
[scala,2]
[spark,1]
[java,2]

-------------------------------------------
Time: 1608724930000 ms
-------------------------------------------

-------------------------------------------
Time: 1608724940000 ms
-------------------------------------------
[hello,1]
[scala,1]
[spark,3]
[world,1]
[java,2]

-------------------------------------------
Time: 1608724950000 ms
-------------------------------------------
蜂蜜柚子加苦茶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spark streaming 窗口 教程
XUJIA2018的博客
12-03 2022
1、窗口介绍 SparkStreaming是基于spark core 的实时架构，虽然SparkStreaming可以进行实时计算，但它并不是一个纯实时计算框架。StreamingContext的批次间隔决定了每隔多久计算一次。 SparkStreaming提供了窗口的计算 ，窗口计算可以整合多个批次的计算结果。在spark streaming 中 ，一共有两种窗口：滑动窗口和滚动窗口。 2、滑动窗口 滑动窗口：需要设置窗口大小和滑动间隔，窗口大小和滑动间隔都是StreamingContext的间隔时间的
Spark Streaming之window（窗口操作）
zp17834994071的博客
09-07 4007
Spark Streaming 还提供了窗口的计算，它允许通过滑动窗口对数据进行转换，窗口转换操作如下图 所示: 在 Spark Streaming 中，数据处理是按批进行的，而数据采集是逐条进行的，因此在 Spark Streaming 中会先设置好批处理间隔，当超过批处理间隔的时候就会把采集到的数据汇总起来成为一批数据交给系统去处理。 对于窗口操作而言，在其窗口内部会有 N 个批处理数据，批处理数据的大小由窗口间隔决定，而窗口间隔指的就是窗口的持续时间。 在窗口操作中，只有窗口的长度满足了才会触发批数
第一章：Spark Streaming 实时计算
08-17
1.Spark Streaming：大数据实时计算介绍2.Spark Streaming：DStream基本工作原理3.Spark Streaming：StreamingContext详解技能点4.Spark Streaming：输入DStream和Receiver详解5.Spark Streaming：DStream的transformation操作概览
sparkStreaming Window
YQlakers的博客
06-05 597
package com.spark.study.streaming; import java.util.List; import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaPairRDD; import org.apache.spark.api.java.function.Function; import
Spark Streaming（五）——window
chaohui2638457321的博客
01-07 291
1、Window 窗口的范围应该是采集周期的整数倍 窗口是可以滑动的，但是默认情况下，一个采集是按照周期滑动的 这样的话，可能造成出现重复数据的计算，为了避免这种情况可以改变滑动的幅度（步长） 关于窗口的两个参数 窗口的时长 滑动的步长 窗口的时长：计算内容的时间范围 滑动的步长：隔多久触发一次计算 package com.zch.spark.streaming ​ import org.apache.spark.S...
Spark Streaming 窗口函数window
giantleech的博客
06-23 662
Spark Streaming 窗口函数window Spark Streaming之window滑动窗口应用，Spark Streaming提供了滑动窗口操作的支持，从而让我们可以对一个滑动窗口内的数据执行计算操作。每次掉落在窗口内的RDD的数据，会被聚合起来执行计算操作，然后生成新的RDD，新的RDD组合成一个新的DStream在窗体函数展示 网官图中所示，就是对每三秒钟的数据执行一次滑动窗口计算，这3秒内的3个RDD会被聚合起来进行处理，然后过了两秒钟，又会对最近三秒内的数据执行滑动窗口计算。所以每个
SparkStreaming之滑动窗口的实现.zip_Spark!_spark stream 窗口_spark streamin
09-23
本资料主要关注的是Spark Streaming中的滑动窗口（Sliding Window）机制，这是实现时间窗口操作的关键概念，对于理解和应用Spark Streaming至关重要。 滑动窗口是实时数据处理中一种常见的抽象概念，用于定义一段...
example-spark：Spark，Spark Streaming和Spark SQL单元测试策略
02-06
在Spark的开发过程中，单元测试是确保代码质量、可维护性和稳定性的关键环节。`example-spark`项目针对Spark、Spark Streaming和Spark SQL提供了全面的单元测试策略，以确保这些组件的功能正确性以及性能表现。以下...
SparkStreaming入门案例
06-22
本文将通过三个例子来演示 Spark Streaming 的使用：监控指定目录并处理该目录下的新文件、监控指定目录并处理该目录下的同一格式的新旧文件、窗口机制处理指定目录下的新文件。 在第一个例子中，我们将监控指定...
spark流数据处理：SparkStreaming的使用
02-26
SparkStreaming可以从很多数据源获取数据，比如：Kafka、Flume、Twitter、ZeroMQ、Kinesis或TCP连接等，并可以用很多高层算子(map/reduce/join/window等)来方便地处理这些数据。最后处理过的数据还可以推送到文件...
spark之sparkStreaming 理解
11-07
spark之sparkStreaming 理解，总结了自己的理解，欢迎大家下载观看！
Spark-Streaming编程指南.docx
最新发布
11-15
Spark Streaming 的强大之处在于它可以无缝集成 Spark Core、Spark SQL、MLlib 和 GraphX，允许用户在实时流处理中应用机器学习和图计算算法，实现复杂的数据分析任务。同时，通过 DStream 的窗口操作，可以实现时间...
spark streaming的window窗口操作
祁东握力的博客
12-26 334
一、StreamingContext时batchDuration参数 这个参数和后面的window方法的参数有些关系 def this(conf: SparkConf, batchDuration: Duration) 1、batchDuration 我们知道，spark的streaming操作其实是一种微批操作。也就是把每个时间段内的数据封装为一个RDD，然后执行相应的算子。这不是本文...
spark streaming
mach_learn的专栏
06-12 3384
Spark streaming是Spark核心API的一个扩展，它对实时流式数据的处理具有可扩展性、高吞吐量、可容错性等特点。我们可以从kafka、flume、Twitter、 ZeroMQ、Kinesis等源获取数据，也可以通过由 高阶函数map、reduce、join、window等组成的复杂算法计算出数据。最后，处理后的数据可以推送到文件系统、数据库、实时仪表盘中。事实上，你可以将处理后的数据应用到Spark的
SparkStreaming（8）：windows窗口操作
小蚯蚓的博客
10-10 450
1.概念 在一定的时间间隔（interval）进行一个时间段（window length）内的数据处理。 【参考：http://spark.apache.org/docs/2.1.0/streaming-programming-guide.html】 2.核心 （1）window length ： 窗口的长度（下图是3） （2）sliding interval： 窗口的间隔（下图...
Spark之SparkStreaming案例-Window Operations
chbxw
05-03 2834
Window OperationsSpark Streaming还提供了窗口计算，允许您在数据的滑动窗口上应用转换。 下图说明了这个滑动窗口。 如图所示，每当窗口滑过源DStream时，落在窗口内的源RDD被组合并进行操作以产生窗口DStream的RDD。在这种具体情况下，操作应用于最近3个时间单位的数据，并以2个时间单位滑动。这表明任何窗口操作都需要指定两个参数。   窗口长度 - 窗口的持续时
SparkStreaming -- 03 【window函数，与SparkSQL的整合】
xiaoxiao______的博客
12-08 275
文章目录1、window函数操作1.1、 window函数的简介1.2、 常用的窗口函数1.3、 案例演示：1.3.1、1.3.2、1.3.3、2、sparkStreaming和SparkSQL的整合 1、window函数操作 1.1、 window函数的简介 SparkStreaming提供了滑动窗口的操作。这样的话，就可以计算窗口内的n个micro-batch的数据，进行聚合. 窗口有两个参数： 窗口大小：指的就是有几个单位时间（time unit）的micro-batch 滑动周期：类似于定时器
2020.12.23课堂笔记(Spark Streaming中的Window操作)
超可爱慕之
12-23 341
窗口时间 windowDuration​：当前窗口要统计多长时间的数据，是批量时间的整数倍 滑动时间 slideDuration​：要多长时间更新一次结果，是批量时间的整数倍 批量处理时间 batchDuration​：多长时间创建一个批次，与实际业务无关，只与数据量有关，数据量大则可以设置短一些，数据量小则设置长一些，但必须小于其他两个时间。
Spark Streaming有状态转换之window的使用
FlatTiger的博客
03-31 174
有状态转换和无状态转换的区别 Spark Streaming中，如果该操作可以同时对不同批次的数据进行处理，就是有状态转换。如果该操作只能对每个批次中的数据依次进行处理，不同批次之间的数据不进行运算，就是无状态转换。 window的功能 可以跨批次处理窗口内的数据。 用于监控某个时间段内数据流量的变化。 代码 window使用需要指定窗口大小和步长。 窗口大小和步长只能时采集周期的整数倍。 def main(args: Array[String]): Unit = { val con
Spark Streaming入门与工作原理
总结来说，Spark Streaming是面向实时数据处理的一个强大框架，它通过微批处理的方式实现了高效率和低延迟，同时保持了Spark生态系统中其他组件的灵活性和易用性。无论是数据清洗、实时分析还是机器学习应用，Spark ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值