多么哇塞的陈哇塞

Spark：Core（三）

01：上篇回顾

02：学习目标

03：外部数据源：场景

04：外部数据源：写Hbase

05：外部数据源：读Hbase

06：外部数据源：写MySQL

07：广播变量：Broadcast Variables

08：累加器：Accumulators

09：内核调度：宽窄依赖

10：内核调度：Shuffle

11：内核调度：基本概念

12：内核调度：调度流程

13：内核调度：并行度

14：SparkCore中的问题

15：SparkSQL的诞生与发展

16：功能特点与应用场景

17：DSL实现WordCount

18：SQL实现WordCount

附录一：Spark Maven依赖

01：上篇回顾

https://blog.csdn.net/m0_57498038/article/details/119106044

RDD的创建方式有几种？
- 方式一：并行化一个已存在的集合
```
sc.parallize / sc.makeRDD
```
- 方式二：读取外部存储系统
```
sc.textFile/sc.wholeTextFile/sc.newAPIHadoopRDD
```
RDD的算子分为几类，有什么区别？
- Transformation ：转换算子
  - 不会触发job以及Task的运行，Lazy模式设计
  - 返回值：RDD类型
- Action：触发算子
  - 会触发job以及Task的运行，数据的使用
  - 返回值：非RDD类型
常用的RDD函数有哪些？
- 基本函数：map、flatMap、filter、take、top、foreach
- 分区操作函数：xxxxPartition
  - 函数：mapPartitions,foreachPartition
  - 功能：对RDD的每个分区调用参数函数进行处理
  - 场景：基于分区的资源构建
- 重分区函数
  - 函数：repartition、coalesce
  - 功能：调整RDD的分区个数，返回一个新的RDD
  - 区别
    - repartition：用于调大分区个数，必须经过shuffle
    - coalesce(分区个数，是否经过shuffle：false)：用于调小分区个数
- 聚合函数
  - 函数
    - reduce：分区内聚合和分区间聚合逻辑一致，没有初始值
    - fold：分区内聚合和分区间聚合逻辑一致，有初始值
    - aggregate：分区内聚合和分区间聚合逻辑可以自定义，有初始值
  - 功能：实现分布式的聚合
- PairRDD函数
  - 函数：xxxxxByKey
    - reduceByKey：按照key分组，使用reduce聚合
    - aggregateByKey：按照key分区，使用aggregate聚合
    - |
    - 底层：combinerByKey：先分区内聚合，再分区间聚合
    - groupByKey：按照key进行分组
      - 将所有数据放在一起以后再统一分组
    - sortByKey：按照Key实现排序
  - 关联函数：Join
    - rdd1：KV
    - rdd2：KW
    - rdd1.join(rdd2) = RDD:[K,(V,W)]
RDD的数据，怎么保证安全性？
- 血链机制：通过依赖关系来恢复RDD的数据
RDD的persist机制是什么？
- 功能：将RDD缓存在Executor中内存或者磁盘中，避免RDD的重复构建
- 函数：persist、cache、unpersist
- 级别
  - 磁盘
  - 内存
  - 优先内存，内存不足再存磁盘
RDD的checkpoint是什么？
- 功能：将RDD的数据持久化存储在HDFS
- 应用：非常重要的RDD或者数据量非常大
- 函数
  - 设置检查点目录：sc.setCheckpointDir
  - 设置检查点：rdd.checkpoint
persist与checkpoint的区别是什么？
- 存活周期
  - persist：主从释放：unpersist
  - checkpoint：手动删除
- 数据内容
  - persist：RDD
  - checkpoint：RDD数据
疑问整理
- persist保存血脉关系不太懂。没有persist,走的血脉来恢复RDD。有了persist,可以直接在缓存拿RDD，不走血脉。如果缓存的数据没了，那RDD保存的血脉关系不也跟着没了。没有领会到这保存血脉的作用
- persist是缓存数据的，task结束缓存就会删除，在没有设置缓存的情况下，数据会进行缓存吗？
  - 不会
- 在stage中，左边运行过的repartition在程序运行一次后再次运行就会变成灰色的，相当于直接拿到了原来运行过的数据，这个过程属于缓存吗？
  - 不属于：属于shuffle的磁盘数据
  - 设计：为了避免重复运行相同Stage

02：学习目标

SparkCore
- 外部数据源：读写Hbase、MySQL
- 共享变量：广播变量、累加器
- 内核调度
  - 宽窄依赖
  - Shuffle
  - 基本概念、调度流程：Master、Worker、Driver、Executor、Application、Job、Stage、Task
  - 并行度
SparkSQL
- 基本设计
- 功能、特点、应用场景
- 基本使用

03：外部数据源：场景

目标：了解SparkCore读写外部数据源的应用场景
实施
- 原始数据
  - HDFS、Hbase
- 数据处理
  - SparkCore
- 结果存储
  - HDFS、Hbase、MySQL
