五.SparkStreaming

最新推荐文章于 2024-07-11 16:34:57 发布
最新推荐文章于 2024-07-11 16:34:57 发布
阅读量153 收藏
点赞数
分类专栏： Spark 文章标签： 大数据 spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44865574/article/details/107049836
版权

五.SparkStreaming

一.SparkStreaming概述
1. SparkStreaming是什么?

Spark Streaming用于流式数据的处理。Spark Streaming支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。

数据输入后可以用Spark的高度抽象原语如：map、reduce、join、window等进行运算。而结果也能保存在很多地方，如HDFS，数据库等。

和Spark基于RDD的概念很相似，Spark Streaming使用离散化流(discretized stream)作为抽象表示，叫作DStream。

DStream 是随时间推移而收到的数据的序列。在内部，每个时间区间收到的数据都作为 RDD 存在，而DStream是由这些RDD所组成的序列(因此得名“离散化”)。

2. SparkStreaming特点
  1. 易用
  2. 容错
  3. 易整合到Spark体系
3. SparkStreaming架构

二. Dstream
1. WordCount 实操
  1. 添加sparkStream 依赖
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.11</artifactId>
    <version>2.1.1</version>
</dependency>
  1. 编写代码
/**
  * Spark Streaming WordCount
  */
object A_HelloWorld {
  def main(args: Array[String]): Unit = {
    //1.初始化SparkConf
    val conf: SparkConf = new SparkConf()
      .setMaster("local[3]")
      .setAppName("Spark Streaming Demo")
    //2.实时数据分析环境对象
    //采集周期：以指定的时间为周期采集实时数据
    val ssc = new StreamingContext(conf, Seconds(5))
    //远程监控端口  nc -lk 9998
    val rid: ReceiverInputDStream[String] = ssc.socketTextStream("192.168.0.112", 9998)
    //解析
    val dstream: DStream[String] = rid.flatMap(_.split(" "))
    val dstream2: DStream[(String, Int)] = dstream.map((_, 1)).reduceByKey(_ + _)
    dstream2.print()

    //启动SparkStreaming最重要的设置
    //1.启动采集器
    ssc.start()
    //2.driver等待采集器执行
    ssc.awaitTermination()

  }
}
2. Dstream 创建
2.1 文件数据源

文件数据流：能够读取所有HDFS API兼容的文件系统文件，通过fileStream方法进行读取，Spark Streaming 将会监控 dataDirectory 目录并不断处理移动进来的文件，记住目前不支持嵌套目录。

streamingContext.textFileStream(dataDirectory)

注意事项：

  1. 文件需要有相同的数据格式；

  2. 文件进入 dataDirectory的方式需要通过移动或者重命名来实现；

  3. 一旦文件移动进目录，则不能再修改，即便修改了也不会读取新数据；

/**
  * 从File中采集数据
  */
object B_FileDataSource {
  def main(args: Array[String]): Unit = {
    //1.初始化SparkConf
    val conf: SparkConf = new SparkConf()
      .setMaster("local[3]")
      .setAppName("Spark Streaming Demo")
    //2.实时数据分析环境对象
    //采集周期：以指定的时间为周期采集实时数据
    val ssc = new StreamingContext(conf,Seconds(5))
    //远程监控端口
    val rid: DStream[String] = ssc.textFileStream("in/sparkstream/test")


    //解析
    val dstream: DStream[String] = rid.flatMap(_.split(" "))
    val dstream2: DStream[(String, Int)] = dstream.map((_,1)).reduceByKey(_+_)
    dstream2.print()

    //启动SparkStreaming最重要的设置
    //1.启动采集器
    ssc.start()
    //2.driver等待采集器执行
    ssc.awaitTermination()

  }
}
2.2 RDD队列

使用ssc.queueStream(queueOfRDDs)来创建DStream，每一个推送到这个队列中的RDD，都会作为一个DStream处理

/**
  * 循环创建几个RDD，将RDD放入队列。通过SparkStream创建Dstream，计算WordCount
  */
