SparkStreaming的简单使用

最新推荐文章于 2022-11-24 18:54:26 发布
最新推荐文章于 2022-11-24 18:54:26 发布
阅读量124 收藏
点赞数
分类专栏： 大数据 文章标签： spark 大数据 实时大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44002865/article/details/119445717
版权

SparkStreaming

文章目录

1、环境准备

导入依赖(pom.xml)

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-core_2.12</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-yarn_2.12</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-sql_2.12</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.27</version>
</dependency>
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-hive_2.12</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.hive</groupId>
    <artifactId>hive-exec</artifactId>
    <version>1.2.1</version>
</dependency>
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.12</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.12</artifactId>
    <version>3.0.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.10.1</version>
</dependency>




2、创建DStream

监听端口

  • ssc.socketTextStream(hostname: String, port: Int)

    • hostname：主机名
    • port：端口号
    import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Duration, StreamingContext}

object Spark01_Streaming_WordCount {
  def main(args: Array[String]): Unit = {
    //TODO 创建采集器SparkStreaming
    //配置信息
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    // 创建采集器SparkStreaming，第一个参数（配置信息），第二个参数（时间（3s））
    val ssc = new StreamingContext(sparkConf, Duration(3 * 1000))

        
    //TODO 业务逻辑
    //通过监控端口创建DStream
    val wordLine: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop151", 9999)
    //WordCount业务逻辑
    val words: DStream[String] = wordLine.flatMap(_.split(" "))
    val wordToMap: DStream[(String, Int)] = words.map((_, 1))
    val wordToCount: DStream[(String, Int)] = wordToMap.reduceByKey(_ + _)
    //输出
    wordToCount.print()

        
    //TODO 启动采集器
    ssc.start()

        
    //TODO 等待采集器的关闭
    ssc.awaitTermination()
  }
}



RDD 队列

  • ssc.queueStream(queue: Queue[RDD[T]], oneAtATime: Boolean)

    • queue：RDD队列。此数据结构的修改必须同步。
    • oneAtATime：在每个间隔中是否应仅从队列中消耗一个RDD
    import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Duration, StreamingContext}
import scala.collection.mutable

object Spark02_Streaming_Queue {
  def main(args: Array[String]): Unit = {
    //TODO 创建采集器SparkStreaming
    //配置信息
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    // 创建采集器SparkStreaming，第一个参数（配置信息），第二个参数（时间（3s））
    val ssc = new StreamingContext(sparkConf, Duration(3 * 1000))

        
    //TODO 业务逻辑
    val queue: mutable.Queue[RDD[Int]] = new mutable.Queue[RDD[Int]]()
    //使用队列创建DStream
    val words: InputDStream[Int] = ssc.queueStream(queue, oneAtATime = false)
    val wordToMap: DStream[(Int, Int)] = words.map((_, 1))
    val wordToCount: DStream[(Int, Int)] = wordToMap.reduceByKey(_ + _)
    //输出
    wordToCount.print()


    //TODO 启动采集器
    ssc.start()

    //定时添加信息
    for(i <- 1 to(5)){
      queue += ssc.sparkContext.makeRDD(1 to(100), 10)
      Thread.sleep(2000)
    }

      
    //TODO 等待采集器的关闭
    ssc.awaitTermination()
  }
}



Kafka

KafkaUtils.createDirectStream(
    ssc: StreamingContext,  //采集器
    locationStrategy: LocationStrategy,  //区位策略（系统的策略）
    consumerStrategy: ConsumerStrategy[K, V]  //消费信息，Set("fzk")：(主题)，kafkaPara：（kafka参数）
)

  • 程序

    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.{Duration, StreamingContext}