- SparkCore的数据源接口
  - parallelize / makeRDD：将一个Scala中的集合转换为一个RDD对象
  - textFile / wholeTextFiles：读取外部文件系统的数据转换为一个RDD对象
  - newAPIHadoopRDD / newAPIHadoopFile：调用Hadoop的InputFormat来读取数据转换为一个RDD对象
小结
- 了解SparkCore读写外部数据源的应用场景

04：外部数据源：写Hbase

目标：掌握SparkCore如何写入数据到Hbase
路径
- step1：MR写Hbase的原理
- step2：Spark写Hbase实现

实施

MR写Hbase的原理
- MR：OutputFormat：TableOutputFormat
- 要求：输出的Value类型必须为Put类型

Spark写Hbase实现

需求：将Wordcount的结果写入hbase
- 表：htb_wordcount
- 列族：info
- rowkey：单词
- 列名：cnt
- 值：单词出现的次数

启动HBASE

start-dfs.sh
zookeeper-daemons.sh start
start-hbase.sh
hbase shell

创建表
```
create 'htb_wordcount','info'
```

开发

package bigdata.spark.core.hbase

import org.apache.hadoop.hbase.HBaseConfiguration
import org.apache.hadoop.hbase.client.Put
import org.apache.hadoop.hbase.io.ImmutableBytesWritable
import org.apache.hadoop.hbase.mapreduce.TableOutputFormat
import org.apache.hadoop.hbase.util.Bytes
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
  * @ClassName SparkCoreWriteToHbase
  * @Description TODO SparkCore 实现写入数据到Hbase
  */
object SparkCoreWriteToHbase {

  def main(args: Array[String]): Unit = {
    //todo:1-构建SparkContext对象
    val sc:SparkContext = {
      //构建SparkConf配置管理对象，类似于Hadoop中的Configuration对象
      val conf = new SparkConf()
          .setMaster("local[2]")//指定运行模式
          .setAppName(this.getClass.getSimpleName.stripSuffix("$"))//指定运行程序名称
//          .set("key","value") //指定额外的属性
      //返回SparkContext对象
      SparkContext.getOrCreate(conf)
    }
    //调整日志级别
    sc.setLogLevel("WARN")

    //todo:2-实现数据的转换处理
    //step1：读取数据
    val inputRdd: RDD[String] = sc.textFile("datas/wordcount/wordcount.data")
    //    println(s"总行数=${inputRdd.count()}")
    //    println(s"第一行=${inputRdd.first()}")

    //step2：处理数据
    val wcRdd: RDD[(String, Int)] = inputRdd
      .filter(line => line != null && line.trim.length > 0)//过滤
      .flatMap(line => line.trim.split("\\s+")) //将每个单词提取
      .map(word => (word,1)) //构建二元组keyvalue
      .reduceByKey((tmp,item) => tmp+item) //按照key进行分组聚合

    //step3：保存结果
    wcRdd.foreach(println)//打印
//    wcRdd.saveAsTextFile("datas")//写入HDFS
    //写入Hbase

    /**
      * def saveAsNewAPIHadoopFile(
      * path: String,               临时目录
      * keyClass: Class[_],         Key的类型
      * valueClass: Class[_],       Value的类型
      * outputFormatClass: Class[_ <: NewOutputFormat[_, _]],  输出类
      * conf: Configuration = self.context.hadoopConfiguration)  Hadoop的配置对象
      */
    //构建一个写入Hbase的配置对象
    val configuration = HBaseConfiguration.create()
    // 设置连接Zookeeper属性
    configuration.set("hbase.zookeeper.quorum", "node1.itcast.cn")
    configuration.set("hbase.zookeeper.property.clientPort", "2181")
    configuration.set("zookeeper.znode.parent", "/hbase")
    // 设置将数据保存的HBase表的名称
    configuration.set(TableOutputFormat.OUTPUT_TABLE, "htb_wordcount")
    //将RDD的数据类型进行转换
    val putRdd = wcRdd
        .map(tuple => {
          //指定返回的Key为rowkey【单词】：ImmutableBytesWritable
          val rowkey = new ImmutableBytesWritable(Bytes.toBytes(tuple._1))
          //构建put对象
          val put = new Put(rowkey.get())
          //添加列
          put.addColumn(Bytes.toBytes("info"),Bytes.toBytes("cnt"),Bytes.toBytes(tuple._2.toString))
          //返回KV
          (rowkey,put)
        })

    putRdd.saveAsNewAPIHadoopFile(
      "datas/sparkcore/tmp",//设置一个程序的临时目录
      classOf[ImmutableBytesWritable],
      classOf[Put],
      classOf[TableOutputFormat[ImmutableBytesWritable]],
      configuration
    )


    //todo:3-释放SparkContext对象
    Thread.sleep(1000000000000000L)
    sc.stop()
  }
}

小结
- 掌握SparkCore如何写入数据到Hbase

05：外部数据源：读Hbase

