Spark核心编程
行动算子
(1)reduce
聚集 RDD 中的所有元素,先聚合分区内数据,再聚合分区间数据。
(2)collect
在驱动程序中,以数组 Array 的形式返回数据集的所有元素。
(3)count
返回 RDD 中元素的个数。
(4)first
返回 RDD 中的第一个元素。
(5)take
返回一个由 RDD 的前 n 个元素组成的数组。
(6)takeOrdered
返回该 RDD 排序后的前 n 个元素组成的数组。
package com.yu.bigdata.spark.core.operatorAction
import org.apache.spark.{SparkConf, SparkContext}
object Spark01_RDD_reduce {
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)执行的方法
//底层代码调用的是环境对象的runJob方法
//底层代码中会创建ActiveJob,并提交执行
//reduce : 聚合数据
val i = rdd.reduce(_ + _)
println(i) //10
//collect:将不同分区的数据按照分区顺序采集到Driver内存中,形成数组
val ints: Array[Int] = rdd.collect()
println(ints) //[I@4a8df3e2
println(ints.mkString(",")) //1,2,3,4
//count: 统计个数
val count: Long = rdd.count()
println(count) //4
//first : 第一个元素
val first: Int = rdd.first()
println(first) //1
//take : 获取数据源的前N个数
val ints1: Array[Int] = rdd.take(2)
println(ints1.mkString(",")) //1,2
//takeOrdered : 排序后取前n个元素
val rdd1 = sc.makeRDD(List(4, 2, 3, 1))
val ints2: Array[Int] = rdd1.takeOrdered(3) //升序
println(ints2.mkString(",")) //1,2,3
val ints3: Array[Int] = rdd1.takeOrdered(3)(Ordering.Int.reverse) //降序
println(ints3.mkString(",")) //4,3,2
}
}
(7)aggregate
分区的数据通过初始值和分区内的数据进行聚合,然后再和初始值进行分区间的数据聚合。
//aggregate : 分区的数据通过初始值和分区内的数据进行聚合
val result: Int = rdd.aggregate(0)(_ + _, _ + _) // (0+1+2) + (0+3+4) = 10
println(result) //10
// (10+1+2) + (10+3+4) = 30 并不是这样
// aggregateByKey:初始值只会参与分区内计算
// aggregate:初始值会参与分区内计算,并且会参与分区间计算
// (10+1+2) + (10+3+4) + 10 = 40 分区间相加时也会加上10
val result1: Int = rdd.aggregate(10)(_ + _, _ + _)
println(result1) //40
(8)fold
折叠操作,aggregate 的简化版操作。
//fold:aggregate简化版本
val result2: Int = rdd.fold(10)(_ + _)
println(result2) //40
(9)countByKey
统计每种 key 的个数。
val rdd = sc.makeRDD(List(1, 1, 3, 4), 2)
val rdd2 = sc.makeRDD(List(
("a", 1), ("a", 3), ("b", 4)
))
// TODO 行动算子
val newRDD1: collection.Map[Int, Long] = rdd.countByValue()
println(newRDD1)
//Map(4 -> 1, 1 -> 2, 3 -> 1)
val newRDD2: collection.Map[String, Long] = rdd2.countByKey()
println(newRDD2)
//Map(a -> 2, b -> 1)
(10)save相关算子
将数据保存到不同格式的文件中。
// TODO 行动算子
rdd.saveAsTextFile("output1")
rdd.saveAsObjectFile("output2")
//saveAsSequenceFile方法要求数据的格式必须为K-V类型
// rdd.saveAsSequenceFile("output3")
(11)foreach
分布式遍历 RDD 中的每一个元素,调用指定函数。
collect采集后发回Driver中打印:
不采集,直接从Executor中打印,并行一起处理,打印顺序不定:
算子:Operator(操作)
RDD方法和Scala集合对象的方法不一样
集合对象的方法都是在同一个节点的内存中完成的
RDD方法可以将计算逻辑发送到Executor端(分布式节点)执行
为了区分不同的处理效果,所以将RDD方法称为算子
RDD方法外部的操作都是在Driver端执行的,而方法内部的逻辑代码是在Executor端执行。
实现wordCount的多种方法:
package com.yu.bigdata.spark.core.wordCount
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.mutable
object Spark04_WordCount {
def main(args: Array[String]): Unit = {
val sparkCont = new SparkConf().setMaster("local[*]").setAppName("wordcount")
val sc = new SparkContext(sparkCont)
wordcount9(sc)
sc.stop()
//groupBy
def wordcount1(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val group: RDD[(String, Iterable[String])] = words.groupBy(word => word)
val wordCount: RDD[(String, Int)] = group.mapValues(iter => iter.size)
}
//groupByKey
def wordcount2(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordOne: RDD[(String, Int)] = words.map((_, 1))
val group: RDD[(String, Iterable[Int])] = wordOne.groupByKey() //效率低
val wordCount: RDD[(String, Int)] = group.mapValues(iter => iter.size)
}
//reduceByKey
def wordcount3(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordOne: RDD[(String, Int)] = words.map((_, 1))
val wordCount = wordOne.reduceByKey(_ + _)
}
//aggregateByKey
def wordcount4(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordOne: RDD[(String, Int)] = words.map((_, 1))
val wordCount = wordOne.aggregateByKey(0)(_+_,_+_)
}
//foldByKey
def wordcount5(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordOne: RDD[(String, Int)] = words.map((_, 1))
val wordCount = wordOne.foldByKey(0)(_+_)
}
//combineByKey
def wordcount6(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordOne: RDD[(String, Int)] = words.map((_, 1))
val wordCount = wordOne.combineByKey(
v => v, //动态转换,下面需要识别
(x:Int, y:Int) => x+y,
(x:Int, y:Int) => x+y
)
}
//countByKey
def wordcount7(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordOne: RDD[(String, Int)] = words.map((_, 1))
val wordCount: collection.Map[String, Long] = wordOne.countByKey()
}
//countByValue
def wordcount8(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val wordCount: collection.Map[String, Long] = words.countByValue()
}
//reduce
def wordcount9(sc: SparkContext): Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words: RDD[String] = rdd.flatMap(_.split(" "))
val mapWords: RDD[mutable.Map[String, Long]] = words.map(
word => {
mutable.Map[String, Long]((word, 1))
}
)
val wordCount: mutable.Map[String, Long] = mapWords.reduce(
(map1, map2) => {
map2.foreach {
case (word, count) => {
val newCount = map1.getOrElse(word, 0L) + count //需要在后面加上L Long类型
map1.update(word, newCount)
}
}
map1
}
)
println(wordCount)
}
}
}
序列化
- 闭包检查
从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor端执行。那么在 scala 的函数式编程中,就会导致算子内经常会用到算子外的数据,这样就形成了闭包的效果,如果使用的算子外的数据无法序列化,就意味着无法传值给 Executor端执行,就会发生错误,所以需要在执行任务计算前,检测闭包内的对象是否可以进行序列化,这个操作我们称之为闭包检测。
package com.yu.bigdata.spark.core.operatorAction
import org.apache.spark.{SparkConf, SparkContext}
object Spark05_RDD_foreach_test {
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 行动算子
val user = new User()
//SparkException: Task not serializable
//RDD算子中传递的函数是会包含闭包操作,那么就会进行检测功能 =》 闭包检测
//自行检测foreach内部的User是否进行了序列化操作
//User在driver中,rdd的执行在Executor中
rdd.foreach(
num => {
println("age: " + (user.age + num))
}
)
//age: 31
//age: 33
//age: 32
//age: 34
sc.stop()
}
//class User extends Serializable { //两种方式均可
case class User() { //样例类在编译时,会自动混入序列化特质(实现可序列化接口)
var age: Int = 30
}
}
- 序列方法和属性
从计算的角度,算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor端执行。
package com.yu.bigdata.spark.core.operatorAction
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark06_RDD_Serial {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
val sc: SparkContext = new SparkContext(conf)
val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", "hive", "atguigu"))
val search = new Search("h")
search.getMatch1(rdd).collect().foreach(println)
search.getMatch2(rdd).collect().foreach(println)
sc.stop()
} }
//查询对象
//类的构造参数query其实是类的属性,构造参数需要进行闭包检测,其实就等同于类进行闭包检测
class Search(query:String) extends Serializable {
def isMatch(s: String): Boolean = {
s.contains(this.query) //类的属性
}
// 函数序列化案例
def getMatch1(rdd: RDD[String]): RDD[String] = {
//rdd.filter(this.isMatch)
rdd.filter(isMatch) //类必须序列化,这里调用到的query才会检测通过
}
// 属性序列化案例
def getMatch2(rdd: RDD[String]): RDD[String] = {
//rdd.filter(x => x.contains(this.query))
//s 是该方法的局部变量,与Search无关,但是在driver中 要改变形成闭包
val s = query //在Driver中 字符串可以序列化 加上这一句就形成闭包了
rdd.filter(x => x.contains(s))
}
}
- Kryo序列化框架
Java 的序列化能够序列化任何的类。但是比较重(字节多),序列化后,对象的提交也比较大。Spark 出于性能的考虑,Spark2.0 开始支持另外一种 Kryo 序列化机制。Kryo 速度是 Serializable 的 10 倍。当 RDD 在 Shuffle 数据的时候,简单数据类型、数组和字符串类型已经在 Spark 内部使用 Kryo 来序列化。
注意:即使使用 Kryo 序列化,也要继承 Serializable 接口。
RDD依赖关系
- RDD血缘关系
RDD 只支持粗粒度转换,即在大量记录上执行的单个操作。将创建 RDD 的一系列 Lineage(血统)记录下来,以便恢复丢失的分区。RDD 的 Lineage 会记录 RDD 的元数据信息和转换行为,当该 RDD 的部分分区数据丢失时,它可以根据这些信息来重新运算和恢复丢失的数据分区。
package com.yu.bigdata.spark.core.depend
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark01_RDD_Dep {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Depend")
val sc = new SparkContext(sparkConf)
val lines: RDD[String] = sc.textFile("datas/2.txt")
println(lines.toDebugString) //打印血缘关系
println("*********************************")
val words: RDD[String] = lines.flatMap(_.split(" ")) //扁平化
println(words.toDebugString)
println("*********************************")
val wordToOne: RDD[(String, Int)] = words.map(
word => (word, 1)
)
println(wordToOne.toDebugString)
println("*********************************")
val wordToCount: RDD[(String, Int)] = wordToOne.reduceByKey(_ + _) //( (x, y) => {x + y} )
println(wordToCount.toDebugString)
println("*********************************")
val array: Array[(String, Int)] = wordToCount.collect()
array.foreach(println)
sc.stop()
}
}
"(2)"表示两个分区。
- RDD依赖关系
所谓的依赖关系,其实就是两个相邻 RDD 之间的关系。
- RDD窄依赖
窄依赖表示每一个父(上游)RDD 的 Partition 最多被子(下游)RDD 的一个 Partition 使用,窄依赖我们形象的比喻为独生子女。
新的RDD的一个分区的数据依赖于旧的RDD一个分区的数据,这个依赖称之为OneToOne依赖。
前后使用同一个task来执行。
- RDD宽依赖
宽依赖表示同一个父(上游)RDD 的 Partition 被多个子(下游)RDD 的 Partition 依赖,会引起 Shuffle,总结:宽依赖我们形象的比喻为多生。
新的RDD的一个分区的数据依赖于旧的RDD多个分区的数据,这个依赖称之为Shuffle依赖。
两个阶段,第一个阶段执行完成再执行第二个阶段,第一个阶段task完成后再执行第二个阶段的task。
- RDD阶段划分
DAG(Directed Acyclic Graph)有向无环图是由点和线组成的拓扑图形,该图形具有方向,不会闭环。例如,DAG 记录了 RDD 的转换过程和任务的阶段。
- RDD阶段划分源码
一开始就存在一个resultStage。
判断是否存在shuffle操作,若存在增加一个shuffle stage,阶段自动增加一个。
- 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 的关系。
阶段 => 任务
ShuffleMapStage => ShuffleMapTask (0 until numPartitions)
ResultMapStage => ResultTask
- RDD任务划分源码
RDD持久化
- RDD Cache缓存
RDD 通过 Cache 或者 Persist 方法将前面的计算结果缓存,默认情况下会把数据以缓存在 JVM 的堆内存中。但是并不是这两个方法被调用时立即缓存,而是触发后面的 action 算 子时,该 RDD 将会被缓存在计算节点的内存中,并供后面重用。
RDD中不存储数据,如果一个RDD需要重复使用,那么需要从头再次执行来获取数据,RDD对象可以重用,但数据无法重用。
持久化是将数据暂时存放在内存当中,重用对象不用重新计算了。
package com.yu.bigdata.spark.core.persist
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object Spark01_RDD_persist {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local").setAppName("persist") //基础配置
val sc = new SparkContext(sparkConf) //创建对象
val list = List("Hello Scala", "Hello Spark")
val rdd = sc.makeRDD(list)
val flatRdd = rdd.flatMap(_.split(" "))
val mapRdd = flatRdd.map(word => {
println("@@@@@@@")
(word, 1)
})
//对RDD持久化
//cache默认持久化的操作,只能将数据保存到内存中
// 如果想要保存到磁盘文件,需要改变存储级别
//mapRdd.cache()
mapRdd.persist(StorageLevel.DISK_ONLY) //只存储到磁盘
val reduceRDD = mapRdd.reduceByKey(_ + _)
reduceRDD.collect().foreach(println)
println("**********************")
val groupRDD = mapRdd.groupByKey()
groupRDD.collect().foreach(println)
sc.stop()
}
}
加上MapRdd.cache()前后:
RDD对象的持久化操作不一定是为了重用,在数据执行时间较长,或数据比较重要的场合也可以采用持久化操作。
- RDD CheckPoint检查点
所谓的检查点其实就是通过将 RDD 中间结果写入磁盘。由于血缘依赖过长会造成容错成本过高,这样就不如在中间阶段做检查点容错,如果检查点之后有节点出现问题,可以从检查点开始重做血缘,减少了开销。
对 RDD 进行 checkpoint 操作并不会马上被执行,必须执行 Action 操作才能触发。
package com.yu.bigdata.spark.core.persist
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{SparkConf, SparkContext}
object Spark02_RDD_persist {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local").setAppName("persist") //基础配置
val sc = new SparkContext(sparkConf) //创建对象
sc.setCheckpointDir("cp")
val list = List("Hello Scala", "Hello Spark")
val rdd = sc.makeRDD(list)
val flatRdd = rdd.flatMap(_.split(" "))
val mapRdd = flatRdd.map(word => {
println("@@@@@@@")
(word, 1)
})
//之前的两种数据保存方式,只是暂时保存,执行完会自动删除
//checkpoint 需要落盘,需要指定检查点保存路径
//检查点路径保存的文件,当作业执行完毕后,不会被删除
//一般保存路径都是在分布式存储系统中:HDFS
mapRdd.checkpoint()
val reduceRDD = mapRdd.reduceByKey(_ + _)
reduceRDD.collect().foreach(println)
println("**********************")
val groupRDD = mapRdd.groupByKey()
groupRDD.collect().foreach(println)
sc.stop()
}
}
- 缓存和检查点区别
1)Cache 缓存只是将数据保存起来,不切断血缘依赖。Checkpoint 检查点切断血缘依赖,重新建立了新的血缘关系。
2)Cache 缓存的数据通常存储在磁盘、内存等地方,可靠性低。Checkpoint 的数据通常存储在 HDFS 等容错、高可用的文件系统,可靠性高。
3)建议对 checkpoint()的 RDD 使用 Cache 缓存,这样 checkpoint 的 job 只需从 Cache 缓存中读取数据即可,否则需要再从头计算一次 RDD。
联合使用:
Rdd.cache() //增加缓存,避免重新跑一个job做checkpoint
Rdd.checkpoint() //增加一个数据检查点
RDD分区器
Spark 目前支持 Hash 分区和 Range 分区,和用户自定义分区。Hash 分区为当前的默认分区。分区器直接决定了 RDD 中分区的个数、RDD 中每条数据经过 Shuffle 后进入哪个分区,进而决定了 Reduce 的个数。
➢ 只有 Key-Value 类型的 RDD 才有分区器,非 Key-Value 类型的 RDD 分区的值是 None
➢ 每个 RDD 的分区 ID 范围:0 ~ (numPartitions - 1),决定这个值是属于那个分区的。
1.Hash分区::对于给定的 key,计算其 hashCode,并除以分区个数取余
2.Range分区:将一定范围内的数据映射到一个分区中,尽量保证每个分区数据均匀,而且分区间有序
3.自定义分区
(1)继承Partition类
(2)重写方法
package com.yu.bigdata.spark.core.part
import org.apache.spark.rdd.RDD
import org.apache.spark.storage.StorageLevel
import org.apache.spark.{Partitioner, SparkConf, SparkContext}
object Spark01_RDD_part {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local").setAppName("persist") //基础配置
val sc = new SparkContext(sparkConf)
val rdd = sc.makeRDD(List(
("nba", "xxxxxx"),
("cba", "xxxxxx"),
("wnba", "xxxxxx"),
("nba", "xxxxxx")
))
val partRDD: RDD[(String, String)] = rdd.partitionBy(new MyPartitioner)
//这样就自定义了分区器
partRDD.saveAsTextFile("output") //查看分区内数据
sc.stop()
}
/*
自定义分区器
1.继承Partition
2.重写方法
*/
class MyPartitioner extends Partitioner{
override def numPartitions: Int = 3
override def getPartition(key: Any): Int = {
key match {
case "nba" => 0
case "wnba" => 1
case _ => 2
}
// if ( key == "nba") {
// 0
// } else if ( key == "wnba") {
// 1
// } else if ( key == 'cba') {
// 2
// } else {
// 2
// }
}
}
}
RDD文件读取与保存
Spark 的数据读取及数据保存可以从两个维度来作区分:文件格式以及文件系统。
文件格式分为:text 文件、csv 文件、sequence 文件以及 Object 文件;
文件系统分为:本地文件系统、HDFS、HBASE 以及数据库。
val rdd = sc.makeRDD(List(
("a", 1),
("b", 2),
("c", 3)
))
//保存
rdd.saveAsTextFile("output")
rdd.saveAsObjectFile("output1")
rdd.saveAsSequenceFile("output2")
//读取
val rdd1 = sc.textFile("output1")
val rdd2 = sc.objectFile[(String, Int)]("output2") //添加一个泛型
val rdd3 = sc.sequenceFile[String, Int]("output3")