object Spark04_Streaming_Kafka {
  def main(args: Array[String]): Unit = {
    //TODO 创建采集器SparkStreaming
    //配置信息
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    // 创建采集器SparkStreaming，第一个参数（配置信息），第二个参数（时间（3s））
    val ssc = new StreamingContext(sparkConf, Duration(3 * 1000))

      
    //TODO 业务逻辑
    //定义 Kafka 参数
    val kafkaPara: Map[String, Object] = Map[String, Object](
      //地址+端口号
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop151:9092,hadoop152:9092,hadoop153:9092",
      //kafka的分组
      ConsumerConfig.GROUP_ID_CONFIG -> "fzk",
      //key的实例化
      "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      //value的实例化
      "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"  
    )
      
    //读取 Kafka 数据创建 DStream
    val kafkaDStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      ssc,  //采集器
      //区位策略（系统的策略）
      LocationStrategies.PreferConsistent,  
      //消费信息，Set("fzk")：(主题)，kafkaPara：（kafka参数）
      ConsumerStrategies.Subscribe[String, String](Set("fzk"), kafkaPara)  
    )
    val valueDStream: DStream[String] = kafkaDStream.map(_.value())
    valueDStream.print()


    //TODO 启动采集器
    ssc.start()

      
    //TODO 等待采集器的关闭
    ssc.awaitTermination()
  }
}



自定义

  • ssc.receiverStream(receiver: Receiver[T])

  • receiver：自定义数据源

  • 第一步：自定义数据源（继承 Receiver，并实现 onStart、onStop 方法来自定义数据源采集）

    class MyReceiver extends Receiver[String](StorageLevel.MEMORY_ONLY){

  private var flag: Boolean = true

  override def onStart(): Unit = {
    //业务逻辑
  }

  override def onStop(): Unit = {
    //业务逻辑
  }
}

  • 第二步：

    import org.apache.spark.SparkConf
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.receiver.Receiver
import org.apache.spark.streaming.{Duration, StreamingContext}
import scala.util.Random

object Spark03_Streaming_Receiver {
  def main(args: Array[String]): Unit = {
    //TODO 创建采集器SparkStreaming
    //配置信息
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    // 创建采集器SparkStreaming，第一个参数（配置信息），第二个参数（时间（3s））
    val ssc = new StreamingContext(sparkConf, Duration(3 * 1000))

        
    //TODO 业务逻辑
    //自定义方式创建DStream
    val data: ReceiverInputDStream[String] = ssc.receiverStream(new MyReceiver)
    data.print()


    //TODO 启动采集器
    ssc.start()

        
    //TODO 等待采集器的关闭
    ssc.awaitTermination()
  }
}




3、DStream 转换

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

无状态转化操作

  • 把简单的 RDD 转化操作应用到每个批次上，也就是转化 DStream 中的每一个 RDD。注意，针对键值对的 DStream 转化操作(比如reduceByKey())要添加 import StreamingContext._才能在 Scala 中使用

    在这里插入图片描述



Transform

  • Transform 允许 DStream 上执行任意的RDD-to-RDD 函数。即使这些函数并没有在DStream 的 API 中暴露出来，通过该函数可以方便的扩展 Spark API。该函数每一批次调度一次。其实也就是对 DStream 中的 RDD 应用转换

  • def transform[U: ClassTag](transformFunc: RDD[T] => RDD[U]): DStream[U]

    //将DString转换成RDD，进行RDD操作
DStream.transform(rdd => rdd)



join

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

  • def join[W: ClassTag](other: DStream[(K, W)]): DStream[(K, (V, W))]

    DStream.join(DStream)



有状态转化操作

UpdateStateByKey

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

  • updateStateByKey() 的结果是一个新的DStream，内部的RDD 序列是由每个时间区间对应的(键，状态)对组成的。

  • 使用(updateStateByKey)

    • 第一步：设置检查点路径
      • ssc.checkpoint("ps")
    • 第二步：使用updateStateByKey
      • def updateStateByKey[S: ClassTag](updateFunc: (Seq[V], Option[S]) => Option[S]): DStream[(K, S)]
    import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Duration, StreamingContext}