目标：掌握SparkCore如何从Hbase中读取数据
路径
- step1：MR读取Hbase原理
- step2：Spark读Hbase实现
- step3：序列化问题

实施

MR读取Hbase原理
- MR：InputFormat：TableInputFormat
  - 功能一：分片：一个Hbase的region对应一个分片
  - 功能二：转换KV
    - K：Rowkey：ImmutableBytesWritable
    - V：Rowkey数据：Result

Spark读Hbase实现

// 设置连接Zookeeper属性
    configuration.set("hbase.zookeeper.quorum", "node1")
    configuration.set("hbase.zookeeper.property.clientPort", "2181")
    configuration.set("zookeeper.znode.parent", "/hbase")
    // 设置读取哪张Hbase的表
    configuration.set(TableInputFormat.INPUT_TABLE, "htb_wordcount")

序列化问题

报错
原因：Spark中需要单独配置序列化机制

解决

// TODO: 设置使用Kryo 序列化方式
.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
// TODO: 注册序列化的数据类型
.registerKryoClasses(Array(classOf[ImmutableBytesWritable], classOf[Result]))

小结
- 掌握SparkCore如何从Hbase中读取数据

06：外部数据源：写MySQL

目标：掌握SparkCore如何将数据写入MySQL
路径
- step1：需求
- step2：实现

实施

需求
- 读MySQL：目前主要通过SparkSQL来实现
- 写MySQL：将分析的结果进行保存

实现

MySQL中建表

登录MySQL：node1
```
mysql -uroot -p
```

建表

USE db_test ;
drop table if exists `tb_wordcount`;
CREATE TABLE `tb_wordcount` (
  `word` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `count` varchar(100) NOT NULL,
  PRIMARY KEY (`word`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci ;

JDBC

jdbc:mysql://node1.itcast.cn:3306/?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true

代码实现

package bigdata.spark.core.mysql

import java.sql.{Connection, DriverManager, PreparedStatement}

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

/**
  * @ClassName SparkCoreWriteToMySQL
  * @Description TODO SparkCore 实现词频统计，结果保存到MySQL中
  */
object SparkCoreWriteToMySQL {

  /**
    * 实现将数据写入MySQL
    * @param part：每个分区
    */
  def saveToMySQL(part: Iterator[(String, Int)]): Unit = {
    //step1：申明驱动类，构建对象
    Class.forName("com.mysql.jdbc.Driver")
    //连接对象
    var conn:Connection = null
    //SQL对象
    var pstm:PreparedStatement = null
    try{
        //获取连接
        conn = DriverManager.getConnection("jdbc:mysql://node1:3306/?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true",
          "root","123456")
        //构建SQL
        val sql = "replace into db_test.tb_wordcount values(?,?)"
        //构建SQL对象
        pstm = conn.prepareStatement(sql)
        //赋值
        part.foreach{
          case (word,cnt) => {
            pstm.setString(1,word)
            pstm.setString(2,cnt.toString)
            //放入批次
            pstm.addBatch()
          }
        }
        //执行批次
        pstm.executeBatch()
    }catch {
      case e:Exception => e.printStackTrace()
    }finally {
      //资源释放
      if(pstm!=null) pstm.close()
      if(conn!=null) conn.close()
    }
  }


  def main(args: Array[String]): Unit = {
    //todo:1-构建SparkContext对象
    val sc:SparkContext = {
      //构建SparkConf配置管理对象，类似于Hadoop中的Configuration对象
      val conf = new SparkConf()
          .setMaster("local[2]")//指定运行模式
          .setAppName(this.getClass.getSimpleName.stripSuffix("$"))//指定运行程序名称
//          .set("key","value") //指定额外的属性
      //返回SparkContext对象
      SparkContext.getOrCreate(conf)
    }
    //调整日志级别
    sc.setLogLevel("WARN")

    //todo:2-实现数据的转换处理
    //step1：读取数据
    val inputRdd: RDD[String] = sc.textFile("datas/wordcount/wordcount.data")
//    println(s"总行数=${inputRdd.count()}")
//    println(s"第一行=${inputRdd.first()}")

    //step2：处理数据
    val wcRdd: RDD[(String, Int)] = inputRdd
      .filter(line => line != null && line.trim.length > 0)//过滤
      .flatMap(line => line.trim.split("\\s+")) //将每个单词提取
      .map(word => (word,1)) //构建二元组keyvalue
      .reduceByKey((tmp,item) => tmp+item) //按照key进行分组聚合

    //step3：保存结果
    wcRdd.foreach(println)
//    wcRdd.saveAsTextFile("datas/output/wc-"+System.currentTimeMillis())
    //将数据写入MySQL中
    wcRdd
      .coalesce(1) //数据量小，降低为1个分区
      .foreachPartition(part => saveToMySQL(part))  //每个分区调用一次写入MySQL

    //todo:3-释放SparkContext对象
    Thread.sleep(1000000000L)
    sc.stop()
  }
}

小结
- 掌握SparkCore如何将数据写入MySQL