第二部分：Spark进阶篇

① process_local : 进程本地化 , task计算的数据在当前Executor中, 不同task计算的时候可以共同用这一个数据集,效率高,节省资源;

② node_local : 节点本地化 , task计算的数据在当前节点上,task计算的时候不需要跨节点拉取数据,速度也是比较快的;

③ no_pref : 没有本地化 ,这个方式的意思就是数据不是本地化的数据; 比如我们的MySQL数据库, 如果我们需要的数据在MySQL中就不牵扯到数据本地化的这个说法;

④ rack_local : task计算所需要的数据在同机架不同节点上, 这种方式中,task计算的数据在不同节点上,就牵扯到网络传输的问题了 ,效率就没有那么高了;

⑤ any : 这种方式就是比较随意的,可能会牵扯到跨机架的数据传输,效率最低;

默认的优先级是从上到下依次降低。

8 SparkSql执行流程

① Parser转换器，第三方类库 Antlr 实现。将 sql 字符串切分成 Token，根据语义规则解析成一颗AST语法树，称为Unresolved Logical Plan 未解决的逻辑计划；

简单来说就是判断 SQL 语句是否符合规范，比如select from where 这些关键字是否写对。就算表名字段名写错也无所谓。

② Unresolved Logical Plan经过Analyzer分析器，借助于表的真实数据元数据 schema catalog，进行数据类型绑定和函数绑定，解析为 resolved Logical Plan 已解决的逻辑计划；

简单来说就是判断 SQL 语句的表名，字段名是否真的在元数据库里存在。

③ Optimizer优化器，基于各种优化规则（常量折叠，谓词下推，列裁剪），将上面的resolved Logical Plan进一步转换为语法树 Optimized Logical Plan 优化的逻辑计划。这个过程称作 RBO（Rule Based Optimizer 基于规则的优化)）。

简单来说就是把可执行的SQL 再调整一下，以便跑得更快。

④ query planner 查询计划器，基于 planning 计划过程，将逻辑计划转换成多个物理计划，再根据代价模型 cost model，筛选出代价最小的物理计划。这个过程称之为 CBO（Cost Based Optimizer 基于成本的优化）。

上面2-3-4步骤合起来，就是 Catalyst 优化器。

⑤ 最后依据最优的物理计划，生成 java 字节码，将 SQL 转换为 DAG，以 RDD 形式进行操作。

8.1 RDD 与 SparkSQL 运行时的区别

和 RDD 不同, SparkSQL 的 Dataset 和 SQL 并不是直接生成计划交给集群执行, 而是经过了一个叫做 Catalyst 的优化器, 这个优化器能够自动帮助开发者优化代码。

8.2 explain参看逻辑计划和物理计划

SparkSQL中的DSL方式：

spark.sql('select count(1) from test_db.table1').explain(True)

spark.sql('select count(1) from test_db.table1').explain(True)

普通SQL方式 explain extended select count(1) from table1;

 explain extended select count(1) from table1;

8.3 Spark SQL 是如何将数据写到Hive表的

方式一：是利用 Spark RDD 的 API 将数据写入 hdfs 形成 hdfs 文件，之后再将 hdfs 文件和 hive 表做加载映射；

方式二：利用 Spark SQL 将获取的数据 RDD 转换成 DataFrame，再将 DataFrame 写成缓存表，最后利用 Spark SQL 直接插入 hive 表中。

8.4 SparkSQL中RDD、DataFrame、DataSet三者的转换

8.4.1 三者共性

① RDD、DataFrame、DataSet全部都是spark平台下的分布式弹性数据集，为处理超大数据提供便捷；

② 三者都有惰性，在进行创建、转换，如map方法时，不会立即执行，只有在遇到Action算子，如foreach()时，三者才会开始遍历运算；

③ 三者都会根据spark的内存情况自动缓冲运算，这样即使数据量大，也不会担心内存溢出；

④ 三者都有partition概念；

⑤ 三者都有许多共同函数，如：filter、排序等；

⑥ 在对DateFrame和DataSet进行操作的都需要包支持；导入 import spark.implicts._ ；

⑦ DataFrame和DataSet均可使用模式匹配获取各个字段的值和类型；

8.4.2 三者区别

① RDD：

RDD一般和SparkMlib(机器学习库)同时使用；

RDD不支持SparkSql操作；

② DataFrame

与RDD和DataSet不同，DataFrame每一行固定内容为Row，每一列的值没法直接访问，只有通过解析才能获取各个字段值；

DataFrame和DataSet一般不与SparkMlib同时使用；

