SparkStreaming

最新推荐文章于 2025-05-27 12:59:17 发布
原创 最新推荐文章于 2025-05-27 12:59:17 发布 · 427 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

SparkStreaming是基于微批处理的实时数据流处理框架，提供高吞吐量和容错能力。它从多种数据源如Kafka、Flume等接收数据，支持复杂的实时计算并能将结果存储在各种系统。相较于Storm，SparkStreaming具有更高的吞吐量，但不是纯实时处理。DStream是其核心概念，可通过多种算子如foreachRDD、updateStateByKey、窗口操作等进行处理。注意SparkStreaming启动和停止的管理，以及receiver模式下的配置。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SparkStreaming

一、SparkStreaming简介

​ SparkStreaming是流式处理框架，是Spark API的扩展，支持可扩展、高吞吐量、容错的实时数据流处理，实时数据的来源可以是：Kafka, Flume, Twitter, ZeroMQ或者TCP sockets，并且可以使用高级功能的复杂算子来处理流数据。例如：map,reduce,join,window 。最终，处理后的数据可以存放在文件系统，数据库等，方便实时展现

​ SparkStreaming底层操作DStream

二、SparkStreaming与Storm区别

1 Storm是纯实时的流式处理框架，SparkStreaming是准实时的处理框架（微批处理）

​ 因为微批处理， SparkStreaming的吞吐量比Storm要高

2 Storm 的事务机制要比SparkStreaming的要完善，SparkStreaming可以手动管理事务

3 Storm支持动态资源调度，SparkStreaming也支持资源调度，但是一般情况下不开启，为了避免内存给了却要不回来的情况

4 Storm不擅长复杂的业务处理，擅长简单的汇总型计算，SparkStreaming擅长复杂的业务处理，因为在SparkStreaming中可以使用core/sql/机器算法

三、SparkStreaming

1 接收数据原理图

在这里插入图片描述

​ SparkStreaming是7 *24h不间断运行, SparkStreaming启动之后,首先会启动一个job ,这个job有一个task来接收数据, task每隔一-段时间将接收来的数据封装到一-个batch中，“这段时间” 就是batchInterval。 生成的每个batch又被封装到一一个 RDD中,这个RDD又被封装到一一个DStream中, SparkStreaming底层操作的就是DStream。 DStream有 自己的Transformation类算子，懒执行，需要DStream的outputOperator类算子触发执行

2 注意事项

Ø 启动socket server 服务器：nc –lk 9999 在集群使用yum install -y nc安装

Ø receiver模式下接收数据，local的模拟线程必须大于等于2，一个线程接收数据，另一个线程执行job

Ø Durations时间设置就是我们能接收的延迟度。这个需要根据集群的资源情况以及任务的执行情况来调节。

​ localhost:4040 查看Active Jobs栏数量看是否堆积

Ø 创建JavaStreamingContext有两种方式（SparkConf,SparkContext）

Ø 所有的代码逻辑完成后要有一个output operation类算子

Ø JavaStreamingContext.start() Streaming框架启动后不能再次添加业务逻辑

Ø JavaStreamingContext.stop() 无参的stop方法将SparkContext一同关闭，stop(false)，不会关闭SparkContext

Ø JavaStreamingContext.stop()停止之后不能再调用start

3 算子

foreachRDD–针对当前批次的数据

注意

Ø 1 需要Action算子触发

Ø 2 在于foreachRDD内部，RDD转换算子外部之间的信息 (Driver端)每次都执行

在转换算子内部，相当于(–Excutor端–)，有数据才执行

SparkStreaming虽不能在运行过程中更改数据信息，但是更改外部文件，因此可以实现动态改变–动态广播变量

package com.cs.scala.sparkString

import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Durations, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**
  * foreachRDD  统计当前这一批次的数据
  *
  * 两种创建Streaming方式
  *       val sc = new SparkContext(conf)
  *       val ssc = new StreamingContext(sc,Durations.seconds(5))
  *   val ssc = new StreamingContext(conf,Durations.seconds(5))
  */
