Spark Streaming

最新推荐文章于 2023-03-20 14:00:38 发布
最新推荐文章于 2023-03-20 14:00:38 发布
阅读量199 收藏
点赞数
分类专栏： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44809337/article/details/112298541
版权

Spark Streaming

一、Spark Streaming

1.1 流处理介绍

  • 流处理特点
（1）输入持续，计算结果持续输出的,实时性要求较高(永远拿不到全量数据去做计算)
（2）先定义计算逻辑，数据到来之后将计算逻辑应用于数据。
  • 批量处理特点
(1)、先有全量数据集，后定义计算逻辑，并将计算逻辑应用于全量数据，计算结果一
     次性全量输出。
  • Spark Streaming 优缺点
1、底层使用批处理模拟流计算。导致了Spark Streaming在流处理领域有者着先天的劣势。
2、可实现实时数据流的可扩展，高吞吐量，容错流处理
3、虽然Spark Streaming 在实时性上不如一些专业的流处理引擎(Storm/Flink)，但是
   Spark Stream在使用吸取RDD设计经验，提供了比较友好的API算子，使得使用RDD做
   批处理的程序员可以平滑的过渡到流处理。

在这里插入图片描述

  • 数据来源可从（如Kafka，Flume，Kinesis或TCP套接字）中获取，
    在这里插入图片描述
    在这里插入图片描述
    Spark Streaming提供称为离散流或DStream的高级抽象，表示连续的数据流。
	DStream可以从来自Kafka，Flume和Kinesis等源的输入数据流创建，也可以通过在
其他DStream上应用高级操作来创建。在内部DStream表示为一系列RDD

1.2 socketTextStream(快速入门)

  • pom.xml
	<dependency>
	    <groupId>org.apache.spark</groupId>
	    <artifactId>spark-core_2.11</artifactId>
	    <version>2.4.3</version>
	</dependency>
	<dependency>
	    <groupId>org.apache.spark</groupId>
	    <artifactId>spark-streaming_2.11</artifactId>
	    <version>2.4.3</version>
	</dependency>
  • SparkStreamWordCounts
	/**
	  * 1、环境 linux--数据来源  netcat
	  * --[root@CentOS ~]# yum install -y nc
	  * --启动nc服务[root@CentOS ~]# nc -lk 9999
	  * 2、状态的管理  无
	  * 3、数据的持久化 无
	  * 4、目的-- 完成指定的时间间隔--数据单词的统计
	  */
object SparkStreamWordCounts01 {
  def main(args: Array[String]): Unit = {
    //    申请两个计算进程（workNode）----
    val conf = new SparkConf()
    		    //设置处理时间的时间间隔
     			.setMaster("local[2]")
     			//appName参数是应用程序在集群UI上显示的名称
     			.setAppName("NetworkWordCount")
   
   //初始化 StreamingContext :要初始化Spark Streaming程序，必须创建一个StreamingContext对象，它是所有Spark Streaming功能的主要入口点
   //注意ssc会在内部创建一个SparkContext（所有Spark功能的起点），如果需要获取SparkContext对象用户可以调用ssc.sparkContext访问,如用户使用SparkContext关闭日志
   
    val ssc = new StreamingContext(conf, Seconds(5))

    // 设置流的数据来源
    ssc.socketTextStream("CentOS61", 9888)
      .flatMap(_.split(" "))
      .map((_, 1))
      .reduceByKey(_+_)
      .print()

    ssc.sparkContext.setLogLevel("FATAL") //关闭日志打印
    ssc.start()
    ssc.awaitTermination()
  }
}
    
需要注意：[root@CentOS ~]# yum install -y nc启动nc服务
         [root@CentOS ~]# nc -lk 9999,注意在调用改程序的时候，需要设置local[n],n>1