DataFrame和DataSet一般都支持SparkSql的操作；

DataFrame和DataSet支持一些特别方便的保存方式，比如：csv ；

③ DataSet

DataSet和DataFrame拥有完全相同的成员函数，区别只是每一行数据类型不同；

DataFrame也可以叫DataSet[Row]，每一行类型是Row，不解析，每一行究竟有哪些字段，各个字段又是什么类型都无从得知。

9 Spark Streaming

9.1 Spark Streaming 基本工作原理

spark streaming 是 spark core API 的一种扩展，可以用于进行大规模、高吞吐量、容错的实时数据流的处理;

原理：接受实时输入数据流，然后将数据拆分成 batch，比如每收集一秒的数据封装成一个 batch，然后将每个 batch 交给 spark 的计算引擎进行处理，最后会生产处一个结果数据流，其中的数据也是一个一个的 batch 组成的。

9.2 DStream以及基本工作原理

DStream 是 spark streaming 提供的一种高级抽象，代表了一个持续不断的数据流；

DStream 可以通过输入数据源来创建，比如 Kafka、flume 等，也可以通过其他 DStream 的高阶函数来创建，比如 map、reduce、join 和 window 等；

DStream 内部其实不断产生 RDD，每个 RDD 包含了一个时间段的数据；
Spark streaming 一定是有一个输入的 DStream 接收数据，按照时间划分成一个一个的 batch，并转化为一个 RDD，RDD 的数据是分散在各个子节点的 partition 中。

9.3 Spark Streaming精准一次消费

① 手动维护偏移量；
② 处理完业务数据后，再进行提交偏移量操作
极端情况下，如在提交偏移量时断网或停电会造成spark程序第二次启动时重复消费问题，所以在涉及到金额或精确性非常高的场景会使用事物保证精准一次消费。

9.4 SparkStreaming有哪几种方式消费Kafka中的数据，它们之间的区别是什么

① receiver方式：
将数据拉取到 executor 中做操作，若数据量大，内存存储不下，可以通过 WAL，设置了本地存储，保证数据不丢失，然后使用 Kafka 高级 API 通过 zk 来维护偏移量，保证消费数据。receiver 消费的数据偏移量是在 zk 获取的，此方式效率低，容易出现数据丢失。

② 基于Direct 方式：
使用 Kafka 底层 Api，其消费者直接连接 kafka 的分区上，因为 createDirectStream 创建的 DirectKafkaInputDStream 每个 batch 所对应的 RDD 的分区与 kafka 分区一一对应，但是需要自己维护偏移量，即用即取，不会给内存造成太大的压力，效率高。

③ 对比：
基于receiver的方式，是使用Kafka的高阶API来在ZooKeeper中保存消费过的offset的。这是消费Kafka数据的传统方式。这种方式配合着WAL机制可以保证数据零丢失的高可靠性，但是却无法保证数据被处理一次且仅一次，可能会处理两次。因为Spark和ZooKeeper之间可能是不同步的。
基于direct的方式，使用kafka的简单api，Spark Streaming自己就负责追踪消费的offset，并保存在checkpoint中。Spark自己一定是同步的，因此可以保证数据是消费一次且仅消费一次。
在实际生产环境中大都用Direct方式

9.5 简述SparkStreaming窗口函数的原理

窗口函数就是在原来定义的SparkStreaming计算批次大小的基础上再次进行封装，每次计算多个批次的数据，同时还需要传递一个滑动步长的参数，用来设置当次计算任务完成之后下一次从什么地方开始计算。

9.6 SparkStreaming写一个WordCount案例

import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.SparkConf

object StreamWordCount {

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

         //1.初始化Spark配置信息
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")  //实时程序里线程数大于2

        //2.初始化SparkStreamingContext
    val ssc = new StreamingContext(sparkConf, Seconds(5))  //采集周期为5秒

       //3.通过监控端口创建DStream，读进来的数据为一行行
    val lineStreams = ssc.socketTextStream("NODE01", 9999)

       //4.将每一行数据做切分，形成一个个单词
    val wordStreams = lineStreams.flatMap(_.split(" "))

       //5.将单词映射成元组（word,1）
    val wordAndOneStreams = wordStreams.map((_, 1))  

       //6.将相同的单词次数做统计
    val wordAndCountStreams = wordAndOneStreams.reduceByKey(_+_)

      //7.打印
    wordAndCountStreams.print()

      //8.启动采集器SparkStreamingContext,开始执行计算
ssc.start()

      //9.等待某个批次的任务处理完,在停止服务.
    ssc.awaitTermination()  
  }
}