object ForeachRDD {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    //注意设置Master的local[]数量，因为在整个过程中，需要两个task(1接收1执行计算)，local默认是 1
    conf.setAppName("foreachRDD").setMaster("local[2]")
//    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(conf,Durations.seconds(5))

    //监控集群端口的工具--socketTextStream
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("sxt002",port = 9999)
    val result: DStream[(String, Int)] = lines.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)

//    result.print(100)
    result.foreachRDD(pairRDD=>{
      val newRDD: RDD[(String, Int)] = pairRDD.filter(one => {
        println("==========Driver=========")
        true
      })
      val resultRDD: RDD[Unit] = newRDD.map(one => {
        println("-----Excutor-----")
      })
      resultRDD.count()

    })

    //框架启动之后是不能在次添加业务逻辑
    // 停止之后是不能在调用start
    ssc.start()
    //表示不间断执行 7*24h
    ssc.awaitTermination()
    //可以在以后找到数据后停止SparkStreaming，若stop(ture)则一同关闭sc
    ssc.stop()
  }
}
updateStateByKey–针对所有批次数据

1、为Spark Streaming中每一个Key维护一份state状态，state类型可以是任意类型的， 可以是一个自定义的对象，那么更新函数也可以是自定义的

2、通过更新函数对该key的状态不断更新，对于每个新的batch而言，Spark Streaming会在使用updateStateByKey的时候为已经存在的key进行state的状态更新

3、根据key更新状态，需要设置 checkpoint来保存状态

4、默认key的状态在内存中 有一份，在checkpoint目录中有一份

5、batchInterval负责将内存文件写在磁盘上 10s为界