1.3 开发步骤

  • 创建 StreamingContext。
  • 必须根据应用程序的延迟要求和可用的群集资源设置批处理间隔。要使群集上运行的Spark Streaming应用程序保持稳定，系统应该能够以接收数据的速度处理数据。换句话说，批处理数据应该在生成时尽快处理。通过监视流式Web UI中的处理时间可以找到是否适用于应用程序，其中批处理时间应小于批处理间隔。
val conf = new SparkConf()
.setMaster("local[5]")
.setAppName("wordCount")
val sc = new SparkContext(conf)
val ssc = new StreamingContext(sc,Seconds(1))
  • 当用户创建完StreamingContext对象之后，用户需要完成以下步骤
- 定义数据源，用于创建输入的 DStreams.
- 定义流计算算子，通过定义这些算子实现对DStream数据转换和输出
- 调用streamingContext.start()启动数据.
- 等待计算结束 (人工结束或者是错误) 调用 streamingContext.awaitTermination().
- 如果是人工结束，程序应当调用 streamingContext.stop()结束流计算.
  • 重要因素需留意
  • 一旦流计算启动，无法再往计算流程中添加计算算子
  • 一旦SparkContext对象被stop后，无法重启。
    *一个JVM系统中只能实例化一个StreamingContext对象。
  • SparkContext被stop()后，内部创建的SparkContext也会被stop.如果仅仅是想Stop StreamingContext, 可以设置stop() 中的可选参数 stopSparkContext=false即可.
  ssc.stop(stopSparkContext = false)

  • 一个SparkContext 可以重复使用并且创建多个StreamingContexts, 前提是上一个启动的StreamingContext 被停止了(但是并没有关闭 SparkContext对象) 。

  • Discretized Streams (DStreams) ，Discretized Stream或DStream是Spark Streaming提供的基本抽象。它表示连续的数据流，可以是从源接收的输入数据流，也可以是通过转换输入流生成的已处理数据流。在内部，DStream由一系列连续的RDD表示，这是Spark对不可变分布式数据集的抽象。DStream中的每个RDD都包含来自特定时间间隔的数据，如下图所示。
    在这里插入图片描述

  • 应用于DStream的任何操作都转换为底层RDD上的操作。例如，在先前Quick Start示例中，flatMap操作应用于行DStream中的每个RDD以生成单词DStream的RDD。如下图所示。
    在这里插入图片描述

  • 这些底层RDD转换由Spark引擎计算。 DStream操作隐藏了大部分细节，并为开发人员提供了更高级别的API以方便使用。

1.4 InputStream & Receivers

  • Input DStream 表示流计算的输入，Spark中默认提供了两类的InputStream：
  • Baisc Source ：例如 filesystem、scoket
  • Advance Source：例如：Kafka、Flume等外围系统的数据。
  • 除filesystem以外，其他的Input DStream默认都会占用一个Core(计算资源)，在测试或者生产环境下，分配给计算应用的Core数目必须大于Receivers个数。（本质上除filesystem源以外，其他的输入都是Receiver抽象类的实现。），例如socketTextStream底层封装了SocketReceiver

1.4.1 Basic Sources

 val conf = new SparkConf().setMaster("local[2]").setAppName("FileSystemWordCount")
    val ssc = new StreamingContext(conf, Seconds(5))
    ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印

    val lines = ssc.textFileStream("hdfs://CentOS:9000/demo/words")

    lines.flatMap(_.split(" "))
      .map((_,1))
      .reduceByKey(_+_)
      .print()

    ssc.start()
    ssc.awaitTermination()

1.4.2 Queue of RDDs as a Stream(测试)

  • 为了使用测试数据测试Spark Streaming应用程序，还可以使用streamingContext.queueStream（queueOfRDDs）基于RDD队列创建DStream。推入队列的每个RDD将被视为DStream中的一批数据，并像流一样处理。
val conf = new SparkConf().setMaster("local[2]").setAppName("FileSystemWordCount")
val ssc = new StreamingContext(conf, Seconds(1))
ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印

val queue=new mutable.Queue[RDD[String]]();
val lines = ssc.queueStream(queue)

