大数据Spark--核心编程

文章目录

IDEA 配置Spark环境
- 增加scala插件
- 创建Maven项目，配置pom.xml
- 配置log4j.properties
Spark 三大数据结构
- RDD
- - RDD概念
  - 核心属性
  - 执行原理
  - 基础编程
  - - RDD创建
    - RDD 并行度与分区
    - RDD转换算子
    - - Value类型
      - 双Value类型
      - Key - Value类型
      - reduceByKey和groupByKey的区别？
        reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别？
    - RDD行动算子
    - RDD 序列化
    - RDD 依赖关系
    - RDD 持久化
    - RDD 分区器
    - RDD 文件读取与保存
- 累加器
- - 实现原理
  - 基础编程
  - - 系统累加器
    - 自定义累加器
- 广播变量
- - 实现原理
  - 基础编程

IDEA 配置Spark环境

增加scala插件

在这里插入图片描述

创建Maven项目，配置pom.xml

<dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.0.0</version>
        </dependency>
</dependencies>

配置log4j.properties

在resources包下创建log4j.properties文件
增加以下代码：

log4j.rootCategory=ERROR, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n 
# Set the default spark-shell log level to ERROR. When running the spark-shell, the
# log level for this class is used to overwrite the root logger's log level, so that
# the user can have different defaults for the shell and regular Spark apps.
log4j.logger.org.apache.spark.repl.Main=ERROR
# Settings to quiet third party logs that are too verbose
log4j.logger.org.spark_project.jetty=ERROR
log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=ERROR
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=ERROR
log4j.logger.org.apache.parquet=ERROR log4j.logger.parquet=ERROR
# SPARK-9183: Settings to avoid annoying messages when looking up nonexistentUDFs in SparkSQL with Hive support
log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=FATAL
log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR

Spark 三大数据结构

RDD : 弹性分布式数据集
累加器：分布式共享只写变量
广播变量：分布式共享只读变量

RDD

RDD概念

RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。

弹性
- 存储的弹性：内存与磁盘的自动切换；
- 容错的弹性：数据丢失可以自动恢复；
- 计算的弹性：计算出错重试机制；
- 分片的弹性：可根据需要重新分片。
分布式：数据存储在大数据集群不同节点上
数据集：RDD封装了计算逻辑，并不保存数据
数据抽象：RDD是一个抽象类，需要子类具体实现
不可变：RDD封装了计算逻辑，是不可以改变的，想要改变，只能产生新的RDD，在新的RDD里面封装计算逻辑
可分区、并行计算

核心属性

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

执行原理

从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。

Spark 框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的
计算任务。然后将任务发到已经分配资源的计算节点上, 按照指定的计算模型进行数据计算。最后得到计算结果。

RDD是Spark框架中用于数据处理的核心模型，接下来我们看看，在Yarn环境中，RDD的工作原理:

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

基础编程

RDD创建

从集合（内存）中创建RDD
从集合中创建RDD，Spark主要提供了两个方法：parallelize和makeRDD

val sparkConf = 
new SparkConf().setMaster("local[*]").setAppName("spark") 
val sparkContext = new SparkContext(sparkConf) 
val rdd1 = sparkContext.parallelize( 
List(1,2,3,4) 
) 
val rdd2 = sparkContext.makeRDD( 
List(1,2,3,4) 
) 
rdd1.collect().foreach(println) 
rdd2.collect().foreach(println) 
sparkContext.stop()

从底层代码实现来讲，makeRDD方法其实就是parallelize方法

def makeRDD[T: ClassTag]( 
seq: Seq[T], 
numSlices: Int = defaultParallelism): RDD[T] = withScope { 
parallelize(seq, numSlices) 
}

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

val sparkConf = 
new SparkConf().setMaster("local[*]").setAppName("spark") 
val sparkContext = new SparkContext(sparkConf) 
val fileRDD: RDD[String] = sparkContext.textFile("input") 
fileRDD.collect().foreach(println) 
sparkContext.stop()

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

RDD 并行度与分区

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

val sparkConf = 
new SparkConf().setMaster("local[*]").setAppName("spark") 
val sparkContext = new SparkContext(sparkConf) 
val dataRDD: RDD[Int] = 
sparkContext.makeRDD( 
List(1,2,3,4), 
4) 
val fileRDD: RDD[String] = 
sparkContext.textFile( 
"input", 
2) 
fileRDD.collect().foreach(println) 
sparkContext.stop()

读取内存数据时，数据可以按照并行度的设定进行数据的分区操作，数据分区规则的
Spark 核心源码如下：

def positions(length: Long, numSlices: Int): Iterator[(Int, Int)] = { 
(0 until numSlices).iterator.map { i => 
	val start = ((i * length) / numSlices).toInt 
	val end = (((i + 1) * length) / numSlices).toInt 
	(start, end) 
	} 
}

读取文件数据时，数据是按照Hadoop文件读取的规则进行切片分区，而切片规则和数据读取的规则有些差异，具体Spark核心源码如下

public InputSplit[] getSplits(JobConf job, int numSplits) 
    throws IOException { 
 
    long totalSize = 0;                           // compute total size 
    for (FileStatus file: files) {                // check we have valid files 
      if (file.isDirectory()) { 
        throw new IOException("Not a file: "+ file.getPath()); 
      } 
      totalSize += file.getLen(); 
    } 
 
    long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits); 
    long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input. 
      FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize); 
       
    ... 
     
    for (FileStatus file: files) { 
     
        ... 
     
    if (isSplitable(fs, path)) { 
          long blockSize = file.getBlockSize(); 
          long splitSize = computeSplitSize(goalSize, minSize, blockSize); 
 
          ... 
 
  } 
  protected long computeSplitSize(long goalSize, long minSize, 
                                       long blockSize) { 
    return Math.max(minSize, Math.min(goalSize, blockSize)); 
  }

RDD转换算子

RDD根据数据处理方式的不同将算子整体上分为Value类型、双Value类型和Key-Value类型

Value类型

1）函数签名

def map[U: ClassTag](f: T => U): RDD[U]

2）函数说明

val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1,2,3,4)) 
val dataRDD1: RDD[Int] = dataRDD.map( 
    num => { 
		num * 2 
	} 
) 
val dataRDD2: RDD[String] = dataRDD1.map( 
	num => { 
		"" + num 
	} 
)

