Spark（四）： Spark 核心编程（上）

最新推荐文章于 2024-05-16 10:24:30 发布

程序胖

最新推荐文章于 2024-05-16 10:24:30 发布

阅读量437

点赞数

分类专栏： Spark 文章标签： spark big data scala

本文链接：https://blog.csdn.net/qq_41816516/article/details/121351070

版权

Spark 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

Spark核心编程
- RDD

Spark核心编程

* Spark 计算框架为了能够进行高并发和高吞吐的数据处理，封装了三大数据结构，用于处理不同的应用场景。三大数据结构分别是：
	* RDD：弹性分布式数据集
	* 累加器：分布式共享只写变量
	* 广播变量：分布式共享只读变量

RDD

在这里插入图片描述

RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。
在知道RDD运行的原理之前，先来研究一下IO的实现原理，看下图
- IO的操作核心还是FileInputStream来读取文件File，外面的InputStreamReader和BufferReader主要是通过包装来将FileInputStream进行功能扩展，以此来达到更好的效果
- 而这种模式是一种设计思想也就是装饰者的设计模式
- 而RDD是一种计算单元，这种计算单元就是有不同的计算方式组装到一起的，所以就类似于上面的装饰者模式，具体看下图
- RDD的数据只有在调用collect方法时，才会真正执行业务逻辑操作，之前的封装都是功能的扩展
- RDD是不保存数据的，但是IO可以临时保存一部分数据
下面解释一下RDD的特点：
弹性：
- 存储的弹性：内存与磁盘的自动切换
- 容错的弹性：数据丢失可以自动恢复
- 计算的弹性：计算出错重试机制
- 分片的弹性：可根据需要重新分片
分布式：数据存储在大数据集群不同点上
数据集：RDD封装了计算逻辑，并不保存数据
数据抽象：RDD是一个抽象类，需要子类具体实现
不可变：RDD封装了计算逻辑，是不可以改变，想要改变，只能产生新的RDD，在新的RDD里面封装计算逻辑
可分区，并行计算

RDD 核心属性

分区列表：RDD数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要属性
分区计算函数：Spark 在计算时，是使用分区函数对每一个分区进行计算
RDD之间的依赖关系：RDD是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个RDD建立依赖关系
分区器：当数据为KV类型数据时，可以通过设定分区器自定义数据的分区
首选位置（可选）：计算数据时，可以根据计算节点的状态来选择不同的节点位置进行计算

RDD 执行原理

从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。
Spark框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的计算任务。然后将任务发到已经分配资源的计算节点上，按照指定的计算模型进行数据计算。最后得到计算结果。
RDD是Spark框架中用于数据处理的核心模型，接下来我们看看，在Yarn环境中，RDD的工作原理。

启动yarn集群环境
Spark 通过申请资源创建调度节点和计算节点
Spark 框架根据需求将计算逻辑根据分区划分成不同的任务
调度节点将任务根据计算节点状态发送到对应的计算节点进行计算

从以上的流程来看，RDD就是将数据和逻辑进行封装，然后生成task发送给Executor的节点执行计算。

RDD 基础编程

RDD 创建

从集合（内存）中创建RDD：Spark 主要提供了两个方法：parallelize 和 makeRDD
- 其中makeRDD 的源码时调用 parallelize 方法，只不过这个方法更好记忆

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

    // 准备环境
    // "local[*]"里面的'*'表示的是CPU线程的核数，如果去掉只写local就表示单线程
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    // 创建RDD
    // 从内存中创建RDD，将内存中集合的数据作为处理的数据源
    val seq = Seq[Int](1,2,3,4)
    //parallelize：并行（同时执行要看CPU核数）
    //val rdd:RDD[Int] = sc.parallelize(seq)
    val rdd = sc.makeRDD(seq)
    rdd.collect().foreach(println)

    // 关闭环境
    sc.stop()
  }
}

