spark之sparkcore学习笔记

SparkCore

第一章 Spark和hadoop的关系

1、Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎，spark的调度系统和存储都是基于hadoop的组件hdfs。

2、Spark作为分析计算的框架是基于内存的，hadoop是基于磁盘的。

3、Spark Task的启动时间快。Spark采用fork线程的方式，而Hadoop采用创建新的进程的方式。

第二章 Spark的快速上手

• pom文件

<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.11</artifactId>
        <version>2.4.5</version>
    </dependency>
</dependencies>

• wordcount程序

// 创建Spark运行配置对象
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")

// 创建Spark上下文环境对象（连接对象）
val sc : SparkContext = new SparkContext(sparkConf)

// 读取文件数据
val fileRDD: RDD[String] = sc.textFile("input/word.txt")

// 将文件中的数据进行分词
val wordRDD: RDD[String] = fileRDD.flatMap( _.split(" ") )

// 转换数据结构 word => (word, 1)
val word2OneRDD: RDD[(String, Int)] = wordRDD.map((_,1))

// 将转换结构后的数据按照相同的单词进行分组聚合
val word2CountRDD: RDD[(String, Int)] = word2OneRDD.reduceByKey(_+_)

// 将数据聚合结果采集到内存中
val word2Count: Array[(String, Int)] = word2CountRDD.collect()

// 打印结果
word2Count.foreach(println)

//关闭Spark连接
sc.stop()

第三章 spark的运行环境

Spark作为一个数据处理框架和计算引擎，被设计在所有常见的集群环境中运行, 在国内工作中主流的环境为Yarn。

yarn模式的提交参数：

bin/spark-submit \
--class 全类名 \
--master yarn \
--deploy-mode cluster \
--driver-memory 2g \
--executor-memory 2g \
--executor-cores 2 \
--num-executors 3 \
jar包位置

第四章、spark的运行架构

4.1 运行架构

Spark框架的核心是一个计算引擎，整体来说，它采用了标准 master-slave的结构。如下图所示，它展示了一个 Spark执行时的基本结构。图形中的Driver表示master，负责管理整个集群中的作业任务调度。图形中的Executor 则是 slave，负责实际执行任务。

4.2 核心组件

4.2.1 Driver

Spark驱动器节点，用于执行Spark任务中的main方法，负责实际代码的执行工作。Driver在Spark作业执行时主要负责：

1、将用户程序转化为作业（job）

2、在Executor之间调度任务(task)

3、跟踪Executor的执行情况

4、通过UI展示查询运行情况

实际上，我们无法准确地描述Driver的定义，因为在整个的编程过程中没有看到任何有关Driver的字眼。所以简单理解，所谓的Driver就是驱使整个应用运行起来的程序，也称之为Driver类。

4.2.2 Executor

Spark Executor是集群中工作节点（Worker）中的一个JVM进程，负责在 Spark 作业中运行具体任务（Task），任务彼此之间相互独立。Spark 应用启动时，Executor节点被同时启动，并且始终伴随着整个 Spark 应用的生命周期而存在。如果有Executor节点发生了故障或崩溃，Spark 应用也可以继续执行，会将出错节点上的任务调度到其他Executor节点上继续运行。

Executor有两个核心功能：

1、 负责运行组成Spark应用的任务，并将结果返回给驱动器进程

2、 它们通过自身的块管理器（Block Manager）为用户程序中要求缓存的 RDD 提供内存式存储。RDD 是直接缓存在Executor进程内的，因此任务可以在运行时充分利用缓存数据加速运算。

4.2.3 ApplicationMaster

Hadoop用户向YARN集群提交应用程序时,提交程序中应该包含ApplicationMaster，用于向资源调度器申请执行任务的资源容器Container，运行用户自己的程序任务job，监控整个任务的执行，跟踪整个任务的状态，处理任务失败等异常情况。

说的简单点就是，RM（资源）和Driver（计算）之间的解耦合靠的就是ApplicationMaster。

4.3 核心概念

4.3.1Executor与Core