object Spark05_Streaming_State {
  def main(args: Array[String]): Unit = {
    //TODO 创建采集器SparkStreaming
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    val ssc = new StreamingContext(sparkConf, Duration(3 * 1000))
    //检查点路径
    ssc.checkpoint("ps")

    //TODO 业务逻辑
    val datas: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop151", 9999)
    val map: DStream[(String, Int)] = datas.map((_, 1))
    //记录历史记录，必须添加检查点路径
    val value: DStream[(String, Int)] = map.updateStateByKey[Int](
      (values: Seq[Int], buff: Option[Int]) => {
        Some(buff.getOrElse(0) + values.sum)
      })
    value.print()


    //TODO 启动采集器
    ssc.start()

    //TODO 等待采集器的关闭
    ssc.awaitTermination()
  }
}



WindowOperations

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

    • 窗口时长(windowDuration)：计算内容的时间范围（时长必须是采集周期的整数倍）

    • 滑动步长(slideDuration)：隔多久触发一次计算（步长必须是采集周期的整数倍）

    • 操作方法

      • window
        • 基于对源DStream 窗化的批次进行计算返回一个新的Dstream
        • def window(windowDuration: Duration, slideDuration: Duration): DStream[T]
      • countByWindow
        • 返回一个滑动窗口计数流中的元素个数
        • def countByWindow(windowDuration: Duration, slideDuration: Duration): DStream[Long]
      • reduceByWindow
        • 通过使用自定义函数整合滑动区间流元素来创建一个新的单元素流
        • def reduceByWindow(Func: (T, T) => T, windowDuration: Duration, slideDuration: Duration): DStream[T]

    • 使用（window）

      import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Duration, StreamingContext}

object Spark06_Streaming_Window {
  def main(args: Array[String]): Unit = {
    //TODO 创建采集器SparkStreaming
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    val ssc = new StreamingContext(sparkConf, Duration(3 * 1000))

    //TODO 业务逻辑
    val datas: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop151", 9999)
    //滑动窗口，第一个参数（窗口时长），第二个参数（滑动步长），这两个参数必须是采集周期的整数倍
    val windowDStream: DStream[String] = datas.window(Duration(6 * 1000), Duration(3 * 1000))
    windowDStream.print()


    //TODO 启动采集器
    ssc.start()

    //TODO 等待采集器的关闭
    ssc.awaitTermination()
  }
}




4、DStream 输出

  • print()

    • 在运行流程序的驱动结点上打印 DStream 中每一批次数据的最开始 10 个元素

      DStream.print()

  • saveAsTextFiles(prefix: String, suffix: String = "")

    • 以 text 文件形式存储这个 DStream 的内容

      DStream.saveAsTextFiles()

  • saveAsObjectFiles(prefix: String, suffix: String = "")

    • 以 Java 对象序列化的方式将 Stream 中的数据保存为 SequenceFiles

      DStream.saveAsObjectFiles()

  • saveAsHadoopFiles[F <: OutputFormat[K, V]](prefix: String, suffix: String)

    • 将 Stream 中的数据保存为 Hadoop files

      DStream.saveAsHadoopFiles()

  • foreachRDD(foreachFunc: RDD[T] => Unit)

    • 这是最通用的输出操作，即将函数 func 用于产生于 stream 的每一个 RDD

      DStream.foreachRDD()




5、优雅关闭

  • 直接关闭

    • ssc.stop()

  • 优雅关闭

    • 第一步：设置开启 优雅的关闭

      • sparkConf.set("spark.streaming.stopGracefullyOnShutdown", "true")

    • 第二步：优雅停止

      • ssc.stop(stopSparkContext = true, stopGracefully = true)
      import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Duration, StreamingContext, StreamingContextState}