从外部存储（文件）创建RDD：由外部存储系统的数据集创建 RDD 包括：本地的文件系统，所有 Hadoop 支持的数据集，比如 HDFS、HBase 等。

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

    // 准备环境
    // "local[*]"里面的'*'表示的是CPU线程的核数，如果去掉只写local就表示单线程
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    // 创建RDD
    // 从文件中创建RDD，将文件中的数据作为处理的数据源
    // path路径默认以当前环境的根路径为基准。可以写绝对路径，也可以写相对路径，也可以是目录名称
    // sc.textFile("")
//    val rdd = sc.textFile("datas")
//    rdd.collect().foreach(println)

    // wholeTextFiles：以文件为单位读取数据
    // 读取的结果表示为元组，第一个元素表示文件路径，第二个元素表示文件内容
    val rdd = sc.wholeTextFiles("datas")

    // 关闭环境
    sc.stop()
  }
}

从其他 RDD 创建：主要是通过一个 RDD 运算完后，再产生新的 RDD。
直接创建 RDD（new）：使用 new 的方式直接构造 RDD，一般由 Spark 框架自身使用。

RDD 并行度与分区

默认情况下，Spark 可以将一个作业切分多个任务后，发送给 Executor 节点并行计算，而能够并行计算的任务数量我们称之为并行度。这个数量可以在构建 RDD 时指定。记住，这里的并行执行的任务数量，并不是指的切分任务的数量，不要混淆了。

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

    // 准备环境
    // "local[*]"里面的'*'表示的是CPU线程的核数，如果去掉只写local就表示单线程
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    //sparkConf.set("spark.default.parallelism","5")
    val sc = new SparkContext(sparkConf)

    // 创建RDD
    // RDD的并行度 & 分区
    // makeRDD方法可以传递第二个参数，这个参数表示分区的数量
    // 第二个参数可以不传递的，那么makeRDD方法会使用默认值：defaultParallelism（默认核数）
    val rdd = sc.makeRDD(List(1, 2, 3, 4))

    // 将处理的数据保存成分区文件
    rdd.saveAsTextFile("output")

    // 关闭环境
    sc.stop()
  }
}

现在有个问题就是读取内存数据的时候，数据是按照并行度的设定进行数据的分区操作，但是数据是怎么分区的呢，分区的规则是怎么样的呢？这个时候就需要观看源码
首先，先点makeRDD方法进去
看来最主要的是parallelize 方法，那我们接着点进去
接着点ParallelCollectionRDD 构建方法进去
所以接着点slice方法进去
很显然，positions方法是重点，我们点进去看看
就是上面这个方法进行切分的，其中length是数据的长度，numSlices是分区数，所以操作如下图
然后创建这个Iterator[(Int, Int)] 之后，回去看那个分割逻辑
使用slice将存储数据分区，逻辑如下
好了，上面是内存数据的分区划分，那文件数据怎么划分呢，跟内存数据一样吗，下面就来看看

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

    // 准备环境
    // "local[*]"里面的'*'表示的是CPU线程的核数，如果去掉只写local就表示单线程
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    //sparkConf.set("spark.default.parallelism","5")
    val sc = new SparkContext(sparkConf)

    // 创建RDD
    // RDD的并行度 & 分区
    // textFile也可以默认设置分区
    val rdd = sc.textFile("datas/1.txt")


    // 将处理的数据保存成分区文件
    rdd.saveAsTextFile("output")

    // 关闭环境
    sc.stop()
  }
}

默认分区到底是多少，进到textFile方法里看看
minPartitions是最小分区数量，但是默认究竟是多少呢？我们点击defaultMinPartitions进去看看
所以这么看一般默认是2，但是真的是这样吗，再做个实验，将1.txt变成下面那种形式，并且将textFile的分区参数设置为2，再看看结果
上面那个奇怪的现象，说明文件数据的分区不是这么简单，所以我们需要深挖，下面我就来看看文件分区的规律，点击textFile进去看看
取这个名字是不是跟hadoop有关，点进去发现并没有什么一样，但是返回来之后，点击TextInputFormat方法就能发现端倪
什么端倪呢？就是这个文件输入类，是使用hadoop的方式，到这里就有点恍然大悟了。
我们的1.txt 是7个字节，根据公式，计算出来的应该是这样，但是这么算似乎是2个分区啊，怎么是三个呢？因为hadoop划分有个特性，如果剩余的空间占要划分的空间大于10%则再加一块，如果小于则不用，所以这里1/3明显大于10%。所以才会多一块。
数据分区的分配总结：
- 数据以行为单位进行读取
  - spark读取文件，采用的是hadoop的方式读取，所以一行一行的读取，和字节数没有关系
