Spark【Spark Streaming】

已于 2023-10-25 19:00:26 修改
阅读量676 收藏
点赞数
分类专栏： Spark 文章标签： spark 大数据 分布式 1024程序员节
于 2023-10-25 09:45:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64261982/article/details/133964098
版权

1、基本数据源

1.1、文件流

在spark Shell 下运行：

[lyh@hadoop102 spark-yarn-3.2.4]$ spark-shell 
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
2022-09-08 08:56:21,875 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
Spark context Web UI available at http://hadoop102:4040
Spark context available as 'sc' (master = local[*], app id = local-1662598583370).
Spark session available as 'spark'.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 3.2.4
      /_/
         
Using Scala version 2.12.15 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_241)
Type in expressions to have them evaluated.
Type :help for more information.

scala> import org.apache.spark.streaming._
import org.apache.spark.streaming._

scala> val ssc = new StreamingContext(sc,Seconds(20))
ssc: org.apache.spark.streaming.StreamingContext = org.apache.spark.streaming.StreamingContext@379899f4

scala> val lines = ssc.textFileStream("file:///home/lyh/streaming/logfile")
lines: org.apache.spark.streaming.dstream.DStream[String] = org.apache.spark.streaming.dstream.MappedDStream@531245fe

scala> val kv = lines.map((_,1)).reduceByKey(_+_)
kv: org.apache.spark.streaming.dstream.DStream[(String, Int)] = org.apache.spark.streaming.dstream.ShuffledDStream@c207c10

scala> kv.print()

scala> ssc.start()

------------------------------------------
Time: 1662598860000 ms
-------------------------------------------

-------------------------------------------
Time: 1662598880000 ms
-------------------------------------------

-------------------------------------------
Time: 1662598900000 ms
-------------------------------------------
(c#,1)
(hh,1)
(h,1)
(javafx,1)
(spark,1)
(hadoop,1)
(js,1)
(java,1)
(s,1)
(c,1)

执行后立即新建终端在  /home/lyh/streaming/logfile 目录下创建文件并写入数据

1.2、Socket 套接字流

// todo 创建环境对象
    val conf = new SparkConf()
    conf.setAppName("word count").setMaster("local[*]")
    val ssc = new StreamingContext(conf,Seconds(3))

    // todo 逻辑处理
    // 获取端口数据(Socket)
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
    val words: DStream[String] = lines.flatMap(_.split(" "))
    val word: DStream[(String,Int)] = words.map((_, 1))
    val wordCount: DStream[(String,Int)] = word.reduceByKey(_ + _)
    wordCount.print()
    // todo 关闭环境
    // 由于SparkStreaming的采集器是长期运行的,所以不能直接关闭
    // 而且main方法的关闭也会使SparkStreaming的采集器关闭
    ssc.start()
    // 等待采集器关闭
    ssc.awaitTermination()

启动 NetCat

> nc -lp 9999 
> hello world
> hello spark
> ...

运行结果： 

1.3、自定义 Socket 数据源

通过自定义 Socket 实现数据源不断产生数据

import java.io.PrintWriter
import java.net.{ServerSocket, Socket}
import scala.io.Source

/**
 * 通过自定义的Socket来不断给客户端发送数据
 */
object MySocketReceiver {

  def index(length: Int): Int = {
    val rdm = new java.util.Random()
    rdm.nextInt(length)
  }

  def main(args: Array[String]): Unit = {

    val fileName = "input/1.txt"
    val lines: List[String] = Source.fromFile(fileName).getLines().toList

    val listener: ServerSocket = new ServerSocket(9999)

    while(true){
      val socket: Socket = listener.accept()
      new Thread(){
        override def run(){
          val out: PrintWriter = new PrintWriter(socket.getOutputStream,true)
          while (true){
            Thread.sleep(1000)
            val content = lines(index(lines.length)) // 源源不断,每次打印list的第(1~length)随机行
            println(content)
            out.write(content + '\n')
            out.flush()
          }
          socket.close()
        }
      }.start()
    }

  }
}

定义一个处理器接收自定义数据源端口发送过来的数据。

def main(args: Array[String]): Unit = {

    // todo 创建环境对象
    val conf = new SparkConf()
    conf.setAppName("word count").setMaster("local[*]")
    val ssc = new StreamingContext(conf,Seconds(3))

    // todo 逻辑处理
    // 获取端口数据(Socket)
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
    val words: DStream[String] = lines.flatMap(_.split(" "))
    val word: DStream[(String,Int)] = words.map((_, 1))
    val wordCount: DStream[(String,Int)] = word.reduceByKey(_ + _)
    wordCount.print()
    // todo 关闭环境
    // 由于SparkStreaming的采集器是长期运行的,所以不能直接关闭
    ssc.start()
    // 等待采集器关闭
    ssc.awaitTermination()

  }

先运行我们的数据源，再运行处理器：

处理器：

1.4、RDD 队列流

import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}