object Spark07_Streaming_Close {
  def main(args: Array[String]): Unit = {
    //TODO 创建采集器SparkStreaming
    //配置信息
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
    //设置优雅的关闭
    sparkConf.set("spark.streaming.stopGracefullyOnShutdown", "true")
    val ssc = new StreamingContext(sparkConf, Duration(3 * 1000))

      
    //TODO 业务逻辑


    //TODO 启动采集器
    ssc.start()

    //优雅停止
    new Thread(new Runnable {
      override def run(): Unit = {
        while(true){
          if(true){  //第三方判断是否停止
            //获取当前采集器状态
            val state: StreamingContextState = ssc.getState
            //判断采集器是否处于活动状态
            if (state == StreamingContextState.ACTIVE) {
              //优雅停止
              ssc.stop(stopSparkContext = true, stopGracefully = true)
              //退出
              System.exit(0)
            }
          }
        }
      }
    }).start()


    //TODO 等待采集器的关闭
    ssc.awaitTermination()
  }
}
code@fzk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark Streaming概述
m0_67806453的博客
06-20 725
目录一，spark Streaming概述（一）什么是Spark streaming（二）Sparing Streaming的主要特点1，易于使用2，易于与Spark体系整合二，Spark Streaming工具原理（一）Spark Streaming工作流程图 （二）分段流 - DSteam （Discretized Stream）1，分段流的概念 2，分段流的实质 4,分段流的操作 （三）输入DStream与Receiver1，输入DStream与Receiver的关系2，本地运行Spark Strea
Spark Streaming 概述
mu_kui的博客
06-20 573
spark学习笔记
Spark Streaming的简单使用
啊帅和和的博客
11-15 1101
目录理解微批处理 spark core和spark sql都是做离线处理（批处理）的，一计算完就没有了，这里的spark streaming是做流处理（数据是源源不断，7*24小时的），实时计算，是一种微批处理 理解微批处理 spark的微批处理相当于给我们所写的代码加上一个定时任务，只要将我们的数据源换掉，不使用HDFS，数据就可以源源不断的获得，并且进行处理 这里的数据源不再是HDFS（比较慢，会有延迟），而是消息队列（数据排队，先进先出），数据会被生产和消费，这里的数据不会被永久存储，一般是七天
【Spark Streaming】Spark Streaming的使用
依旧的博客
04-21 4984
一、Spark Streaming引入 集群监控 一般的大型集群和平台, 都需要对其进行监控的需求。 要针对各种数据库, 包括 MySQL, HBase 等进行监控 要针对应用进行监控, 例如 Tomcat, Nginx, Node.js 等 要针对硬件的一些指标进行监控, 例如 CPU, 内存, 磁盘 等 Spark Streaming介绍 官网：http://spark.apac...
SparkStreaming
醉与浮的博客
11-21 1094
spark stream教程及demo
Spark Streaming
weixin_57821489的博客
03-17 3714
Spark Streaming介绍 随着大数据的发展，人们对大数据的处理要求也越来越高，传统的MapReduce等批处理框架在某些特定领域（如实时用户推荐、用户行为分析）已经无法满足人们对实时性的需求，因此诞生了一批如S4、Storm的流式的、实时计算框架。而Spark由于其优秀的调度机制，快速的分布式计算能力，能够以极快的速度进行迭代运算。正是由于Spark的这些优势，使得Spark能够在某种程度上进行实时处理，Spark Streaming正是构建在此之上的流式框架。 Spark Streaming作为
Spark基本原理与使用--Spark Streaming
qq_44528357的博客
11-24 886
spark streaming基本原理与使用
SparkStreaming之checkpoint机制使用讲解
遥望......
04-09 2007
一 什么类型的数据需要使用checkpoint? Spark Streaming是最需要进行容错的，因为一般都是7 * 24小时运转，所以需要将足够的信息checkpoint到容错的存储系统上，比如HDFS,从而能够让他从失败中进行恢复。有两种数据需要被进行checkpoint: 1、元数据checkpoint： # 配置信息：创建spark streaming应用程序的配置信息，比如Spa...
SparkStreaming—入门概述
weixin_44604159的博客
10-21 1094
SparkStreaming的基本介绍
Spark Streaming 总结
机械工程跑路哥
09-12 2260
Spark Streaming 是什么 **SparkStreaming**就是将连续的数据 **持久化**，**离散化**，然后进行**批量处理**的框架； **SparkStreaming**是**准实时**（秒级别）、**微批次**的数据处理框架；
Spark学习笔记Spark Streaming的使用
08-25
Spark Streaming 使用指南 Spark Streaming 是一个基于 Spark Core 之上的实时计算框架，可以从很多数据源消费数据并对数据进行处理。在 Spark Streaming 中，有一个最基本的抽象叫 DStream（代理），本质上就是一...
Spark Streaming 示例
04-03
`SparkStreaming.zip` 文件可能包含了一个示例项目，演示了如何创建一个 Spark Streaming 应用来从 Kafka 消费数据。代码通常会包含以下步骤： 1. 创建 SparkConf 对象，配置 Spark 应用的属性，如应用程序名称、...
SparkStreamingKafka:Spark Streaming日志到kafka
05-17
将Spark Streaming与Kafka结合使用，可以实现高效、容错的数据流处理。 **一、Spark Streaming简介** Spark Streaming构建在Spark核心引擎之上，提供了微批处理的概念，允许对实时数据进行近实时处理。它将数据流...
spark-mqtt-sample:使用Spark Streaming的简单MQTT客户端
05-02
本篇文章将深入探讨如何使用Spark Streaming实现一个简单的MQTT（Message Queuing Telemetry Transport）客户端，以便从MQTT服务器接收和处理实时数据。 MQTT是一种轻量级的消息协议，广泛应用于物联网(IoT)设备的...
spark sparkStreaming sparkMaven
03-24
SparkStreaming是Spark的一个核心组件，专门用于处理实时数据流。与传统的批处理不同，SparkStreaming支持微批处理，将实时数据流分割成小批次进行处理，这在一定程度上兼顾了实时性和容错性。而Maven是Java项目管理...
Flink-CDC-快速入手（MySQL为例）
qq_44002865的博客
09-13 2201
官方文档地址上面所用的反序列化器是自带的String字符串序列化器我们可以自定义反序列化器，实现//1.创建执行环境 StreamExecutionEnvironment env = StreamExecutionEnvironment . getExecutionEnvironment();
Kafka的详细使用
qq_44002865的博客
08-20 1712
kafka详细使用（从安装到程序开发详细使用）
HBase的详细使用
qq_44002865的博客
08-09 1702
HBase 文章目录HBase1、安装2、shell命令基本操作表的操作数据的操作3、API准备环境表操作API（DDL）判断表是否存在创建表删除表创建命名空间数据操作API（DML）插入数据获取数据（get）获取数据（scan）删除数据MapReduce环境准备官方案例自定义Hbase-MapReduce将 HDFS 中的数据写入到 Hbase 表中（打成jar包上传到服务器运行）将一张表中的部分数据通过 MR 迁入到另一张表中（在本地运行）4、优化高可用预分区（四种方式）基础优化 1、安装 第一步：
Flume的详细使用
qq_44002865的博客
08-09 1480
Flume 文章目录Flume1、简介2、快速入门安装3、配置及简单使用配置source配置（常用）sink配置（常用）channel配置（常用）使用监控端口数据到控制台（netcat-memeory-logger）实时监控单个追加文件到控制台（exec-memeory-logger）实时监控单个追加文件到HDFS（exec-memeory-hdfs）实时监控目录下多个新文件（spooldir-memory-hdfs）实时监控目录下的多个追加文件（taildir-memory-hdfs）Flume对接Kaf
sparkstreaming 状态
最新发布
05-24
Spark Streaming使用内存来存储这些状态，当节点失败或重新启动时，这些状态将被丢失。 - 状态一致的状态：这种状态通常用于跟踪聚合函数或更复杂的状态信息。Spark Streaming使用检查点来存储这些状态，以便在节点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值