Spark3——核心编程

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)
    }
  }
}

序列化

1. 闭包检查

从计算的角度, 算子以外的代码都是在 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
  }
}

2. 序列方法和属性

从计算的角度，算子以外的代码都是在 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))
  }
}

3. Kryo序列化框架

Java 的序列化能够序列化任何的类。但是比较重（字节多），序列化后，对象的提交也比较大。Spark 出于性能的考虑，Spark2.0 开始支持另外一种 Kryo 序列化机制。Kryo 速度是 Serializable 的 10 倍。当 RDD 在 Shuffle 数据的时候，简单数据类型、数组和字符串类型已经在 Spark 内部使用 Kryo 来序列化。
注意：即使使用 Kryo 序列化，也要继承 Serializable 接口。

RDD依赖关系

1. 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)"表示两个分区。

2. RDD依赖关系

所谓的依赖关系，其实就是两个相邻 RDD 之间的关系。

3. RDD窄依赖

窄依赖表示每一个父(上游)RDD 的 Partition 最多被子（下游）RDD 的一个 Partition 使用，窄依赖我们形象的比喻为独生子女。

新的RDD的一个分区的数据依赖于旧的RDD一个分区的数据，这个依赖称之为OneToOne依赖。

前后使用同一个task来执行。

4. RDD宽依赖

宽依赖表示同一个父（上游）RDD 的 Partition 被多个子（下游）RDD 的 Partition 依赖，会引起 Shuffle，总结：宽依赖我们形象的比喻为多生。

新的RDD的一个分区的数据依赖于旧的RDD多个分区的数据，这个依赖称之为Shuffle依赖。

两个阶段，第一个阶段执行完成再执行第二个阶段，第一个阶段task完成后再执行第二个阶段的task。

5. RDD阶段划分

DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向，不会闭环。例如，DAG 记录了 RDD 的转换过程和任务的阶段。

6. RDD阶段划分源码

一开始就存在一个resultStage。

判断是否存在shuffle操作，若存在增加一个shuffle stage，阶段自动增加一个。

7. 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

9. RDD任务划分源码

RDD持久化

1. 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对象的持久化操作不一定是为了重用，在数据执行时间较长，或数据比较重要的场合也可以采用持久化操作。

2. 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()
  }
}

3. 缓存和检查点区别

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")