mapPartitions

1）函数签名

def mapPartitions[U: ClassTag]( 
	f: Iterator[T] => Iterator[U], 
	preservesPartitioning: Boolean = false): RDD[U]

2）函数说明

将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子  - mapPartitions
    val rdd = sc.makeRDD(List(1, 2, 3, 4), 2)

    val mapRdd : RDD[Int] = rdd.mapPartitionsWithIndex(
      (index, iter) => {
        if(index == 1) {
          iter
        } else {
          Nil.iterator
        }
      }
    )
    mapRdd.collect().foreach(println)

    sc.stop()

  }

map和mapPartitions的区别？
- 数据处理角度
  Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而mapPartitions算子是以分区为单位进行批处理操作。
- 功能的角度
  Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据
- 性能的角度
  Map 算子因为类似于串行操作，所以性能比较低，而是mapPartitions算子类似于批处理，所以性能较高。但是mapPartitions算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用map操作。
mapPartitionsWithIndex

1）函数签名

def mapPartitionsWithIndex[U: ClassTag]( 
	f: (Int, Iterator[T]) => Iterator[U], 
	preservesPartitioning: Boolean = false): RDD[U]

2）函数说明
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。

val dataRDD1 = dataRDD.mapPartitionsWithIndex( 
	(index, datas) => { 
		datas.map(index, _) 
	} 
)

flatMap

1）函数签名

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]

2）函数说明
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射

val dataRDD = sparkContext.makeRDD(List( 
	List(1,2),List(3,4) 
),1) 
val dataRDD1 = dataRDD.flatMap( 
	list => list 
)

glom

1）函数签名

def glom(): RDD[Array[T]]

2）函数说明

将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子  - map
    val rdd = sc.makeRDD(List(1, 2, 3, 4), 2)

    val glomRDD = rdd.glom()

    glomRDD.collect().foreach(data => println(data.mkString(",")))

    sc.stop()

  }

groupBy

1）函数签名

def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

2）函数说明

将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中

一个组的数据在一个分区中，但是并不是说一个分区中只有一个组

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子  -- groupBy
    val rdd = sc.makeRDD(List("Hello", "Spark", "Scala", "Hadoop"), 2)

    // 分组和分区没有必然的关系
    val groupRDD = rdd.groupBy(_.charAt(0))

    groupRDD.collect().foreach(println)

    sc.stop()
  }

filter

1）函数签名

def filter(f: T => Boolean): RDD[T]

2）函数说明

将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。

  // 过滤偶数
  def main(args: Array[String]): Unit = {

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子  -- filter
    val rdd = sc.makeRDD(List(1, 2, 3, 4))

    val filterRDD = rdd.filter(num => num % 2 != 0)

    filterRDD.collect().foreach(println)

    sc.stop()
  }

sample

1）函数签名

def sample( 
withReplacement: Boolean, 
fraction: Double, 
seed: Long = Utils.random.nextLong): RDD[T]

2）函数说明

根据指定的规则从数据集中抽取数据

val dataRDD = sparkContext.makeRDD(List( 
1,2,3,4 
),1) 
// 抽取数据不放回（伯努利算法） 
// 伯努利算法：又叫0、1分布。例如扔硬币，要么正面，要么反面。 
// 具体实现：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于不
要 
// 第一个参数：抽取的数据是否放回，false：不放回 
// 第二个参数：抽取的几率，范围在[0,1]之间,0：全不取；1：全取； 
// 第三个参数：随机数种子 
val dataRDD1 = dataRDD.sample(false, 0.5) 
// 抽取数据放回（泊松算法） 
// 第一个参数：抽取的数据是否放回，true：放回；false：不放回 
// 第二个参数：重复数据的几率，范围大于等于0.表示每一个元素被期望抽取到的次数 
// 第三个参数：随机数种子 
val dataRDD2 = dataRDD.sample(true, 2)

distinct

1）函数签名

def distinct()(implicit ord: Ordering[T] = null): RDD[T] 
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

2）函数说明

将数据集中重复的数据去重

val dataRDD = sparkContext.makeRDD(List( 
1,2,3,4,1,2 
),1) 
val dataRDD1 = dataRDD.distinct() 
val dataRDD2 = dataRDD.distinct(2)

coalesce

1）函数签名

def coalesce(numPartitions: Int, shuffle: Boolean = false, 
partitionCoalescer: Option[PartitionCoalescer] = Option.empty) 
(implicit ord: Ordering[T] = null) 
: RDD[T]

2）函数说明

根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率

当spark 程序中，存在过多的小任务的时候，可以通过coalesce方法，收缩合并分区，减少分区的个数，减小任务调度成本

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子  - coalesce

    val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3)

    // coalesce 方法默认情况下不会将分区的数据打乱重新组合
    // 这种情况下的缩减分区可能会导致 数据不均衡, 出现数据倾斜
    // 如果想要数据均衡, 可以进行shuffle
    val newRDD = rdd.coalesce(2, true)

    newRDD.saveAsTextFile("output")

    sc.stop()

  }

repartition

1）函数签名

def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

2）函数说明

该操作内部其实执行的是coalesce操作，参数shuffle的默认值为true。无论是将分区数多的RDD转换为分区数少的RDD，还是将分区数少的RDD转换为分区数多的RDD，repartition操作都可以完成，因为无论如何都会经shuffle过程。

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子  - repartition -- 扩大分区
    val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 2)

    // repartition可以进行扩大分区 默认执行shuffle
    val newRDD = rdd.repartition(3)

    newRDD.saveAsTextFile("output")

    sc.stop()
  }