lines.flatMap(_.split(" "))
.map((_,1))
.reduceByKey(_+_)
.print()

ssc.start()
for(i <- 1 to 30){
    queue += ssc.sparkContext.makeRDD(List("this is a demo","hello how are you"))
    Thread.sleep(1000)
}
ssc.stop()

1.4.3Advance Source Kafka

  • Kafka对接Spark Streaming
  • pom.xml
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
    <version>2.4.3</version>
</dependency>

val conf = new SparkConf().setMaster("local[2]").setAppName("FileSystemWordCount")
    val ssc = new StreamingContext(conf, Seconds(1))
    ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印

    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "CentOS:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "group1",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )

    KafkaUtils.createDirectStream(ssc,
      LocationStrategies.PreferConsistent,//设置加载数据位置策略，
      Subscribe[String,String](Array("topic01"),kafkaParams))
        .map(record => record.value())
        .flatMap(_.split(" "))
        .map((_,1))
        .reduceByKey(_+_)
        .print()

    ssc.start()
    ssc.awaitTermination()

1.4.3 动态的数据 kafka 和静态的数据，两个流的合并

package com.baizhi.demo02

import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.apache.spark.streaming.kafka010.{KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * 1、需求： 动态的数据 kafka 和静态的数据 ，两个流的合并
  * 2、数据的来源
  * --动态的数据 kafka
  * --静态的数据 程序内部产生（客户的信息）
  * 3、结果集的处理
  * --打印输出
  *   CentOS61
  * [root@CentOS ~]# start-dfs.sh
  * [root@CentOS ~]# start-yarn.sh
  * [root@CentOSX ~]# /usr/zookeeper-3.4.6/bin/zkServer.sh start zoo.cfg
  * [root@CentOSX ~]# cd /usr/kafka_2.11-2.2.0
  * [root@CentOSX kafka_2.11-2.2.0]# ./bin/kafka-server-start.sh -daemon config/server.properties
  * [root@CentOS61 kafka_2.11-2.2.0]#  ./bin/kafka-topics.sh --zookeeper CentOS61:2181 --list
  *
  * [root@CentOS61 kafka_2.11-2.2.0]#
  *   ./bin/kafka-console-producer.sh --broker-list CentOS61:9092 --topic topic01
  * [root@CentOSA kafka_2.11-2.2.0]#
  *   ./bin/kafka-console-consumer.sh  --bootstrap-server CentOS61:9092 --topic topic01

  */
object SparkStreamWordCounts {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
    val ssc = new StreamingContext(conf, Seconds(1))

    //    kafka的链接参数
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "CentOS61:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "group1",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )

    //    静态的数据--客户的信息
    val cacheRDD = ssc.sparkContext.makeRDD(List("001 zhangsan", "002 lisi", "003 zhaoliu"))
      .map(item => (item.split("\\s+")(0), item.split("\\s+")(1)))
      .distinct()
      .cache()

    //001 apple
    KafkaUtils.createDirectStream(ssc, LocationStrategies.PreferConsistent, Subscribe[String, String](Array("topic01"), kafkaParams))
      .map(record => record.value())
      .map(value => {
               val tokens = value.split("\\s+")
              (tokens(0), tokens(1))})

      //该算子可以将DStream的数据转变成RDD，用户操作流数据就像操作RDD感觉是一样的
      .transform(rdd => {rdd.rightOuterJoin(cacheRDD)}) //流的合并
      .filter(t => {t._2._1 != None})
      .print() //  结果 (001,(Some(apple),zhangsan))


    ssc.sparkContext.setLogLevel("FATAL") //关闭日志打印
    ssc.start()
    ssc.awaitTermination()
  }
}

二 、Spark Stream 算子