Spark Executor是集群中运行在工作节点（Worker）中的一个JVM进程，是整个集群中的专门用于计算的节点。在提交应用中，可以提供参数指定计算节点的个数，以及对应的资源。这里的资源一般指的是工作节点Executor的内存大小和使用的虚拟CPU核（Core）数量。

应用程序相关启动参数如下：

4.3.2 并行度（Parallelism）

在分布式计算框架中一般都是多个任务同时执行，由于任务分布在不同的计算节点进行计算，所以能够真正地实现多任务并行执行，记住，这里是并行，而不是并发。这里我们将整个集群并行执行任务的数量称之为并行度。那么一个作业到底并行度是多少呢？这个取决于框架的默认配置。应用程序也可以在运行过程中动态修改。

4.3.3 有向无环图（DAG）

这里所谓的有向无环图，并不是真正意义的图形，而是由Spark程序直接映射成的数据流的高级抽象模型。简单理解就是将整个程序计算的执行过程用图形表示出来,这样更直观，更便于理解，可以用于表示程序的拓扑结构。

DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向，不会闭环。

4.2 提交流程

yarn-cluster:

yarn-client:

第五章 spark核心编程

Spark计算框架为了能够对数据进行高并发和高吞吐的处理，封装了三大数据结构，用于处理不同的应用场景。三大数据结构分别是：

• RDD : 弹性分布式数据集

• 累加器：分布式共享只写变量

• 广播变量：分布式共享只读变量

5.1 RDD

5.1.1 什么是RDD

RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合，rdd中存储了逻辑，并没有存储数据。

5.1.2 执行原理

从计算的角度来讲，数据处理过程中需要计算资源（内存&CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。

Spark框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的计算任务。然后将任务发到分配资源的节点上, 按照指定的计算模型进行数据计算。最后得到计算结果。

RDD是Spark框架中用于数据处理的核心模型，接下来我们看看，在Yarn环境中，RDD的工作原理:

1. 启动Yarn集群环境
   

2. Spark通过申请资源创建调度节点和计算节点
   

3. Spark框架根据需求将计算逻辑根据分区划分成不同的任务
   

4. 调度节点将任务根据计算节点状态发送到对应的计算节点进行计算

从以上流程可以看出RDD在整个流程中主要用于将逻辑进行封装，并生成Task发送给Executor节点执行计算，接下来我们就一起看看Spark框架中RDD是具体是如何进行数据处理的。

5.1.3 基础编程

1、rdd的创建

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

• 从集合（内存中创建RDD）