sortBy

1）函数签名

def sortBy[K]( 
f: (T) => K,
ascending: Boolean = true, 
numPartitions: Int = this.partitions.length) 
(implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

2）函数说明

该操作用于排序数据。在排序之前，可以将数据通过f函数进行处理，之后按照f函数处理的结果进行排序，默认为升序排列。排序后新产生的RDD的分区数与原RDD的分区数一致。中间存在shuffle的过程

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // TODO 算子  -- sortBy --排序
    val rdd = sc.makeRDD(List(1, 3, 5, 2, 6, 4), 1)

    // sortBy方法可以根据指定的规则对数据源中的数据进行排序, 默认为升序, 第二个参数可以指定 改为false即为降序
    // sortBy默认情况下, 不会改变分区, 但是中间存在shuffle操作
    val sortRDD = rdd.sortBy(num => num, false)

    sortRDD.saveAsTextFile("output")

    sc.stop()

  }

双Value类型

intersection

1）函数签名

def intersection(other: RDD[T]): RDD[T]

2）函数说明

对源RDD和参数RDD求交集后返回一个新的RDD

union

1）函数签名

def union(other: RDD[T]): RDD[T]

2）函数说明

对源RDD和参数RDD求并集后返回一个新的RDD

subtract

1）函数签名

def subtract(other: RDD[T]): RDD[T]

2）函数说明

以一个RDD元素为主，去除两个RDD中重复元素，将其他元素保留下来。求差集

1）函数签名

def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]

2）函数说明

将两个RDD中的元素，以键值对的形式进行合并。其中，键值对中的Key为第1个RDD
中的元素，Value为第2个RDD中的相同位置的元素。

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- 双 Value类型
    val rdd1 = sc.makeRDD(List(1, 2, 3, 4))
    val rdd2 = sc.makeRDD(List(3, 4, 5, 6))

    // 交集
    val rdd3 = rdd1.intersection(rdd2)
    println(rdd3.collect().mkString(","))

    // 并集
    val rdd4 = rdd1.union(rdd2)
    println(rdd4.collect().mkString(","))

    // 差集
    val rdd5 = rdd1.subtract(rdd2)
    println(rdd5.collect().mkString(","))

    // 拉链
    val rdd6 = rdd1.zip(rdd2)
    println(rdd6.collect().mkString(","))

    sc.stop()

  }

Key - Value类型

partitionBy

1）函数签名

def partitionBy(partitioner: Partitioner): RDD[(K, V)]

2）函数说明

将数据按照指定Partitioner重新进行分区。Spark默认的分区器是HashPartitioner

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- key-Value类型
    val rdd = sc.makeRDD(List(1, 2, 3, 4),2)

    val mapRDD = rdd.map((_,1))
    // RDD => PairRDDFunctions
    // 隐式转换 (二次编译)

    // partitionBy() 根据指定的分区规则对数据进行重分区
    mapRDD.partitionBy(new HashPartitioner(2))
      .saveAsTextFile("output")

    sc.stop()

  }

reduceByKey

1）函数签名

def reduceByKey(func: (V, V) => V): RDD[(K, V)] 
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

2）函数说明

可以将数据按照相同的Key对Value进行聚合

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- reduceByKey
    val rdd = sc.makeRDD(List(
      ("a", 1), ("a", 2), ("a", 3), ("b", 4)
    ))

    // reduceByKey: 相同的key的数据进行value数据的聚合操作
    // scala语言中的聚合操作是两两聚合, spark是基于scala开发的, 所以它的聚合操作也是两两聚合

    // reduceByKey中如果 key的数据只有一个, 是不会参与运算的
    val reduceRDD = rdd.reduceByKey((x: Int, y: Int) => {
      x + y
    })

    reduceRDD.collect().foreach(println)

    sc.stop()

  }

groupByKey

1）函数签名

def groupByKey(): RDD[(K, Iterable[V])] 
def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])] 
def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]

2）函数说明

将数据源的数据根据key对value进行分组

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- groupByKey

    val rdd = sc.makeRDD(List(
      ("a", 1), ("a", 2), ("a", 3), ("b", 4)
    ))

    // groupByKey : 将数据源中的数据,相同的key的数据分在一个组中,形成 一个对偶元组
    // 元组中的第一个元素就是key
    // 元组中的第二个元素就是相同的key的value的集合
    val groupRDD = rdd.groupByKey()

    groupRDD.collect().foreach(println)

    sc.stop()

  }

reduceByKey和groupByKey的区别？

从shuffle 的角度：reduceByKey 和groupByKey 都存在shuffle 的操作，但是reduceByKey可以在shuffle 前对分区内相同key的数据进行预聚合（combine）功能，这样会减少落盘的数据量，而groupByKey只是进行分组，不存在数据量减少的问题reduceByKey性能比较高。

从功能的角度：reduceByKey其实包含分组和聚合的功能。GroupByKey只能分组，不能聚合，所以在分组聚合的场合下，推荐使用reduceByKey，如果仅仅是分组而不需要聚合。那么还是只能使用groupByKey

aggregateByKey

1）函数签名

def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, 
combOp: (U, U) => U): RDD[(K, U)]

2）函数说明

将数据根据不同的规则进行分区内计算和分区间计算

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- aggregateByKey

    val rdd = sc.makeRDD(List(
      ("a", 1), ("a", 2), ("a", 3), ("a", 4)
    ), 2)
    //[a,[1,2]] [a,[3,4]]
    // (a, 2) (a, 4)

    // aggregateByKey存在函数柯里化, 有两个参数列表
    // 第一个参数列表 需要传递 一个参数 表示为初始值
    // 主要用于碰到第一个key和value进行分区内的计算
    // 第二个参数列表 需要传递两个参数
    // 第一个参数表示分区内的计算规则
    // 第二个参数表示分区间的计算规则
    rdd.aggregateByKey(0)(
      (x, y) => math.max(x, y),
      (x, y) => x + y
    ).collect().foreach(println)

    sc.stop()

  }