2.1 transform(func)

  • 改算子可以将DStream的数据转变成RDD，用户操作流数据就像操作RDD感觉是一样的。
 val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
      val ssc = new StreamingContext(conf, Seconds(1))
      val kafkaParams = Map[String, Object](
        "bootstrap.servers" -> "CentOS:9092",
        "key.deserializer" -> classOf[StringDeserializer],
        "value.deserializer" -> classOf[StringDeserializer],
        "group.id" -> "group1",
        "enable.auto.commit" -> (false: java.lang.Boolean)
      )
   
    val cacheRDD = ssc.sparkContext.makeRDD(List("001 zhangsan", "002 lisi", "003 zhaoliu"))
      .map(item => (item.split("\\s+")(0), item.split("\\s+")(1)))
      .distinct()
      .cache()
      
      //001 apple
      KafkaUtils.createDirectStream(ssc,
        LocationStrategies.PreferConsistent,
        Subscribe[String,String](Array("topic01"),kafkaParams))
        .map(record => record.value())
        .map(value=>{
          val tokens = value.split("\\s+")
          (tokens(0),tokens(1))
        })
       .transform(rdd=>{rdd.rightOuterJoin(cacheRDD)})
       .filter(t=> {t._2._1!=None})
       .print()

    ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
    ssc.start()
    ssc.awaitTermination()

2.2 UpdateStateByKey (完成流的单词计数统计)

  • 结果全量输出
/**
  *  1、环境 linux--数据来源  netcat
  *     --[root@CentOS ~]# yum install -y nc
  *     --启动nc服务[root@CentOS ~]# nc -lk 9999
  *
  *  2、结果：完成数据的统计计数（程序启动开始的，所有的数据）
  *   如：
  *      this is book
  *         (this 1)
  *         (is 1)
  *         (book 1)
  *      this is book
  *         (this 2)
  *         (is   2)
  *         (book 2)
  *      this is book
  *        (this 2)
  *        (is   2)
  *        (book 2)
  * 3、数据的储存 hdfs
  * --(缺点)关闭程序，数据丢失无法从hdfs中获取
  * */
object SparkStreamWordCounts01 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
    val ssc = new StreamingContext(conf, Seconds(5))

    //将状态临时存入HDFS目录中。//在JVM启动参数中添加-DHADOOP_USER_NAME=root（解决权限的问题）.
    ssc.checkpoint("hdfs://CentOS61:9000/checkpoints")

    def updateFun(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
      var total = newValues.sum + runningCount.getOrElse(0)
      Some(total)
    }

    ssc.socketTextStream("CentOS61", 9999)
      .flatMap(_.split("\\s+"))
      .map((_, 1))
      .updateStateByKey(updateFun) //状态的 从初始开始计数 保存当前系统的数据
      .print()

    ssc.sparkContext.setLogLevel("FATAL") //关闭日志打印
    ssc.start()
    ssc.awaitTermination()
  }
}
* 因为UpdateStateByKey 算子每一次的输出都是全量输出，在做状态更新的时候代价较高，
* 因此推荐大家使用mapWithState

2.3 mapWithState(完成流的单词计数统计,)

  • 结果局部输出
/**
  * 1、需求：完成数据的统计计数
  * 2、数据的来源 -netcat
  *                [root@CentOS ~]# yum install -y nc
  *    启动nc服务   [root@CentOS ~]# nc -lk 9999
  * 3、数据的储存 -hdfs
  * --关闭程序，数据丢失无法 从hdfs 中获取
  * --展示的是，修改的数据
  * 4、环境 netcat hdfs
  *
  * 5 结果：完成数据的统计计数（程序启动开始的，输出局部的数据）
  *  如：输入 this is book
  *         (this 1)
  *         (is 1)
  *         (book 1)
  *
  *      输入  this
  *      输出 （this，2）
  *
  */
object SparkStreamWordCounts02 {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")

    val ssc = new StreamingContext(conf, Seconds(1))
    ssc.checkpoint("hdfs://CentOS61:9000/checkpoints")