package com.hgp.sparkcore

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore02_createRDD_01 {
  def main(args: Array[String]): Unit = {
    // todo 从集合和内存中创建rdd

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    //创建rdd
    val listRDD: RDD[Int] = sc.parallelize(
      List(1, 2, 3, 4),2//分区数量
    )
    val seqRDD = sc.makeRDD(
      Seq(1, 2, 3, 4)
    )
     
   sc.stop()
  }
}
/*从底层代码实现来讲，makeRDD方法其实就是parallelize方法
/

• 从外部文件(存储)中创建

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore02_createRDD_02 {
  def main(args: Array[String]): Unit = {
    // todo 从外部文件（存储）中读取创建
    Logger.getLogger("org").setLevel(Level.WARN)
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)
    val textRDD = sc.textFile("input/rdd.txt")
    textRDD.collect().foreach(println)
    sc.stop()
  }
}

• 从一个rdd中创建出另外一个rdd

package com.hgp.sparkcore
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD
object sparkcore02_createRDD_03 {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)
    //创建rdd
    val listRDD: RDD[Int] = sc.parallelize(
      List(1, 2, 3, 4), 2 //分区数量
    )
    val mapRDD = listRDD.map(t => t + 1)
  }
}

5.1.4 rdd的转换算子

1、map

• 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform_map {
  def main(args: Array[String]): Unit = {

    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)
    val seqRDD = sc.makeRDD(
      Seq(1, 2, 3, 4)
    )
    val mapRDD = seqRDD.map(
      t => t + "love"
    )
    mapRDD.collect().foreach(println)
    sc.stop()
  }
}

2、mapPartitons

• 将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform_mapPartions {
  def main(args: Array[String]): Unit = {

    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val seqRDD = sc.makeRDD(
      Seq(1, 2, 3, 4), 6
    )

    val mapPartitionsRDD = seqRDD.mapPartitions(
      datas => {
        datas.map(
          datas => datas + "aa"
        )
      }
    )
    mapPartitionsRDD.collect().foreach(println)

    sc.stop()
  }
}

3、flatMap

• 将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform03_flatmap {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val textRDD: RDD[String] = sc.textFile("input/word.txt")

    val flatRDD = textRDD.flatMap(a => a).map(
      datas => {
        datas + "i love you"
      }
    )
    flatRDD.collect().foreach(println)
    sc.stop()
  }
}

• flatmap和map区别

map处理是以一行为单位进行处理的，flatmap是把多条数据按照特点格式分成多行数据进行处理。

4、glom

• 将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform04_glom {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val seqRDD = sc.makeRDD(
      Seq(1, 2, 3, 4, 5), 3
    )
    val glomRDD = seqRDD.glom()

    val maxRDD = glomRDD.map(
      t => t.max
    )
    val ints: Array[Int] = maxRDD.collect()
    println(ints.sum)
  }
}

5、groupby

• 将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中

  一个组的数据在一个分区中，但是并不是说一个分区中只有一个组
  

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform05_groupby {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List("Hello", "hive", "hbase", "Hadoop")
    )
    val groupRDD = listRDD.groupBy(
      word => word(0)
    )
    groupRDD.collect().foreach(println)
    //    (h,CompactBuffer(hive, hbase))
    //    (H,CompactBuffer(Hello, Hadoop))
    // CompactBuffer-->是一个很容易进行循环遍历的集合
    sc.stop()
  }
}

6、filter

• 将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。

  当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，极限情况下，可能会出现数据倾斜。

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform06_filter {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val dataRDD = sc.makeRDD(
      List(1, 2, 3, 4, 5, 6)
    )
    val filterRDD = dataRDD.filter(t => t % 2 == 0)

    println(filterRDD.collect().mkString(","))
  }
}

7、sample

• 根据指定的规则从数据集中抽取数据

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform07_sample {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val dataRDD = sc.makeRDD(
      List(1,2,3,4)
    )
    val sampleRDD = dataRDD.sample(true, 0.5)
    // 第一个参数：抽取的数据是否放回，false：不放回
    // 第二个参数：抽取的几率，范围在[0,1]之间,0：全不取；1：全取；
    println(sampleRDD.collect().mkString(","))
  }
}

8、distinct

• 将数据集中重复的数据去重

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform08_distinct {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val dataRDD = sc.makeRDD(
      List(1,1,2,3,4,1,3),2
    )
    dataRDD.distinct().collect().foreach(println)
    sc.stop()
  }
}

9、coalesce

• 根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效

10、repartition

• 一般是用来增大分区的，一定会发生shuffle的过程 ，默认调用的是coalesce

11、sortby

• 该操作用于排序数据。在排序之前，可以将数据通过f函数进行处理，之后按照f函数处理的结果进行排序，默认为正序排列。排序后新产生的RDD的分区数与原RDD的分区数一致。

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform09_sortby {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(1, 2, 4, 1, 3, 4, 66, 1, 34, 5)
    )
    println(listRDD.sortBy(t => t, true).collect().mkString(","))
  }
}

12、intersection

• 对源RDD和参数RDD求交集后返回一个新的RDD

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform10_intersection {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD01=sc.makeRDD(
      List(1,2,3,4)
    )

    val listRDD02=sc.makeRDD(
      List(2,3,4,5)
    )

    println(listRDD01.intersection(listRDD02).collect().mkString(","))
  }

}

13、union

• 对源RDD和参数RDD求并集后返回一个新的RDD

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform11_union {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD01=sc.makeRDD(
      List(1,2,3,4)
    )

    val listRDD02=sc.makeRDD(
      List(2,3,4,5)
    )

    println(listRDD01.union(listRDD02).collect().mkString(","))
  }

}

14、subtract

• 以一个RDD元素为主，去除两个RDD中重复元素，将其他元素保留下来。求差集

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform12_subtract {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD01=sc.makeRDD(
      List(1,2,3,4)
    )

    val listRDD02=sc.makeRDD(
      List(2,3,4,5)
    )

    println(listRDD01.subtract(listRDD02).collect().mkString(","))
  }

}

15、zip

• 将两个RDD中的元素，以键值对的形式进行合并。其中，键值对中的Key为第1个RDD

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform_zip {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(1, 2, 3, 4)
    )
    val nameRDD = sc.makeRDD(
      List("张三", "李四", "王五","刘能")
    )
    listRDD.zip(nameRDD).collect().foreach(println)
  }
}

16、reducebykey

• 可以将数据按照相同的Key对Value进行聚合

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform14_reducebykey {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val dataRDD1 = sc.makeRDD(
      List(("a", 1), ("a", 3), ("b", 2))
    )
    val dataRDD2 = dataRDD1.reduceByKey(_+_)

    println(dataRDD2.collect().mkString(","))

  }

}

17、groupbykey

• 可以将数据按照相同的Key对Val

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform15_groupbykey {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val dataRDD1 = sc.makeRDD(
      List(("a", 1), ("a", 3), ("b", 2))
    )

    val groupbykeyRDD = dataRDD1.groupByKey()

    println(groupbykeyRDD.collect().mkString(","))
  }

}

• reduceByKey和groupByKey的区别？

两个算子没有使用上的区别。所以使用的时候需要根据应用场景来选择。

从性能上考虑，reduceByKey存在预聚合功能，这样，在shuffle的过程中，落盘的数据量会变少，所以读写磁盘的速度会变快。性能更高

18、aggregateByKey

• 将数据根据不同的规则进行分区内计算和分区间计算

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform16_aggregatebykey {
  def main(args: Array[String]): Unit = {

    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)


    val listRDD = sc.makeRDD(
      List(("a", 1), ("a", 3), ("b", 2), ("c", 3)), 3
    )
    val aggRDD = listRDD.aggregateByKey(2)(
      (x, y) => math.max(x, y),
      (x, y) => x + y
    )
    
    println(aggRDD.collect().mkString(","))

    sc.stop()
  }
}

19、foldByKey

• 当分区内计算规则和分区间计算规则相同时，aggregateByKey就可以简化为foldByKey

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform17_foldbykey {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)


    val listRDD = sc.makeRDD(
      List(("a", 1), ("a", 3), ("b", 2), ("c", 3)), 3
    )
    val aggRDD = listRDD.foldByKey(2)(_+_)

    println(aggRDD.collect().mkString(","))

    sc.stop()
  }

}

20、combineByKey

• 最通用的对key-value型rdd进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform18_combinebykey {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98))
    )
    val comRDD = listRDD.combineByKey(
      t => (t, 1),
      (a: (Int, Int), b) => (a._1 + b, a._2 + 1),
      (a: (Int, Int), b: (Int, Int)) => (a._1 + b._1, a._2 + b._2)
    )
    println(comRDD.map(t => t._2._1 / t._2._2).collect().mkString(","))
    sc.stop()
  }
}

21、sortbykey

• 在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform19_sortbykey {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    println(sc.makeRDD(
      List(
        ("a", 1), ("b", 2), ("d", 3), ("c", 4)
      )
    ).sortByKey(true).collect().mkString(","))
  }

}

22、join

• 在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素连接在一起的(K,(V,W))的RDD
• 如果key不相等，key如果有两个RDD中不一致，那么数据无法连接。但是如果key有重复的，那么数据会多次l连接

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

/**
 * @Author: 何广谱
 * @project BigData-partiice
 * @description TODO 
 * @Date: 2020/10/9 16:39
 */
