Spark学习笔记(2)——SparkCore之RDD(1)

---

1.RDD

1.1 RDD简介

RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是spark中最基本的数据处理模型，是最小的计算单元它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合
➢ 弹性
⚫ 存储的弹性：内存与磁盘的自动切换；
⚫ 容错的弹性：数据丢失可以自动恢复；
⚫ 计算的弹性：计算出错重试机制；
⚫ 分片的弹性：可根据需要重新分片。
➢ 分布式：数据存储在大数据集群不同节点上
➢ 数据集：RDD 封装了计算逻辑，并不保存数据
➢ 数据抽象：RDD 是一个抽象类，需要子类具体实现
➢ 不可变：RDD 封装了计算逻辑，是不可以改变的，想要改变，只能产生新的 RDD，在
新的 RDD 里面封装计算逻辑
➢ 可分区、并行计算

如图所示，RDD封装了处理逻辑。当时候提交时，源数据被切分中多个Task，分发到不同的Executor节点，通过RDD中封装的逻辑进行计算任务。
RDD在代码中是一个抽象类，每一个具体实现的RDD都具有不同的功能，RDD的设计使用了装饰者模式，类似于java io中的流（即我们可以把字节流FileInputStream包装成字符流，又可以把字符流包装成缓冲流）
如下图，我们可以把一个HadoopRDD包装成MapPartitionsRDD

1.2 RDD核心属性

protected def getPartitions : scala.Array[org.apache.spark.Partition]

分区列表：RDD 数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要属性

def compute(split : org.apache.spark.Partition, context : org.apache.spark.TaskContext) : scala.Iterator[T]

分区计算函数：Spark 在计算时，是使用分区函数对每一个分区进行计算

protected def getDependencies : scala.Seq[org.apache.spark.Dependency[_]] = { /* compiled code */ }

RDD 之间的依赖关系：RDD 是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个 RDD 建
立依赖关系

val partitioner : scala.Option[org.apache.spark.Partitioner] = { /* compiled code */ }

分区器（可选）:当数据为 KV 类型数据时，可以通过设定分区器自定义数据的分区

protected def getPreferredLocations(split : org.apache.spark.Partition) : scala.Seq[_root_.scala.Predef.String] = { /* compiled code */ }

首选位置（可选）:计算数据时，可以根据计算节点的状态选择不同的节点位置进行计算

1.3 执行原理

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

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

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

1. 启动 Yarn 集群环境
   
2. Spark 通过申请资源创建调度节点和计算节点
   
3. Spark 框架根据需求将计算逻辑根据分区划分成不同的任务
   
4. 调度节点将任务根据计算节点状态发送到对应的计算节点进行计算
   
   从以上流程可以看出 RDD 在整个流程中主要用于将逻辑进行封装，并生成 Task 发送给Executor 节点执行计算。

1.4 基础编程

1.4.1创建RDD

在 Spark 中创建 RDD 的创建方式可以分为四种：

(1) 从集合（内存）中创建 RDD

object RDDCreat {
  def main(args: Array[String]): Unit = {
    //准备环境
    val sparkConf = new SparkConf().setMaster("local[4]").setAppName("RDD")
    val sparkContext = new SparkContext(sparkConf)
    //创建RDD
    //从内存中创建RDD,将内存中集合的数据作为处理的数据源
    val seq =Seq[Int](1,2,3,4)
    //parallelize并行
    //val rdd = sparkContext.parallelize(seq)
    //makeRDD其实就是调用了parallelize
    val rdd = sparkContext.makeRDD(seq)
    //RDD本身不存储数据，只有在collect方法执行时，才执行其本身的逻辑
    rdd.collect().foreach(println)
    //释放环境
    sparkContext.stop()
  }

}

(2) 从文件中创建 RDD

 val sparkConf = new SparkConf().setMaster("local[4]").setAppName("RDD")
    val sparkContext = new SparkContext(sparkConf)
    //从文件中构建RDD,path可以是绝对路径，相对路径，也可是目录。
    //path路径还可以存在通配符*
    //还是可以是HDFS文件路径
    //textFile以行来读取数据
    var rdd: RDD[String] = sparkContext.textFile("data")
    //wholeTextFiles以文件为单位读取数据
    var rdd1: RDD[(String, String)] = sparkContext.wholeTextFiles("data")
    rdd.collect().foreach(println)
    rdd1.collect().foreach(println)

以文件为单位读取数据的结果

1.4.2 RDD源数据分区