foldByKey

1）函数签名

def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

2）函数说明

当分区内计算规则和分区间计算规则相同时，aggregateByKey就可以简化为foldByKey

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- foldByKey

    val rdd = sc.makeRDD(List(
      ("a", 1), ("a", 2), ("a", 3), ("a", 4)
    ), 2)

    // 如果聚合计算时, 分区内和分区间的计算规则相同, spark提供了简化的方法

    rdd.foldByKey(0)(_+_).collect().foreach(println)

    sc.stop()

  }

combineByKey

1）函数签名

def combineByKey[C]( 
createCombiner: V => C, 
mergeValue: (C, V) => C, 
mergeCombiners: (C, C) => C): RDD[(K, C)]

2）函数说明

最通用的对key-value型rdd进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。

小练习：将数据List((“a”, 88), (“b”, 95), (“a”, 91), (“b”, 93), (“a”, 95), (“b”, 98))求每个 key 的平
均值

val list: List[(String, Int)] = List(("a", 88), ("b", 95), ("a", 91), ("b", 93), 
("a", 95), ("b", 98)) 
val input: RDD[(String, Int)] = sc.makeRDD(list, 2) 
val combineRdd: RDD[(String, (Int, Int))] = input.combineByKey( 
(_, 1), 
(acc: (Int, Int), v) => (acc._1 + v, acc._2 + 1), 
(acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2) 
)

reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别？

reduceByKey: 相同 key 的第一个数据不进行任何计算，分区内和分区间计算规则相同

FoldByKey: 相同 key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同

AggregateByKey：相同 key 的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同

CombineByKey:当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。

sortByKey

1）函数签名

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length) 
: RDD[(K, V)]

2）函数说明

在一个(K,V)的RDD上调用，K必须实现Ordered接口(特质)，返回一个按照key进行排序的

join

1）函数签名

def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

2）函数说明

在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素连接在一起的(K,(V,W))的 RDD

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- join

    val rdd1 = sc.makeRDD(List(
      ("a", 1), ("b", 2), ("c", 3)
    ))

    val rdd2 = sc.makeRDD(List(
      ("a", 4), ("b", 5), ("c", 6)
    ))

    // join : 两个不同数据源的数据, 相同的key的value会连接在一起, 形成元组
    // 如果两个数据源的key没有匹配上, 那么数据不会出现在结果中
    // 如果两个数据源中key有多个相同的, 会依次匹配, 可能会出现 笛卡儿积, 数据量会几何倍数增长, 会导致性能降低
    val joinRDD = rdd1.join(rdd2)

    joinRDD.collect().foreach(println)

    sc.stop()

  }

leftOuterJoin

1）函数签名

def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]

2）函数说明

类似于SQL语句的左外连接

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- leftOuterJoin rightOuterJoin

    val rdd1 = sc.makeRDD(List(
      ("a", 1), ("b", 2), ("c", 3)
    ))

    val rdd2 = sc.makeRDD(List(
      ("a", 4), ("b", 5), ("c", 6)
    ))

    val leftJoinRDD = rdd1.leftOuterJoin(rdd2)
    val rightJoinRDD = rdd1.rightOuterJoin(rdd2)

    leftJoinRDD.collect().foreach(println)
    rightJoinRDD.collect().foreach(println)

    sc.stop()

  }

cogroup

1）函数签名

def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]

2）函数说明

在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // 交集、并集、差集需要要求两个数据类型保持一致
    // 拉链操作两个数据源的类型可以不一致

    // TODO 算子  -- cogroup(分组连接)

    val rdd1 = sc.makeRDD(List(
      ("a", 1), ("b", 2), ("c", 3)
    ))

    val rdd2 = sc.makeRDD(List(
      ("a", 4), ("b", 5), ("c", 6)
    ))

    val cgRDD = rdd1.cogroup(rdd2)

    cgRDD.collect().foreach(println)

    sc.stop()

  }

RDD行动算子

reduce

1）函数签名

def reduce(f: (T, T) => T): T

2）函数说明

聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1,3,4,2))

    // TODO - 行动算子

    // reduce
    val i = rdd.reduce(_ + _)

    println(i)

    // collect : 方法会将不同分区的数据按照分区顺序采集到Driver端内存中, 形成数组
    val ints = rdd.collect()
    println(ints.mkString(","))

    // count : 数据源中数据的个数
    val cnt = rdd.count()
    println(cnt)

    // first : 获取数据源中数据的第一个
    val first = rdd.first()
    println(first)

    // take : 获取N个数据
    val ints1 = rdd.take(3)
    println(ints1.mkString(","))

    // takeOrdered : 数据排序后, 取3个数据
    val ints2 = rdd.takeOrdered(3)
    println(ints2.mkString(","))

    sc.stop()
  }

collect

1）函数签名

def collect(): Array[T]

2）函数说明

在驱动程序中，以数组Array的形式返回数据集的所有元素

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1,2,3,4))

    // TODO - 行动算子
    // 所谓的行动算子, 其实就是触发作业(Job)执行的方法
    // 底层代码调用的是环境对象的run.Job方法
    // 底层代码中会创建Action.Job, 并提交执行
    rdd.collect(),foreach(println)

    sc.stop()
  }

count

1）函数签名

def count(): Long

2）函数说明

返回RDD中元素的个数

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) 
// 返回RDD中元素的个数 
val countResult: Long = rdd.count()

first

1）函数签名

def first(): T

2）函数说明

返回RDD中的第一个元素

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) 
// 返回RDD中元素的个数 
val firstResult: Int = rdd.first() 
println(firstResult)

take

1）函数签名

def take(num: Int): Array[T]

2）函数说明