- 数据读取时以偏移量为单位，偏移量不会被重复读取，下面是演示图

RDD 转换算子

RDD 根据数据处理方式的不同将算子整体上分为 Value 类型、双 Value 类型和 Key-Value 类型
Value 类型
- map
  - 函数签名：def map[数据类型] (函数方法): RDD[数据类型]
  - 函数说明：将处理的数据逐条进行映射转换，这里的在转换可以是类型的转换，也可以是值的转换。
  - 注意：
    - RDD的计算一个分区内的数据是一个一个执行逻辑，只有前面一个数据全部的逻辑执行完毕后，才会执行下一个数据，分区内的数据的执行是有序的
    - 不同分区数据计算是无序的
- mapPartitons
  - 函数签名：def mapPartitions[U: ClassTag] ( f: Iterator[T] => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]
  - 函数说明：将待处理的数据以分区为单位送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。
  - 注意：
    - 可以以分区为单位及逆行数据转换操作
    - 但是会将整个分区的数据加载到内存进行引用
    - 如果处理完的数据是不会被释放掉的，存在对象的引用
    - 在内存较小，数据量较大的场合下，容易出现内存溢出
  - 与map算子的区别
    - 从数据处理的角度：
      - map算子是分区内一个数据一个数据的执行，类似于串行操作。
      - mapPartitions 算子是以分区为单位进行批处理操作
    - 从功能的角度：
      - map算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。
      - mapPartition算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据
    - 从性能的角度：
      - map算子因为类似于串行操作，所以性能比较低
      - mapPartitions算子类似于批处理，所以性能比较高。但是会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。
- mapPartitionsWithIndex
  - 函数签名：def mapPartitionsWithIndex[U: ClassTag] ( f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]
  - 函数说明：将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。
- flatMap
  - 函数签名：def flatMap[U: ClassTag] (f: T => TraversableOnce[U]): RDD[U]
  - 函数说明：将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
- glom
  - 函数签名：def glom(): RDD[Array[T]]
  - 函数说明：将同一个分区的数据直接转换成相同类型的内存数组进行处理，分区不变