内存RDD

 val conf: SparkConf = new SparkConf().setMaster("local[4]").setAppName("RDD")
    val sparkContext = new SparkContext(conf)
    //makeRDD方法的第二个参数即为分区的数量，不给定这个参数的话，默认从配置对象获取这个参数spark.default.paralleism的值，如果获取不到，则使用totalCores这个属性，就是你配置的当前环境最大可使用的cpu核心数
    val rdd = sparkContext.makeRDD(List(1,2,3,4),2)
    //将结果保存成文件
    rdd.saveAsTextFile("output")
    sparkContext.stop()

可以看到这个List被分成了2个文件


文件RDD
文件的分区模式与Hadoop是一样的

///textFile方法中第二个参数表示最小分区，如果文件数据量不能整除，那么根据Hadoop的1.1原则，当多出10%以上的数据时，会多出一个分区，否则就不会
var rdd2: RDD[String] = sparkContext.textFile("data", 2)

1.4.3 RDD算子

在RDD中，存在两类方法

1. 转换：功能的补充和封装，将旧的RDD包装成新的RDD，比如flatmap,map
2. 行动: 触发任务的调度和作业的执行，比如collect

这样的方法呢，就叫做算子（operator)

1.4.3.1 转换算子

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

Value类型

1.map

** 函数签名**

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

示例

object Transform {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sparkContext = new SparkContext(conf)
    //注意，不同分区的数据是并行计算的
    var rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
    var rddmap: RDD[Int] = rdd.map((num) => {
      num * 2
    })
    rddmap.collect().foreach(println)
  }

}

运行结果

2.mapPartitions

函数签名

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

函数说明
该方法和map的区别是将数据（以分区为单位）全部读取到缓存再执行计算逻辑，而不是读一个算一个

示例

 val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sparkContext = new SparkContext(conf)
    var rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4))
    //MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，
//所以可以增加或减少数据
    val rddmapPartitions = rdd.mapPartitions((iter=>{iter.map(_+1)}))
    rddmapPartitions.collect().foreach(println)

当内存小，数据多时，可能会造成oom

3.mapPartitionsWithIndex

故名思意，这个算子可以获取分区的索引
函数签名

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

示例：如果是第一个分区，返回数据的迭代器，如果不是，返回一个空列表的迭代器

val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sparkContext = new SparkContext(conf)
    var rdd: RDD[Int] = sparkContext.makeRDD(List(1, 2, 3, 4),2)
    rdd.mapPartitionsWithIndex((index,iter)=>{
      if(index==1)
        iter
      else Nil.iterator
    })

4.flatmap

函数签名

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

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

示例：拆分一个句子的所有单词

val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sparkContext = new SparkContext(conf)
    val rdd = sparkContext.makeRDD(List("hello scala spark"))
    val rddflatmap = rdd.flatMap(list => list.split(" "))
    rddflatmap.foreach(println)

示例：将 List(List(1,2),3,List(4,5))进行扁平化操作
当元素类型不确定时候，可以使用scala中的模式匹配

var rdd: RDD[Any] = sparkContext.makeRDD(List(List(1, 2), 3, List(4, 5)))
    var rddfaltmap: RDD[Int] = rdd.flatMap((data => {
      data match {
        case list: List[Int] => list
        case dat: Int => List(dat)
      }
    }))
    rddfaltmap.foreach(println)

5.glom

函数签名

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

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

6.groupBy

函数签名

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

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

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

示例:将奇偶数放在不同的分区

val conf = new SparkConf().setMaster("local[*]").setAppName("test")
    val sc = new SparkContext(conf)
    val rdd = sc.makeRDD(List(1,2,3,4),2)
    //指定分区的key
    val rddGroup = rdd.groupBy((num)=>num%2)
    rddGroup.collect().foreach(println)

这个例子中，不同分区的数据被重新组合了

7.filter

** 函数签名**

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

** 函数说明**
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。

当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜

8.sample

函数签名

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

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

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

9.distinct

函数签名

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

** 函数说明**
将数据集中重复的数据去重

10.coalesce

函数签名

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

函数说明
根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本

def coalesce(numPartitions: Int, //新的分区个数
shuffle: Boolean = false,//是否shuffle，即打乱重新分区。默认为否，这样可能导致数据倾斜
 partitionCoalescer: Option[PartitionCoalescer] = Option.empty)
 (implicit ord: Ordering[T] = null)
 : RDD[T]

** 补充**
怎样扩大分区
当coalesce的分区数大于原分区数，再指定shuffle操作为true，就可以实现扩大分区个数的效果了
spark将这个操作又重新封装成了repartition方法。我们可以直接调用repatition实现扩大分区