import scala.collection.mutable

object SparkStreaming02_RDDStream {

  def main(args: Array[String]): Unit = {

    // 1. 初始化配置信息
    val conf = new SparkConf()
    conf.setAppName("rdd Stream").setMaster("local[*]")

    // 2.初始化SparkStreamingContext
    val ssc = new StreamingContext(conf,Seconds(4))

    // 3.创建RDD队列
    val rddQueue: mutable.Queue[RDD[Int]] = new mutable.Queue[RDD[Int]]()

    // 4.创建QueueInputStream
    // oneAtATime = true 默认，一次读取队列里面的一个数据
    // oneAtATime = false， 按照设定的时间，读取队列里面数据
    val inputStream: InputDStream[Int] = ssc.queueStream(rddQueue,oneAtATime = false)

    // 5. 处理队列中的RDD数据
    val sumStream: DStream[Int] = inputStream.reduce(_ + _)

    // 6. 打印结果
    sumStream.print()

    // 7.启动任务
    ssc.start()

    // 8.向队列中放入RDD
    for(i <- 1 to 5){
      rddQueue += ssc.sparkContext.makeRDD(1 to 5)
      Thread.sleep(2000)
    }

    // 9. 等待数据源进程停止后关闭
    ssc.awaitTermination()
  }

}

2、高级数据源

2.1、Kafka 数据源

2.1.1、消费者程序处理流数据

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.kafka.common.serialization.StringDeserializer
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}

object SparkStreaming03_Kafka {

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setMaster("local[*]").setAppName("kafka source")
    val ssc = new StreamingContext(conf,Seconds(3))

    // 定义Kafka参数: kafka集群地址、消费者组名称、key序列化、value序列化
    val kafkaPara: Map[String,Object] = Map[String,Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop104:9092",
      ConsumerConfig.GROUP_ID_CONFIG ->"lyh",
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer",
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer]
    )

    // 读取Kafka数据创建DStream
    val kafkaDStream: InputDStream[ConsumerRecord[String,String]] = KafkaUtils.createDirectStream[String,String](
      ssc,
      LocationStrategies.PreferConsistent,  //优先位置
      ConsumerStrategies.Subscribe[String,String](Set("testTopic"),kafkaPara) // 消费策略：（订阅多个主题，配置参数）
    )

    // 将每条消息的KV取出
    val valueDStream: DStream[String] = kafkaDStream.map(_.value())

    // 计算WordCount
    valueDStream.flatMap(_.split(" "))
      .map((_,1))
      .reduceByKey(_+_)
      .print()

    // 开启任务
    ssc.start()
    ssc.awaitTermination()

  }

}

2.1.2、生产者生产数据

（1）kafka 端生产数据

启动 Kafka 集群

创建 Topic（指定一个分区三个副本）： 

kafka-topics.sh --bootstrap-server hadoop102:9092 --topic <topic名称> --create --partitions 1 --replication-factor 3

 查看是否生成 Topic：