- groupBy
  - 函数签名：def groupBy[K] (f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
  - 函数说明：将数据根据指定的规矩进行分组，分区默认不变，但是数据会被打乱重新组合，我们这样的操作称之为shuffle。
- filter
  - 函数签名：def filter(f: T => Boolean): RDD[T]
  - 函数说明：
    - 将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
    - 当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能出现数据倾斜
- sample
  - 函数签名：def sample( withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T]
  - 函数说明：根据指定的规则从数据集中抽取数据
- distinct
  - 函数签名：
    - def distinct()(implicit ord: Ordering[T] = null): RDD[T]
    - def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
  - 函数说明：将数据集中重复的数据去重
- coalesce
  - 函数签名：def coalesce(numPartitions: Int, shuffle: Boolean = false,partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null): RDD[T]
  - 函数说明：根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率，当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本
- repartition
  - 函数签名：def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
  - 函数说明：该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true。无论是将分区数多的RDD 转换为分区数少的 RDD，还是将分区数少的 RDD 转换为分区数多的 RDD，repartition操作都可以完成，因为无论如何都会经 shuffle 过程。
- sortBy
  - 函数签名：def sortBy[K] (f: (T) => Kascending: Boolean = true, numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]
  - 函数说明：该操作用于排序数据。在排序之前，可以将数据通过 f 函数进行处理，之后按照 f 函数处理的结果进行排序，默认为升序排列。排序后新产生的 RDD 的分区数与原 RDD 的分区数一致。中间存在 shuffle 的过程
  - 注意：
    - sortBy方法可以根据指定的规则对数据源中的数据进行排序，默认为升序，第二个参数可以改变。
双Value类型：也就是两个集合变成一个集合
- intersection：交集
  - 函数签名：def intersection(other: RDD[T]): RDD[T]
  - 函数说明：对源 RDD 和参数 RDD 求交集后返回一个新的 RDD
- union：并集
  - 函数签名：def union(other: RDD[T]): RDD[T]
  - 函数说明：对源 RDD 和参数 RDD 求并集后返回一个新的 RDD
- subtract：差集
  - 函数签名：def subtract(other: RDD[T]): RDD[T]
  - 函数说明：以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集
- zip：拉链
  * 函数签名：def zip[U: ClassTag] (other: RDD[U]): RDD[(T, U)]
  * 函数说明：将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD中的元素，Value 为第 2 个 RDD 中的相同位置的元素。
  * 注意：
  * 两个数据源要求分区数量要保持一致
  * 两个数据源要求分区数据数据量保持一致
Key-Value类型
- partitionBy
  - 函数签名：def partitionBy(partitioner: Partitioner): RDD[(K, V)]
  - 函数说明：将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是HashPartitioner
- reduceByKey
  - 函数签名：
    - def reduceByKey(func: (V, V) => V): RDD[(K, V)]
    - def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
  - 函数说明：
    - 可以将数据按照相同的Key对Value进行聚合
- groupByKey
  - 函数签名：
    - def groupByKey(): RDD[(K, Iterable[V])]
    - def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])]
    - def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]
  - 函数说明：将数据源的数据根据key对value进行分组
  - 跟 reduceByKey 的区别：
    - 从shuffle的角度：reduceByKey和groupByKey 都存在shuffle操作，但是reduceByKey可以在shuffle前对分区内相同key的数据进行预聚合功能，这样会减少落盘的数据量，而groupByKey只是进行分组，不存在数据量减少的问题，reduceByKey性能比较高。
    - 从功能的角度：reduceByKey其实包含分组和聚合的功能。GroupByKey只能分组，不能聚合。所以再分组聚合的场合下，推荐使用reduceByKey，如果仅仅是分组而不需要聚合。那么还是只能使用groupByKey
  - aggregateByKey
    - 函数签名：def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U,
      combOp: (U, U) => U): RDD[(K, U)]
    - 函数说明：
      - 将数据根据不同的规则进行分区内计算和分区间计算
      - aggregateByKey 算子是函数柯里化，存在两个参数列表
        第一个参数列表中的参数表示初始值
        第二个参数列表中含有两个参数
        第一个参数表示分区内的计算规则
        第二个参数表示分区间的计算规则
  - foldByKey
    - 函数签名：def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
    - 函数说明：当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为 foldByKey
  - combineByKey
    - 函数签名：def combineByKey[ C] ( createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C): RDD[(K, C)]
    - 函数说明：
      - 最通用的对 key-value 型 rdd 进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。
      - 第一个参数表示：将相同key的第一个数据进行结构的转换，实现操作
      - 第二个参数表示：分区内的计算规则
      - 第三个参数表示：分区间的计算规则
  - reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别？
    - reduceByKey: 相同 key 的第一个数据不进行任何计算，分区内和分区间计算规则相同
    - foldByKey：相同的key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同
    - aggregateByKey：相同key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同
    - combineByKey：当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。
  - join
    - 函数签名：def join[W] (other: RDD[(K, W)]): RDD[(K, (V, W))]
    - 函数说明：在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的 RDD
  - leftOuterJoin
    - 函数签名：def leftOuterJoin[W] (other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
    - 函数说明：类似于 SQL 语句的左外连接
  - cogroup
    - 函数签名：def cogroup[W] (other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]
    - 函数说明：在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD
  - 案例实操：
    - 数据准备：时间搓，省份，城市，用户，广告，中间字段使用空格分隔。
    - 需求描述：统计出每一个省份每个广告被点击数量排行的Top3
    - 代码实现：

	package com.bigdata.spark.core.rdd_builder

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Spark10_RDD_TEST {

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

    // "local[*]"里面的'*'表示的是CPU线程的核数，如果去掉只写local就表示单线程
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    //sparkConf.set("spark.default.parallelism","5")
    val sc = new SparkContext(sparkConf)

    //1. 获取源数据
    val data = sc.textFile("datas/agent.log");

    //2. 将元数据进行结构的转换，方便统计
    val mapRDD = data.map {
      line => {
        val details = line.split(" ")
        ((details(1), details(4)), 1)
      }
    }


    //3. 将转换结构后的数据，进行分组聚合
    val reduceRDD:RDD[((String, String), Int)] = mapRDD.reduceByKey(_+_)

    //4. 将聚合的结果进行结构的转换
    val newMapRDD = reduceRDD.map {
      case ((prv, ad), sum) => {
        (prv, (ad, sum))
      }
    }

    //5. 将转换结构后的数据根据省份进行分组
    val groupRDD = newMapRDD.groupByKey()

    //6. 将分组后的数据组内排序，取前三名
    val resultRDD = groupRDD.mapValues {
      rdd => {
        rdd.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
      }
    }

    //7. 采集数据打印在控制台
    resultRDD.foreach(println)

    sc.stop()
  }
}