def main(args: Array[String]): Unit = {
  val conf = new SparkConf()
  conf.setMaster("local[2]")
  conf.setAppName("UpdateStateByKey")
  val ssc = new StreamingContext(conf,Durations.seconds(5))
  //设置日志级别
  ssc.sparkContext.setLogLevel("ERROR")
  val lines: ReceiverInputDStream[String] = ssc.socketTextStream("c7node5",9999)
  val words: DStream[String] = lines.flatMap(line=>{line.split(" ")})
  val pairWords: DStream[(String, Int)] = words.map(word => {
    (word, 1)
  })

  ssc.checkpoint("./Test_spark/data/streamingCheckpoint")

  /**
    * currentValues :当前批次某个 key 对应所有的value 组成的一个集合
    * preValue : 以往批次当前key 对应的总状态值
    */
  val result: DStream[(String, Int)] = pairWords.updateStateByKey((currentValues: Seq[Int], preValue: Option[Int]) => {
    var totalValues = 0
    if (!preValue.isEmpty) {
      totalValues += preValue.get
    }
    for(value <- currentValues){
      totalValues += value
    }

    Option(totalValues)
  })
  result.print()
  ssc.start()
  ssc.awaitTermination()
  ssc.stop()
窗口操作–针对某一时间段批次数据

在这里插入图片描述

Ø 假设每隔5s 1个batch,上图中窗口长度为15s，窗口滑动间隔10s。

Ø 窗口长度和滑动间隔必须是batchInterval的整数倍。如果不是整数倍会检测报错。

Ø reduceByKeyAndWindow 窗口操作 checkpoint 保存数据

Ø 窗口操作优化的机制 实时数 = 总-旧+新

 val conf = new SparkConf()
    conf.setAppName("windowOperator")
    conf.setMaster("local[2]")
    val ssc = new StreamingContext(conf,Durations.seconds(5))
    ssc.sparkContext.setLogLevel("Error")
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("sxt002",9999)
    val words: DStream[String] = lines.flatMap(line=>{line.split(" ")})
    val pairWords: DStream[(String, Int)] = words.map(word=>{(word,1)})

    /**
      * 窗口操作普通的机制
      */
//    val windowResult: DStream[(String, Int)] =
//      pairWords.reduceByKeyAndWindow((v1:Int, v2:Int)=>{v1+v2},Durations.seconds(15),Durations.seconds(5))

    /**
      * 窗口操作优化的机制
      * 因为要保存状态所以要设置checkpoint路径
      * 实时数 = 原总数-旧+新
      */
    ssc.checkpoint("./Test_spark/data/streamingCheckpoint")
    val windowResult: DStream[(String, Int)] = pairWords.reduceByKeyAndWindow(
      (v1:Int, v2:Int)=>{v1+v2},
      (v1:Int, v2:Int)=>{v1-v2},
      Durations.seconds(15),
      Durations.seconds(5))

    windowResult.print()

    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
transform

Ø transform可以拿到DStream的RDD，经过RDD的算子后，要返回RDD，返回的RDD又被封装到一个DStream

Ø 过滤黑名单，如果输入的含有xxx，就过滤掉不取

Ø 作用和foreachRDD类似，–Driver端，Excutor端 --动态广播变量

    val conf = new SparkConf()
    conf.setAppName("transform")
    conf.setMaster("local[2]")
    val ssc = new StreamingContext(conf,Durations.seconds(5))
//    ssc.sparkContext.setLogLevel("Error")
    /**
      * 广播黑名单
      */
    val blackList: Broadcast[List[String]] = ssc.sparkContext.broadcast(List[String]("zhangsan","lisi"))

    /**
      * 从实时数据【"hello zhangsan","hello lisi"】中发现 数据的第二位是黑名单人员，过滤掉
      */
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("c7node5",9999)
    val pairLines: DStream[(String, String)] = lines.map(line=>{(line.split(" ")(1),line)})
    val resultDStream: DStream[String] = pairLines.transform(pairRDD => {
      println("=======Driver=======")
      val filterRDD: RDD[(String, String)] = pairRDD.filter(tp => {
        val nameList: List[String] = blackList.value
        !nameList.contains(tp._1)
      })
      val returnRDD: RDD[String] = filterRDD.map(tp => tp._2)
      returnRDD
    })

    resultDStream.print()

    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
saveAsTextFiles(prefix, [suffix])–将DStream内容保存为文本文件

Ø SparkStreaming监控一个目录数据时，无法监控目录下已经存在的文件 ，可以监控增加的文件

Ø 增加的文件必须是原子性产生(文件中不能写莫名东西)

Ø 命名格式是 refix-TIME_IN_MS[.suffix]

result.saveAsTextFiles("./data/streamingSavePath/prefix","suffix")

val conf = new SparkConf()
conf.setMaster("local")
conf.setAppName("saveAsTextFile")
val ssc = new StreamingContext(conf,Durations.seconds(5))
val lines: DStream[String] = ssc.textFileStream("./Test_spark/data/streamingCopyFile")
val words: DStream[String] = lines.flatMap(line=>{line.split(" ")})
val pairWords: DStream[(String, Int)] = words.map(word=>{(word,1)})
val result: DStream[(String, Int)] = pairWords.reduceByKey((v1:Int, v2:Int)=>{v1+v2})
//保存的多级目录就直接写在前缀中
result.saveAsTextFiles("./Test_spark/data/streamingSavePath/prefix","suffix")
ssc.start()
ssc.awaitTermination()
ssc.stop()
Driver-HA

两方面设置：

​ 1 在提交application时，添加–supervice 如果挂点会自动重启Driver

​ 2 代码层面 StreamingContext.getOrCreate(原逻辑，新逻辑)

需要注意的是，Driver重启之后用的仍然是旧逻辑，新逻辑不会被用，除非清空checkpoint所有的目录信息

默认checkpoint 存储：
    1.配置信息
    2.DStream操作逻辑
    3.job的执行进度
    4.offset

  //设置checkpoint目录
  val ckDir = "./Test_spark/data/streamingCheckpoint"
  def main(args: Array[String]): Unit = {

    val ssc: StreamingContext = StreamingContext.getOrCreate(ckDir,CreateStreamingContext)
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()

  }

  def CreateStreamingContext() = {
    println("=======Create new StreamingContext =======")
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("DriverHA")
    val ssc: StreamingContext = new StreamingContext(conf,Durations.seconds(5))
    ssc.sparkContext.setLogLevel("Error")

    ssc.checkpoint(ckDir)
    val lines: DStream[String] = ssc.textFileStream("./Test_spark/data/streamingCopyFile")
    val words: DStream[String] = lines.flatMap(line=>{line.trim.split(" ")})
    val pairWords: DStream[(String, Int)] = words.map(word=>{(word,1)})
    val result: DStream[(String, Int)] = pairWords.reduceByKey((v1:Int, v2:Int)=>{v1+v2})

    result.print()

	//更改逻辑
//    result.foreachRDD(pairRDD=>{
//      pairRDD.filter(one=>{
//        println("*********** filter *********")
//        true
//      })
//      pairRDD.foreach(println)
//    })

    ssc
Spark-Streaming
开水烫鱼的博客
01-26 392
WordCount object WordCount { def main(args: Array[String]): Unit = { //1.创建sparkContext val conf = new SparkConf().setAppName("WordCount").setMaster("local[2]") val sc = new SparkContext...
spark streaming
11-03
spark streaming spark流式计算 Spark Streaming 是Spark核心API的一个扩展，可以实现高吞吐量的、具备容错机制的实时流数据的处理。支持从多种数据源获取数据
Spark Streaming流数据计算全面指南
最新发布
2302_80153634的博客
05-27 792
Spark Streaming是Spark核心API的扩展，支持实时数据流的可扩展、高吞吐量、容错处理。本文将全面介绍Spark Streaming的核心概念、应用场景和实战技巧。Spark Streaming通过DStream抽象实现了高效的流数据处理，能够与Spark生态无缝集成。本文涵盖了从基础概念到高级应用的完整知识体系，并通过词频统计案例演示了核心功能的使用方法。掌握这些技术后，开发者可以构建各种实时数据处理应用，如实时监控、日志分析、实时推荐等。
基于Spark Streaming的大数据实时流计算平台和框架，并且是基于运行在yarn模式运行的spark streaming
05-08
一个完善的Spark Streaming二次封装开源框架，包含：实时流任务调度、kafka偏移量管理，web后台管理，web api启动、停止spark streaming，宕机告警、自动重启等等功能支持，用户只需要关心业务代码，无需关注繁琐的...
HBase-SparkStreaming:从HBase表读取并写入HBase表的简单Spark Streaming项目
05-13
HBase-SparkStreaming 从HBase表读取并写入HBase表的简单Spark Streaming项目 #Prereqs运行 创建一个要写入的hbase表：a）启动hbase shell $ hbase shell b）创建表create'/ user / chanumolu / sensor'，{NAME =>'...
SparkStreaming流式日志过滤与分析
05-30
（1）利用SparkStreaming从文件目录读入日志信息，日志内容包含： ”日志级别、函数名、日志内容“ 三个字段，字段之间以空格拆分。请看数据源的文件。 （2）对读入都日志信息流进行指定筛选出日志级别为error或warn...
sparkStreaming
kylin_xue的专栏
02-20 444
目录 核心概念 DStream Receiver Transformation Output Operation IDEA搭建SparkStreaming环境的pom文件 带状态的算子：UpdateStateByKey 基于window的统计 核心概念 SparkStreaming可以简单的理解为 StreamingContext将数据按照时间分为很多小的RDD，然后再交给Sp...
Spark Streaming 教程文档--概述、基本概念、性能调优
sunyang098的博客
03-31 7033
SparkStreaming教程 本文章主要讲述SparkStreaming概念原理、基本概念、以及调优等一些知识点。 1      概述 1.1  SparkStreaming是什么 Spark Streaming 是个批处理的流式（实时）计算框架。其基本原理是把输入数据以某一时间间隔批量的处理，当批处理间隔缩短到秒级时，便可以用于处理实时数据流。 　  支持从多种数据源获取数据，包括
Spark 之 SparkStreaming
向日葵的博客
12-02 1164
SparkStreaming前言Spark 知识系列文章一、Spark Streaming1.1 Spark Streaming 架构1.2 DStream 入门案例（Wordcount）1.3 Dstream转换二、窗口函数总结 前言 本文介绍了有关SparkStreaming的相关知识，包括SparkStreaming架构、SparkStreaming实现WordCount案例、窗口函数等。 Spark 知识系列文章    此处罗列了有关Spark相关知识的其他文章，有需要的可以进行点击查阅。  
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值