11.sortBy

函数签名

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

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

双Value类型

12.intersection（交集）

** 函数签名**

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

** 函数说明**
对源 RDD 和参数 RDD 求交集后返回一个新的 RDD
示例：

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

13.union（并集）

函数签名
def union(other: RDD[T]): RDD[T]
函数说明
对源 RDD 和参数 RDD 求并集后返回一个新的 RDD

14.subtract（差集）

函数签名

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

函数说明
以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。

15.zip（拉链）

函数签名

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

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

补充
不可以将分区数量不一致或者分区中元素数量不一致的RDD进行zip

Key-Value类型

16.partitionBy

函数签名

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

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

 val conf = new SparkConf().setMaster("local[*]").setAppName("test")
    val sc = new SparkContext(conf)
    val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1,"aaa"),(2,"bbb"),(3,"ccc")),3)
    //partitionBy是PairRDDFunctions类的方法，这里用到了隐式转换
    //当第一次编码类型不通过是，scala会尝试在上下文寻找隐士函数转换类型
    rdd.partitionBy(new HashPartitioner(2)).saveAsTextFile("output")

17.reduceByKey

函数签名

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

函数说明
可以将数据按照相同的 Key 对 Value 进行两两聚合
reduceBykey要求分区内和分区间不独立，因为在shuffle阶段前会在分区内进行相同的key之间的聚合
示例

 val conf = new SparkConf().setMaster("local[*]").setAppName("test")
    val sc = new SparkContext(conf)
    val rdd = sc.makeRDD(List(("a",1),("a",2),("a",3),("b",4)))
    //函数参数是两个value
    rdd.reduceByKey((x,y)=>x+y).collect().foreach(println)

18.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 进行分组
与groupBy的区别是：groupByKey的分区key是指定的，value会独立出来，groupBy的分区key是指定的，会把整理进行分组

19.aggregateByKey

函数签名

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

函数说明
将数据根据不同的规则进行分区内聚合和分区间聚合

//第一个参数列表需要转递一个参数，表示为初始值
//主要用于碰见第一个key的时候和value进行分区计算
//注意返回的数据类型是初始值类型
def aggregateByKey[U: ClassTag](zeroValue: U)
//第二个参数列表转递两个函数
//第一个函数表示分区内聚合规则
(seqOp: (U, V) => U,
 combOp: (U, U) => U): RDD[(K, U)]

示列：求不同key的value平均数

def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName("test")
    val sc = new SparkContext(conf)
    val rdd = sc.makeRDD(List(("a", 4), ("a", 5), ("a", 3),
      ("b", 4), ("b", 6), ("b", 20)))
    //初始值元组（key个数，value总和)
    var rddAggregateBykey: RDD[(String, (Int, Int))] = rdd.aggregateByKey((0, 0))((t, v) => {
      (t._1 + 1, t._2 + v)
    }, (u1, u2) => {
      (u1._1 + u2._1, u1._2 + u2._2)
    })
    rddAggregateBykey.map((t)=>(t._1,t._2._2/t._2._1)).collect().foreach(println)
  }

20.foldByKey

函数签名

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

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

21.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()允许用户返回值的类型与输入不一致。
与aggregateByKey的区别在于，combineByKey第一个参数是一个函数，作用是让第一个数据转换成我们需要的数据结构

思考一个问题：reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别？

1. reduceByKey: 相同 key 的第一个数据不进行任何计算，分区内和分区间计算规则相同
2. FoldByKey: 相同 key 的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同
3. AggregateByKey：相同 key 的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相
4. CombineByKey:当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。

这四个算子都调用了combineByKeyWithClassTag方法

22.sortByKey

函数签名

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

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

23.join

函数签名

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

函数说明
在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的 RDD
如果不存在相同key，那么这个key就会被丢掉
如果相同的key很多，便会依次匹配，出现笛卡尔积，数据量大幅增长

24.leftOuterJoin

函数签名

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

函数说明

类似于 SQL 语句的左外连接

补充：右连接就是rightOuterJoin

25.cogroup

函数签名

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

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

1.4.3.2 行动算子

所谓行动算子，其实就是触发作业(job)执行的方法
底层代码调用的是环境对象的runjob方法

reduce

函数签名

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

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

collect

函数签名

def collect(): Array[T]

函数说明
以数组 Array 的形式返回数据集的所有元素到driver端内存中

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

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

foreach

函数签名

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

函数说明
分布式遍历 RDD 中的每一个元素，调用指定函数
这是在executor端执行的