SparkStreaming中的Window操作(driver、executor的执行顺序以及 foreach 及 foreach partition 的效率)

最新推荐文章于 2023-06-30 15:38:54 发布
置顶 最新推荐文章于 2023-06-30 15:38:54 发布
阅读量443 收藏
点赞数
分类专栏： Spark Streaming 文章标签： Spark Streaming Window操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43434273/article/details/111596494
版权

SparkStreaming中的Window操作

窗口函数定义

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

需要注意的是窗口长度，和窗口移动速率需要是batch time的整数倍。

在这里插入图片描述

1. 创建topic

kafka-topics.sh --create --zookeeper 192.168.116.60:2181 --topic sparkKafkaDemo  --partitions 1 --replication-factor 1

2. 开启生产者topic

kafka-console-producer.sh --topic  sparkKafkaDemo  --broker-list 127.0.0.1:9092

提醒：每次写程序需要修改 object类名、setAppName、 (ConsumerConfig.GROUP_ID_CONFIG, “kafkaGroup2”)

3. window(windowLength, slideInterval)

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

package cn.bright.kafka.Spark

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}

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description  window
  */
object SparkWindowDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo")
    val streamingContext = new StreamingContext(conf,Seconds(2))

    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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)
    )

//  注意:窗口长度,窗口移动速率需要是batch time的整数倍
    val numStream: DStream[(String, Int)] = kafkaStream.flatMap(line => line.value().toString.split("\\s+"))
      .map((_, 1))
      .window(Seconds(8),Seconds(6))    //流窗口  采集周期时间长度为8秒，窗口移动速率参数为6秒

    numStream.print()

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

3.1 测试

input:
在这里插入图片描述
output：
在这里插入图片描述

4. countByWindow(windowLength,slideInterval)

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

package cn.bright.kafka.Spark

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

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description  返回指定窗口元素的个数
  */
object SparkWindowDemo2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo2")
    val streamingContext = new StreamingContext(conf,Seconds(2))
    
// 设置checkpoint   idea项目根目录创建文件夹 checkpoint
    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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[Long] = kafkaStream.flatMap(line => line.value().toString.split("\\s+"))
      .map((_, 1))
      .countByWindow(Seconds(8), Seconds(6))

    numStream.print()

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

4.1 测试

input:

>java
>java
>scala
>scala

output:

-------------------------------------------
Time: 1608721234000 ms
-------------------------------------------
1

-------------------------------------------
Time: 1608721240000 ms
-------------------------------------------
1

-------------------------------------------
Time: 1608721246000 ms
-------------------------------------------
2

5. countByValueAndWindow(windowLength,slideInterval, [numTasks])

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

package cn.bright.kafka.Spark

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

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description
  */
object SparkWindowDemo3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo3")
    val streamingContext = new StreamingContext(conf,Seconds(2))

   // 设置checkpoint   idea项目根目录创建文件夹 checkpoint
    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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[(String,Long)] = kafkaStream
      .flatMap(line => line.value().toString.split("\\s+"))
      .countByValueAndWindow(Seconds(8), Seconds(6))

    numStream.print()

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

5.1 测试

input:

>java
>java
>java
>scala
>scala
>scala

output:

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

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

-------------------------------------------
Time: 1608721840000 ms
-------------------------------------------
(scala,2)

6. reduceByWindow(func,windowLength,slideInterval)

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

package cn.bright.kafka.Spark

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

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description
  */
object SparkWindowDemo4 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo4")
    val streamingContext = new StreamingContext(conf,Seconds(2))

    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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] = kafkaStream
      .flatMap(line => line.value().toString.split("\\s+"))
      .reduceByWindow(_ + ":" + _, Seconds(8), Seconds(2))

    numStream.print()

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

6.1 测试

input:

>java
>java
>java
>scala
>scala
>scala
>scala

output:

-------------------------------------------
Time: 1608722104000 ms
-------------------------------------------
java:java:java