    ssc.socketTextStream("CentOS61", 9999)
      .flatMap(_.split("\\s+"))
      .map((_, 1))
      //展示跟新的数据(区别，updateStateByKey展示所有的结果，数据量大时，不满足业务场景)
      .mapWithState(StateSpec.function((k: String, v: Option[Int], state: State[Int]) => {
      var total = 0
      if (state.exists()) {
        total = state.getOption().getOrElse(0)//历史值
      }
      total += v.getOrElse(1)//当前值
      state.update(total) //持久化状态

      (k, total)
    })).print()

    ssc.sparkContext.setLogLevel("FATAL") //关闭日志打印
    ssc.start()
    ssc.awaitTermination()
  }
}

2.4 mapWithState(重启中恢复状态)

/**
  * 1、重启中恢复hdfs（本地）状态
  * 2、数据来源 netcat
  *                      [root@CentOS ~]# yum install -y nc
  *          启动nc服务   [root@CentOS ~]# nc -lk 9999
  * 3、数据存放的位置 hdfs 或者本地
  * 4、设置checkpointPath--具有数据的持久化，关闭程序 下一次重启，数据可读取先前的状态
  * 5 结果：完成数据的统计计数（程序启动开始的，输出局部的数据）
  *   如：输入 this is book
  *         (this 1)
  *          (is 1)
  *          (book 1)
  *          
  *       输入  this
  *       输出 （this，2）
  *
  */

object SparkStreamWordCounts {
  def main(args: Array[String]): Unit = {
    var checkpointPath = "hdfs://CentOS61:9000/checkpoints"
    //var checkpointPath="file:///F:/checkpoints"

    var ssc = StreamingContext.getOrCreate(checkpointPath, () => {
     //创建过不会初始化，删除目录会自动创建目录并初始化检查点
     //第一次启时候初始化，一旦程序书写完成后，无法进行修改。
     //如关闭程序，注释print() 重启应用，则会继续的进行响应的打印。
      println("=======init=======")
      val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
      val ssc = new StreamingContext(conf, Seconds(5)) //--设置处理时间的时间间隔

      ssc.checkpoint(checkpointPath)
      ssc.socketTextStream("CentOS61", 9999)
        .flatMap(_.split("\\s+"))
        .map((_, 1))
         //如果数据有，恢复原有的数据，没有则执行新增存储结果值。
        .mapWithState(StateSpec.function((k: String, v: Option[Int], state: State[Int]) => {
          var total = 0
          if (state.exists()) {
            total = state.getOption().getOrElse(0)
          }
          total += v.getOrElse(1)
          state.update(total) //跟新状态
          (k, total)
        }))
        设置状态持久化的频率，改频率不能高于 微批 拆分频率 ts>=5s
        .checkpoint(Seconds(5))
        .print()
      ssc
    })

    ssc.sparkContext.setLogLevel("FATAL") //关闭日志打印
    ssc.start()
    ssc.awaitTermination()
  }
}

2.5 Output Operations（输出操作foreachRDD）

/**
  * 1、数据来源 netcat
  * 2、状态的持久化 --redis--
  *
  */
object SparkStreamWordCounts {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
    val ssc = new StreamingContext(conf, Seconds(1)) //批次一秒

    ssc.socketTextStream("CentOS61", 9999)
      .flatMap(_.split("\\s+"))
      .map((_, 1))
      .window(Seconds(5), Seconds(5)) //窗口的长度，滑动的频率
      .reduceByKey((v1: Int, v2: Int) => v1 + v2)
      .foreachRDD(rdd => { // 最常用的输出算子 --foreachPartition 拿每个分区的数据
        rdd.foreachPartition(items => {
          //状态的持久化 --redis--
          var jedisPool = new JedisPool("CentOS61", 6379)
          val jedis = jedisPool.getResource
          val pipeline = jedis.pipelined() //jedis批处理
          val map = items.map(t => (t._1, t._2 + "")).toMap.asJava
          pipeline.hmset("wordcount", map)
          pipeline.sync()
          jedis.close()
        })
      })

