Spark--spark核心编程（RDD的概念）

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

• RDD : 弹性分布式数据集
• 累加器：分布式共享只写变量
• 广播变量：分布式共享只读变量

RDD

1.什么是RDD

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

弹性

• 存储的弹性：内存与磁盘的自动切换；
• 容错的弹性：数据丢失可以自动恢复；
• 计算的弹性：计算出错重试机制；
• 分片的弹性：可根据需要重新分片。

分布式

数据存储在大数据集群不同节点上

数据集

RDD 封装了计算逻辑，并不保存数据

数据抽象

RDD 是一个抽象类，需要子类具体实现

不可变

RDD 封装了计算逻辑，是不可以改变的，想要改变，只能产生新的RDD，在新的RDD 里面封装计算逻辑

可分区、并行计算

RDD和IO流的关系

• RDD的数据处理方式类似于IO流，也有装饰者设计模式
• RDD的数据只有在调用collect方法时，才会真正执行业务逻辑操作，之前的封装全部都是功能的扩展
• RDD是不保存数据的，但是IO可以临时保存一部分数据

2.核心属性

1. 分区列表
   RDD 数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要属性。
2. 分区计算函数
   Spark 在计算时，是使用分区函数对每一个分区进行计算
3. RDD 之间的依赖关系
   RDD 是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个 RDD 建立依赖关系
4. 分区器（可选）
   当数据为 KV 类型数据时，可以通过设定分区器自定义数据的分区
5. 首选位置（可选）
   计算数据时，可以根据计算节点的状态选择不同的节点位置进行计算

3.执行原理

• 从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。
• Spark 框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的计算任务。然后将任务发到已经分配资源的计算节点上, 按照指定的计算模型进行数据计算。最后得到计算结果。
• RDD 是 Spark 框架中用于数据处理的核心模型，接下来我们看看，在 Yarn 环境中，RDD 的工作原理:
  1）启动 Yarn 集群环境
  

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

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

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

从以上流程可以看出 RDD 在整个流程中主要用于将逻辑进行封装，并生成 Task 发送给Executor 节点执行计算

4.基础编程

4.1 RDD创建

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

object Spark_rdd_01 {
  def main(args: Array[String]): Unit = {
    //TODO 准备环境
    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(conf)

    //TODO 创建RDD
    //从内存中创建RDD，将内存中集合的数据作为处理的数据源
    val seq=Seq[Int](1,2,3,4)
    //parallelize:并行
    //val rdd: RDD[Int] = sc.parallelize(seq)
    //makeRDD方法在底层实现时其实就是调用了rdd对象的parallelize方法
    val rdd: RDD[Int] = sc.makeRDD(seq)
    rdd.collect().foreach(println)
    
    //TODO 关闭环境
    sc.stop()
  }
}

1
2
3
4

• 从外部存储（文件）创建RDD

object Spark_rdd_01 {
  def main(args: Array[String]): Unit = {
    //TODO 准备环境
    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(conf)

    //TODO 创建RDD
    //从文件中创建RDD，将文件中的数据作为处理的数据源
    //path路径默认以当前环境的根路径为基准，可以写绝对路径，也可以写相对路径
    //path路径可以是文件的具体路径，也可以是目录名称
    //val rdd=sc.textFile("datas")
    //path路径还可以使用通配符
    //val rdd=sc.textFile("datas/1*.txt")
    //path还可以是分布式存储系统的路径:HDFS
    //val rdd=sc.textFile("hdfs://linux1:8020/test.txt")
    //textFile:以行为单位来读取数据，读取的数据都是字符串
    //wholeTextFiles:以文件为单位读取数据
    //val rdd = sc.wholeTextFiles("datas")
    //读取的结果表示为元组，第一个元素表示文件路径，第二个元素表示文件内容
    val rdd: RDD[String] = sc.textFile("datas\\1.txt")
    rdd.collect().foreach(println)

    //TODO 关闭环境
    sc.stop()
  }
}

Hello World
Hello Spark
hello scala
hello Spark

• 从其他RDD创建
• 直接创建RDD

4.2 RDD并行度与分区

object Spark_rdd_01 {
  def main(args: Array[String]): Unit = {
    //TODO 准备环境
    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    //conf.set("spark.default.parallelism","5")  可以手动配置核数
    val sc = new SparkContext(conf)

    //TODO 创建RDD
    //RDD的并行度&分区
    //makeRDD方法可以传递第二个参数，这个参数表示分区的数量
    //第二个参数可以不传递的，那么makeRDD方法会使用默认值：defaultParallelism（默认为）
    //源码scheduler.conf.getInt("spark.default.parallelism",totalCores)
    //spark在默认情况下，从配置对象中获取配置参数：spark.default.parallelism
    //如果获取不到，那么使用totalCores属性，这个属性取值为当前运行环境的最大可用核数
    val rdd: RDD[Int] = sc.makeRDD(
      List(1, 2, 3, 4), 2
    )

    //将处理的数据保存成分区文件
    rdd.saveAsTextFile("output")

    //TODO 关闭环境
    sc.stop()
  }
}

object Spark_rdd_01 {
  def main(args: Array[String]): Unit = {
    //TODO 准备环境
    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(conf)

    //TODO 创建RDD
    //textFile可以将文件作为数据处理的数据源，默认也可以设定分区,默认分区数是2
    //minPartition:最小分区数量
    //math.min(defaultParallelism,2)
    //如果不想使用默认的分区数量，可以通过第二个参数指定分区数
    //Spark读取文件，底层其实使用的是Hadoop的读取方式
    //分区数量的计算方式：
    // totalSize=7
    // goalSize=7/2=3(byte)
    // 7/3=2...1(1.1)+1=3(分区)
    val rdd: RDD[String] = sc.textFile("datas\\1.txt",3)
    
    //将处理的数据保存成分区文件
    rdd.saveAsTextFile("output")
    
    //TODO 关闭环境
    sc.stop()
  }
}

1.txt

1
2
3

object Spark_rdd_01 {
  def main(args: Array[String]): Unit = {
    //TODO 准备环境
    val conf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(conf)

    //TODO 创建RDD
   //TODO 数据分区的分配
    //1.数据以行为单位进行读取
    //  spark读取文件，采用的是hadoop的方式读取，所以一行一行读取，和字节数没有关系
    //2.数据读取时以偏移量为单位,偏移量不会被重复读取
    /*字节      偏移量
    * 1@@    => 012
    * 2@@    => 345
    * 3      => 6
    */
    //3.数据分区的偏移量范围的计算
    /*分区    偏移量范围
    * 0   => [0,3]  =>12
    * 1   => [3,6]  =>3
    * 2   => [6,7]  =>
    */

    //如果数据源为多个文件，那么计算分区时以文件为单位进行分区
    val rdd: RDD[String] = sc.textFile("datas\\1.txt",2)

    //将处理的数据保存成分区文件
    rdd.saveAsTextFile("output")

    //TODO 关闭环境
    sc.stop()
  }
}

4.3 RDD转换算子