二、SparkCore
第1章 RDD概述
1.1 什么是RDD
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据（计算）抽象。代码中是一个抽象类，它代表一个不可变、可分区、里面的元素可并行计算的集合。
分布式：数据的来源
数据集：数据的类型&计算类型的封装（数据模型）
弹性：
不可变：计算逻辑不可变
可分区：提高数据处理能力
并行计算：多任务同时执行
1.2 RDD的属性
- 一组分区（Partition），即数据集的基本组成单位;
- 一个计算每个分区的函数;
- RDD之间的依赖关系;
- 一个Partitioner，即RDD的分片函数;
- 一个列表，存储存取每个Partition的优先位置（preferred location）。
1.3 RDD特点
RDD表示只读的分区的数据集，对RDD进行改动，只能通过RDD的转换操作，由一个RDD得到一个新的RDD，新的RDD包含了从其他RDD衍生所必需的信息。RDDs之间存在依赖，RDD的执行是按照血缘关系延时计算的。如果血缘关系较长，可以通过持久化RDD来切断血缘关系。
1.3.1 分区
RDD逻辑上是分区的，每个分区的数据是抽象存在的，计算的时候会通过一个compute函数得到每个分区的数据**。
- 如果RDD是通过已有的文件系统构建，则compute函数是读取指定文件系统中的数据，
- 如果RDD是通过其他RDD转换而来，则compute函数是执行转换逻辑将其他RDD的数据进行转换。
1.3.2 只读
如下图所示，RDD是只读的，要想改变RDD中的数据，只能在现有的RDD基础上创建新的RDD。
由一个RDD转换到另一个RDD，可以通过丰富的操作算子实现，不再像MapReduce那样只能写map和reduce了，如下图所示。
RDD的操作算子包括两类：
- 一类叫做transformations，它是用来将RDD进行转化，构建RDD的血缘关系；
- 另一类叫做actions，它是用来触发RDD的计算，得到RDD的相关计算结果或者将RDD保存的文件系统中。
1.3.3 依赖
RDDs通过操作算子进行转换，转换得到的新RDD包含了从其他RDDs衍生所必需的信息，RDDs之间维护着这种血缘关系，也称之为依赖。
如下图所示，依赖包括两种
- 一种是窄依赖，RDDs之间分区是一一对应的，
- 另一种是宽依赖，下游RDD的每个分区与上游RDD(也称之为父RDD)的每个分区都有关，是多对多的关系。
1.3.4 缓存
如果在应用程序中多次使用同一个RDD，可以将该RDD缓存起来，该RDD只有在第一次计算的时候会根据血缘关系得到分区的数据，在后续其他地方用到该RDD的时候，会直接从缓存处取而不用再根据血缘关系计算，这样就加速后期的重用。
如下图所示，RDD-1经过一系列的转换后得到RDD-n并保存到hdfs，RDD-1在这一过程中会有个中间结果，如果将其缓存到内存，那么在随后的RDD-1转换到RDD-m这一过程中，就不会计算其之前的RDD-0了。
1.3.5 CheckPoint
虽然RDD的血缘关系天然地可以实现容错，当RDD的某个分区数据失败或丢失，可以通过血缘关系重建。但是对于长时间迭代型应用来说，随着迭代的进行，RDDs之间的血缘关系会越来越长，一旦在后续迭代过程中出错，则需要通过非常长的血缘关系去重建，势必影响性能。为此，RDD支持checkpoint将数据保存到持久化的存储中，这样就可以切断之前的血缘关系，因为checkpoint后的RDD不需要知道它的父RDDs了，它可以从checkpoint处拿到数据。
它和持久化有什么区别呢？
-
持久化只是将数据保存在BlockManager中，而RDD的lineage是不变的。但是checkpoint执行完后，RDD已经没有之前所谓的依赖RDD了，而只有一个强行为其设置的checkpointRDD，RDD的lineage（血缘关系，依赖关系）改变了。
-
持久化的数据丢失可能性更大，磁盘、内存都可能会存在数据丢失的情况。但是checkpoint的数据通常是存储在如HDFS等容错、高可用的文件系统，数据丢失可能性较小。
注：默认情况下，如果某个RDD没有持久化，但是设置了checkpoint，会存在问题，本来这个job都执行结束了，但是由于中间RDD没有持久化，checkpoint job想要将RDD的数据写入外部文件系统的话，需要全部重新计算一次，再将计算出来的RDD数据checkpoint到外部文件系统。所以，建议对checkpoint()的RDD使用persist(StorageLevel.DISK_ONLY)，该RDD计算之后，就直接持久化到磁盘上。后面进行checkpoint操作时就可以直接从磁盘上读取RDD的数据，并checkpoint到外部文件系统。**
/**
\* Mark this RDD for checkpointing. It will be saved to a file inside the checkpoint
\* directory set with `SparkContext#setCheckpointDir` and all references to its parent
\ * RDDs will be removed. This function must be called before any job has been
\ * executed on this RDD. It is strongly recommended that this RDD is persisted in
\* memory, otherwise saving it on a file will require recomputation.
*/
第2章 RDD编程
2.1 编程模型
在Spark中，RDD被表示为对象，通过对象上的方法调用来对RDD进行转换。经过一系列的transformations定义RDD之后，就可以调用actions触发RDD的计算，action可以是向应用程序返回结果(count, collect等)，或者是向存储系统保存数据(saveAsTextFile等)。在Spark中，只有遇到action，才会执行RDD的计算(即延迟计算)，这样在运行时可以通过管道的方式传输多个转换。
要使用Spark，开发者需要编写一个Driver程序，它被提交到集群以调度运行Worker，如下图所示。Driver中定义了一个或多个RDD，并调用RDD上的action，Worker则执行RDD分区计算任务。
2.2 RDD的创建
在Spark中创建RDD的创建方式可以分为三种：
- 从集合中创建RDD；
- 从外部存储创建RDD；
- 从其他RDD创建。
2.2.1 从集合中创建
- parallelize
- makeRDD （底层调用parallelize）
1）使用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
2）使用makeRDD()从集合创建
scala> val rdd1 = sc.makeRDD(Array(1,2,3,4,5,6,7,8))
rdd1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at makeRDD at <console>:24
2.2.2 由外部存储系统的数据集创建
包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等，我们会在第4章详细介绍。
scala> val rdd2= sc.textFile("hdfs://hadoop102:9000/RELEASE")
rdd2: org.apache.spark.rdd.RDD[String] = hdfs:// hadoop102:9000/RELEASE MapPartitionsRDD[4] at textFile at <console>:24
2.3 RDD的转换
2.3.1 Value类型
| 序号 | 算子 | 描述 | 备注 |
|---|---|---|---|
| 01 | map（func） | ... | ... |
| 02 | mapPartitions（func） | 类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U] | ... |
| 03 | PartitionsWithIndex（func） | 类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U] val indexRdd = rdd.mapPartitionsWithIndex((index,items)=>(items.map((index,_)))) | ... |
| 04 | flatMap（func） | 类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素） val flatMap = sourceFlat.flatMap(1 to _) | ... |
| 05 | glom | 将每一分区形成一个数组，新的RDD类型是RDD[Array[T]] val rdd = sc.parallelize(1 to 16,4) ==> rdd.glom().collect() ==> res25: Array[Array[Int]] = Array(Array(1, 2, 3, 4), Array(5, 6, 7, 8), Array(9, 10, 11, 12), Array(13, 14, 15, 16)) | ... |
| 06 | groupBy（func） | 分组，按照传入函数的返回值进行分组。将相同的key对应的值放入一个迭代器 ==>group.collect ==> res0: Array[(Int, Iterable[Int])] = Array((0,CompactBuffer(2, 4)), (1,CompactBuffer(1, 3))) | ... |
| 07 | filter（func） | ... | ... |
| 08 | sample（withReplace，fraction，seed） | 以指定的随机种子随机抽样出数量为fraction的数据，withReplacement表示是抽出的数据是否放回，true为有放回的抽样，false为无放回的抽样，seed用于指定随机数生成器种子 | ... |
| 09 | distinct（[numTasks]] | 对源RDD去重，返回新的RDD，默认，并行任务8个,但是可以传入一个可选的numTasks参数改变它 | ... |
| 10 | coalesce（numPartitions） | 缩减分区数，用于大数据集过滤后，提高小数据集的执行效率 | ... |
| 11 | Repartition（numPartitions） | 根据分组数，重新通过网络重新随机洗牌所有数据, 默认有shuffle | ... |
| 12 | sortBy（func,[ascending], [numTasks]） | 使用func先对数据进行处理，按照处理后的数据比较结果排序，默认为正序 ==>对比（sortWith:sortWith指操作集合，使用规则，sortBy集合和RDD都能操作，使用的是个属性） | ... |
| 13 | Pipe（command, [envVars]） | 管道，针对每个分区，都执行一个shell脚本，返回输出的RDD 注意：脚本需要放在Worker节点可以访问到的位置 | ... |
2.3.2 双Value类型
| 序号 | 算子 | 描述 |
|---|---|---|
| 01 | union(otherDataset) | 不去重 |
| 02 | subtract (otherDataset) | ... |
| 03 | intersection(otherDataset) | |
| 04 | cartesian(otherDataset) | ... |
| 05 | zip(otherDataset) | 将两个RDD组合成Key/Value形式的RDD,这里默认两个RDD的partition数量以及元素数量都相同，否则会抛出异常 |
2.3.3 Key-Value类型
1. partitionBy案例
作用：对pairRDD进行分区操作，如果原有的partionRDD和现有的partionRDD是一致的话就不进行分区， 否则会生成ShuffleRDD，即会产生shuffle过程。
需求：创建一个4个分区的RDD，对其重新分区
（1）创建一个RDD
scala> val rdd = sc.parallelize(Array((1,"aaa"),(2,"bbb"),(3,"ccc"),(4,"ddd")),4)
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[44] at parallelize at <console>:24
（2）查看RDD的分区数
scala> rdd.partitions.size
res24: Int = 4
（3）对RDD重新分区
scala> var rdd2 = rdd.partitionBy(new org.apache.spark.HashPartitioner(2)) //其中的2是分区数
rdd2: org.apache.spark.rdd.RDD[(Int, String)] = ShuffledRDD[45] at partitionBy at <console>:26
（4）查看新RDD的分区数
scala> rdd2.partitions.size
res25: Int = 2
2. groupByKey案例
作用：groupByKey也是对每个key进行操作，但只生成一个sequence。
需求：创建一个pairRDD，将相同key对应值聚合到一个sequence中，并计算相同key对应值的相加结果。
（1）创建一个pairRDD
scala> val words = Array("one", "two", "two", "three", "three", "three")
words: Array[String] = Array(one, two, two, three, three, three)
scala> val wordPairsRDD = sc.parallelize(words).map(word => (word, 1))
wordPairsRDD: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[4] at map at <console>:26
（2）将相同key对应值聚合到一个sequence中
scala> val group = wordPairsRDD.groupByKey()
group: org.apache.spark.rdd.RDD[(String, Iterable[Int])] = ShuffledRDD[5] at groupByKey at <console>:28
（3）打印结果
scala> group.collect()
res1: Array[(String, Iterable[Int])] = Array((two,CompactBuffer(1, 1)), (one,CompactBuffer(1)), (three,CompactBuffer(1, 1, 1)))
3. reduceByKey(func, [numTasks])
在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置。
需求：创建一个pairRDD，计算相同key对应值的相加结果
（1）创建一个pairRDD
scala> val rdd = sc.parallelize(List(("female",1),("male",5),("female",5),("male",2)))
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[46] at parallelize at <console>:24
（2）计算相同key对应值的相加结果
scala> val reduce = rdd.reduceByKey((x,y) => x+y)
reduce: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[47] at reduceByKey at <console>:26
（3）打印结果
scala> reduce.collect()
res29: Array[(String, Int)] = Array((female,6), (male,7))
**reduceByKey和groupByKey的区别**
1. reduceByKey：按照key进行聚合，在shuffle之前有combine（预聚合）操作，返回结果是RDD[k,v].
2. groupByKey：按照key进行分组，直接进行shuffle。
3. 开发指导：reduceByKey比groupByKey，建议使用。但是需要注意是否会影响业务逻辑。
4. aggregateByKey案例
参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)
作用：在kv对的RDD中，，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。
2. 参数描述：
（1）zeroValue：给每一个分区中的每一个key一个初始值；
（2）seqOp：函数用于在每一个分区中用初始值逐步迭代value；
（3）combOp：函数用于合并每个分区中的结果。
val rdd = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
val agg = rdd.aggregateByKey(0)(math.max(_,_),_+_)
5. foldByKey案例
参数：(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
作用：aggregateByKey的简化操作，seqop和combop相同
val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)),3)
val agg = rdd.foldByKey(0)(_+_)
6. combineByKey[C] 案例
**参数：(createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C) **
作用：对相同K，把V合并成一个集合。
参数描述：
（1）createCombiner: combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素,combineByKey()会使用一个叫作createCombiner()的函数来创建那个键对应的累加器的初始值
（2）mergeValue: 如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并
（3）mergeCombiners: 由于每个分区都是独立处理的， 因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器， 就需要使用用户提供的 mergeCombiners() 方法将各个分区的结果进行合并。
val combine = 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))
7. sortByKey([ascending], [numTasks]) 案例
作用：在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
需求：创建一个pairRDD，按照key的正序和倒序进行排序
（1）创建一个pairRDD
scala> val rdd = sc.parallelize(Array((3,"aa"),(6,"cc"),(2,"bb"),(1,"dd")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[14] at parallelize at <console>:24
（2）按照key的正序
scala> rdd.sortByKey(true).collect()
res9: Array[(Int, String)] = Array((1,dd), (2,bb), (3,aa), (6,cc))
（3）按照key的倒序
scala> rdd.sortByKey(false).collect()
res10: Array[(Int, String)] = Array((6,cc), (3,aa), (2,bb), (1,dd))
8. mapValues案例
针对于(K,V)形式的类型只对V进行操作
需求：创建一个pairRDD，并将value添加字符串"|||"
（1）创建一个pairRDD
scala> val rdd3 = sc.parallelize(Array((1,"a"),(1,"d"),(2,"b"),(3,"c")))
rdd3: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[67] at parallelize at <console>:24
（2）对value添加字符串"|||"
scala> rdd3.mapValues(_+"|||").collect()
res26: Array[(Int, String)] = Array((1,a|||), (1,d|||), (2,b|||), (3,c|||))
9. join(otherDataset, [numTasks])
作用：在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
需求：创建两个pairRDD，并将key相同的数据聚合到一个元组(一对一)。
【类似SQL中的join一对一，即使是对应多条】
（1）创建第一个pairRDD
scala> val rdd = sc.parallelize(Array((1,"a"),(2,"b"),(3,"c")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[32] at parallelize at <console>:24
（2）创建第二个pairRDD
scala> val rdd1 = sc.parallelize(Array((1,4),(2,5),(3,6)))
rdd1: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[33] at parallelize at <console>:24
（3）join操作并打印结果
scala> rdd.join(rdd1).collect()
res13: Array[(Int, (String, Int))] = Array((1,(a,4)), (2,(b,5)), (3,(c,6)))
10. cogroup(otherDataset, [numTasks])
作用：在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable
需求：创建两个pairRDD，并将key相同的数据聚合到一个迭代器。
（1）创建第一个pairRDD
scala> val rdd = sc.parallelize(Array((1,"a"),(2,"b"),(3,"c")))
rdd: org.apache.spark.rdd.RDD[(Int, String)] = ParallelCollectionRDD[37] at parallelize at <console>:24
（2）创建第二个pairRDD
scala> val rdd1 = sc.parallelize(Array((1,4),(2,5),(3,6)))
rdd1: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[38] at parallelize at <console>:24
（3）cogroup两个RDD并打印结果
scala> rdd.cogroup(rdd1).collect()
res14: Array[(Int, (Iterable[String], Iterable[Int]))] = Array((1,(CompactBuffer(a),CompactBuffer(4))), (2,(CompactBuffer(b),CompactBuffer(5))), (3,(CompactBuffer(c),CompactBuffer(6))))
类似于SQL中的全连接，没有匹配项的也会打印出来
2.4 Action
| 序号 | 算子 | 描述 |
|---|---|---|
| 1 | reduce(func) | 。。。 |
| 2 | collect(func) | 。。。 |
| 3 | count(func) | 。。。 |
| 4 | first(n) | 。。。 |
| 5 | take(n) | 。。。 |
| 6 | takeOrdered(n) | 。。。 |
| 7 | aggregate(zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U) | 。。。 |
| 8 | fold(num)(func) | 。。。 |
| 9 | countByKey() 针对(K,V) | 类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。 |
| 10 | foreach(func) | 。。。 |
| 11 | saveAsTextFile(path) | 。。。 |
| 12 | saveAsSequenceFile(path) | 。。。 |
| 13 | saveAsObjectFile(path) | 。。。 |
浙公网安备 33010602011771号