object sparkcore03_transform_join {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val rdd1 = sc.makeRDD(
      Array((1, "a"), (2, "b"), (3, "c"))
    )

    val rdd2 = sc.makeRDD(
      Array((1, 4), (2, 5), (3, 6))
    )

    println(rdd1.join(rdd2).collect().mkString(","))
  }

}

还有的join的算子有：leftOuterJoin.

23、cogroup

• 在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore03_transform20_cogroup {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(
        ("a", 1), ("b", 2), ("d", 3), ("c", 4)
      ))

    val listRDD1 = sc.makeRDD(
      List(
        ("a", 1), ("b", 2), ("d", 3), ("c", 4)
      ))

    val cogroupRDD: RDD[(String, (Iterable[Int], Iterable[Int]))] = listRDD.cogroup(listRDD1)

    cogroupRDD.collect().foreach(println)

   sc.stop()
  }

}

5.1.5 行动算子

行动算子不会产生新的rdd

1、reduce

• 聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore04_action_reduce {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(1, 2, 3, 4)
    )
    println(listRDD.reduce(
      (x, y) => x + y
    ))
  }
}

2、collect

• 在驱动程序中，以数组Array的形式返回数据集的所有元素

3、count

• 返回RDD中元素的个数

4、first

• 返回RDD中的第一个元素