object D_Rdd {
  def main(args: Array[String]): Unit = {
    //1.初始化SparkConf
    val conf: SparkConf = new SparkConf()
      .setMaster("local[3]")
      .setAppName("Spark Streaming Demo")
    //2.实时数据分析环境对象
    //采集周期：以指定的时间为周期采集实时数据
    val ssc = new StreamingContext(conf, Seconds(5))
    //3.创建RDD队列
    val rddQueue = new mutable.Queue[RDD[Int]]()

    //4.创建QueueInputDStream
    val inputStream = ssc.queueStream(rddQueue, oneAtATime = false)

    //5.处理队列中的RDD数据
    val mappedStream = inputStream.map((_, 1))
    val reducedStream = mappedStream.reduceByKey(_ + _)

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

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

    //8.循环创建并向RDD队列中放入RDD
    for (i <- 1 to 5) {
      rddQueue += ssc.sparkContext.makeRDD(1 to 300, 10)
      Thread.sleep(2000)
    }

    //启动SparkStreaming最重要的设置
    //9.driver等待采集器执行
    ssc.awaitTermination()

  }
}
2.3 自定义数据源

需要继承Receiver，并实现onStart、onStop方法来自定义数据源采集。

/**
  * 自定义采集器
  */
object C_MyReceiver {
  def main(args: Array[String]): Unit = {
    //1.初始化SparkConf
    val conf: SparkConf = new SparkConf()
      .setMaster("local[3]")
      .setAppName("Spark Streaming Demo")
    //2.实时数据分析环境对象
    //采集周期：以指定的时间为周期采集实时数据
    val ssc = new StreamingContext(conf, Seconds(5))
    //远程监控端口
    val rid: ReceiverInputDStream[String] = ssc.receiverStream(new MyReceiver("118.89.20.151", 9999))


    //解析
    val dstream: DStream[String] = rid.flatMap(_.split(" "))
    val dstream2: DStream[(String, Int)] = dstream.map((_, 1)).reduceByKey(_ + _)
    dstream2.print()

    //启动SparkStreaming最重要的设置
    //1.启动采集器
    ssc.start()
    //2.driver等待采集器执行
    ssc.awaitTermination()

  }
}

/**
  * 声明自定义采集器,继承Receiver类，实现抽象方法
  */
class MyReceiver(host: String, port: Int) extends Receiver[String](StorageLevel.MEMORY_ONLY) {
  var socket: Socket = null


  def receive(): Unit = {
    socket = new Socket(host, port)
    val reader = new BufferedReader(new InputStreamReader(socket.getInputStream))
    var line: String = null
    while ((line = reader.readLine()) != null) {
      //将采集的数据存储到采集器的内部进行转换
      if ("END".equals(line)) {
        return
      } else {
        this.store(line)
      }
    }
  }


  override def onStart(): Unit = {
    new Thread(new Runnable {
      override def run(): Unit = {
        receive()
      }
    })
  }

  override def onStop(): Unit = {
    socket.close()
    socket = null
  }
}
2.4 kafka 数据源
  1. 导入依赖
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
    <version>2.4.3</version>
</dependency>
  1. 简单版
/**
  * Spark Streaming 使用kafka作为数据源
  */
object E_DataSourceFromKafka {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[3]").setAppName("KafkaStreaming")
    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(sc, Seconds(3))
    val topics = Array("xiahu2")
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "node3:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "default",
      "auto.offset.reset" -> "earliest",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )

    val stream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      ssc,
      PreferConsistent,
      Subscribe[String, String](topics, kafkaParams)
    )

    stream.foreachRDD { rdd =>
      val offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      rdd.foreachPartition(recordIt => {
        for (record <- recordIt) {
          println(record.value())
        }
      })
      // some time later, after outputs have completed
      stream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
    }

    ssc.start()
    ssc.awaitTermination()
  }
}
  1. 复杂版就是在简单版内添加其他逻辑
3. Dstream 转换
3.1 无状态转化操作

无状态转化操作就是把简单的RDD转化操作应用到每个批次上，也就是转化DStream中的每一个RDD。部分无状态转化操作列在了下表中。

注意，针对键值对的DStream转化操作(比如reduceByKey())要添加import StreamingContext._才能在Scala中使用

3.2 有状态转化操作（重点）

直接看代码

/**
  *
  * @author Xiahu
  * @create 2020/6/29
  *
  *         状态转换
  */