kafka-topics.sh --bootstrap-server hadoop102:9092 --list

生产者生产数据：

> kafka-console-producer.sh --bootstrap-server hadoop102:9092 --topic <topic名称>
> hello world
> hello spark
> ...
（2）编写生产者程序
package com.lyh

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.kafka.common.serialization.StringDeserializer
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}

object SparkStreaming03_Kafka {

  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setMaster("local[*]").setAppName("kafka source")
    val ssc = new StreamingContext(conf,Seconds(3))

    // 定义Kafka参数: kafka集群地址、消费者组名称、key序列化、value序列化
    val kafkaPara: Map[String,Object] = Map[String,Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop104:9092",
      ConsumerConfig.GROUP_ID_CONFIG ->"lyh",
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer",
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer]
    )

    // 读取Kafka数据创建DStream
    val kafkaDStream: InputDStream[ConsumerRecord[String,String]] = KafkaUtils.createDirectStream[String,String](
      ssc,
      LocationStrategies.PreferConsistent,  //优先位置
      ConsumerStrategies.Subscribe[String,String](Set("testTopic"),kafkaPara) // 消费策略：（订阅多个主题，配置参数）
    )

    // 将每条消息的KV取出
    val valueDStream: DStream[String] = kafkaDStream.map(_.value())

    // 计算WordCount
    valueDStream.flatMap(_.split(" "))
      .map((_,1))
      .reduceByKey(_+_)
      .print()

   // 开启任务
    ssc.start()
    ssc.awaitTermination()

  }

}

3、转换操作

3.1、无状态转换操作

3.2、有状态转换操作

3.1.1、滑动窗口转换操作

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

object SparkStreaming05_Window {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("sparkStreaming window")
    val ssc = new StreamingContext(conf,Seconds(3))

    val lines:DStream[String] = ssc.socketTextStream("localhost", 9999)

    val word_kv = lines.map((_, 1))

    /**
     * 收集器收集RDD合成DStream: 3s 窗口范围: 12s 窗口滑动间隔: 6s/次
     * 1. windowLength：表示滑动窗口的长度，即窗口内包含的数据的时间跨度。它是一个Duration对象，用于指定窗口的时间长度。
     * 2. slideInterval：表示滑动窗口的滑动间隔，即每隔多长时间将窗口向右滑动一次。同样是一个Duration对象。
     * 返回一个新的 DStream
     **/
    val wordToOneByWindow:DStream[(String,Int)] = word_kv.window(Seconds(12), Seconds(6))

    // 窗口每滑动一次(6s),对窗口内的数据进行一次聚合操作.

    val res: DStream[(String,Int)] = wordToOneByWindow.reduceByKey(_ + _)

    res.print()

    ssc.start()
    ssc.awaitTermination()
  }
}

3.1.2、updateStateByKey

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

/**
 * DStream 有状态转换操作之 updateStateByKey(func) 转换操作
 */
object SparkStreaming04_State {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("kafka state")
    val ssc = new StreamingContext(conf,Seconds(3))

    /**
     * 设置检查点目录的作用是为了确保Spark Streaming应用程序的容错性和可恢复性。
     * 在Spark Streaming应用程序运行过程中，它会将接收到的数据分成一批批进行处理。
     * 通过设置检查点目录，Spark Streaming会定期将当前的处理状态、接收到的数据偏移量等信息保存到可靠的存储系统中，
     * 比如分布式文件系统（如HDFS）或云存储服务（如Amazon S3）。
     * 一旦应用程序出现故障或崩溃，它可以从最近的检查点中恢复状态，并从上次处理的位置继续处理数据，从而确保数据的完整性和一致性。
     */
    //检查点的路径如果是本地路径要+ file:// 否则认为是 hdfs路径 / 开头
    ssc.checkpoint("file:///D://IdeaProject/SparkStudy/data/")  //设置检查点,检查点具有容错机制