RDD行动算子

所谓的行动算子，其实就是触发作业（JOB）执行的方法
底层代码调用的是环境对象的runJob方法
底层代码中会创建ActiveJob。并提交执行
reduce
- 函数签名：def reduce(f: (T, T) => T): T
- 函数说明：聚集 RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据
collect
- 函数签名：def collect(): Array[T]
- 函数说明：在驱动程序中，以数组 Array 的形式返回数据集的所有元素
count
- 函数签名：def count(): Long
- 函数说明：返回 RDD 中元素的个数
first
- 函数签名：def first(): T
- 函数说明：返回 RDD 中的第一个元素
take
- 函数签名：def take(num: Int): Array[T]
- 函数说明：返回一个由 RDD 的前 n 个元素组成的数组
takeOrdered
- 函数签名：def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]
- 函数说明：返回该 RDD 排序后的前 n 个元素组成的数组
aggregate
- 函数签名：def aggregate[U: ClassTag] (zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U
- 函数说明：分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合
fold
- 函数签名：def fold(zeroValue: T)(op: (T, T) => T): T
- 函数说明：折叠操作，aggregate 的简化版操作
countByKey
- 函数签名：def countByKey(): Map[K, Long]
- 函数说明：统计每种 key 的个数
save
- 函数签名：
  - def saveAsTextFile(path: String): Unit
  - def saveAsObjectFile(path: String): Unit
  - def saveAsSequenceFile( path: String, codec: Option[Class[_ <: CompressionCodec]] = None): Unit
- 函数说明：
  - 将数据保存到不同格式的文件中
    - saveAsTextFile：保存成 Text 文件
    - saveAsObjectFile：序列化成对象保存到文件
    - saveAsSequenceFile：保存成 Sequencefile 文件
foreach
- 函数签名：def foreach(f: T => Unit): Unit = withScope { val cleanF = sc.clean(f)
  sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF))}
- 函数说明：分布式遍历 RDD 中的每一个元素，调用指定函数

程序胖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spark（四）： Spark 核心编程（上）

文章目录Spark核心编程RDDRDD 核心属性RDD 执行原理RDD 基础编程RDD 创建RDD 并行度与分区RDD 转换算子Spark核心编程* Spark 计算框架为了能够进行高并发和高吞吐的数据处理，封装了三大数据结构，用于处理不同的应用场景。三大数据结构分别是： * RDD：弹性分布式数据集 * 累加器：分布式共享只写变量 * 广播变量：分布式共享只读变量RDDRDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数
复制链接

扫一扫