object F_StateTransform {
  def main(args: Array[String]): Unit = {
    //1.初始化SparkConf
    val conf: SparkConf = new SparkConf()
      .setMaster("local[3]")
      .setAppName("Spark Streaming Demo")
    //2.实时数据分析环境对象
    //采集周期：以指定的时间为周期采集实时数据
    val ssc = new StreamingContext(conf, Seconds(5))
    //远程监控端口
    val rid: DStream[String] = ssc.textFileStream("in/sparkstream/test")

    //todo 保存数据的状态,需要设定检查点的路径
    ssc.checkpoint("/tmp")

    //解析
    val dstream: DStream[String] = rid.flatMap(_.split(" "))
    val dstream2: DStream[(String, Int)] = dstream.map((_, 1))

    //将转换结构后的数据做聚合操作
    val value: DStream[(String, Int)] = dstream2.updateStateByKey {
      case (seq, buffer) => {
        val sum: Int = buffer.getOrElse(0) + seq.sum
        Option(sum)
      }
    }
    println(value)

    /**
      * 无状态数据与有状态数据:
      *  无状态:       有状态:
      *   (A,1)        (A,1)
      *   (A,1)        (A,1),(A,1)
      *   (A,3)        (A,3),(A,1),(A,1)
      *   (A,1)        (A,1),(A,3),(A,1),(A,1)
      *   (A,2)        (A,2),(A,2),(A,1),(A,3),(A,1),(A,1)
      *
      *   有状态的数据每次都会带着之前的数据一起返回
      */

    //启动SparkStreaming最重要的设置
    //1.启动采集器
    ssc.start()
    //2.driver等待采集器执行
    ssc.awaitTermination()
  }
}
3.3 window

WindowOperations可以设置窗口的大小和滑动窗口的间隔来动态的获取当前Steaming的允许状态。

基于窗口的操作会在一个比StreamingContext 的批次间隔更长的时间范围内，通过整合多个批次的结果，计算出整个窗口的结果。

注意：所有基于窗口的操作都需要两个参数，分别为窗口时长以及滑动步长，两者都必须是 StreamContext 的批次间隔的整数倍。

  1. scala 内的滑步操作
/**
  *
  * @author Xiahu
  * @create 2020/6/29
  *         scala窗口操作
  */
object G_WindowDemo {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5, 6, 7, 8)
    //滑动窗口
    val iterator: Iterator[List[Int]] = list.sliding(3)
    for (num <- iterator) {
      println(num)
    }
  }
}
  1. spark 内的 窗口操作
/**
  *
  * @author Xiahu
  * @create 2020/6/29
  *
  *         spark 内使用窗口
  */
object G_WindowDemo2 {
  def main(args: Array[String]): Unit = {
    //1.初始化SparkConf
    val conf: SparkConf = new SparkConf()
      .setMaster("local[3]")
      .setAppName("Spark Streaming Demo")
    //2.实时数据分析环境对象
    //采集周期：以指定的时间为周期采集实时数据
    val ssc = new StreamingContext(conf, Seconds(5))
    //远程监控端口
    val rid: DStream[String] = ssc.textFileStream("in/sparkstream/test")

    //窗口大小应该为采集周期的整数倍,窗口滑动的步长也是采集周期的整数倍
    val windowDstream: DStream[String] = rid.window(Seconds(10), Seconds(10))

    //解析
    val dstream: DStream[String] = windowDstream.flatMap(_.split(" "))
    val dstream2: DStream[(String, Int)] = dstream.map((_, 1)).reduceByKey((_ + _))
    println(dstream2)

    //启动SparkStreaming最重要的设置
    //1.启动采集器
    ssc.start()
    //2.driver等待采集器执行
    ssc.awaitTermination()
  }
}
3.4 Transform

Transform原语允许DStream上执行任意的RDD-to-RDD函数。

即使这些函数并没有在DStream的API中暴露出来，通过该函数可以方便的扩展Spark API。

该函数每一批次调度一次。其实也就是对DStream中的RDD应用转换。

/**
  *
  * @author Xiahu
  * @create 2020/6/29
  *
  *         转换
  */