    ssc.sparkContext.setLogLevel("FATAL") //关闭日志打印
    ssc.start()
    ssc.awaitTermination()
  }
}
  • 安装redis
    在这里插入图片描述
    *上传redis，执行make命令
    8 在这里插入图片描述
  • 修改配置文件
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  • 后台运行
    在这里插入图片描述
  • 启动redis服务
    在这里插入图片描述
  • 运行结果
    在这里插入图片描述

三 、window（窗口 ）

在这里插入图片描述

3.1 滑动窗口

  • 注意：Spark的流处理中要求窗口的长度以及滑动间隔必须是微批的整数倍。
	窗口长度=滑动时间
	一个tuple只属于一个窗口

3.2 滚动窗口

	窗口长度   ！=  滑动时间
	一个tuple可以属于多个窗口


val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
    val ssc = new StreamingContext(conf, Seconds(1))//批次一秒
    ssc.socketTextStream("CentOS",9999)
      .flatMap(_.split("\\s+"))
      .map((_,1))
       //5个批次为窗口的长度，滑动的频率为5。
      .reduceByKeyAndWindow((v1:Int,v2:Int)=> v1+v2,Seconds(5),Seconds(5))
      .print()

    ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
    ssc.start()
    ssc.awaitTermination()
~chun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark Streaming概述
m0_67806453的博客
06-20 716
目录一，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开发基础
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
07-03 517
大数据实验教学系统Spark Streaming开发基础Spark Core它的核心就是RDD，对于Spark Streaming来说，它的核心是DStream，DStream类似于RDD，它实质上一系列的RDD的集合，DStream可以按照秒数将数据流进行批量的划分。首先从接收到流数据之后，将其划分为多个batch，然后提交给Spark集群进行计算，最后将结果批量输出到HDFS或者数据库以及前端页面展示等等。图2 Spark Streaming原理   Spark Streaming有以下特点：   1、
SparkStreaming
m0_58421245的博客
11-15 758
一、SparkStreaming概述 1. 数据处理类型分类 - 静态数据 - 数据源是不变的、有限的、显式离散的 - 多适用于批量计算、离线计算 - 流数据 - 数据是变动的、无限的、连续的 - 多适用于实时计算，能在秒级、秒内处理完成 - 实时数据分类 - 小时级 - 分钟级 - 秒级 - sparkstreaming是什么 - 一句话总结：微批处理的流式（数据）实时计算框架 - 原理：是把输入数据以某一时间间隔批量的处理，当批处理...
Spark Streaming 总结
机械工程跑路哥
09-12 2014
Spark Streaming 是什么 **SparkStreaming**就是将连续的数据 **持久化**，**离散化**，然后进行**批量处理**的框架； **SparkStreaming**是**准实时**（秒级别）、**微批次**的数据处理框架；
Spark Streaming提取数据
jiandanbuguo的博客
01-03 1276
一、简介 Spark Streaming是一个从各种来源获取实时流数据的框架。它支持的流资包括HDFS、Kafka、Flume以及自定义流等。Spark Streaming操作可以从故障中自动恢复，这对于在线数据处理十分重要。Spark Streaming表示使用离散流（DStream）的流数据，该数据流周期性的创建包含最后一个时间窗口中进入的数据的RDD. Spark Streaing可以与单个程序中的其他Spark组建结合，将实时处理与机器学习、SQL和图形操作统一起来。从Spark2.0开始，新的结构
SparkStreaming 详解
静远小和尚的博客
07-28 1618
原文链接：https://www.toutiao.com/i6854493461903901197/ 本文主要从以下几个方面介绍SparkStreaming: 一、SparkStreaming是什么 二、SparkStreaming支持的业务场景 三、SparkStreaming的相关概念 四、DStream介绍 五、SparkStreaming的机制 六、SparkStreaming的Demo 一、SparkStreaming是什么 在讲sparkStreaming是什么之前首先讲一下为
【Spark Streaming】Spark Streaming的使用
依旧的博客
04-21 4956
一、Spark Streaming引入 集群监控 一般的大型集群和平台, 都需要对其进行监控的需求。 要针对各种数据库, 包括 MySQL, HBase 等进行监控 要针对应用进行监控, 例如 Tomcat, Nginx, Node.js 等 要针对硬件的一些指标进行监控, 例如 CPU, 内存, 磁盘 等 Spark Streaming介绍 官网：http://spark.apac...
07-SparkStreaming
PenguinLittle的博客
03-22 2176
07-Spark Streaming 1.目标 掌握spark Streaming的原理和架构 掌握DStream的相关操作 实现spark Streaming与flume整合 实现spark Streaming与kafaka整合 2.spark Streaming介绍 2.1.什么是spark Streaming spark Streaming类似于Apache Storm，用于流式数据处理。根据官方文档介绍，spark Streaming有高吞吐量和容错能力强等特点。 spark S
Spark Streaming基本概念
晓晓的天空
03-20 1592
Spark Streaming基本概念
spark streaming
03-14
spark streaming streaming
sparkstreaming.zip
11-27
java的sparkstreaming连接kafka的例子，kafka生产者生产消息，消费者读取消息，sparkstreaming读取kafka小区并进行存储iotdb数据库。
SparkStreaming编程讲解
01-30
1.什么是SparkStreaming？2.SparkStreaming可以接受那些数据源？3.Dstream，我们可以进行哪两种操作？Sparkstreaming:构建在Spark上处理Stream数据的框架，基本的原理是将Stream数据分成小的时间片断（几秒），以...
基于多种编程语言的卡拉音乐播放器设计源码
05-28
本项目是基于多种编程语言的卡拉音乐播放器设计源码，包含625个文件，其中包括389个JavaScript文件、70个TypeScript文件、52个PNG图像文件、22个JSON配置文件、19个Vue文件、12个MAP文件、11个WXSS样式文件、9个WXML模板文件、7个SVG文件和5个EOT字体文件。系统专注于提供卡拉音乐播放器功能，支持歌曲播放、播放列表管理等功能，为用户提供了一个稳定、高效的卡拉音乐播放器。
QTabWidget实现的炫酷标签工具栏+源码
05-28
qt 用法链接：https://menghui666.blog.csdn.net/article/details/139276655?spm=1001.2014.3001.5502 该项目基于QTabWidget和QTabBar实现了灵活的标签工具栏，主要包含如下功能： 1、标签栏可以收起，可以展开 2、可以在标签栏中添加新的标签界面 3、可以从标签工具栏中把界面拖出来，也可以拖回去 4、关闭拖出来的界面会自动回到标签工具栏 5、可以调换标签工具栏中界面的顺序
VB学生公寓管理系统(源代码+论文).rar
05-28
计算机专业毕业设计VB精品论文资源
基于springboot的高校心理教育辅导管理系统
05-28
开发语言：Java JDK版本：JDK1.8（或11） 服务器：tomcat 数据库：mysql 5.6/5.7（或8.0） 数据库工具：Navicat 开发软件：idea 依赖管理包：Maven 代码+数据库保证完整可用，可提供远程调试并指导运行服务（额外付费）～ 如果对系统的中的某些部分感到不合适可提供修改服务，比如题目、界面、功能等等... 声明： 1.项目已经调试过，完美运行 2.需要远程帮忙部署项目，需要额外付费 3.本项目有演示视频，如果需要观看，请联系我v:19306446185 4.调试过程中可帮忙安装IDEA，eclipse，MySQL，JDK，Tomcat等软件 重点： 需要其他Java源码联系我，更多源码任你选，你想要的源码我都有！ https://img-blog.csdnimg.cn/direct/e73dc0ac8d27434b86d886db5a438c71.jpeg
debugpy-1.0.0b1-cp34-cp34m-manylinux1_x86_64.whl
最新发布
05-28
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值