5、take

• 返回一个由RDD的前n个元素组成的数组

6、takeOrdered

• 返回该RDD排序后的前n个元素组成的数组

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore04_action_takeOrdered {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(1, 9, 4, 5, 2, 3)
    )

    val ints = listRDD.takeOrdered(5)
    ints.foreach(println)
  }
}

7、aggregate

• 分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore04_action_aggregate {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(1, 2, 3, 4), 8
    )

    val i = listRDD.aggregate(10)(
      (x, y) => (x + y),
      (x, y) => (x + y)
    )
    println(i)
  }
}

8、fold

• aggregate的分区逻辑和分区间的逻辑是一样的

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore04_action_fold {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    val listRDD = sc.makeRDD(
      List(1, 2, 3, 4), 8
    )

    val i = listRDD.fold(10)(_ + _)
    println(i)
  }
}

9、countByKey

• 统计每种key的个数

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore04_action_countbykey {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)
    val dataRDD1 = sc.makeRDD(
      List(("a", 1), ("a", 3), ("b", 2))
    )
    val stringToLong: collection.Map[String, Long] = dataRDD1.countByKey()

    stringToLong.foreach(println)
    sc.stop()
  }
}

10、save相关的算子

// 保存成Text文件
rdd.saveAsTextFile("output")

// 序列化成对象保存到文件
rdd.saveAsObjectFile("output1")

// 保存成Sequencefile文件
rdd.map((_,1)).saveAsSequenceFile("output2")

11、foreach

• [所有的算子都是在driver端运行的，算子里面的逻辑是在executor端执行的。](// 保存成Text文件

5.1.6 RDD的序列化

1. 闭包检查

从计算的角度, 算子以外的代码都是在Driver端执行, 算子里面的代码都是在Executor端执行。那么在scala的函数式编程中，就会导致算子内经常会用到算子外的数据，这样就形成了闭包的效果，如果使用的算子外的数据无法序列化，就意味着无法传值给Executor端执行，就会发生错误，所以需要在执行任务计算前，检测闭包内的对象是否可以进行序列化，这个操作我们称之为闭包检测。

2）序列化方法和属性

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD

object spark05_serializable {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)

    //3.创建一个RDD
    val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", "hive", "kafka"))

    //3.1创建一个Search对象
    val search = new Search("hello")

    //3.2 函数传递，打印：ERROR Task not serializable
    search.getMatch1(rdd).collect().foreach(println)

    //3.3 属性传递，打印：ERROR Task not serializable
    search.getMatch2(rdd).collect().foreach(println)

    //4.关闭连接
    sc.stop()
  }

}
class Search(query:String) extends Serializable {

  def isMatch(s: String): Boolean = {
    s.contains(query)
  }

  // 函数序列化案例
  def getMatch1 (rdd: RDD[String]): RDD[String] = {
    //rdd.filter(this.isMatch)
    rdd.filter(isMatch)
  }

  // 属性序列化案例
  def getMatch2(rdd: RDD[String]): RDD[String] = {
    //rdd.filter(x => x.contains(this.query))
    rdd.filter(x => x.contains(query))
    //val q = query
    //rdd.filter(x => x.contains(q))
  }
}