    val lines: DStream[String] = ssc.socketTextStream("localhost",9999)

    val word_kv = lines.map((_, 1))

    val stateDStream: DStream[(String, Int)] = word_kv.updateStateByKey(
      /** 参数是一个函数
       1. Seq[Int]: 当前key对应的所有value值的集合,因为我们的value是Int,所以这里也是Int
       2. Option[Int]: 当前key的历史状态,对于wordCount,历史值就是上一个DStream中这个key的value计算结果(求和结果)
       Option 是 Scala 中用来表示可能存在或可能不存在的值的容器，是一种避免空引用（null reference）问题的模式。
       Option[Int] 有两个可能的实例：
          (1) Some(value: Int)：表示一个包含 Int 类型值的 Option。
          (2) None：表示一个空的 Option，不包含任何值。
      **/
      (values: Seq[Int], state: Option[Int]) => {
        val currentCount = values.foldLeft(0)(_ + _)
        val previousCount = state.getOrElse(0)
        Option(currentCount + previousCount)
      }
    )

    stateDStream.print()
    stateDStream.saveAsTextFiles("./out") //输出结果保存到 文本文件中
    ssc.start()
    ssc.awaitTermination()
  }
}

4、输出操作

4.1、输出到文本文件

上面 3.1.2 中就保存DStream输出到了本地：

stateDStream.saveAstextFiles("./out")

4.2、输出到MySQL数据库

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

import java.sql.{Connection, PreparedStatement}

object NetWorkWordCountStateMySQL {

  def main(args: Array[String]): Unit = {

    val updateFunc = (values: Seq[Int],state: Option[Int]) => {
      val currentCount = values.foldLeft(0)(_+_)
      val previousCount = state.getOrElse(0)
      Some(currentCount + previousCount)
    }

    val conf = new SparkConf().setMaster("local[*]").setAppName("state mysql")
    val ssc = new StreamingContext(conf,Seconds(5))
    // file:\\ 代表本地文件系统 如果用的是 /user/... 这种形式是 HDFS 文件系统 需要启动Hadoop集群
    ssc.checkpoint("file:\\D:\\IdeaProjects\\SparkStudy\\data\\state")

    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
    val word_kv: DStream[(String, Int)] = lines.flatMap(_.split(" ").map((_, 1))).reduceByKey(_ + _)

    val stateDStream: DStream[(String, Int)] = word_kv.updateStateByKey[Int](updateFunc)
    stateDStream.print()

    stateDStream.foreachRDD( rdd=> {

      def func(records: Iterator[(String,Int)]): Unit ={
        var conn: Connection = null
        var stmt: PreparedStatement = null
        try{
          conn = DBUtils.getConnection("jdbc:mysql://127.0.0.1:3306/spark","root","Yan1029.")
          records.foreach(p=>{
            val sql = "insert into wordcount values (?,?)"
            stmt = conn.prepareStatement(sql)
            stmt.setString(1,p._1.trim)
            stmt.setInt(2,p._2)
            stmt.executeUpdate()    //不executeUpdate就不会写入数据库
          })
        }catch {
          case e: Exception => e.printStackTrace()
        }finally {
//          if (stmt!=null) stmt.close()
//          DBUtils.close()
        }
      }
      val repartitionedRDD: RDD[(String,Int)] = rdd.repartition(3)  //扩大分区用 repartition
      repartitionedRDD.foreachPartition(func)
    })
    ssc.start()
    ssc.awaitTermination()
  }

}

运行结果：

5、优雅的关闭和恢复数据

5.1、关闭SparkStreaming

        流式任务通常都需要7*24小时执行，但是有时涉及到升级代码需要主动停止程序，但是分布式程序，没办法做到一个个进程去杀死，所以配置优雅的关闭就显得至关重要了。
       关闭方式：我们通常使用外部文件系统来控制内部程序关闭。

package com.lyh

import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.fs.{FileSystem, Path}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.{Seconds, StreamingContext, StreamingContextState}

