Spark RDD的转换

Spark RDD的转换_第1张图片

按颜色区分转换:

  • 绿色是单 RDD 窄依赖转换
  • 黑色是多 RDD 窄依赖转换
  • 紫色是 KV 洗牌型转换
  • 黄色是重分区转换
  • 蓝色是特例的转换

单 RDD 窄依赖转换

MapPartitionRDD

这个 RDD 在第一次分析中已经分析过。简单复述一下:

  • 依赖列表:一个窄依赖,依赖上游 RDD
  • 分区列表:上游 RDD 的分区列表
  • 计算流程:映射关系(输入一个分区,返回一个迭代器)
  • 分区器 :上游 RDD 的分区器
  • 存储位置:上游 RDD 的优先位置 可见除了计算流程,其他都是上游 RDD 的内容。
  1. map 传入一个带“值到值”转化函数的迭代器(例如字符串到字符串长度)
  2. mapPartitions 传入一个“迭代器到迭代器”的转化函数,如果需要按分区做一些比较重的过程(例如数据库连接等)
  3. flatMap 传入一个“迭代器到迭代器的迭代器”的转化函数(例如,统计字母,“字符串的迭代器”到“‘字符的迭代器’的迭代器”)
  4. filter 传入了一个带“值到布尔值”筛选函数的迭代器

PartitionwiseSampledRDD

在分区中采样的RDD

  • 分区列表:在上游的分区的基础上包装一个采样过程,形成一个新的分区PartitionwiseSampledRDDPartition
  • 计算流程:采样器返回的迭代器
  • 其他成分:与上游 RDD 相同 PartitionwiseSampledRDD,有放回的采样用泊松采样器,无放回的采样用伯努利采样器,传给分区器。

多 RDD 窄依赖

UnionRDD

  • 依赖列表:每个上游 RDD 一个RangeDependency,每个RangeDependency依赖上游 RDD 的所有分区
  • 分区列表:每个上游 RDD 一个UnionPartition,构成列表
  • 计算流程:获得目标分区的迭代器
  • 分区器 :None
  • 存储位置:每个上游 RDD 的优先位置

CartesianRDD

笛卡尔积,是两个 RDD 每个数据都进行一次关联。下文中两个 RDD 的关联中,两个 RDD 分别称为 rdd1、rdd2。

  • 依赖列表:两个窄依赖组成的数组,分别依赖 rdd1、rdd2
  • 分区列表:“rdd1的分区数 乘以 rdd2的分区数”个分区
  • 计算流程:rdd1的一条记录与 rdd2的一条记录合成元组
  • 分区器 :None
  • 存储位置:rdd1、rdd2的存储位置的积

洗牌型转换

洗牌型转换,是多个 RDD 关联的的转换。

CoGroupedRDD

多个源 RDD 依据 key 关联,key 相同的合并,形成最终的目标 RDD。

  • 依赖列表:每个源 RDD 一个依赖,构成列表。如果源 RDD 的分区器与目标的分区器相同,则是1-to-1依赖,如果不同,则是洗牌依赖
  • 分区列表:目标 RDD 分区器指定的分区数量个CoGroupPartition,每个分区记录了数据来源分区。其中如果是洗牌依赖的数据源,需要洗牌过程,具体洗牌过程以后再分析
  • 计算流程:返回一个迭代器,迭代对象是 key 和 key 对应源分区迭代器的数组 组成的元祖
  • 分区器 :目标 RDD 的分区器
  • 存储位置:None

ShuffledRDD

同样是多个源 RDD 依据 key 关联,key 相同的做排序或聚合运算,形成最终的目标 RDD。

  • 依赖列表:一个洗牌依赖,依赖所有上游 RDD
  • 分区列表:目标 RDD 分区器指定的分区数量个ShuffledRDDPartition,每个分区只有一个编号(因为每个上游分区)
  • 计算流程:洗牌过程,具体洗牌过程以后再分析
  • 分区器 :目标 RDD 的分区器
  • 存储位置:None

除了这五个成员以外,还有另外几个重要的成员:序列化器、key 排序器、聚合器、map 端合并器,他们都将用于洗牌

其他

  • coalesce,是减少分区数量,可以在过滤之后,使数据更集中,以提高效率
  • repartition,是重新分区,增加或减少分区数量,数据随机重新分配,可以消除分区间的数据量差异
  • pipe,是与外部程序管道关联,从外部程序中获取数据。

Scala语法

在 RDD.scala中,几乎每一个转换和操作函数都会有一个withScope,例如:

def map[U: ClassTag](f: T => U): RDD[U] = withScope {
    val cleanF = sc.clean(f)
    new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.map(cleanF))
}
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] = withScope {
    val cleanF = sc.clean(f)
    new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.flatMap(cleanF))
}

withScope是一个函数,调用了RDDOperationScope.withScope方法:

private[spark] def withScope[U](body: => U): U = RDDOperationScope.withScope[U](sc)(body)

withScope就像是一个 AOP(面向切面编程),嵌入到所有RDD 的转换和操作的函数中,RDDOperationScope会把调用栈记录下来,用于绘制Spark UI的 DAG(有向无环图,可以理解为 Spark 的执行计划)。

我们用下面的代码简单演示一下 Scala 用函数做 AOP:

object Day1 {
  def main(args: Array[String]) = {
    Range(1,5).foreach(twice)
    println()
    Array("China", "Beijing", "HelloWorld").foreach(length)
  }

  def twice(i: Int): Int = aopPrint {
    i * 2
  }

  def length(s: String): Int = aopPrint {
    s.length
  }

  def aopPrint[U](i: => U): U = {
    print(i + " ")
    i
  }
}

aopPrint的 入参是“一个返回类型为U的函数”。这段程序中aopPrint就是一个模拟的切面,作用是把所有的函数返回值打印出来。结果是:

2 4 6 8 
5 7 10

从代码上看,aopPrint并没有降低代码的可读性。读者依然能很清楚地读懂twice和length函数。打印返回结果这个流程是独立于函数之外的切面。

结论

  1. RDD 的转换分图上几种
  2. RDD 的转换可以看成是产生新的 RDD,而新的 RDD 记录了每一个分区依赖上游的哪些分区、每个分区如何用上游分区计算而来

 

你可能感兴趣的:(知识总结,spark,大数据,RDD)