object H_Transform {
  def main(args: Array[String]): Unit = {
    //1.初始化SparkConf
    val conf: SparkConf = new SparkConf()
      .setMaster("local[3]")
      .setAppName("Spark Streaming Demo")
    //2.实时数据分析环境对象
    //采集周期：以指定的时间为周期采集实时数据
    val ssc = new StreamingContext(conf, Seconds(5))
    //远程监控端口
    val rid: DStream[String] = ssc.textFileStream("in/sparkstream/test")
    //todo Driver 端 执行1次
    rid.map {
      case x => {
        //todo Executor 端 执行n次 (n表示Excutor的个数)
        x
      }
    }

    //转换
    //todo Driver 端 执行1次
    rid.transform {
      case rdd => {
        //todo Driver 端执行 执行m 次, m表示采集周期
        rdd.map{
          case x => {
            //TODO Executor 端  执行n次 (n表示Excutor的个数)
            x
          }
        }
      }
    }


    //解析
    val dstream: DStream[String] = rid.flatMap(_.split(" "))
    val dstream2: DStream[(String, Int)] = dstream.map((_, 1))

    //启动SparkStreaming最重要的设置
    //1.启动采集器
    ssc.start()
    //2.driver等待采集器执行
    ssc.awaitTermination()
  }
}
3.5 Join

连接操作（leftOuterJoin, rightOuterJoin, fullOuterJoin也可以），可以连接

  1. Stream-Stream
  2. windows-stream to windows-stream
  3. stream-dataset
val stream1: DStream[String, String] = ...
val stream2: DStream[String, String] = ...
val joinedStream = stream1.join(stream2)

val windowedStream1 = stream1.window(Seconds(20))
val windowedStream2 = stream2.window(Minutes(1))
val joinedStream = windowedStream1.join(windowedStream2)
    
//Stream-dataset joins
val dataset: RDD[String, String] = ...
val windowedStream = stream.window(Seconds(20))...
val joinedStream = windowedStream.transform { rdd => rdd.join(dataset) }
4. Dstream 输出

输出操作指定了对流数据经转化操作得到的数据所要执行的操作(例如把结果推入外部数据库或输出到屏幕上)。

与RDD中的惰性求值类似，如果一个DStream及其派生出的DStream都没有被执行输出操作，那么这些DStream就都不会被求值。

如果StreamingContext中没有设定输出操作，整个context就都不会启动。

4.1 print()

在运行流程序的驱动结点上打印DStream中每一批次数据的最开始10个元素。这用于开发和调试。在Python API中，同样的操作叫print()

4.2 saveAsTextFiles(prefix,[suffix])

以text文件形式存储这个DStream的内容。每一批次的存储文件名基于参数中的prefix和suffix。

”prefix-Time_IN_MS[.suffix]”.

4.3 saveAsObjectFiles(prefix,[suffix])

以Java对象序列化的方式将Stream中的数据保存为 SequenceFiles . 每一批次的存储文件名基于参数中的为"prefix-TIME_IN_MS[.suffix]". Python中目前不可用。

4.4 saveAsHadoopFiles(prefix,[suffix])

将Stream中的数据保存为Hadoop files. 每一批次的存储文件名基于参数中的为"prefix-TIME_IN_MS[.suffix]"

4.5 foreachRDD(func)

这是最通用的输出操作，即将函数 func 用于产生于 stream的每一个RDD。其中参数传入的函数func应该实现将每一个RDD中数据推送到外部系统，如将RDD存入文件或者通过网络将其写入数据库。

注意：函数func在运行流应用的驱动中被执行，同时其中一般函数RDD操作从而强制其对于流RDD的运算。

通用的输出操作foreachRDD()，它用来对DStream中的RDD运行任意计算。这和transform() 有些类似，都可以让我们访问任意RDD。在foreachRDD()中，可以重用我们在Spark中实现的所有行动操作。

比如，常见的用例之一是把数据写到诸如MySQL的外部数据库中。 注意：

（1）连接不能写在driver层面；

（2）如果写在foreach则每个RDD都创建，得不偿失；

fix-TIME_IN_MS[.suffix]". Python中目前不可用。

4.4 saveAsHadoopFiles(prefix,[suffix])

将Stream中的数据保存为Hadoop files. 每一批次的存储文件名基于参数中的为"prefix-TIME_IN_MS[.suffix]"

4.5 foreachRDD(func)

这是最通用的输出操作，即将函数 func 用于产生于 stream的每一个RDD。其中参数传入的函数func应该实现将每一个RDD中数据推送到外部系统，如将RDD存入文件或者通过网络将其写入数据库。