import java.net.URI

object SparkStreaming06_Close {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("sparkStreaming close")
    val ssc = new StreamingContext(conf,Seconds(3))

    val lines:DStream[String] = ssc.socketTextStream("localhost", 9999)
    val word_kv = lines.map((_, 1))

    word_kv.print()

    ssc.start()

    // 再创建一个线程去关闭
    new Thread(new MonitorStop(ssc)).start()

    ssc.awaitTermination()  //阻塞当前main线程
  }
}

class MonitorStop(ssc: StreamingContext) extends Runnable{
  override def run(): Unit = {
    while (true){ // 一直轮询判断
      Thread.sleep(5000)  //每5s检查一遍
      val fs: FileSystem = FileSystem.get(new URI("hdfs://hadoop102:9000"),new Configuration(),"lyh")
      val exists: Boolean = fs.exists(new Path("hdfs://hadoop102:9000/stopSpark"))
      if (exists) { //如果比如（MySQL出现了一行数据、Zookeeper的某个节点出现变化、hdfs是否存在某个目录...）就关闭
        val state: StreamingContextState = ssc.getState()
        if (state == StreamingContextState.ACTIVE){
          // 优雅地关闭-处理完当前的数据再关闭
          // 计算节点不再接受新的数据，而是把现有的数据处理完毕，然后关闭
          ssc.stop(true,true)
          System.exit(0)
        }
      }
    }
  }
}

5.2、恢复检查点的数据

使用 getActiveOrCreate 的方法来对上一个失败的 Spark 任务进行数据恢复（通过检查点来进行恢复）

方法说明：

        若Application为首次重启，将创建一个新的StreamingContext实例；如果Application从失败中重启，从checkpoint目录导入checkpoint数据来重新创建StreamingContext实例。

import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.{Seconds, StreamingContext, StreamingContextState}

import java.net.URI

object SparkStreaming07_Resume {
  def main(args: Array[String]): Unit = {

    //好处：若Application为首次重启，将创建一个新的StreamingContext实例；如果Application从失败中重启，从checkpoint目录导入checkpoint数据来重新创建StreamingContext实例。
    val ssc: StreamingContext = StreamingContext.getActiveOrCreate("file:\\D:\\IdeaProjects\\SparkStudy\\data\\state", () => {
      val conf = new SparkConf().setMaster("local[*]").setAppName("sparkStreaming resume")
      val ssc = new StreamingContext(conf, Seconds(3))

      val lines: DStream[String] = ssc.socketTextStream("localhost", 9999)
      val word_kv = lines.map((_, 1))

      word_kv.print()

      ssc
    })
    // 依然设置检查点 防止application失败后丢失数据
    ssc.checkpoint("file:\\D:\\IdeaProjects\\SparkStudy\\data\\state")

    ssc.start()
    ssc.awaitTermination()  //阻塞当前main线程
  }
}

