Spark - [04] RDD编程

题记部分

一、RDD编程模型

  在 Spark 中，RDD 被表示为对象，通过对象上的方法调用来对 RDD 进行转换。经过一系列的 transformations 定义 RDD 之后，就可以调用 actions 触发 RDD的计算，action 可以是向应用程序返回结果（count，collect等），或者是向存储系统保存数据（saveAsTextFile等）。在 Spark 中，只有遇到 action，才会执行 RDD 的计算（即延迟计算），这样在运行时可以通过管道的方式传输多个转换。
  要使用 Spark，开发者需要编写一个 Driver 程序，它被提交到集群以调度运行 Worker。

二、RDD的创建

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

• 从集合中创建 RDD
• 从外部存储创建 RDD
• 从其他 RDD 创建

（1）从集合中创建RDD

# 使用 parallelize( ) 从集合创建
scala> val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

# 使用 makeRDD( ) 从集合创建
scala> val rdd1 = sc.makeRDD(Array(1,2,3,4,5,6,7,8))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

（2）从外部存储创建RDD

包括本地的文件系统，还有所有 Hadoop 支持的数据集，比如 HDFS、Cassandra、HBase 等。

scala> var rdd2 = sc.textFile("hdfs://host:9000/RELEASE")
rdd2: org.apache.spark.rdd.RDD[String] = hdfs://host:9000/RELEASE
MapPartitionsRDD[4] at textFile at <console>:24

（3）从其他RDD创建

通过 transformation 算子返回 value 类型的RDD 或者 KV 类型的RDD

三、RDD的转换

3.1、Value类型

（1）map( )

作用：返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成。

理解：可以对接收到的每一条数据进行处理

// 创建
scala> val source = sc.parallelize(1 to 10)
source:org.apache.spark.rdd.RDD[Int]=ParallelCollectionRDD[8] at parallelize at <console>:24
// 打印
scala> source.collect()
res7:Array[Int]=Array(1,2,3,4,5,6,7,8,9,10)
// 将所有元素 *2 
scala> val mapadd = source.map(_*2)
mapadd:org.apache.spark.rdd.RDD[Int]=MapPartitionsRDD[9] at map at <console>: 26
// 打印最终结果
scala> mapadd.collect()
res8:Array[Int]=Array(2,4,6,8,10,12,14,16,18,20)

（2）mapPartitions( )

作用：类似于 map，但独立地在 RDD 的每一个分片上运行，因此在类型为 T 的 RDD 上运行时，func 的函数类型必须是 Iterator[T] => Iterator[U]。

假设有N个元素，有M个分区，那么map 的函数将被调用N次，而mapPartitions 被调用M次，一个函数一次处理所有分区。

// 创建RDD
scala> val rdd = sc.parallelize(Array(1,2,3,4))
rdd:org.apache.spark.rdd.RDD[Int]=ParallelCollectionRDD[4] at parallelize at <console>:24
// 每个元素*2组成新的RDD
scala> rdd.mapPartitions(x=>x.map(_*2))
res3:org.apache.spark.rdd.RDD[Int]=MapPartitionsRDD [6] at mapPartitions at <console>:27
// 打印新的RDD
scala> res3.collect
res4: Array[Int]=Array(2,4,6,8)

map( ) 和 mapPartitions( ) 区别

map()：每次处理一条数据

mapPartitions()：每次处理一个分区的数据，这个分区的数据处理完后，原RDD中分区的数据才能释放，可能导致 OOM

开发指导：当内存空间较大的时候建议使用 mapPartition( )，以提高处理效率。

（3）mapPartitionsWithIndex( )

作用：类似于 mapPartitions，但 func 带有一个整数参数表示分片的索引值，因此在类型为 T 的 RDD上运行时，func的函数类型必须是（Int，Iterator[T]） => Iterator[U]

// 创建RDD
scala> val rdd = sc.parallelize(Array(1,2,3,4))
rdd:org.apache.spark.rdd.RDD[Int]=ParallelCollectionRDD[4] at parallelize at <console>:24
// 每个元素跟所在分区形成一个元组组成一个新的RDD
scala> val indexRdd = rdd.mapPartitionsWithIndex((index,items)=>(items.map(index,_)))
indexRdd:org.apache.spark.rdd.RDD[(Int,Int)]=MapPartitionsRDD[5] at mapPartitionsWithIndex at <console>:26

scala>indexRdd.collect
res2:Array[(Int,Int)]=Array((0,1),(0,2),(1,3),(1,4))

（4）flatMap( )

作用：类似于 map，但是每一个输入元素可以被映射为0或者多个输出元素（所以func 应该返回一个序列，而不是单一元素）

需求：创建一个元素为1-5的RDD，运用 flatMap 创建一个新的RDD，新的RDD为原 RDD 的每个元素的2倍（2,4,6,8,10）

// 创建RDD
scala> val sourceFlat = sc.parallelize(1 to 5)
sourceFlat: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[12] at parallelize at <console>:24

scala>sourceFlat.collect()
res11: Array[Int] = Array(1,2,3,4,5)

scala> val flatMap = sourceFlat.flatMap(1 to _)
flatMap:org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[13] at flatMap at <console>: 26

scala> flatMap.collect()
res12: Array[Int]=Array(1,1,2,1,2,3,1,2,3,4,1,2,3,4,5)

3.2、双Value类型交互

3.3、key-value类型

— 要养成终身学习的习惯 —