注意：函数func在运行流应用的驱动中被执行，同时其中一般函数RDD操作从而强制其对于流RDD的运算。

通用的输出操作foreachRDD()，它用来对DStream中的RDD运行任意计算。这和transform() 有些类似，都可以让我们访问任意RDD。在foreachRDD()中，可以重用我们在Spark中实现的所有行动操作。

比如，常见的用例之一是把数据写到诸如MySQL的外部数据库中。 注意：

（1）连接不能写在driver层面；

（2）如果写在foreach则每个RDD都创建，得不偿失；

（3）增加foreachPartition，在分区创建。使用foreachPartition，在该算子下构造逻辑

地球人是我哈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【学习笔记】大数据技术之SparkStreaming
prague6695的博客
04-21 2053
这里写目录标题思考？SparkStreaming 的wordcount第1章 SparkStreaming 概述1.1 Spark Streaming 是什么1.2 Spark Streaming 的特点1.3 Spark Streaming 架构1.3.1 架构图1.3.2 背压机制第 2 章 Dstream 入门2.1 WordCount 案例实操2.2 WordCount 解析第 3 章 DStream 创建3.1 RDD 队列3.1.1 用法及说明3.1.2 案例实操3.2 自定义数据源3.2.1
Spark(五)Spark Streaming
weixin_38527856的博客
11-08 138
一 流数据 针对两种典型的数据：静态数据和流数据，对应两种不同的计算-批量计算和实时计算 批量计算：MapReduce,一次性处理大规模的静态数据，无法满足秒级响应 流计算：实时获取不同数据源的海量数据，经过实时分析处理，获得有价值的信息；流数据的价值随着时间流逝慢慢降低 流数据框架：高性能（每秒能处理几十万条数据），海量式（支持TB、PB级的数据规模），实时性（低延迟、达到秒级别及毫秒级别），分布式（支持大数据基本架构，平滑扩展），易用性（用户可快速开发和部署），可靠性（可靠地处理流数据）
spark streaming
qq_25460227的博客
08-03 1148
Spark Streaming 课程目标 掌握Spark Streaming的原理 熟练使用Spark Streaming完成流式计算任务 Spark Streaming介绍 Spark Streaming概述 什么是Spark Streaming Spark Streaming类似于Apache Storm，用于流式数据的处理。根据其官方文档介绍，Spark...
SparkStreaming Java
weixin_34128839的博客
08-14 466
2019独角兽企业重金招聘Python工程师标准>>> ...
Spark Core快速入门系列(4) | ＜Action＞ 行动算子转换算子
不温卜火
07-24 5714
  大家好，我是不温卜火，是一名计算机学院大数据专业大二的学生，昵称来源于成语—不温不火，本意是希望自己性情温和。作为一名互联网行业的小白，博主写博客一方面是为了记录自己的学习过程，另一方面是总结自己所犯的错误希望能够帮助到很多和自己一样处于起步阶段的萌新。但由于水平有限，博客中难免会有一些错误出现，有纰漏之处恳请各位大佬不吝赐教！暂时只有csdn这一个平台，博客主页：https://buwenbuhuo.blog.csdn.net/   此篇为大家带来的是Spark Core Transformat.