让线程再跑一会
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spark sparkStreaming sparkMaven
03-24
SparkStreaming是Spark的一个核心组件，专门用于处理实时数据流。与传统的批处理不同，SparkStreaming支持微批处理，将实时数据流分割成小批次进行处理，这在一定程度上兼顾了实时性和容错性。而Maven是Java项目管理...
SparkStreaming编程讲解
01-30
1.什么是SparkStreaming？2.SparkStreaming可以接受那些数据源？3.Dstream，我们可以进行哪两种操作？Sparkstreaming:构建在Spark上处理Stream数据的框架，基本的原理是将Stream数据分成小的时间片断（几秒），以...
Spark Streaming 整体介绍
GIS摆渡人
12-22 667
1. 概要 Hadoop的MapReduce及Spark SQL等只能进行离线计算，无法满足实时性要求较高的业务需求，例如实时推荐，实时网站性能分析等，流式计算可以解决这些问题，spark Streaming就是现在常用的流式计算框架。作为spark的五大核心组件之一，spark Streaming原生地支持多种数据源的接入，而且可以与Spark MLLib、Graphx结合起来使用，具有...
SparkStreaming
m0_58421245的博客
11-15 833
一、SparkStreaming概述 1. 数据处理类型分类 - 静态数据 - 数据源是不变的、有限的、显式离散的 - 多适用于批量计算、离线计算 - 流数据 - 数据是变动的、无限的、连续的 - 多适用于实时计算，能在秒级、秒内处理完成 - 实时数据分类 - 小时级 - 分钟级 - 秒级 - sparkstreaming是什么 - 一句话总结：微批处理的流式（数据）实时计算框架 - 原理：是把输入数据以某一时间间隔批量的处理，当批处理...
Spark之Spark Streaming
lslslslslss的博客
02-18 2245
Spark Streaming是什么 Spark Streaming用于流式数据处理 DStream是什么 Spark Streaming使用离散化流作为抽象表示，称作DStream，是随着时间的推移而得到的数据的序列。在DStream内部，每个时间区间收到的数据都作为RDD存在，DStream就是由这些RDD所组成的序列，DStream就是对RDD在实时处理场景中的一种封装。 架构图 DStream的创建 1.通过RDD队列 ...
Spark Streaming
qw311113qin的博客
05-27 1395
离散流：连续不断流入的数据，按时间处理，比如，连续一分钟内收集的数据作为一个单元，单元之间是相互独立的，就是把连续不断的数据流，切出不同的离散分片。把数据进行离散化处理；DStream是Spark Streaming特有的数据类型，代表一系列连续的RDD，可以看做一组RDDs，即RDD的一个序列，相当于是在RDD的基础上做了对时间的依赖。小方块代表一个数据，虚线与虚线之间代表数据窗口，比如说一分钟，五分钟等，在时间创建内，把小数据积累起来，构成大的批量数据文件，多个小数据块DAG汇聚成的大数据流DAG；
spark sparkStreaming思维导图
hongchenshijie的博客
05-11 628
大纲如下: 部分详情如下: 自己整理的一份spark_streaming 思维导图,后续还会有其它的思维导图分享,尽请期待!!! 如有需要原文件欢迎给我浏览,留下邮箱等联系方式!!! 最后也就是最重要的一点: 制作不易,可以的话给个点赞关注加收藏!!! ...
Spark Streaming提取数据
jiandanbuguo的博客
01-03 1332
一、简介 Spark Streaming是一个从各种来源获取实时流数据的框架。它支持的流资包括HDFS、Kafka、Flume以及自定义流等。Spark Streaming操作可以从故障中自动恢复，这对于在线数据处理十分重要。Spark Streaming表示使用离散流（DStream）的流数据，该数据流周期性的创建包含最后一个时间窗口中进入的数据的RDD. Spark Streaing可以与单个程序中的其他Spark组建结合，将实时处理与机器学习、SQL和图形操作统一起来。从Spark2.0开始，新的结构
SparkStreaming 详解
静远小和尚的博客
07-28 1733
原文链接：https://www.toutiao.com/i6854493461903901197/ 本文主要从以下几个方面介绍SparkStreaming: 一、SparkStreaming是什么 二、SparkStreaming支持的业务场景 三、SparkStreaming的相关概念 四、DStream介绍 五、SparkStreaming的机制 六、SparkStreaming的Demo 一、SparkStreaming是什么 在讲sparkStreaming是什么之前首先讲一下为
Spark Streaming及示例
Joker_Jiang3的博客
07-05 1268
Spark Streaming及示例 一、Spark Streaming介绍 Spark Streaming是近实时(near real time)的小批处理系统 。Spark Streaming是Spark core API的扩展，支持实时数据流的处理，并且具有可扩展，高吞吐量，容错的特点。 数据可以从许多来源获取，如Kafka，Flume，Kinesis或TCP sockets，并且可以使用复杂的算法进行处理，这些算法使用诸如map，reduce，join和window等高级函数表示。 最后，处理后的数
Spark Streaming 总结
机械工程跑路哥
09-12 2297
Spark Streaming 是什么 **SparkStreaming**就是将连续的数据 **持久化**，**离散化**，然后进行**批量处理**的框架； **SparkStreaming**是**准实时**（秒级别）、**微批次**的数据处理框架；
Spark Streaming基本概念
晓晓的天空
03-20 1649
Spark Streaming基本概念
SparkStreaming入门案例
06-22
Spark Streaming 入门案例 Spark Streaming 是一种构建在 Spark 上的实时计算框架，用来处理大规模流式数据。它将从数据源（如 Kafka、Flume、Twitter、ZeroMQ、HDFS 和 TCP 套接字）获得的连续数据流，离散化成一...
Spark Streaming 示例
04-03
`SparkStreaming.zip` 文件可能包含了一个示例项目，演示了如何创建一个 Spark Streaming 应用来从 Kafka 消费数据。代码通常会包含以下步骤： 1. 创建 SparkConf 对象，配置 Spark 应用的属性，如应用程序名称、...
spark shell
最新发布
m0_74934794的博客
07-19 263
2.1.1读取linux文件系统的文件创建RDD。2.1.2读取hdfs文件系统上的文件创建RDD。--需要保证每一个worker中都有该文件。--过滤数据,保留每行中含有hello的数据。2.2使用Parallelize创建RDD。2.3从其他的RDD中创建新的RDD。--对RDD中的数据进行过滤操作。--统计RDD中的数据记录表。2.1 读取文件创建RDD。--读取RDD的第一条数据。4.实现wordcount。1.进行shell命令行。3.对RDD进行操作。--读取中的N条数据。
从数据湖到湖仓一体：统一数据架构演进之路
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
07-17 1362
本文详细探讨了从数据湖到湖仓一体的演进过程及其在现代数据管理中的重要性。湖仓一体由Databricks于2020年提出，旨在融合数据湖和数据仓库的优势，通过无缝集成，实现数据存储和管理的统一架构。 湖仓一体的出现主要是为了降低成本和解决数据孤岛问题。传统的数据湖和数据仓库各自独立建设，导致重复投资和数据管理上的困难，而湖仓一体通过简化基础架构、提升数据存储弹性和质量，有效减少了这些问题。
《基于 CDC、Spark Streaming、Kafka 实现患者指标采集》
山人行
07-18 1381
本篇文章分享一下博主所在公司的患者指标采集的解决方案。主要是基于实现，由于涉及公司隐私，内容主要以方案介绍为主，有需要探讨的可以留言。好，让我们开始。上文介绍了博主所在公司的《基于 CDC、Spark Streaming、Kafka 实现患者指标采集》方案。💗 后续会逐步分享企业实际开发中的实战经验，有需要交流的可以联系博主。
通过 EMR Serverless Spark 提交 PySpark 流任务
科技很有意思
07-19 745
本文将指导您使用EMR Serverless Spark提交PySpark流式任务，展示其在流处理方面的易用性和可运维性。
【分布式计算框架MapReduce和Spark】使用MapReduce和Spark进行大数据处理
weixin_39372311的博客
07-19 1257
MapReduce是由Google提出的一个分布式计算模型，用于处理大规模数据集。其核心思想是将复杂的计算任务分解为简单的Map和Reduce两个阶段，通过分布式计算提高处理效率。Spark是一个快速、通用的分布式计算系统，最初由加州大学伯克利分校的AMPLab开发，现由Apache基金会维护。Spark基于内存计算，具有比MapReduce更高的处理速度和更丰富的API。
深入理解Spark Structured Streaming
"Spark Streaming是Apache Spark项目中的一个模块，用于处理实时数据流。它提供了一个高级抽象，允许开发者以类似批处理的方式编写流处理应用程序，从而实现高吞吐量和容错性。随着Spark的发展，Structured ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

让线程再跑一会

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值