-------------------------------------------
Time: 1608722106000 ms
-------------------------------------------
java:java:java:scala:scala

-------------------------------------------
Time: 1608722108000 ms
-------------------------------------------
java:java:java:scala:scala:scala:scala

-------------------------------------------
Time: 1608722110000 ms
-------------------------------------------
java:java:java:scala:scala:scala:scala

-------------------------------------------
Time: 1608722112000 ms
-------------------------------------------
scala:scala:scala:scala

-------------------------------------------
Time: 1608722114000 ms
-------------------------------------------
scala:scala

7. reduceByKeyAndWindow(func,windowLength, slideInterval, [numTasks])

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

package cn.bright.kafka.Spark

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

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description
  */
object SparkWindowDemo5 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo5")
    val streamingContext = new StreamingContext(conf,Seconds(2))

    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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,Int)] = kafkaStream
      .flatMap(line => line.value().toString.split("\\s+"))
      .map((_, 1))
      //.reduceByKeyAndWindow((x:Int,y:Int)=>{x+y}, Seconds(8), Seconds(2))
      .reduceByKeyAndWindow((x:Int,y:Int)=>{x+y}, (x:Int,y:Int)=>{x-y},Seconds(8), Seconds(2))


    numStream.print()

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

7.1 测试

input:

>java
>java
>java
>java
>scala
>scala
>scala
>scala

output:

-------------------------------------------
Time: 1608722410000 ms
-------------------------------------------
(java,3)

-------------------------------------------
Time: 1608722412000 ms
-------------------------------------------
(java,4)

-------------------------------------------
Time: 1608722414000 ms
-------------------------------------------
(scala,4)
(java,4)

-------------------------------------------
Time: 1608722416000 ms
-------------------------------------------
(scala,4)
(java,4)

-------------------------------------------
Time: 1608722418000 ms
-------------------------------------------
(scala,4)
(java,1)

-------------------------------------------
Time: 1608722420000 ms
-------------------------------------------
(scala,4)
(java,0)

-------------------------------------------
Time: 1608722422000 ms
-------------------------------------------
(scala,0)
(java,0)

8. transform:业务需求需要更改数据结构是可以使用transform完成转化工作

package cn.bright.kafka.Spark

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.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description
  */
object SparkWindowDemo6 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo6")
    val streamingContext = new StreamingContext(conf,Seconds(2))

    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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)
    )

    // 业务需求需要更改数据结构是可以使用transform完成转化工作
    val numStream: DStream[((String, String), Int)] = kafkaStream.transform((rdd, timestamp) => {
      val format: SimpleDateFormat = 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()
  }
}

8.1 测试

input:

>java
>java
>java
>java
>scala
>scala
>scala
>scala

output:

-------------------------------------------
Time: 1608722714000 ms
-------------------------------------------
((java,20201223 19:25:14),4)

-------------------------------------------
Time: 1608722716000 ms
-------------------------------------------

-------------------------------------------
Time: 1608722718000 ms
-------------------------------------------

-------------------------------------------
Time: 1608722720000 ms
-------------------------------------------
((scala,20201223 19:25:20),4)

9. transform 转换成spark sql 进行流式处理

package cn.bright.kafka.Spark

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.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description
  */
object SparkWindowDemo7 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo7")
    val streamingContext = new StreamingContext(conf,Seconds(2))

    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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[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 tupple2RDD: RDD[(String, Int)] = words.map((_, 1))

      tupple2RDD.toDF("name", "cn").createOrReplaceTempView("tbwordcount")

      val frame: DataFrame = sqlContext.sql("select name,count(cn) from tbwordcount group by name")

      val dataset: Dataset[(String, Long)] = frame.map(row => {
        val name: String = row.getAs[String]("name")
        val count: Long = row.getAs[Long]("cn")
        (name, count)
      })
      
      //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
  }
}

9.1 测试

input:

>scala
>scala
>scala
>scala
>scala
>java
>java
>java
>java
>java
>java

output:

-------------------------------------------
Time: 1608723156000 ms
-------------------------------------------
[scala,5]

-------------------------------------------
Time: 1608723158000 ms
-------------------------------------------

-------------------------------------------
Time: 1608723160000 ms
-------------------------------------------
[java,4]

-------------------------------------------
Time: 1608723162000 ms
-------------------------------------------
[java,2]

10. SparkStreaming 的driver、executor的执行顺序以及 foreach 及 foreach partition 的效率对比

package cn.bright.kafka.Spark

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

/**
  * @Author Bright
  * @Date 2020/12/22
  * @Description
  */
object SparkWindowDemo8 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("SparkWindowDemo8")
    val streamingContext = new StreamingContext(conf,Seconds(2))

    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "192.168.116.60: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)
    )

//    println("driver")
//    val wordStream: DStream[String] = kafkaStream.flatMap(
//      line => {
//        println("executor")
//        line.value().toString.split("\\s+")
//      }
//    )
//
//    wordStream.print()


//    println("driver")   // 1 只执行一次
//    val wordStream: DStream[String] = kafkaStream.transform(
//      (rdd) => {
//        println("采集周期开始")   // n次  数据采集周期
//        //println(rdd)
//        val value: RDD[String] = rdd.flatMap(
//          x => {
//            println("执行器executor")   //数据进入n次 就执行n次
//            x.value().split("\\s+")
//          }
//        )
//        value
//      }
//    )
//    wordStream.print()

    //foreach  遍历每一个RDD中的元素 会出现driver很繁忙的情况
//    println("driver")
//    kafkaStream.foreachRDD(
//      (rdd)=>{
//        println("bb")
//        rdd.foreach(
//          x=>{
//            println("cc")
//            val strings: Array[String] = x.value().toString.split("\\s+")
//            println(strings.toList)
//          }
//        )
//      }
//    )


    //RDD foreachpartition  的效率比foreach高 但可能存在OOM的情况  内存溢出
    println("driver")
    kafkaStream.foreachRDD(
      (rdd)=>{
        println("bb")
        rdd.foreachPartition(
          x=>{
            println("cc")
            x.foreach(
              y=>{
                println("dd")
                println(y.value().toString.split("\\s+"))
              }
            )
          }
        )
      }
    )

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

10.1 测试

input:

>java
>java
>java
>java
>scala
>scala
>scala
>scala
>scala

output:

bb
cc
bb
cc
dd
[Ljava.lang.String;@fa3b8f8
dd
[Ljava.lang.String;@41adc6d
dd
[Ljava.lang.String;@1cb77cd4
dd
[Ljava.lang.String;@45bf48f6
dd
[Ljava.lang.String;@57c94cc1
bb
cc
dd
[Ljava.lang.String;@19903d1d
dd
[Ljava.lang.String;@46a045f3
bb
cc
dd
[Ljava.lang.String;@e7ed727
bb
cc
dd
[Ljava.lang.String;@30395d92
dd
[Ljava.lang.String;@57e4cb4d
bb
cc
dd
[Ljava.lang.String;@d402d9
dd
[Ljava.lang.String;@6c775000
dd
[Ljava.lang.String;@654faaab
bb
cc

maven依赖

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.kafka</groupId>
      <artifactId>kafka_2.11</artifactId>
      <version>2.0.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.kafka</groupId>
      <artifactId>kafka-streams</artifactId>
      <version>2.0.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>2.4.5</version>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming_2.11</artifactId>
      <version>2.4.5</version>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
      <version>2.4.5</version>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>2.4.5</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.6.6</version>
    </dependency>
  </dependencies>
Bright Huang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
0438-如何指定Spark1作业中Driver和Executor使用指定范围内端口
01-20
在CDH集群中提交Spark作业，大家也都知道Spark的Driver和Executor之间通讯端口是随机的，Spark会随选择1024和65535（含）之间的端口，因此在集群之间不建议启用防火墙。在前面Fayson介绍了《如何指定Spark2作业中...
Spark Streaming的窗口操作
xiaomin1991222的专栏
10-12 172
Spark Streaming的Window Operation可以理解为定时的进行一定时间段内的数据的处理。 不要怪我语文不太好。。下面上原理图吧，一图胜千言： 滑动窗口在监控和统计应用的场景比较广泛，比如每隔一段时间(2s)统计最近3s的请求量或者异常次数，根据请求或者异常次数采取相应措施 如图： 1. 红色的矩形就是一个窗口，窗口hold的是一段时间内的数据流。 2.这里面...
Spark Streaming之五：Window窗体相关操作
weixin_34396103的博客
04-09 383
SparkStreaming之window滑动窗口应用，Spark Streaming提供了滑动窗口操作的支持，从而让我们可以对一个滑动窗口内的数据执行计算操作。每次掉落在窗口内的RDD的数据，会被聚合起来执行计算操作，然后生成的RDD，会作为window DStream的一个RDD。 网官图中所示，就是对每三秒钟的数据执行一次滑动窗口计算，这3秒内的3个RDD会被聚合起来进行处理，然后过了两秒...
【Spark五十八】Spark Streaming详解（重点窗口计算）
bit1129的博客
02-13 3268
前面有几篇关于Spark Streaming的博客，那会只是作为Spark入门，快速体验Spark之用，只是照着葫芦画瓢。本文结合Spark官网上Spark Streaming的编程指南对Spark Streaming进行介绍 StreamingContext 如同SparkContext一样，StreamingContext也是Spark Streaming应用程序通往Spark集群的通...
spark streaming 窗口 教程
XUJIA2018的博客
12-03 1968
1、窗口介绍 SparkStreaming是基于spark core 的实时架构，虽然SparkStreaming可以进行实时计算，但它并不是一个纯实时计算框架。StreamingContext的批次间隔决定了每隔多久计算一次。 SparkStreaming提供了窗口的计算 ，窗口计算可以整合多个批次的计算结果。在spark streaming 中 ，一共有两种窗口：滑动窗口和滚动窗口。 2、滑动窗口 滑动窗口：需要设置窗口大小和滑动间隔，窗口大小和滑动间隔都是StreamingContext的间隔时间的
关于Spark Streaming的时间窗口
econg的博客
06-30 471
通过本文的简介和示例代码，我们了解了如何在 Java 环境下使用 Spark Streaming 调试时间窗口操作。时间窗口是处理实时数据流的重要工具，掌握调试技巧能够帮助我们快速解决问题并提高数据处理效率。本文将介绍如何使用 Spark Streaming 在 Java 环境下调试时间窗口操作，包括代码示例和逻辑解析。接下来，我们需要设置输入数据流。示例代码仅用于演示基本的时间窗口调试，实际应用中可能涉及到更复杂的数据处理逻辑和调试方式。现在我们已经设置好输入数据流，接下来是设置时间窗口并执行数据处理。
大数据组件-监控-spark-driver/executor性能的prometheus-grafana模板插件
01-29
大数据组件-监控-spark-driver/executor性能的prometheus-grafana模板插件
Redis 中spark参数executor-cores引起的异常解决办法
09-09
主要介绍了Redis 中spark参数executor-cores引起的异常解决办法的相关资料,需要的朋友可以参考下
Spark Streaming 流式处理整合Kafka.rar
最新发布
10-18
Spark Streaming 中提供了如下三种位置策略，用于指定 Kafka 主题分区与 Spark 执行程序 Executors 之间的分配关系： + **PreferConsistent** : 它将在所有的 Executors 上均匀分配分区； + **PreferBrokers** : ...
java 中Executor, ExecutorService 和 Executors 间的不同
08-30
主要介绍了java 中Executor, ExecutorService 和 Executors 间的不同的相关资料,需要的朋友可以参考下
SparkStreaming-相关窗口操作
啊帅和和的博客
01-18 1911
目录提前封装好的重复代码将日志信息调整为ERRORwindowcountByWindowreduceByWindowreduceByKeyAndWindow不保留数值保留数值countByValueAndWindow 提前封装好的重复代码 按照我的习惯，先把重复的代码做一个简单的封装，后面直接继承就可，这里的窗口长度为3，滑动频率为1 package com.shujia.test import org.apache.spark.SparkContext import org.apache.spark.
Spark Streaming窗口
DataJunGe的博客
03-19 198
Spark Streaming窗口 以上的图描述的是一个滑动（sliding）窗口: window size: 3个时间单位 slide interval： 2个时间时间 Tumbling(翻滚)窗口 Sliding(滑动)窗口 窗口操作函数 countByWindow(windowLength, slideInterval) 统计每一个窗口中，元素的个数 // 必须设置检查点目录 ...
SparkStreaming---窗口函数
shall潇の菜园
06-23 321
文章目录一、窗口函数二、transform 一、窗口函数 package window import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord} import org.apache.spark.SparkConf import org.apache.spark.streaming.dstream.{DStream, InputDStream} import org.apache.spark.streaming.kaf
大数据开发 | Spark Streaming窗口函数
zjjcchina的博客
06-16 484
在Spark Streaming中，它是一种在实时数据流中进行聚合操作的方法，将一定时间范围内的数据收集在一起，进行处理并输出结果，可以帮助我们对数据流进行更精细的处理和分析。例如，如果将窗口大小设置为10秒，滑动间隔设置为5秒，那么每5秒钟会有一个新的窗口开始，每个窗口包含前10秒钟的数据，而每个窗口之间会有5秒钟的重叠部分。与滑动窗口不同的是，滚动窗口中的窗口之间没有重叠部分，即每个窗口的数据都是不重叠的。需要注意的是，Map窗口函数只能对窗口内的数据进行操作，无法获取窗口的元数据信息。
spark streaming 之window窗口操作
weixin_49165958的博客
12-23 329
窗口函数，就是在DStream流上，以一个可配置的长度为窗口，以一个可配置的速率向前移动窗口，根据窗口函数的具体内容，分别对当前窗口中的这一波数据采取某个对应的操作算子。 需要注意的是窗口长度，和窗口移动速率需要是batch time的整数倍。 1.window(windowLength, slideInterval) 该操作由一个DStream对象调用，传入一个窗口长度参数，一个窗口移动速率参数，然后将当前时刻当前长度窗口中的元素取出形成一个新的DStream。 object SparkWindowDe
SparkStreaming（8）：windows窗口操作
小蚯蚓的博客
10-10 433
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 Streaming 滑动窗口实践
waynecook的专栏
07-23 643
import org.apache.spark.SparkConf import org.apache.spark.streaming.{Seconds, StreamingContext} import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream} import org.junit.Test /** spark 滑动窗口测试（slide window） * * 参考 https://www.cnblogs..
SparkStreaming之滑动窗口的实现
CatherineHuangTT的博客
11-24 823
import org.apache.spark.SparkConf import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream} import org.apache.spark.streaming.{Seconds, StreamingContext} import org.apache.log4j.{Logge
[转载]SparkStreaming的窗口操作及实战
gggSam的博客
07-21 167
【必会】SparkStreaming的窗口操作及实战 Window Operations（窗口操作）可以设置窗口大小和滑动窗口间隔来动态的获取当前Streaming的状态。基于窗口的操作会在一个比 StreamingContext 的 batchDuration（批次间隔）更长的时间范围内，通过整合多个批次的结果，计算出整个窗口的结果。 下面，通过一张图来描述SparkStreaming的窗口操作，如图所示。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6ndjNawZ-1
spark driver和executor
03-16
Spark Driver和Executor是Spark中的两个重要组件。 Spark Driver是Spark应用程序的主要组件，它负责协调和管理整个应用程序的执行过程。它负责将应用程序分解成任务，并将这些任务分配给不同的Executor进行执行。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值