返回一个由RDD的前n个元素组成的数组

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) 
// 返回RDD中元素的个数 
val takeResult: Array[Int] = rdd.take(2) 
println(takeResult.mkString(","))

takeOrdered

1）函数签名

def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]

2）函数说明

返回该RDD排序后的前n个元素组成的数组

val rdd: RDD[Int] = sc.makeRDD(List(1,3,2,4)) 
// 返回RDD中元素的个数 
val result: Array[Int] = rdd.takeOrdered(2)

aggregate

1）函数签名

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U

2）函数说明

分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1,2,3,4), 2)

    // TODO - 行动算子 aggregate

    // aggregateByKey : 初始值只会参与分区内计算
    // aggregate : 初始值会参与分区内计算, 并且也参与分区间计算
    // 10 + 13 + 17 = 40
    val result = rdd.aggregate(10)(_ + _, _ + _)

    println(result)

    sc.stop()
  }

fold

1）函数签名

def fold(zeroValue: T)(op: (T, T) => T): T

2）函数说明

折叠操作，aggregate的简化版操作

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1,2,3,4), 2)

    // TODO - 行动算子 fold

    // aggregateByKey : 初始值只会参与分区内计算
    // aggregate : 初始值会参与分区内计算, 并且也参与分区间计算
    // 10 + 13 + 17 = 40
    val result = rdd.fold(10)(_ + _)

    println(result)

    sc.stop()
  }

countByKey

1）函数签名

def countByKey(): Map[K, Long]

2）函数说明

统计每种key的个数

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

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
    val sc = new SparkContext(sparkConf)

    // val rdd = sc.makeRDD(List(1,2,3,4), 2)

    val rdd = sc.makeRDD(List(
      ("a", 1), ("a", 1), ("a", 1)
    ))

    // TODO - 行动算子 countByKey

    // val intToLong = rdd.countByValue()
    // println(intToLong)

    val stringToLong = rdd.countByKey()
    println(stringToLong)

    sc.stop()
  }

save 相关算子

1）函数签名

def saveAsTextFile(path: String): Unit 
def saveAsObjectFile(path: String): Unit 
def saveAsSequenceFile( 
path: String, 
codec: Option[Class[_ <: CompressionCodec]] = None): Unit

2）函数说明

将数据保存到不同格式的文件中

// 保存成Text文件 
rdd.saveAsTextFile("output") 
// 序列化成对象保存到文件 
rdd.saveAsObjectFile("output1") 
// 保存成Sequencefile文件 
rdd.map((_,1)).saveAsSequenceFile("output2")

foreach

1）函数签名

def foreach(f: T => Unit): Unit = withScope { 
val cleanF = sc.clean(f) 
sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF)) 
}

2）函数说明

分布式遍历RDD中的每一个元素，调用指定函数

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) 
// 收集后打印 
rdd.map(num=>num).collect().foreach(println) 
println("****************") 
// 分布式打印 
rdd.foreach(println)

RDD 序列化

1）闭包检查
从计算的角度, 算子以外的代码都是在Driver端执行, 算子里面的代码都是在Executor端执行。那么在scala的函数式编程中，就会导致算子内经常会用到算子外的数据，这样就形成了闭包的效果，如果使用的算子外的数据无法序列化，就意味着无法传值给Executor端执行，就会发生错误，所以需要在执行任务计算前，检测闭包内的对象是否可以进行序列化，这个操作我们称之为闭包检测。Scala2.12版本后闭包编译方式发生了改变

序列化方法和属性
从计算的角度, 算子以外的代码都是在Driver端执行, 算子里面的代码都是在Executor端执行

object serializable02_function { 
 
    def main(args: Array[String]): Unit = { 
        //1.创建SparkConf并设置App名称 
        val conf: SparkConf = new 
SparkConf().setAppName("SparkCoreTest").setMaster("local[*]") 
 
        //2.创建SparkContext，该对象是提交Spark App的入口 
        val sc: SparkContext = new SparkContext(conf) 
 
        //3.创建一个RDD 
        val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", 
"hive", "atguigu")) 
 
        //3.1创建一个Search对象 
        val search = new Search("hello") 
 
        //3.2 函数传递，打印：ERROR Task not serializable 
        search.getMatch1(rdd).collect().foreach(println) 
 
        //3.3 属性传递，打印：ERROR Task not serializable 
        search.getMatch2(rdd).collect().foreach(println) 
 
        //4.关闭连接 
        sc.stop() 
    } 
} 
 
class Search(query:String) extends Serializable { 
 
    def isMatch(s: String): Boolean = { 
        s.contains(query) 
    } 
 
    // 函数序列化案例 
    def getMatch1 (rdd: RDD[String]): RDD[String] = { 
        //rdd.filter(this.isMatch) 
        rdd.filter(isMatch) 
    }
	 // 属性序列化案例 
    def getMatch2(rdd: RDD[String]): RDD[String] = { 
        //rdd.filter(x => x.contains(this.query)) 
        rdd.filter(x => x.contains(query)) 
        //val q = query 
        //rdd.filter(x => x.contains(q)) 
    } 
}

Kryo序列化框架
参考地址: https://github.com/EsotericSoftware/kryo
Java的序列化能够序列化任何的类。但是比较重（字节多），序列化后，对象的提交也
比较大。Spark出于性能的考虑，Spark2.0开始支持另外一种Kryo序列化机制。Kryo速度是Serializable的10倍。当RDD在Shuffle数据的时候，简单数据类型、数组和字符串类型已经在Spark内部使用Kryo来序列化。
注意：即使使用Kryo序列化，也要继承Serializable接口。

object serializable_Kryo { 
 