3. Kryo序列化框架

object serializable_Kryo {

    def main(args: Array[String]): Unit = {

        val conf: SparkConf = new SparkConf()
                .setAppName("SerDemo")
                .setMaster("local[*]")
                // 替换默认的序列化机制
                .set("spark.serializer","org.apache.spark.serializer.KryoSerializer")
                // 注册需要使用 kryo 序列化的自定义类
                .registerKryoClasses(Array(classOf[Searcher]))

        val sc = new SparkContext(conf)

        val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello hive", "kafka", "hahah"), 2)

        val searcher = new Searcher("hello")
        val result: RDD[String] = searcher.getMatchedRDD1(rdd)

        result.collect.foreach(println)
    }
}
case class Searcher(val query: String) {

    def isMatch(s: String) = {
        s.contains(query)
    }

    def getMatchedRDD1(rdd: RDD[String]) = {
        rdd.filter(isMatch) 
    }

    def getMatchedRDD2(rdd: RDD[String]) = {
        val q = query
        rdd.filter(_.contains(q))
    }
}

5.1.7 RDD的依赖关系

1）RDD的血缘关系

RDD只支持粗粒度转换，即在大量记录上执行的单个操作。将创建RDD的一系列Lineage（血统）记录下来，以便恢复丢失的分区。RDD的Lineage会记录RDD的元数据信息和转换行为，当该RDD的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据分区。

2）RDD依赖关系

这里所谓的依赖关系，其实就是RDD之间的关系

3）RDD的宽依赖

有shuffle的过程

4）RDD的窄依赖

没有shuffle的过程

5）RDD的阶段划分

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

7、RDD任务划分

RDD任务切分中间分为：Application、Job、Stage和Task

Application：初始化一个SparkContext即生成一个Application；

Job：一个Action算子就会生成一个Job；

Stage：Stage等于宽依赖(ShuffleDependency)的个数加1；

Task：一个Stage阶段中，最后一个RDD的分区个数就是Task的个数。

5.1.8 RDD的持久化

1）RDD cache 缓存

RDD通过Cache或者Persist方法将前面的计算结果缓存，默认情况下会把数据以序列化的形式缓存在JVM的堆内存中。但是并不是这两个方法被调用时立即缓存，而是触发后面的action算子时，该RDD将会被缓存在计算节点的内存中，并供后面重用。

// cache操作会增加血缘关系，不改变原有的血缘关系
println(wordToOneRdd.toDebugString)

// 数据缓存。
wordToOneRdd.cache()

// 可以更改存储级别
//mapRdd.persist(StorageLevel.MEMORY_AND_DISK_2)

2. rdd的checkpoint

所谓的检查点其实就是通过将RDD中间结果写入磁盘

由于血缘依赖过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果检查点之后有节点出现问题，可以从检查点开始重做血缘，减少了开销。

对RDD进行checkpoint操作并不会马上被执行，必须执行Action操作才能触发。

// 设置检查点路径
sc.setCheckpointDir("./checkpoint1")


val lineRdd: RDD[String] = sc.textFile("input/1.txt")

// 业务逻辑
val wordRdd: RDD[String] = lineRdd.flatMap(line => line.split(" "))

val wordToOneRdd: RDD[(String, Long)] = wordRdd.map {
    word => {
        (word, System.currentTimeMillis())
    }
}
// 增加缓存,避免再重新跑一个job做checkpoint
wordToOneRdd.cache()
// 数据检查点：针对wordToOneRdd做检查点计算
wordToOneRdd.checkpoint()

// 触发执行逻辑
wordToOneRdd.collect().foreach(println)

• 缓存和检查点区别

1）Cache缓存只是将数据保存起来，不切断血缘依赖。Checkpoint检查点切断血缘依赖。

2）Cache缓存的数据通常存储在磁盘、内存等地方，可靠性低。Checkpoint的数据通常存储在HDFS等容错、高可用的文件系统，可靠性高。