SparkStreaming编程讲解
01-30
1.什么是SparkStreaming？2.SparkStreaming可以接受那些数据源？3.Dstream，我们可以进行哪两种操作？Sparkstreaming:构建在Spark上处理Stream数据的框架，基本的原理是将Stream数据分成小的时间片断（几秒），以...
大数据sparkStreaming.docx
06-21
Spark Streaming 大数据处理实践 大数据处理是当前数据科学和 IT 行业的热门话题，Spark Streaming 是 Apache Spark 中的一种实时流数据处理引擎，本文将介绍如何使用 Spark Streaming 处理大数据，并结合 ...
SparkStreamingKafka:Spark Streaming日志到kafka
05-17
import org.apache.spark.streaming.api.java.JavaStreamingContext; import scala.Tuple2; // 创建Spark配置 SparkConf conf = new SparkConf().setAppName("SparkStreamingKafka").setMaster("local[2]"); // ...
Hadoop原理与技术Spark Streaming操作实验
05-24
1.理解Spark Streaming的工作流程。 2.理解Spark Streaming的工作原理。 3.学会使用Spark Streaming处理流式数据。 二、实验环境 Windows 10 VMware Workstation Pro虚拟机 Hadoop环境 Jdk1.8 三、实验内容 （一）...
基于 Spark Streaming 的电影推荐系统.zip
03-14
《基于Spark Streaming的电影推荐系统》 在当今大数据时代，实时数据分析已经成为许多企业和组织的核心竞争力。Spark Streaming，作为Apache Spark项目的一部分，为处理实时数据流提供了高效、灵活且可扩展的解决...
dataframe获取分区个数及每个分区的内容
盛源的博客
04-19 2897
1 dataframe获取分区个数 val df = spark.sparkContext.makeRDD(1.to(100), 4).toDF("id") val partition_num=df.rdd.partitions.length println(partition_num) 2 dataframe获取每个分区的内容 // 构造测试数据 val df = spark.s...
java makerdd_Spark常用函数示例
weixin_34280468的博客
02-16 810
1、parallelize说明：通过调用SparkContext的parallelize方法，在一个已经存在的Scala集合上创建的(一个Seq对象)。集合的对象将会被拷贝，创建出一个可以被并行操作的分布式数据集。valdata=sc.parallelize(List(1,2,3,4,5))data.collect执行显示如下：res2:Array[Int]=Array(1,...
SparkStreaming笔记(一）
smallworldxyl的博客
02-06 221
package org.xyl import org.apache.spark.SparkConf import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream} import org.apache.spark.streaming.{Seconds, StreamingContext} object SparkStreaming_01 { def main(args: Array[String]): Unit = {
实时流计算Spark Streaming原理介绍
weixin_42073629的博客
07-11 639
1、Spark Streaming简介 1.1概述 Spark Streaming是Spark核心API的一个扩展，可以实现高吞吐量的、具备容错机制的实时流数据的处理。支持从多种数据源获取数据，包括Kafka、Flume、Twitter、ZeroMQ、Kinesis以及TCP sockets，从数据源获取数据之后，可以使用诸如map、reduce、join和window等高级函数进行复杂算法的处理。最后还可以将处理结果存储到文件系统，数据库和实时仪表盘。在“One Stack rule them ...
SparkStreaming-实时数据采集
吃鱼的博客
10-19 909
1.SparkStreaming的架构 2.实例 一个实时计算的wordcount object WordCount { def main(args: Array[String]): Unit = { //使用sparkstreaming来完成wordcount //spark的配置对象 val conf = new SparkConf().setMaster("l...
Spark基础-parallelize函数和makeRDD函数的区别
liweiminlining的专栏
03-23 2198
Spark基础-parallelize函数和makeRDD函数的区别
spark常见的RDD
shuimofengyang的博客
08-29 686
RDD定义 弹性分布式数据集。 是spark为简化用户的使用，对所有的底层数据进行的抽象，以面向对象的方式提供了RDD很多的方法，通过这些方法来对RDD进行计算和输出。RDD是Spark的基石，所有的上层模块全部都是由RDD来实现。 RDD的特性 a）不可变， 对于所有RDD的操作都将产生一个新的RDD。 b)可分区， RDD是通过将数据进行分区保存的。 c)弹性： 存储的弹性：内存与...
Spark parallelize函数和makeRDD函数的区别(Array-->RDD)
写博客只为学习
04-27 633
我们知道，在Spark中创建RDD的创建方式大概可以分为三种： [b]（1）、从集合中创建RDD；[/b] [color=red][b]（2）、从外部存储创建RDD；[/b][/color] [color=blue][b]（3）、从其他RDD创建。[/b][/color] 而从集合中创建RDD，[b]Spark主要提供了两中函数：parallelize和makeRDD[/b]。我们可以...
rabbitmq集群创建admin用户之后，提示can access virtual hosts是No access状态
最新发布
jiang0615csdn的博客
07-11 86
rabbitmq集群创建admin用户之后，提示can access virtual hosts是No access状态
大数据基础面试题五：spark core & sql & streaming
06-28
Spark Streaming的作用是将流式数据分成一系列小批次进行处理，然后利用Spark Core进行分布式计算，最后将计算结果返回给用户。 4. Spark Core和Spark SQL的区别是什么？ Spark Core是Spark的核心组件，提供了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值