    def main(args: Array[String]): Unit = { 
 
        val conf: SparkConf = new SparkConf() 
                .setAppName("SerDemo") 
                .setMaster("local[*]") 
                // 替换默认的序列化机制 
                .set("spark.serializer", 
"org.apache.spark.serializer.KryoSerializer") 
                // 注册需要使用 kryo 序列化的自定义类 
                .registerKryoClasses(Array(classOf[Searcher])) 
 
        val sc = new SparkContext(conf) 
 
        val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello atguigu", 
"atguigu", "hahah"), 2) 
 
        val searcher = new Searcher("hello") 
        val result: RDD[String] = searcher.getMatchedRDD1(rdd) 
 
        result.collect.foreach(println) 
    } 
} 
case class Searcher(val query: String) { 
 
    def isMatch(s: String) = { 
        s.contains(query) 
    } 
 
    def getMatchedRDD1(rdd: RDD[String]) = { 
        rdd.filter(isMatch)  
    } 
 
    def getMatchedRDD2(rdd: RDD[String]) = { 
        val q = query 
        rdd.filter(_.contains(q)) 
    } 
}

RDD 依赖关系

（1）RDD血缘关系

RDD只支持粗粒度转换，即在大量记录上执行的单个操作。将创建RDD的一系列Lineage（血统）记录下来，以便恢复丢失的分区。RDD的Lineage会记录RDD的元数据信息和转换行为，当该RDD的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据分区。

val fileRDD: RDD[String] = sc.textFile("input/1.txt") 
println(fileRDD.toDebugString) 
println("----------------------") 
 
val wordRDD: RDD[String] = fileRDD.flatMap(_.split(" ")) 
println(wordRDD.toDebugString) 
println("----------------------") 
 
val mapRDD: RDD[(String, Int)] = wordRDD.map((_,1)) 
println(mapRDD.toDebugString) 
println("----------------------") 
 
val resultRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_) 
println(resultRDD.toDebugString) 
 
resultRDD.collect()

（2）RDD 依赖关系

这里所谓的依赖关系，其实就是两个相邻RDD之间的关系

val sc: SparkContext = new SparkContext(conf) 
 
val fileRDD: RDD[String] = sc.textFile("input/1.txt") 
println(fileRDD.dependencies) 
println("----------------------") 
 
val wordRDD: RDD[String] = fileRDD.flatMap(_.split(" ")) 
println(wordRDD.dependencies) 
println("----------------------") 
 
val mapRDD: RDD[(String, Int)] = wordRDD.map((_,1)) 
println(mapRDD.dependencies) 
println("----------------------") 
 
val resultRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_) 
println(resultRDD.dependencies) 
 
resultRDD.collect()

（3）RDD 窄依赖

窄依赖表示每一个父(上游)RDD的Partition最多被子（下游）RDD的一个Partition使用，
窄依赖我们形象的比喻为独生子女。

class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd)

（4）RDD 宽依赖

宽依赖表示同一个父（上游）RDD的Partition被多个子（下游）RDD的Partition依赖，会引起Shuffle，总结：宽依赖我们形象的比喻为多生。

（5）RDD 阶段划分

DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向，不会闭环。

（6）RDD 阶段划分源码

try { 
  // New stage creation may throw an exception if, for example, jobs are run on 
a 
  // HadoopRDD whose underlying HDFS files have been deleted. 
  finalStage = createResultStage(finalRDD, func, partitions, jobId, callSite) 
} catch { 
  case e: Exception => 
    logWarning("Creating new stage failed due to exception - job: " + jobId, e) 
    listener.jobFailed(e) 
    return 
} 
 
…… 
 
private def createResultStage( 
  rdd: RDD[_], 
  func: (TaskContext, Iterator[_]) => _, 
  partitions: Array[Int], 
  jobId: Int, 
  callSite: CallSite): ResultStage = { 
val parents = getOrCreateParentStages(rdd, jobId) 
val id = nextStageId.getAndIncrement() 
val stage = new ResultStage(id, rdd, func, partitions, parents, jobId, callSite) 
stageIdToStage(id) = stage 
updateJobIdStageIdMaps(jobId, stage) 
stage 
}
…… 
private def getOrCreateParentStages(rdd: RDD[_], firstJobId: Int): List[Stage] 
= { 
getShuffleDependencies(rdd).map { shuffleDep => 
getOrCreateShuffleMapStage(shuffleDep, firstJobId) 
}.toList 
} 
…… 
private[scheduler] def getShuffleDependencies( 
rdd: RDD[_]): HashSet[ShuffleDependency[_, _, _]] = { 
val parents = new HashSet[ShuffleDependency[_, _, _]] 
val visited = new HashSet[RDD[_]] 
val waitingForVisit = new Stack[RDD[_]] 
waitingForVisit.push(rdd) 
while (waitingForVisit.nonEmpty) { 
val toVisit = waitingForVisit.pop() 
if (!visited(toVisit)) { 
visited += toVisit 
toVisit.dependencies.foreach { 
case shuffleDep: ShuffleDependency[_, _, _] => 
parents += shuffleDep 
case dependency => 
waitingForVisit.push(dependency.rdd) 
} 
} 
} 
parents 
}

（7）RDD 任务划分

RDD任务切分中间分为：Application、Job、Stage和Task

Application：初始化一个SparkContext即生成一个Application；
Job：一个Action算子就会生成一个Job；
Stage：Stage 等于宽依赖(ShuffleDependency)的个数加1；
Task：一个Stage阶段中，最后一个RDD的分区个数就是Task的个数。
注意：Application->Job->Stage->Task 每一层都是 1 对 n 的关系。

（8）RDD 任务划分源码