3）建议对checkpoint()的RDD使用Cache缓存，这样checkpoint的job只需从Cache缓存中读取数据即可，否则需要再从头计算一次RDD。

5.1.9 RDD的分区器

RDD默认采用的分区格式是hash 还有的分区格式是range 还可以自定义分区器

5.10 RDD的文件读取和保存

ark的数据读取及数据保存可以从两个维度来作区分：文件格式以及文件系统。

文件格式分为：text文件、json文件、csv文件、sequence文件以及Object文件；

文件系统分为：本地文件系统、HDFS、HBASE以及数据库。

• text文件

// 读取输入文件
val inputRDD: RDD[String] = sc.textFile("input/1.txt")

// 保存数据
inputRDD.saveAsTextFile("output")

• json文件

如果JSON文件中每一行就是一个JSON记录，那么可以通过将JSON文件当做文本文件来读取，然后利用相关的JSON库对每一条数据进行JSON解析。

val jsonRDD: RDD[String] = sc.textFile("input/user.json")

// 导入解析Json所需的包并解析Json
import scala.util.parsing.json.JSON
val resultRDD: RDD[Option[Any]] = jsonRDD.map(JSON.parseFull)

5.2 累加器

实现原理：

累加器用来把Executor端变量信息聚合到Driver端。在Driver程序中定义的变量，在Executor端的每个Task都会得到这个变量的一份新的副本，每个task更新这些副本的值后，传回Driver端进行merge。

• 系统累加器

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.{SparkConf, SparkContext}

object sparkcore06_longAccumulator {
  def main(args: Array[String]): Unit = {
    // todo 系统累加器
    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)
    // 声明累加器
    val sum = sc.longAccumulator("sum")

    val listRDD = sc.makeRDD(
      List(1, 2, 3, 4, 5)
    )
    listRDD.foreach {
      data => sum.add(data)
    }
    println(sum)
  }
}

• 自定义累加器

package com.hgp.sparkcore

import org.apache.spark.util.AccumulatorV2

import scala.collection.mutable
object sparkcore06_longAccumulator01 {
  def main(args: Array[String]): Unit = {
    // TODO 自定义累加器

  }
}

class MyAccumulator extends AccumulatorV2[String, mutable.Map[String, Long]] {

  var map: mutable.Map[String, Long] = mutable.Map()

  // 累加器是否为初始状态
  override def isZero: Boolean = {
    map.isEmpty
  }

  // 复制累加器
  override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = {
    new MyAccumulator()

  }

  // 重置累加器
  override def reset(): Unit = {
    map.clear()
  }

  //向累加器中添加数据
  override def add(v: String): Unit = {
    map(v) = map.getOrElse(v, 0L) + 1L
  }
  //合并累加器
  override def merge(other: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = {
    val map1 = map
    val map2 = other.value

    map = map1.foldLeft(map2)(
      (innerMap, kv) => {
        innerMap(kv._1) = innerMap.getOrElse(kv._1, 0L) + kv._2
        innerMap
      }
    )
  }
  override def value: mutable.Map[String, Long] = map
}

5.3 广播变量

广播变量用来高效分发较大的对象。向所有工作节点发送一个较大的只读值，以供一个或多个Spark操作使用。比如，如果你的应用需要向所有节点发送一个较大的只读查询表，广播变量用起来都很顺手。在多个并行操作中使用同一个变量，但是 Spark会为每个任务分别发送。

package com.hgp.sparkcore

import org.apache.log4j.{Level, Logger}
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object sparkcore07_broadcast {
  def main(args: Array[String]): Unit = {

    Logger.getLogger("org").setLevel(Level.WARN)

    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("create_rdd")
    val sc = new SparkContext(sparkConf)
    val listRDD = sc.makeRDD(
      List(1, 2, 3, 4, 5)
    )
    val list = List(6, 7, 8, 9, 10)
    val broadcast = sc.broadcast(list)
    val rdd: RDD[(Int, Int)] = listRDD.map {
      case (data) => {
        var num = 0
        for (a <- broadcast.value) {
          num = a
        }
        (data, num)
      }
    }
    println(rdd.collect().mkString(":"))
  }
}