val tasks: Seq[Task[_]] = try { 
  stage match { 
    case stage: ShuffleMapStage => 
      partitionsToCompute.map { id => 
        val locs = taskIdToLocations(id) 
        val part = stage.rdd.partitions(id) 
        new ShuffleMapTask(stage.id, stage.latestInfo.attemptId, 
          taskBinary, part, locs, stage.latestInfo.taskMetrics, properties, 
Option(jobId), 
          Option(sc.applicationId), sc.applicationAttemptId) 
      } 
 
    case stage: ResultStage => 
      partitionsToCompute.map { id => 
        val p: Int = stage.partitions(id) 
        val part = stage.rdd.partitions(p) 
        val locs = taskIdToLocations(id) 
        new ResultTask(stage.id, stage.latestInfo.attemptId, 
          taskBinary, part, locs, id, properties, stage.latestInfo.taskMetrics, 
          Option(jobId), Option(sc.applicationId), sc.applicationAttemptId) 
      } 
  } 
 
…… 
 
val partitionsToCompute: Seq[Int] = stage.findMissingPartitions() 
 
…… 
 
override def findMissingPartitions(): Seq[Int] = { 
mapOutputTrackerMaster 
  .findMissingPartitions(shuffleDep.shuffleId) 
  .getOrElse(0 until numPartitions) 
}

RDD 持久化

RDD Cache 缓存
RDD 通过 Cache 或者 Persist 方法将前面的计算结果缓存，默认情况下会把数据以缓存在 JVM 的堆内存中。但是并不是这两个方法被调用时立即缓存，而是触发后面的 action 算子时，该 RDD 将会被缓存在计算节点的内存中，并供后面重用

// cache 操作会增加血缘关系，不改变原有的血缘关系
println(wordToOneRdd.toDebugString)
// 数据缓存。
wordToOneRdd.cache()
// 可以更改存储级别
//mapRdd.persist(StorageLevel.MEMORY_AND_DISK_2)

存储级别
在这里插入图片描述
Spark 会自动对一些 Shuffle 操作的中间数据做持久化操作(比如：reduceByKey)。这样做的目的是为了当一个节点 Shuffle 失败了避免重新计算整个输入。但是，在实际使用的时候，如果想重用数据，仍然建议调用 persist 或 cache

RDD CheckPoint 检查点
所谓的检查点其实就是通过将 RDD 中间结果写入磁盘
由于血缘依赖过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果检查点之后有节点出现问题，可以从检查点开始重做血缘，减少了开销。
对 RDD 进行 checkpoint 操作并不会马上被执行，必须执行 Action 操作才能触发

// 设置检查点路径
sc.setCheckpointDir("./checkpoint1")
// 创建一个 RDD，读取指定位置文件:hello atguigu atguigu
val lineRdd: RDD[String] = sc.textFile("input/1.txt")
// 业务逻辑
val wordRdd: RDD[String] = lineRdd.flatMap(line => line.split(" "))
val wordToOneRdd: RDD[(String, Long)] = wordRdd.map {
 word => {
 (word, System.currentTimeMillis())
 }
}
// 增加缓存,避免再重新跑一个 job 做 checkpoint
wordToOneRdd.cache()
// 数据检查点：针对 wordToOneRdd 做检查点计算
wordToOneRdd.checkpoint()
// 触发执行逻辑
wordToOneRdd.collect().foreach(println)

缓存和检查点区别
1）Cache 缓存只是将数据保存起来，不切断血缘依赖。Checkpoint 检查点切断血缘依赖。
2）Cache 缓存的数据通常存储在磁盘、内存等地方，可靠性低。Checkpoint 的数据通常存储在 HDFS 等容错、高可用的文件系统，可靠性高。
3）建议对 checkpoint()的 RDD 使用 Cache 缓存，这样 checkpoint 的 job 只需从 Cache 缓存中读取数据即可，否则需要再从头计算一次 RDD

RDD 分区器

Spark 目前支持 Hash 分区和 Range 分区，和用户自定义分区。Hash 分区为当前的默认分区。分区器直接决定了 RDD 中分区的个数、RDD 中每条数据经过 Shuffle 后进入哪个分区，进而决定了 Reduce 的个数。

Hash 分区：对于给定的 key，计算其 hashCode,并除以分区个数取余

class HashPartitioner(partitions: Int) extends Partitioner {
 require(partitions >= 0, s"Number of partitions ($partitions) cannot be 
negative.")
 def numPartitions: Int = partitions
 def getPartition(key: Any): Int = key match {
 case null => 0
 case _ => Utils.nonNegativeMod(key.hashCode, numPartitions)
 }
 override def equals(other: Any): Boolean = other match {
 case h: HashPartitioner =>
 h.numPartitions == numPartitions
 case _ =>
 false
 }
 override def hashCode: Int = numPartitions
}

Range 分区：将一定范围内的数据映射到一个分区中，尽量保证每个分区数据均匀，而
且分区间有序

class RangePartitioner[K : Ordering : ClassTag, V](
 partitions: Int,
 rdd: RDD[_ <: Product2[K, V]],
 private var ascending: Boolean = true)
 extends Partitioner {
 // We allow partitions = 0, which happens when sorting an empty RDD under the 
default settings.
 require(partitions >= 0, s"Number of partitions cannot be negative but found 
$partitions.")
 private var ordering = implicitly[Ordering[K]]
 // An array of upper bounds for the first (partitions - 1) partitions
 private var rangeBounds: Array[K] = {
 ...
 }
 def numPartitions: Int = rangeBounds.length + 1
 private var binarySearch: ((Array[K], K) => Int) = 
CollectionsUtils.makeBinarySearch[K]
def getPartition(key: Any): Int = {
 val k = key.asInstanceOf[K]
 var partition = 0
 if (rangeBounds.length <= 128) {
 // If we have less than 128 partitions naive search
 while (partition < rangeBounds.length && ordering.gt(k, 
rangeBounds(partition))) {
 partition += 1
 }
 } else {
 // Determine which binary search method to use only once.
 partition = binarySearch(rangeBounds, k)
 // binarySearch either returns the match location or -[insertion point]-1
 if (partition < 0) {
 partition = -partition-1
 }
 if (partition > rangeBounds.length) {
 partition = rangeBounds.length
 }
 }
 if (ascending) {
 partition
 } else {
 rangeBounds.length - partition
 }
 }
 override def equals(other: Any): Boolean = other match {
 ...
 }
 override def hashCode(): Int = {
 ...
 }
 @throws(classOf[IOException])
 private def writeObject(out: ObjectOutputStream): Unit = 
Utils.tryOrIOException {
 ...
 }
 @throws(classOf[IOException])
 private def readObject(in: ObjectInputStream): Unit = Utils.tryOrIOException 
{
 ...
 }
}

用户自定义分区

import org.apache.spark.{Partitioner, SparkConf, SparkContext}

object Spark01_RDD_part {

  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(
      ("nba", "xxxxxxxxxxxx"),
      ("cba", "xxxxxxxxxxxx"),
      ("wnba", "xxxxxxxxxxxx"),
      ("nba", "xxxxxxxxxxxx")
    ))

    val partRDD = rdd.partitionBy(new MyPartitioner)

    partRDD.saveAsTextFile("output")

    sc.stop()
  }

  /**
   * 自定义分区器
   * 1、继承Partitioner
   * 2、重写方法
   */
  class MyPartitioner extends Partitioner {
    // 分区数量
    override def numPartitions: Int = 3

    // 根据数据的key值, 返回数据的分区索引（从0开始）
    override def getPartition(key: Any): Int = {
      key match {
        case "nba" => 0
        case "cba" => 1
        case _ => 2
      }
    }

  }
}

RDD 文件读取与保存

Spark 的数据读取及数据保存可以从两个维度来作区分：文件格式以及文件系统。
- 文件格式分为：text 文件、csv 文件、sequence 文件以及 Object 文件；
- 文件系统分为：本地文件系统、HDFS、HBASE 以及数据库。

text 文件

// 读取输入文件
val inputRDD: RDD[String] = sc.textFile("input/1.txt")
// 保存数据
inputRDD.saveAsTextFile("output")

sequence 文件

SequenceFile 文件是 Hadoop 用来存储二进制形式的 key-value 对而设计的一种平面文件(Flat 
File)。在 SparkContext 中，可以调用 sequenceFile[keyClass, valueClass](path)。
// 保存数据为 SequenceFile
dataRDD.saveAsSequenceFile("output")
// 读取 SequenceFile 文件
sc.sequenceFile[Int,Int]("output").collect().foreach(println)

object 对象文件

 对象文件是将对象序列化后保存的文件，采用 Java 的序列化机制。可以通过 objectFile[T: ClassTag](path)函数接收一个路径，读取对象文件，返回对应的 RDD，也可以通过调用saveAsObjectFile()实现对对象文件的输出。因为是序列化所以要指定类型。

// 保存数据
dataRDD.saveAsObjectFile("output")
// 读取数据
sc.objectFile[Int]("output").collect().foreach(println)

累加器

实现原理

累加器用来把 Executor 端变量信息聚合到 Driver 端。在 Driver 程序中定义的变量，在Executor 端的每个 Task 都会得到这个变量的一份新的副本，每个 task 更新这些副本的值后，传回 Driver 端进行 merge。

基础编程

系统累加器

val rdd = sc.makeRDD(List(1,2,3,4,5))
// 声明累加器
var sum = sc.longAccumulator("sum");
rdd.foreach(
 num => {
 // 使用累加器
 sum.add(num)
 }
)
// 获取累加器的值
println("sum = " + sum.value)

自定义累加器

import org.apache.spark.util.AccumulatorV2
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.mutable

object Spark04_Acc_WordCount {

  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List("hello", "spark", "hello", "scala"))

    // 累加器 : wordcount
    // 创建累加器对象
    val wcAcc = new MyAccumulator

    // 向spark进行注册
    sc.register(wcAcc, "wordcountAcc")

    rdd.foreach(
      word => {
        // 数据的累加 (使用累加器)
        wcAcc.add(word)
      }
    )

    // 获取累加器的结果
    println(wcAcc.value)

    sc.stop()
  }

  /**
   * 自定义累加器 : wordcount
   * 1、继承AccumulatorV2, 定义泛型
   * IN : 累加器输入的数据类型 String
   * OUT : 累加器返回的数据类型 Map
   *
   * 2、重写方法
   */
  class MyAccumulator extends AccumulatorV2[String, mutable.Map[String, Long]] {

    private var wcMap = mutable.Map[String, Long]()

    // 判断是否为初始状态
    override def isZero: Boolean = {
      wcMap.isEmpty
    }

    override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = {
      new MyAccumulator
    }

    override def reset(): Unit = {
      wcMap.clear()
    }

    // 获取累加器需要计算的值
    override def add(word: String): Unit = {
      val newCnt = wcMap.getOrElse(word, 0L) + 1
      wcMap.update(word, newCnt)
    }

    // 合并累加器
    override def merge(other: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = {
      val map1 = this.wcMap
      val map2 = other.value

      map2.foreach {
        case (word, count) => {
          val newCount = map1.getOrElse(word, 0L) + count
          map1.update(word, newCount)
        }
      }
    }

    // 累加器结果
    override def value: mutable.Map[String, Long] = {
      wcMap
    }
  }
}

广播变量

实现原理

广播变量用来高效分发较大的对象。向所有工作节点发送一个较大的只读值，以供一个或多个 Spark 操作使用。比如，如果你的应用需要向所有节点发送一个较大的只读查询表，广播变量用起来都很顺手。在多个并行操作中使用同一个变量，但是Spark 会为每个任务分别发送。

基础编程

import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.mutable

object Spark02_Bc {

  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    val rdd1 = sc.makeRDD(List(
      ("a", 1),
      ("b", 2),
      ("c", 3)
    ))

    val map = mutable.Map(("a", 4), ("b", 5), ("c", 6))

    // 封装广播变量
    val bc = sc.broadcast(map)

    rdd1.map {
      case (w, c) => {
        // 使用广播变量
        val l = bc.value.getOrElse(w, 0)
        (w, (c, l))
      }
    }.collect().foreach(println)

    sc.stop()
  }

}