惊了！10万字的Spark全文！

Hello，大家好，这里是857技术社区，我是社区创始人之一，以后会持续给大家更新大数据各组件的合集内容，路过给个关注吧!!!

今天给大家分享一篇小白易读懂的 Spark万字概念长文，本篇文章追求的是力求精简、通俗易懂。希望能为新手的入门学习扫清障碍，从基础概念入手、再到原理深入，由浅入深地轻松掌握Spark。

文章目录

- - 首先介绍一下 Spark 的发展史！！！！！
  - 其次 Spark 为什么会流行呢？？？？
  - 一、Spark 概述详解
  - - 1、Spark 是什么？
    - 2、Spark 架构组成及原理
    - 3、Spark 特点！
    - 4、Spark 的几种运行模式
  - 二、Spark 的三大集群模式详解！（附带各模式部署步骤）
  - - 1、standalone 集群模式
    - - 1.1 集群角色介绍
      - 1.2 集群规划
      - 1.3 修改配置并分发
      - 1.4 启动和停止
      - 1.5 查看 web 界面
      - 1.6 测试
    - 2、standalone-HA 高可用模式
    - - 2.1 原理
      - 2.2 配置 HA
      - 2.3 启动 zk 集群
      - 2.4 启动 Spark 集群
      - 2.5 测试 HA
      - 2.6 测试集群模式提交任务
    - 3、 on yarn 集群模式
    - - 3.1 准备工作
      - 3.2 cluster 模式
      - 3.3 client 模式[了解]
      - 3.4 两种模式的区别
    - 4、 Spark 参数详解
    - - 4.1 spark-shell
      - 4.2 spark-submit
      - 4.3 参数总结
  - 三、SparkCore 入门详解
  - - 1、RDD 详解
    - - 1.1 什么是 RDD?
      - 1.2 为什么要有 RDD?
      - 1.3 RDD 的主要属性
    - 2、RDD-API
    - - 2.1 创建 RDD
      - 2.2 RDD 的方法/算子分类
      - 2.3 基础练习[快速演示]
    - 3、RDD 的持久化/缓存
    - - 3.1 引入
      - 3.2 持久化/缓存 API 详解
      - 3.3 代码演示
      - 3.4 总结
    - 4、RDD 容错机制 Checkpoint
    - - 4.1 引入
      - 4.2 代码演示
      - 4.3 总结
    - 5、RDD 依赖关系
    - - 5.1. 宽窄依赖
      - 5.2 为什么要设计宽窄依赖
    - 6、DAG 的生成和划分 Stage（上面也有提到 DAG）
    - - 6.1 为什么要划分 Stage? --并行计算
      - 6.2 如何划分 DAG 的 stage
      - 6.3 总结
    - 7、Spark 运行原理及流程
    - - 7.1. 基本流程
      - 7.2 流程图解
      - 7.3 总结
    - 8、RDD 累加器和广播变量
    - - 8.1 累加器
      - 8.2 广播变量
    - 9、RDD 数据源
    - - 9.1 普通文本文件
      - 9.2 JDBC[掌握]
      - 9.3 HadoopAPI[了解]
      - 9.4 SequenceFile 文件[了解]
      - 9.5 对象文件[了解]
      - 9.6 HBase[了解]
      - 9.7 扩展阅读
  - 四、SparkSQL 入门详解
  - - 1、Spark SQL概述
    - - 1.1 Spark SQL官方介绍
      - 1.2 Spark SQL 的特点
      - 1.3 SQL优缺点
      - 1.4 Hive和SparkSQL
      - 1.5 Spark SQL数据抽象
    - 2、Spark SQL初体验
    - - 2.1 入口-SparkSession
      - 2.2. 创建DataFrame
      - 2.3 创建DataSet
      - 2.4 两种查询风格[先了解]
      - 2.5 总结
    - 3、使用IDEA开发Spark SQL
    - - 3.1 创建DataFrame/DataSet
      - 3.2 花式查询
      - 3.3 相互转化
      - 3.4 Spark SQL完成WordCount
    - 4、Spark SQL多数据源交互
    - - 4.1 写数据
      - 4.2 读数据
      - 4.3 总结
    - 5、Spark SQL自定义函数
    - - 5.1 自定义函数分类
      - 5.2 自定义UDF
      - 5.3 自定义UDAF[了解]
    - 6、扩展：开窗函数
    - - 6.1 概述
      - 6.2 准备工作
      - 6.3 聚合开窗函数
      - 6.4 排序开窗函数
    - 7、Spark-On-Hive
    - - 7.1 概述
      - 7.2 Hive开启MetaStore服务
      - 7.3 SparkSQL整合Hive MetaStore
      - 7.4 使用SparkSQL操作Hive表
  - 五、Spark Streaming引入详解
  - - 1、新的场景需求
    - 2、Spark Streaming介绍
    - 3、实时计算所处的位置
  - 六、Spark Streaming原理
  - - 1、SparkStreaming原理
    - - 1.1 整体流程
      - 1.2 数据抽象
    - 2、DStream相关操作
    - - 2.1 Transformations
      - 2.2 Output/Action
    - 3、总结
  - 七、Spark Streaming实战
  - - 1、WordCount
    - - 1.1 需求&准备
      - 1.2 代码演示
      - 1.1.3 执行
    - 2、updateStateByKey
    - - 2.1 问题
      - 2.2 代码演示
      - 2.3 执行
    - 3、reduceByKeyAndWindow
    - - 3.1 图解
      - 3.2 代码演示
      - 3.3 执行
    - 4、统计一定时间内的热门词汇TopN
    - - 4.1 需求
      - 4.2 代码演示
      - 4.3 执行
  - 八、整合kafka
  - - 1、Kafka快速回顾
    - - 1.1 核心概念图解
      - 1.2 常用命令
    - 2、整合Kafka两种模式说明
    - - 2.1 ★面试题：Receiver & Direct
      - 2.2 总结：
    - 3、spark-streaming-kafka-0-8(了解)
    - - 3.1 Receiver
      - 3.2 Direct
    - 4、spark-streaming-kafka-0-10
    - 5、扩展：Kafka手动维护偏移量
  - 九、Structured Streaming曲折发展史
  - - 1、Spark Streaming
    - 2、Structured Streaming
    - - 2.1 介绍
      - 2.2 API
      - 2.3 主要优势
      - 2.4 编程模型
  - 十、Structured Streaming实战
  - - 1、创建Source
    - 2、读取Socket数据
    - 3、读取目录下文本数据
    - 4、计算操作
    - 5、输出
    - 6、output mode
    - 7、output sink
  - 十一、StructuredStreaming与其他技术整合
  - - 1、整合Kafka
    - - 1.1 官网介绍
      - 1.2 整合环境准备
    - 2、整合MySQL
    - - 2.1 简介
      - 2.2 代码演示

首先介绍一下 Spark 的发展史！！！！！

代码语言：javascript复制

大数据、人工智能( Artificial Intelligence )像当年的石油、电力一样，正以前所未有的广度和深度影响所有的行业，现在及未来公司的核心壁垒是数据，核心竞争力来自基于大数据的人工智能的竞争。
Spark是当今大数据领域最活跃、最热门、最高效的大数据通用计算平台，
2009年诞生于美国加州大学伯克利分校AMP 实验室，
2010年通过BSD许可协议开源发布，
2013年捐赠给Apache软件基金会并切换开源协议到切换许可协议至Apache2.0，
2014年2月，Spark成为Apache的顶级项目
2014年11月, Spark的母公司Databricks团队使用Spark刷新数据排序世界记录
Spark成功构建起了一体化、多元化的大数据处理体系。在任何规模的数据计算中， Spark在性能和扩展性上都更具优势。
(1) Hadoop 之父Doug Cutting指出：Use of MapReduce engine for Big Data projects will decline, replaced by Apache Spark (大数据项目的MapReduce引擎的使用将下降，由Apache Spark 取代)
(2)Hadoop 商业发行版本的市场领导者Cloudera 、HortonWorks 、MapR 纷纷转投Spark,并把Spark作为大数据解决方案的首选和核心计算引擎。
2014年的如此Benchmark测试中， Spark秒杀Hadoop ，在使用十分之一计算资源的情况下，相同数据的排序上， Spark比MapReduce快3倍！在没有官方PB 排序对比的情况下，首次将S park 推到了IPB 数据(十万亿条记录) 的排序，在使用190个节点的情况下，工作负载在4小时内完成， 同样远超雅虎之前使用3800台主机耗时16个小时的记录。
2015年6月，Spark最大的集群来自腾讯–8000个节点，单个Job最大分别是阿里巴巴和Databricks–1PB，震撼人心！同时，Spark的Contributor比2014年涨了3倍，达到730人：总代码行数也比2014年涨了2倍多，达到40行。
IBM于2015 年6 月承诺大力推进Apache Spark 项目， 并称该项目为：以数据为主导的，未来十年最重要的新的开源项目。这－承诺的核心是将Spark 嵌入IBM 业内领先的分析和商务平台，并将Spark 作为一项服务，在IBMB平台上提供给客户。IBM还将投入超过3500名研究和开发人员在全球10余个实验室开展与Spark相关的项目，并将为Spark开源生态系统无偿提供突破性的机器学习技术–IBM SystemML。同时，IBM还将培养超过100万名Spark数据科学家和数据工程师。
2016年，在有“计算界奥运会”之称的国际著名Sort Benchmark全球数据排序大赛中，由南京大学计算机科学与技术系PASA大数据实验室、阿里巴巴和Databricks公司组成的参赛因队NADSort，以144美元的成本完成lOOTB标准数据集的排序处理，创下了每TB数据排序1.44美元成本的最新世界纪录，比2014 年夺得冠军的加州大学圣地亚哥分校TritonSort团队每TB数据4.51美元的成本降低了近70%，而这次比赛依旧使用Apache Spark大数据计算平台，在大规模并行排序算法以及Spark系统底层进行了大量的优化，以尽可能提高排序计算性能并降低存储资源开销，确保最终赢得比赛。
在FullStack理想的指引下，Spark中的Spark SQL 、SparkStreaming 、MLLib 、GraphX 、R五大子框架和库之间可以无缝地共享数据和操作， 这不仅打造了Spark在当今大数据计算领域其他计算框架都无可匹敌的优势， 而且使得Spark正在加速成为大数据处理中心首选通用计算平台。

其次 Spark 为什么会流行呢？？？？

代码语言：javascript复制

原因1：优秀的数据模型和计算抽象

Spark 产生之前，已经有MapReduce这类非常成熟的计算系统存在了，并提供了高层次的API(map/reduce)，把计算运行在集群中并提供容错能力，从而实现分布式计算。
虽然MapReduce提供了对数据访问和计算的抽象，但是对于数据的复用就是简单的将中间数据写到一个稳定的文件系统中(例如HDFS)，所以会产生数据的复制备份，磁盘的I/O以及数据的序列化，所以在遇到需要在多个计算之间复用中间结果的操作时效率就会非常的低。而这类操作是非常常见的，例如迭代式计算，交互式数据挖掘，图计算等。
认识到这个问题后，学术界的AMPLab提出了一个新的模型，叫做RDD。RDD是一个可以容错且并行的数据结构(其实可以理解成分布式的集合，操作起来和操作本地集合一样简单)，它可以让用户显式的将中间结果数据集保存在内存中，并且通过控制数据集的分区来达到数据存放处理最优化.同时RDD也提供了丰富的 API (map、reduce、foreach、redeceByKey…)来操作数据集。后来 RDD被AMPLab在一个叫做 Spark 的框架中提供并开源.
简而言之，Spark借鉴了MapReduce思想发展而来，保留了其分布式并行计算的优点并改进了其明显的缺陷。让中间数据存储在内存中提高了运行速度、并提供丰富的操作数据的API提高了开发速度。

代码语言：javascript复制

原因2：完善的生态圈

目前，Spark已经发展成为一个包含多个子项目的集合，其中包含SparkSQL、Spark Streaming、GraphX、MLlib等子项目
Spark Core：实现了Spark的基本功能，包含RDD、任务调度、内存管理、错误恢复、与存储系统交互等模块。
Spark SQL：Spark用来操作结构化数据的程序包。通过Spark SQL，我们可以使用SQL操作数据。
Spark Streaming：Spark提供的对实时数据进行流式计算的组件。提供了用来操作数据流的API。
Spark MLlib：提供常见的机器学习(ML)功能的程序库。包括分类、回归、聚类、协同过滤等，还提供了模型评估、数据导入等额外的支持功能。
GraphX(图计算)：Spark中用于图计算的API，性能良好，拥有丰富的功能和运算符，能在海量数据上自如地运行复杂的图算法。
集群管理器：Spark设计为可以高效地在一个计算节点到数千个计算节点之间伸缩计算。

代码语言：javascript复制

扩展阅读：Spark VS Hadoop
★注意:
尽管Spark相对于Hadoop而言具有较大优势，但Spark并不能完全替代Hadoop ，Spark主要用于替代Hadoop中的MapReduce计算模型。存储依然可以使用HDFS，但是中间结果可以存放在内存中；调度可以使用Spark内置的，也可以使用更成熟的调度系统YARN等
实际上，Spark已经很好地融入了Hadoop生态圈，并成为其中的重要一员，它可以借助于YARN实现资源调度管理，借助于HDFS实现分布式存储。
此外，Hadoop可以使用廉价的、异构的机器来做分布式存储与计算，但是，Spark对硬件的要求稍高一些，对内存与CPU有一定的要求。

一、Spark 概述详解

1、Spark 是什么？

代码语言：javascript复制

Apache Spark是用于大规模数据处理的统一分析引擎
Spark基于内存计算，提高了在大数据环境下数据处理的实时性，
同时保证了高容错性和高可伸缩性，允许用户将Spark部署在大量硬件之上，形成集群。

Spark 官网

http://spark.apachecn.org

2、Spark 架构组成及原理

代码语言：javascript复制

1.Spark Core：包含Spark的基本功能；尤其是定义RDD的API、操作以及这两者上的动作。其他Spark的库都是构建在RDD和Spark Core之上的。

2.Spark SQL：提供通过Apache Hive的SQL变体Hive查询语言（HiveQL）与Spark进行交互的API。每个数据库表被当做一个RDD，Spark SQL查询被转换为Spark操作。

3.Spark Streaming：对实时数据流进行处理和控制。Spark Streaming允许程序能够像普通RDD一样处理实时数据。

4.MLlib：一个常用机器学习算法库，算法被实现为对RDD的Spark操作。这个库包含可扩展的学习算法，比如分类、回归等需要对大量数据集进行迭代的操作。

5.GraphX：控制图、并行图操作和计算的一组算法和工具的集合。GraphX扩展了RDD API，包含控制图、创建子图、访问路径上所有顶点的操作。

Spark 架构的组成图如下：

代码语言：javascript复制

有图可见，Master是Spark的主控节点，在实际的生产环境中会有多个Master，只有一个Master处于active状态。Worker是Spark的工作节点，向Master汇报自身的资源、Executeor执行状态的改变，并接受Master的命令启动 Executor或Driver。Driver是应用程序的驱动程序，每个应用包括许多小任务，Driver负责推动这些小任务的有序执行。
Executor是Spark的工作进程，由Worker监管，负责具体任务的执行。

Master-Worker（分别的作用及关系）

代码语言：javascript复制

整个Spark集群中，分为Master节点与worker节点，同时一个集群有多个master节点和多个worker节点。

1.Master：主节点，该节点负责管理worker节点，我们从master节点提交应用，负责将串行任务变成可并行执行的任务集Tasks，同时还负责出错问题处理等；

2.Worker:从节点，该节点与master节点通信，负责执行任务并管理executor进程。它为集群中任何可以运行Application代码的节点，在Standalone模式中指的是通过slave文件配置的Worker节点，在Spark on Yarn模式下就是NoteManager节点。

1.Application

代码语言：javascript复制

Appliction都是指用户编写的Spark应用程序，其中包括一个Driver功能的代码和分布在集群中多个节点上运行的Executor代码

2.Driver

代码语言：javascript复制

Driver是spark的驱动节点，用于执行spark任务中的main方法，负责实际代码的执行工作。主要负责以下任务：
1）将用户程序转化为作业（job）
2）在Executor之间调度任务
3）跟踪Executor的执行情况
4）通过 UI 展示查询运行情况

通俗理解Driver就是驱使整个应用运行起来的程序，也称之为Driver类

3.Executor

代码语言：javascript复制

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

1）负责运行组成Spark应用的任务，并将结果返回给驱动器进程
2）它们通过自身的块管理器（Block Manager）为用户程序中要求缓存的RDD 提供内存式存储。RDD是直接缓存在Executor进程内的，因此任务可以在运行时充分利用缓存数据加速运算。


理解2：
执行器，为某个Application运行在worker节点上的一个进程，该进程负责运行某些Task，并且负责将数据存到内存或磁盘上，每个Application都有各自独立的一批Executor进程。executor宿主在worker节点上，每个 Worker 上存在一个或多个Executor进程，每个executor持有一个线程池，每个线程可以执行一个task。根据Executor上CPU-core的数量，其每个时间可以并行多个跟core一样数量的task。task任务即为具体执行的Spark程序的任务。executor执行完task以后将结果返回给driver，每个executor执行的task都属于同一个应用。此外executor还有一个功能就是为应用程序中要求缓存的 RDD 提供内存式存储，RDD是直接缓存在executor进程内的，因此任务可以在运行时充分利用缓存数据加速运算。
当我们在代码中执行了cache/persist等持久化操作时，根据我们选择的持久化级别的不同，每个task计算出来的数据也会保存到Executor进程的内存或者所在节点的磁盘文件中。

因此Executor的内存主要分为三块：第一块是让task执行我们自己编写的代码时使用，默认是占Executor总内存的20%；第二块是让task通过shuffle过程拉取了上一个stage的task的输出后，进行聚合等操作时使用，默认也是占Executor总内存的20%；第三块是让RDD持久化时使用，默认占Executor总内存的60%。

task的执行速度是跟每个Executor进程的CPU core数量有直接关系的。一个CPU core同一时间只能执行一个线程。而每个Executor进程上分配到的多个task，都是以每个task一条线程的方式，多线程并发运行的。如果CPU core数量比较充足，而且分配到的task数量比较合理，那么通常来说，可以比较快速和高效地执行完这些task线程。

4.Cluter Manager

代码语言：javascript复制

集群管理器，指的是在集群上获取资源的外部服务。目前有三种类型：

1）Standalone : spark原生的资源管理，由Master负责资源的分配，易于构建集群
2）Apache Mesos：通用的集群管理，与hadoop MR兼容性良好的一种资源调度框架，可以在其上运行Hadoop MapReduce和一些服务应用
3）Hadoop Yarn: 主要是指Yarn中的ResourceManager

在集群不是特别大，并且没有mapReduce和Spark同时运行的需求的情况下，用Standalone模式效率最高。

5.Task（任务）

代码语言：javascript复制

真正执行计算的部分。Stage相当于TaskSet，每个Stage内部包含了多个Task，将各个Task下发到各个Executor执行计算。
每个Task的处理逻辑完全一样，不同的是对应处理的数据。即：移动计算而不是移动数据。

Task是真正干活的，所以说是它间接决定了Spark程序的快慢也不过分。

6.Job（作业）

代码语言：javascript复制

Spark根据行动操作触发提交作业，以行动操作将我们的代码切分为多个Job。

7.Stage（调度阶段）

代码语言：javascript复制

每个Job中，又会根据宽依赖将Job划分为多个Stage(包括ShuffleMapStage和ResultStage)。

Job、Stage、Task 的对应关系如下：

8.DAGScheduler

代码语言：javascript复制

根据Job构建基于Stage的DAG（Directed Acyclic Graph有向无环图)，并提交Stage给TASkScheduler。 其划分Stage的依据是RDD之间的依赖的关系找出开销最小的调度方法

扩展（DAG 划分 Stage 原理）：

代码语言：javascript复制

Spark 在分布式环境下将数据分区， 然后将作业转化为DAG, 并分阶段进行 DAG的调度和任务的分布式并行处理。DAG将调度提交给DAGScheduler, DAGScheduler调度时会根据是否需要经过Shuffle过程将 Job划分为多个Stage。


为了方便理解DAGScheduler划分Stage的原理，下面来看一个典型的DAG划分Stage示意图，如图所示。

代码语言：javascript复制

在上图中，RDD a 到 ShuffledRDD之间， 以及UnionRDD到CoGroupedRDD之间的数据需要经过Shuffle过程， 因此ROD a 和UnionRDD分别是Stage 1 跟Stage 3和Stage 2 跟Stage 3的划分点。而ShuffledRDD到CoGroupedRDD之间，以及RDD b到MappedRDD到UnionRDD和RDD c 到UnionRDD之间的数据不需要经过Shuffle过程。因此，ShuffledRDD和CoGroupedRDD的依赖是窄依赖，两个RDD属于同一个Stage3，其余RDD划分为2个Stage。Stage1和Stage2是相对独立的，可以并行运行。Stage3则依赖于Stage1和Stage2的运行结果，所以Stage3最后执行。
由此可见，在DAGScheduler调度过程中，Stage阶段换份是依据作业是否有Shuffle过程，也就是存在ShuffleDependency的宽依赖时，需要进行Shuffle，此时才会将作业划分为多个Stage。

9.TASKSedulter

代码语言：javascript复制

TaskScheduler概念:
将TaskSET提交给worker运行，每个Executor运行什么Task就是在此处分配的。TaskScheduler维护所有TaskSet，当Executor向Driver发生心跳时，TaskScheduler会根据资源剩余情况分配相应的Task。另外TaskScheduler还维护着所有Task的运行标签，重试失败的Task。

TaskScheduler 原理：
1）DAGScheduler在提交Taskset给底层调度器的时候是面向接口TaskScheduler的，这符合面向对象中依赖抽象原则，带来底层资源调度器的可插拔性， 导致Spark可以运行在众多的资源高度器模式上。例如：Standalone, Yarn, Mesos, local. EC2及其它自定义的资源调度器
2）在SparkContext实例化的时候通过createTaskScheduler来创建 TaskSchedulerImpl和StandaloneSchedulerBackend。在TaskSchedulerImpl的initialize方法中把StandaloneSchedulerBackend 传进来从而赋值给TaskSchedulerImpl的backend；在TaskSchedulerImple调用start方法的时候会调用 backend.start方法。
3）TaskScheduler的核心任务是提交TaskSet到集群运算并汇报结果
   a)为TaskSet创建和维护一个TaskSetManager并追踪任务的本地性以及错误信息；
   b)遇到 Straggle任务会放到其它的节点进行重试。
   c)向DAGScheduler 汇报执行情况，包括在Shuffle输出lost的时候报告fetch failed错误等信息。
4）TaskScheduler内部会握有SchedulerBackend，从Standalone的模式来讲，具体实现是StandaloneSchedulerBackend。
5）StandaloneSchedulerBackend在启动的时候创建StandaloneAppClient实例并在该实例Start的时候启动了ClientEndpoint这个消息循环体，ClientEndpoint在启动的时候会向Master注册当前程序。而StandaloneSchedulerBackend的父类CoarseGrainedSchedulerBackend在start的时候会实例化类型为DriverEndpoint的消息循环体。StandaloneSchedulerBackend专门负责收集Worker上的资源信息。当ExecutorBackend启动的时候会发送RegisteredExecutor信息向DriverEndpoint注册。此时StandaloneSchedulerBackend就掌握了当前应用程序拥有的计算资源，就是通过 StandaloneSchedulerBackend拥有的计算资源来具体运行Task。
6）SparkContext、DAGScheduler、TaskSchedulerImpl、StandaloneSchedulerBackend在应用程序启动的时候只实例化一次，应用程序存在期间始终存在这些对象。

下图展示了 TaskScheduler 的作用：

3、Spark 特点！

● 快

代码语言：javascript复制

与Hadoop的MapReduce相比，Spark基于内存的运算要快100倍以上，
基于硬盘的运算也要快10倍以上。Spark实现了高效的DAG执行引擎，
可以通过基于内存来高效处理数据流。

● 易用（算法多）

代码语言：javascript复制

MR只支持一种计算算法，Spark支持多种算法。
Spark支持Java、Python、R和Scala的API，还支持超过80种高级算法，
使用户可以快速构建不同的应用。而且Spark支持交互式的Python和Scala的 shell，
可以非常方便地在这些shell中使用Spark集群来验证解决问题的方法。

● 通用

代码语言：javascript复制

Spark提供了统一的解决方案。Spark可以用于批处理、交互式查询(Spark SQL)、
实时流处理(Spark Streaming)、机器学习(Spark MLlib)和图计算(GraphX)。
这些不同类型的处理都可以在同一个应用中无缝使用。Spark 统一的解决方案非常具有吸引力，
毕竟任何公司都想用统一的平台去处理遇到的问题，减少开发和维护的人力成本和部署平台的物力成本。

● 兼容性

代码语言：javascript复制

Spark可以非常方便地与其他的开源产品进行融合。比如，Spark可以使用Hadoop的YARN和Apache Mesos作为它的资源管理和调度器，
并且可以处理所有Hadoop支持的数据，包括HDFS、HBase和Cassandra等。
这对于已经部署Hadoop集群的用户特别重要，因为不需要做任何数据迁移就可以使用Spark的强大处理能力。
Spark也可以不依赖于第三方的资源管理和调度器，它实现了Standalone作为其内置的资源管理和调度框架，
这样进一步降低了Spark的使用门槛，使得所有人都可以非常容易地部署和使用 Spark。
此外，Spark还提供了在EC2上部署Standalone的Spark集群的工具。

4、Spark 的几种运行模式

代码语言：javascript复制

1.local 本地模式(单机)–开发测试使用
分为local单线程和local-cluster多线程

2.standalone 独立集群模式–开发测试使用
典型的Mater/slave模式

3.standalone-HA 高可用模式–生产环境使用
基于standalone模式，使用zk搭建高可用，避免Master是有单点故障的

4.on yarn 集群模式–生产环境使用
运行在yarn集群之上，由yarn负责资源管理，Spark负责任务调度和计算，
好处：计算资源按需伸缩，集群利用率高，共享底层存储，避免数据跨集群迁移。

5.on mesos 集群模式–国内使用较少
运行在mesos资源管理器框架之上，由mesos负责资源管理，Spark负责任务调度和计算

6.on cloud 集群模式–中小公司未来会更多的使用云服务
比如AWS的EC2，使用这个模式能很方便的访问Amazon的S3

二、Spark 的三大集群模式详解！（附带各模式部署步骤）

1、standalone 集群模式

1.1 集群角色介绍

standalone 独立集群模式–开发测试使用

代码语言：javascript复制

Spark是基于内存计算的大数据并行计算框架，
实际中运行计算任务肯定是使用集群模式，
那么我们先来学习Spark自带的standalone集群模式了解一下它的架构及运行机制。

Standalone集群使用了分布式计算中的master-slave模型，
master是集群中含有master进程的节点
slave是集群中的worker节点含有Executor9进程

Spark 架构图如下(先了解)：

1.2 集群规划

代码语言：javascript复制

node01:master
node02:slave/worker
node03:slave/worker

1.3 修改配置并分发

1）修改 Spark 配置文件（进入到自己解压后的 spark 目录下）

代码语言：javascript复制

cd /export/servers/spark/conf
mv spark-env.sh.template spark-env.sh
vim  spark-env.sh
#配置java环境变量(如果之前配置过了就不需要动了)
export JAVA_HOME=/export/servers/jdk1.8
#指定spark Master的IP
export SPARK_MASTER_HOST=node01
#指定spark Master的端口
export SPARK_MASTER_PORT=7077
mv slaves.template slaves
vim  slaves
node02
node03

2）配置 spark 环境变量 (建议不添加，避免和 Hadoop 的命令冲突)

代码语言：javascript复制

将spark添加到环境变量,添加以下内容到 /etc/profile
export SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
export PATH=$PATH:$SPARK_HOME/bin

注意:

代码语言：javascript复制

hadoop/sbin 的目录和 spark/sbin 可能会有命令冲突：
start-all.sh stop-all.sh

解决方案：
1.把其中一个框架的sbin从环境变量中去掉；
2.改名 hadoop/sbin/start-all.sh 改为: start-all-hadoop.sh

3)通过 scp 命令将配置文件分发到其他机器上

代码语言：javascript复制

scp -r /export/servers/spark node02:/export/servers
scp -r /export/servers/spark node03:/export/servers
scp /etc/profile root@node02:/etc
scp /etc/profile root@node03:/etc


source /etc/profile 刷新配置

1.4 启动和停止

集群启动和停止

代码语言：javascript复制

在主节点上启动spark集群
/export/servers/spark/sbin/start-all.sh
在主节点上停止spark集群
/export/servers/spark/sbin/stop-all.sh

单独启动和停止

代码语言：javascript复制

在master安装节点上启动和停止master：
start-master.sh
stop-master.sh
在Master所在节点上启动和停止worker(work指的是slaves配置文件中的主机名)
start-slaves.sh
stop-slaves.sh

1.5 查看 web 界面

代码语言：javascript复制

正常启动spark集群后，查看spark的web界面，查看相关信息。

http://node01:8080/

1.6 测试

需求

代码语言：javascript复制

使用集群模式运行Spark程序读取HDFS上的文件并执行WordCount

集群模式启动 spark-shell

代码语言：javascript复制

/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/bin/spark-shell --master spark://node01:7077

运行程序

代码语言：javascript复制

sc.textFile("hdfs://node01:8020/wordcount/input/words.txt")
.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_   _)
.saveAsTextFile("hdfs://node01:8020/wordcount/output2")

SparkContext web UI

代码语言：javascript复制

http://node01:4040/jobs/

注意

代码语言：javascript复制

集群模式下程序是在集群上运行的，不要直接读取本地文件，应该读取hdfs上的 因为程序运行在集群上，具体在哪个节点上我们运行并不知道，其他节点可能并没有那个数据文件

2、standalone-HA 高可用模式

2.1 原理

代码语言：javascript复制

Spark Standalone集群是Master-Slaves架构的集群模式，和大部分的Master-Slaves结构集群一样，存在着Master单点故障的问题。
如何解决这个单点故障的问题，Spark提供了两种方案：

1.基于文件系统的单点恢复(Single-Node Recovery with Local File System)--只能用于开发或测试环境。
2.基于zookeeper的Standby Masters(Standby Masters with ZooKeeper)--可以用于生产环境。

2.2 配置 HA

该 HA 方案使用起来很简单，首先启动一个 ZooKeeper 集群，然后在不同节点上启动 Master，注意这些节点需要具有相同的 zookeeper 配置。

代码语言：javascript复制

1)先停止Sprak集群
/export/servers/spark/sbin/stop-all.sh

2)在node01上配置：
vim /export/servers/spark/conf/spark-env.sh

3)注释掉Master配置
#export SPARK_MASTER_HOST=node01

4)在spark-env.sh添加SPARK_DAEMON_JAVA_OPTS，内容如下：

export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER
-Dspark.deploy.zookeeper.url=node01:2181,node02:2181,node03:2181
-Dspark.deploy.zookeeper.dir=/spark"

参数说明
spark.deploy.recoveryMode：恢复模式
spark.deploy.zookeeper.url：ZooKeeper的Server地址
spark.deploy.zookeeper.dir：保存集群元数据信息的文件、目录。包括Worker、Driver、Application信息。

2.3 启动 zk 集群

代码语言：javascript复制

zkServer.sh status
zkServer.sh stop
zkServer.sh start

2.4 启动 Spark 集群

代码语言：javascript复制

1)node01上启动Spark集群执行
/export/servers/spark/sbin/start-all.sh

2)在node02上再单独只起个master:
/export/servers/spark/sbin/start-master.sh

3)注意：
在普通模式下启动spark集群
只需要在主节点上执行start-all.sh 就可以了
在高可用模式下启动spark集群
先需要在任意一台主节点上执行start-all.sh
然后在另外一台主节点上单独执行start-master.sh

4)查看node01和node02
http://node01:8080/
http://node02:8080/

可以观察到有一台状态为StandBy

2.5 测试 HA

代码语言：javascript复制

测试主备切换

1)在node01上使用jps查看master进程id
2)使用kill -9 id号强制结束该进程
3)稍等片刻后刷新node02的web界面发现node02为Alive

2.6 测试集群模式提交任务

代码语言：javascript复制

1.集群模式启动spark-shell
/export/servers/spark/bin/spark-shell --master
spark://node01:7077,node02:7077

2.运行程序
sc.textFile("hdfs://node01:8020/wordcount/input/words.txt")
.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_   _)
.saveAsTextFile("hdfs://node01:8020/wordcount/output3")

3、 on yarn 集群模式

官方文档http://spark.apache.org/docs/latest/running-on-yarn.html

3.1 准备工作

代码语言：javascript复制

1.安装启动Hadoop(需要使用HDFS和YARN，已经ok)
2.安装单机版Spark(已经ok)
注意：不需要集群，因为把Spark程序提交给YARN运行本质上是把字节码给YARN集群上的JVM运行，
但是得有一个东西帮我去把任务提交上个YARN，所以需要一个单机版的Spark，
里面的有spark-shell命令，spark-submit命令
3.修改配置：
在spark-env.sh ，添加HADOOP_CONF_DIR配置，指明了hadoop的配置文件的位置
vim /export/servers/spark/conf/spark-env.sh
export HADOOP_CONF_DIR=/export/servers/hadoop/etc/hadoop

3.2 cluster 模式

代码语言：javascript复制

1)说明
在企业生产环境中大部分都是cluster部署模式运行Spark应用
Spark On YARN的Cluster模式 指的是Driver程序运行在YARN集群上

2)补充Driver是什么:
运行应用程序的main()函数并创建SparkContext的进程

3)图解

代码语言：javascript复制

4)运行示例程序
 spark-shell是一个简单的用来测试的交互式窗口
spark-submit用来提交打成jar包的任务

/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/bin/spark-submit 
--class org.apache.spark.examples.SparkPi 
--master yarn 
--deploy-mode cluster 
--driver-memory 1g 
--executor-memory 1g 
--executor-cores 2 
--queue default 
/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/examples/jars/spark-examples_2.11-2.2.0.jar 
10

5)查看界面
http://node01:8088/cluster

3.3 client 模式[了解]

代码语言：javascript复制

1)说明
学习测试时使用，开发不用，了解即可
Spark On YARN的Client模式 指的是Driver程序运行在提交任务的客户端

2)图解

代码语言：javascript复制

3)运行示例程序

/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/bin/spark-submit 
--class org.apache.spark.examples.SparkPi 
--master yarn 
--deploy-mode client 
--driver-memory 1g 
--executor-memory 1g 
--executor-cores 2 
--queue default 
/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/examples/jars/spark-examples_2.11-2.2.0.jar 
10

3.4 两种模式的区别

Cluster 和 Client 模式最本质的区别是：Driver 程序运行在哪里！

代码语言：javascript复制

运行在YARN集群中就是Cluster模式，
运行在客户端就是Client模式

当然还有由本质区别延伸出来的区别，面试的时候能简单说出几点就行

代码语言：javascript复制

cluster模式：生产环境中使用该模式
1.Driver程序在YARN集群中
2.应用的运行结果不能在客户端显示
3.该模式下Driver运行ApplicattionMaster这个进程中，如果出现问题，yarn会重启ApplicattionMaster(Driver)

client模式：
1.Driver运行在Client上的SparkSubmit进程中
2.应用程序运行结果会在客户端显示

4、 Spark 参数详解

4.1 spark-shell

spark-shell 是 Spark 自带的交互式 Shell 程序，方便用户进行交互式编程，用户可以在该命令行下可以用 scala 编写 spark 程序，适合学习测试时使用！

代码语言：javascript复制

示例:
spark-shell可以携带参数
spark-shell --master local[N] 数字N表示在本地模拟N个线程来运行当前任务
spark-shell --master local[*] *表示使用当前机器上所有可用的资源
默认不携带参数就是--master local[*]
spark-shell --master spark://node01:7077,node02:7077 表示运行在集群上

4.2 spark-submit

spark-submit 命令用来提交 jar 包给 spark 集群/YARN spark-shell 交互式编程确实很方便我们进行学习测试，但是在实际中我们一般是使用 IDEA 开发 Spark 应用程序打成 jar 包交给 Spark 集群/YARN 去执行。spark-submit 命令是我们开发时常用的!!!

代码语言：javascript复制

示例：计算π

cd /export/servers/spark
/export/servers/spark/bin/spark-submit 
--class org.apache.spark.examples.SparkPi 
--master spark://node01:7077  
--executor-memory 1g 
--total-executor-cores 2 
/export/servers/spark/examples/jars/spark-examples_2.11-2.2.0.jar 
10

4.3 参数总结

Master 参数形式

其他参数示例

代码语言：javascript复制

--master spark://node01:7077    指定Master的地址
--name "appName"                 指定程序运行的名称
--class                           程序的main方法所在的类
--jars  xx.jar                    程序额外使用的jar包
--driver-memory 512m             Driver运行所需要的内存, 默认1g
--executor-memory 2g             指定每个executor可用内存为 2g， 默认1g
--executor-cores 1               指定每一个executor可用的核数
--total-executor-cores 2         指定整个集群运行任务使用的cup 核数为2个
 --queue default            指定任务的对列
--deploy-mode               指定运行模式（client/cluster）

注意：

代码语言：javascript复制

如果worker节点的内存不足，那么在启动spark-submit的时候，就不能为executor分配超出worker可用的内存容量。
如果–executor-cores超过了每个worker可用的cores，任务处于等待状态。
如果–total-executor-cores即使超过可用的cores，默认使用所有的。以后当集群其他的资源释放之后，就会被该程序所使用。
如果内存或单个executor的cores不足，启动spark-submit就会报错，任务处于等待状态，不能正常执行。

三、SparkCore 入门详解

1、RDD 详解

1.1 什么是 RDD?

RDD(Resilient Distributed Dataset)叫做弹性分布式数据集，是 Spark 中最基本的数据抽象，代表一个不可变、可分区、里面的元素可并行计算的集合。

代码语言：javascript复制

单词拆解
Resilient ：它是弹性的，RDD中的数据可以保存在内存中或者磁盘里面
Distributed ：它里面的元素是分布式存储的，可以用于分布式计算
Dataset: 它是一个集合，可以存放很多元素

1.2 为什么要有 RDD?

代码语言：javascript复制

在许多迭代式算法(比如机器学习、图算法等)和交互式数据挖掘中，不同计算阶段之间会重用中间结果，即一个阶段的输出结果会作为下一个阶段的输入。但是，之前的MapReduce框架采用非循环式的数据流模型，把中间结果写入到HDFS中，带来了大量的数据复制、磁盘IO和序列化开销。且这些框架只能支持一些特定的计算模式(map/reduce)，并没有提供一种通用的数据抽象。
AMP实验室发表的一篇关于RDD的论文:《Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing》就是为了解决这些问题的
RDD提供了一个抽象的数据模型，让我们不必担心底层数据的分布式特性，只需将具体的应用逻辑表达为一系列转换操作(函数)，不同RDD之间的转换操作之间还可以形成依赖关系，进而实现管道化，从而避免了中间结果的存储，大大降低了数据复制、磁盘IO和序列化开销，并且还提供了更多的API(map/reduec/filter/groupBy…)

1.3 RDD 的主要属性

代码语言：javascript复制

1)A list of partitions ：
一组分片(Partition)/一个分区(Partition)列表，即数据集的基本组成单位。
对于RDD来说，每个分片都会被一个计算任务处理，分片数决定并行度。
用户可以在创建RDD时指定RDD的分片个数，如果没有指定，那么就会采用默认值。

2)A function for computing each split ：
一个函数会被作用在每一个分区。
Spark中RDD的计算是以分区为单位的，compute函数会被作用到每个分区上

3)A list of dependencies on other RDDs：
一个RDD会依赖于其他多个RDD。
RDD的每次转换都会生成一个新的RDD，所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD的所有分区进行重新计算。(Spark的容错机制)

4)Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)：
Spark中的分区函数，一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。
对于KV类型的RDD会有一个Partitioner函数，即RDD的分区函数（可选项）
只有对于key-value的RDD，才会有Partitioner，非key-value的RDD的Parititioner的值是None。Partitioner函数决定了RDD本身的分区数量，也决定了parent RDD Shuffle输出时的分区数量。

5)Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)：
可选项,一个列表，存储每个Partition的位置(preferred location)。
对于一个HDFS文件来说，这个列表保存的就是每个Partition所在的块的位置。按照"移动数据不如移动计算"的理念，Spark在进行任务调度的时候，会尽可能选择那些存有数据的worker节点来进行任务计算。

总结

RDD 是一个数据集，不仅表示了数据集，还表示了这个数据集从哪来，如何计算。

代码语言：javascript复制

主要属性包括
1.多分区
2.计算函数
3.依赖关系
4.分区函数(默认是hash)
5.最佳位置

2、RDD-API

2.1 创建 RDD

代码语言：javascript复制

1）由外部存储系统的数据集创建，包括本地的文件系统，还有所有Hadoop支持的数据集，比如HDFS、Cassandra、HBase等

val rdd1 = sc.textFile(“hdfs://node01:8020/wordcount/input/words.txt”)

2）通过已有的RDD经过算子转换生成新的RDD

val rdd2=rdd1.flatMap(_.split(" "))

3）由一个已经存在的Scala集合创建

val rdd3 = sc.parallelize(Array(1,2,3,4,5,6,7,8))
或者
val rdd4 = sc.makeRDD(List(1,2,3,4,5,6,7,8))
makeRDD方法底层调用了parallelize方法

2.2 RDD 的方法/算子分类

2.2.1 分类

RDD 的算子分为两类:

代码语言：javascript复制

1）Transformation转换操作:返回一个新的RDD
2）Action动作操作:返回值不是RDD(无返回值或返回其他的)

注意:

代码语言：javascript复制

RDD不实际存储真正要计算的数据，而是记录了数据的位置在哪里，数据的转换关系(调用了什么方法，传入什么函数)

RDD中的所有转换都是惰性求值/延迟执行的，也就是说并不会直接计算。只有当发生一个要求返回结果给Driver的 Action动作时，这些转换才会真正运行。
之所以使用惰性求值/延迟执行，是因为这样可以在Action时对RDD操作形成DAG有向无环图进行Stage的划分和并行优化，这种设计让Spark更加有效率地运行。

2.2.2 Transformation 转换算子

转换含义

map(func) 返回一个新的 RDD，该 RDD 由每一个输入元素经过 func 函数转换后组成 filter(func) 返回一个新的 RDD，该 RDD 由经过 func 函数计算后返回值为 true 的输入元素组成 flatMap(func) 类似于 map，但是每一个输入元素可以被映射为 0 或多个输出元素(所以 func 应该返回一个序列，而不是单一元素) mapPartitions(func) 类似于 map，但独立地在 RDD 的每一个分片上运行，因此在类型为 T 的 RDD 上运行时，func 的函数类型必须是 Iterator[T] => Iterator[U] mapPartitionsWithIndex(func) 类似于 mapPartitions，但 func 带有一个整数参数表示分片的索引值，因此在类型为 T 的 RDD 上运行时，func 的函数类型必须是(Int, Interator[T]) => Iterator[U] sample(withReplacement, fraction, seed) 根据 fraction 指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed 用于指定随机数生成器种子 union(otherDataset) 对源 RDD 和参数 RDD 求并集后返回一个新的 RDD intersection(otherDataset) 对源 RDD 和参数 RDD 求交集后返回一个新的 RDD distinct([numTasks])) 对源 RDD 进行去重后返回一个新的 RDD groupByKey([numTasks]) 在一个(K,V)的 RDD 上调用，返回一个(K, Iterator[V])的 RDD reduceByKey(func, [numTasks]) 在一个(K,V)的 RDD 上调用，返回一个(K,V)的 RDD，使用指定的 reduce 函数，将相同 key 的值聚合到一起，与 groupByKey 类似，reduce 任务的个数可以通过第二个可选的参数来设置 aggregateByKey(zeroValue)(seqOp, combOp, [numTasks]) 分组操作。调用 groupByKey，常用。类似于 aggregate，操作的数据类型。 sortByKey([ascending], [numTasks]) 在一个(K,V)的 RDD 上调用，K 必须实现 Ordered 接口，返回一个按照 key 进行排序的(K,V)的 RDD sortBy(func,[ascending], [numTasks]) 与 sortByKey 类似，但是更灵活 join(otherDataset, [numTasks]) 在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素对在一起的(K,(V,W))的 RDD cogroup(otherDataset, [numTasks]) 在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD cartesian(otherDataset) 笛卡尔积 pipe(command, [envVars]) 对 rdd 进行管道操作 coalesce(numPartitions) 减少 RDD 的分区数到指定值。在过滤大量数据之后，可以执行此操作 repartition(numPartitions) 重新给 RDD 分区

2.2.3 Action 动作算子

动作含义

reduce(func) 通过 func 函数聚集 RDD 中的所有元素，这个功能必须是可交换且可并联的 collect() 在驱动程序中，以数组的形式返回数据集的所有元素 count() 在驱动程序中，以数组的形式返回数据集的所有元素 first() 返回 RDD 的第一个元素(类似于 take(1)) take(n) 返回一个由数据集的前 n 个元素组成的数组 takeSample(withReplacement,num, [seed]) 返回一个数组，该数组由从数据集中随机采样的 num 个元素组成，可以选择是否用随机数替换不足的部分，seed 用于指定随机数生成器种子 takeOrdered(n, [ordering]) 返回自然顺序或者自定义顺序的前 n 个元素 saveAsTextFile(path) 将数据集的元素以 textfile 的形式保存到 HDFS 文件系统或者其他支持的文件系统，对于每个元素，Spark 将会调用 toString 方法，将它装换为文件中的文本 saveAsSequenceFile(path) 将数据集中的元素以 Hadoop sequencefile 的格式保存到指定的目录下，可以使 HDFS 或者其他 Hadoop 支持的文件系统。 saveAsObjectFile(path) 将数据集的元素，以 Java 序列化的方式保存到指定的目录下 countByKey() 针对(K,V)类型的 RDD，返回一个(K,Int)的 map，表示每一个 key 对应的元素个数。 foreach(func) 在数据集的每一个元素上，运行函数 func 进行更新。 foreachPartition(func) 在数据集的每一个分区上，运行函数 func

统计操作

算子含义

count 个数 mean 均值 sum 求和 max 最大值 min 最小值 variance 方差 sampleVariance 从采样中计算方差 stdev 标准差:衡量数据的离散程度 sampleStdev 采样的标准差 stats 查看统计结果

2.3 基础练习[快速演示]

2.3.1 准备工作

集群模式启动

代码语言：javascript复制

启动Spark集群
/export/servers/spark/sbin/start-all.sh
启动spark-shell
/export/servers/spark/bin/spark-shell 
--master spark://node01:7077 
--executor-memory 1g 
--total-executor-cores 2

或本地模式启动

代码语言：javascript复制

/export/servers/spark/bin/spark-shell

2.3.2 WordCount

代码语言：javascript复制

val res = sc.textFile("hdfs://node01:8020/wordcount/input/words.txt")
.flatMap(_.split(" ")).map((_,1)).reduceByKey(_ _)

//上面的代码不会立即执行,因为都是 Transformation 转换操作 //下面的代码才会真正的提交并执行,因为是 Action 动作/行动操作

代码语言：javascript复制

res.collect

2.3.3 创建 RDD

代码语言：javascript复制

val rdd1 = sc.parallelize(List(5,6,4,7,3,8,2,9,1,10))
val rdd2 = sc.makeRDD(List(5,6,4,7,3,8,2,9,1,10))

2.3.4 查看该 RDD 的分区数量

代码语言：javascript复制

sc.parallelize(List(5,6,4,7,3,8,2,9,1,10)).partitions.length
//没有指定分区数,默认值是2

sc.parallelize(List(5,6,4,7,3,8,2,9,1,10),3).partitions.length
//指定了分区数为3

sc.textFile("hdfs://node01:8020/wordcount/input/words.txt").partitions.length
//2

RDD 分区的数据取决于哪些因素？

代码语言：javascript复制

RDD分区的原则是使得分区的个数尽量等于集群中的CPU核心(core)数目，这样可以充分利用CPU的计算资源,但是在实际中为了更加充分的压榨CPU的计算资源,会把并行度设置为cpu核数的2~3倍。RDD分区数和启动时指定的核数、调用方法时指定的分区数、如文件本身分区数 有关系

分区原则

代码语言：javascript复制

1）启动的时候指定的CPU核数确定了一个参数值:
spark.default.parallelism=指定的CPU核数(集群模式最小2)

2）对于Scala集合调用parallelize(集合,分区数)方法,
如果没有指定分区数,就使用spark.default.parallelism,
如果指定了就使用指定的分区数(不要指定大于spark.default.parallelism)

3）对于textFile(文件,分区数) defaultMinPartitions

如果没有指定分区数sc.defaultMinPartitions=min(defaultParallelism,2)
如果指定了就使用指定的分区数sc.defaultMinPartitions=指定的分区数

rdd 的分区数

代码语言：javascript复制

对于本地文件:
rdd的分区数 = max(本地file的分片数， sc.defaultMinPartitions)

对于HDFS文件:
rdd的分区数 = max(hdfs文件的block数目， sc.defaultMinPartitions)
所以如果分配的核数为多个，且从文件中读取数据创建RDD，即使hdfs文件只有1个切片，最后的Spark的RDD的partition数也有可能是2

2.3.5 不同转换算子的意义以及应用

代码语言：javascript复制

1）map
对RDD中的每一个元素进行操作并返回操作的结果
//通过并行化生成rdd
val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
//对rdd1里的每一个元素
rdd1.map(_ * 2).collect
//collect方法表示收集,是action操作

2）filter
注意:函数中返回True的被留下,返回False的被过滤掉
val rdd2 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
val rdd3 = rdd2.filter(_ >= 10)
rdd3.collect
//10

3）flatmap
对RDD中的每一个元素进行先map再压扁,最后返回操作的结果
val rdd1 = sc.parallelize(Array(“a b c”, “d e f”, “h i j”))
//将rdd1里面的每一个元素先切分再压平
val rdd2 = rdd1.flatMap(_.split(’ '))
rdd2.collect
//Array[String] = Array(a, b, c, d, e, f, h, i, j)

4）sortBy
val rdd1 = sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
val rdd2 = rdd1.sortBy(x=>x,true)
// x=>x 表示按照元素本身进行排序,True表示升序
rdd2.collect
//1,2,3,…
val rdd2 = rdd1.sortBy(x=>x "",true)
//x=>x ""表示按照x的字符串形式排序变成了字符串,结果为字典顺序
rdd2.collect
//1,10,2,3…

5）交集、并集、差集、笛卡尔积
注意类型要一致
val rdd1 = sc.parallelize(List(5, 6, 4, 3))
val rdd2 = sc.parallelize(List(1, 2, 3, 4))
//union不会去重
val rdd3 = rdd1.union(rdd2)
rdd3.collect
//去重
rdd3.distinct.collect
//求交集
val rdd4 = rdd1.intersection(rdd2)
rdd4.collect
//求差集
val rdd5 = rdd1.subtract(rdd2)
rdd5.collect
//笛卡尔积
val rdd1 = sc.parallelize(List(“jack”, “tom”))//学生
val rdd2 = sc.parallelize(List(“java”, “python”, “scala”))//课程
val rdd3 = rdd1.cartesian(rdd2)//表示所有学生的所有选课情况
rdd3.collect
//Array[(String, String)] = Array((jack,java), (jack,python), (jack,scala), (tom,java), (tom,python), (tom,scala))

6）join
join(内连接)聚合具有相同key组成的value元组
val rdd1 = sc.parallelize(List((“tom”, 1), (“jerry”, 2), (“kitty”, 3)))
val rdd2 = sc.parallelize(List((“jerry”, 9), (“tom”, 8), (“shuke”, 7), (“tom”, 2)))
val rdd3 = rdd1.join(rdd2)
rdd3.collect
//Array[(String, (Int, Int))] = Array((tom,(1,8)), (tom,(1,2)), (jerry,(2,9)))

图解 1

代码语言：javascript复制

val rdd4 = rdd1.leftOuterJoin(rdd2) //左外连接,左边的全留下,右边的满足条件的才留下
rdd4.collect
//Array[(String, (Int, Option[Int]))] = Array((tom,(1,Some(2))), (tom,(1,Some(8))), (jerry,(2,Some(9))), (kitty,(3,None)))

图解 2

代码语言：javascript复制

val rdd5 = rdd1.rightOuterJoin(rdd2)
rdd5.collect
//Array[(String, (Option[Int], Int))] = Array((tom,(Some(1),2)), (tom,(Some(1),8)), (jerry,(Some(2),9)), (shuke,(None,7)))

val rdd6 = rdd1.union(rdd2)
rdd6.collect
//Array[(String, Int)] = Array((tom,1), (jerry,2), (kitty,3), (jerry,9), (tom,8), (shuke,7), (tom,2))
7）groupbykey
groupByKey()的功能是，对具有相同键的值进行分组。
比如，对四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)，
采用groupByKey()后得到的结果是：(“spark”,(1,2))和(“hadoop”,(3,5))。
//按key进行分组
val rdd6 = sc.parallelize(Array((“tom”,1), (“jerry”,2), (“kitty”,3), (“jerry”,9), (“tom”,8), (“shuke”,7), (“tom”,2)))
val rdd7=rdd6.groupByKey
rdd7.collect
//Array[(String, Iterable[Int])] = Array((tom,CompactBuffer(1, 8, 2)), (jerry,CompactBuffer(2, 9)), (shuke,CompactBuffer(7)), (kitty,CompactBuffer(3)))

8）cogroup[了解]
cogroup是先RDD内部分组,在RDD之间分组
val rdd1 = sc.parallelize(List((“tom”, 1), (“tom”, 2), (“jerry”, 3), (“kitty”, 2)))
val rdd2 = sc.parallelize(List((“jerry”, 2), (“tom”, 1), (“shuke”, 2)))
val rdd3 = rdd1.cogroup(rdd2)
rdd3.collect
// Array((tom,(CompactBuffer(1, 2),CompactBuffer(1))), (jerry,(CompactBuffer(3),CompactBuffer(2))), (shuke,(CompactBuffer(),CompactBuffer(2))), (kitty,(CompactBuffer(2),CompactBuffer())))

9）groupBy
根据指定的函数中的规则/key进行分组
val intRdd = sc.parallelize(List(1,2,3,4,5,6))
val result = intRdd.groupBy(x=>{if(x%2 == 0)“even” else “odd”}).collect
//Array[(String, Iterable[Int])] = Array((even,CompactBuffer(2, 4, 6)), (odd,CompactBuffer(1, 3, 5)))

10）reduce
val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5))
//reduce聚合
val result = rdd1.reduce(_   )
// 第一 上次一个运算的结果,第二个_ 这一次进来的元素

★面试题
reduceByKey是Transformation还是Action? --Transformation
reduce是Transformation还是Action? --Action

11）reducebykey
注意reducebykey是转换算子
reduceByKey(func)的功能是，使用func函数合并具有相同键的值。
比如，reduceByKey((a,b) => a b)，有四个键值对(“spark”,1)、(“spark”,2)、(“hadoop”,3)和(“hadoop”,5)
对具有相同key的键值对进行合并后的结果就是：(“spark”,3)、(“hadoop”,8)。
可以看出，(a,b) => a b这个Lamda表达式中，a和b都是指value，
比如，对于两个具有相同key的键值对(“spark”,1)、(“spark”,2)，a就是1，b就是2。

val rdd1 = sc.parallelize(List((“tom”, 1), (“jerry”, 3), (“kitty”, 2), (“shuke”, 1)))
val rdd2 = sc.parallelize(List((“jerry”, 2), (“tom”, 3), (“shuke”, 2), (“kitty”, 5)))
val rdd3 = rdd1.union(rdd2) //并集
rdd3.collect

//Array[(String, Int)] = Array((tom,1), (jerry,3), (kitty,2), (shuke,1), (jerry,2), (tom,3), (shuke,2), (kitty,5))

//按key进行聚合
val rdd4 = rdd3.reduceByKey(_   _)
rdd4.collect

//Array[(String, Int)] = Array((tom,4), (jerry,5), (shuke,3), (kitty,7))

12）repartition

改变分区数
val rdd1 = sc.parallelize(1 to 10,3) //指定3个分区
//利用repartition改变rdd1分区数
//减少分区
rdd1.repartition(2).partitions.length //新生成的rdd分区数为2
rdd1.partitions.length //3 //注意:原来的rdd分区数不变
//增加分区
rdd1.repartition(4).partitions.length
//减少分区
rdd1.repartition(3).partitions.length
//利用coalesce改变rdd1分区数
//减少分区
rdd1.coalesce(2).partitions.size
rdd1.coalesce(4).partitions.size

★注意：
repartition可以增加和减少rdd中的分区数，
coalesce默认减少rdd分区数，增加rdd分区数不会生效。
不管增加还是减少分区数原rdd分区数不变,变的是新生成的rdd的分区数

★应用场景:
在把处理结果保存到hdfs上之前可以减少分区数(合并小文件)
sc.textFile(“hdfs://node01:8020/wordcount/input/words.txt”)
.flatMap(.split(" ")).map((,1)).reduceByKey( )
.repartition(1)
//在保存到HDFS之前进行重分区为1,那么保存在HDFS上的结果文件只有1个
.saveAsTextFile(“hdfs://node01:8020/wordcount/output5”)

13）collect
val rdd1 = sc.parallelize(List(6,1,2,3,4,5), 2)
rdd1.collect

14）count
count统计集合中元素的个数
rdd1.count //6

求RDD中最外层集合里面的元素的个数
val rdd3 = sc.parallelize(List(List(“a b c”, “a b b”),List(“e f g”, “a f g”), List(“h i j”, “a a b”)))
rdd3.count //3

15）distinct
val rdd = sc.parallelize(Array(1,2,3,4,5,5,6,7,8,1,2,3,4), 3)
rdd.distinct.collect

16）top
//取出最大的前N个
val rdd1 = sc.parallelize(List(3,6,1,2,4,5))
rdd1.top(2)

17）take
//按照原来的顺序取前N个
rdd1.take(2) //3 6
//需求:取出最小的2个
rdd1.sortBy(x=>x,true).take(2)

18）first
//按照原来的顺序取前第一个
rdd1.first

19）keys、values
val rdd1 = sc.parallelize(List(“dog”, “tiger”, “lion”, “cat”, “panther”, “eagle”), 2)
val rdd2 = rdd1.map(x => (x.length, x))
rdd2.collect
//Array[(Int, String)] = Array((3,dog), (5,tiger), (4,lion), (3,cat), (7,panther), (5,eagle))
rdd2.keys.collect
//Array[Int] = Array(3, 5, 4, 3, 7, 5)
rdd2.values.collect
//Array[String] = Array(dog, tiger, lion, cat, panther, eagle)

20）mapValues
mapValues表示对RDD中的元素进行操作,Key不变,Value变为操作之后
val rdd1 = sc.parallelize(List((1,10),(2,20),(3,30)))
val rdd2 = rdd1.mapValues(_*2).collect //_表示每一个value ,key不变,将函数作用于value
//(1,20),(2,40),(3,60)

21）collectAsMap
转换成Map
val rdd = sc.parallelize(List((“a”, 1), (“b”, 2)))
rdd.collectAsMap
//scala.collection.Map[String,Int] = Map(b -> 2, a -> 1)

面试题：foreach 和 foreachPartition

代码语言：javascript复制

val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
rdd1.foreach(x => println(x*100)) //x是每一个元素
rdd1.foreachPartition(x => println(x.reduce(_   _))) //x是每个分区

注意:foreach和foreachPartition都是Action操作,但是以上代码在spark-shell中执行看不到输出结果,
原因是传给foreach和foreachPartition的计算函数是在各个分区执行的,即在集群中的各个Worker上执行的

应用场景:
比如在函数中要将RDD中的元素保存到数据库
foreach:会将函数作用到RDD中的每一条数据,那么有多少条数据,操作数据库连接的开启关闭就得执行多少次
foreachPartition:将函数作用到每一个分区,那么每一个分区执行一次数据库连接的开启关闭,有几个分区就会执行数据库连接开启关闭
 import org.apache.spark.{SparkConf, SparkContext}

object Test {
  def main(args: Array[String]): Unit = {
    val config = new SparkConf().setMaster("local[*]").setAppName("WordCount")
    val sc = new SparkContext(config)
    //设置日志输出级别
    sc.setLogLevel("WARN")
    val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
    //Applies a function f to all elements of this RDD.
    //将函数f应用于此RDD的所有元素
    rdd1.foreach(x => println(x*100))
 //把函数传给各个分区,在分区内循环遍历该分区中的元素
 //x每个元素,即一个一个的数字
    println("==========================")
    //Applies a function f to each partition of this RDD.
    //将函数f应用于此RDD的每个分区
    rdd1.foreachPartition(x => println(x.reduce(_   _)))
 //把各个分区传递给函数执行
 //x是每个分区
  }
}

面试题：map 和 mapPartitions

代码语言：javascript复制

将每一个分区传递给函数
val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
rdd1.mapPartitions(x=>x.map(y=>y*2)).collect
//x是每一个分区,y是分区中的元素

扩展：mapPartitionsWithIndex（同时获取分区号）

代码语言：javascript复制

功能：取分区中对应的数据时，还可以将分区的编号取出来，这样就可以知道数据是属于哪个分区的
val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 3)
//该函数的功能是将对应分区中的数据取出来，并且带上分区编号
// 一个index 分区编号
// 一个iter分区内的数据


val func = (index: Int, iter: Iterator[Int]) => {
iter.map(x => “[partID:”   index   ", val: "   x   “]”)
}
rdd1.mapPartitionsWithIndex(func).collect
//Array[String] = Array(
[partID:0, val: 1], [partID:0, val: 2], [partID:0, val: 3],
[partID:1, val: 4], [partID:1, val: 5], [partID:1, val: 6],
[partID:2, val: 7], [partID:2, val: 8], [partID:2, val: 9]
)

扩展：aggregate

代码语言：javascript复制

val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 3)

//0表示初始值
//第一个_ ,表示区内聚合,第一个_表示历史值,第二个_表示当前值
//第二个 _,表示区间聚合,第一个_表示历史值,第二个_表示当前值

val result1: Int = rdd1.aggregate(0)( _   _ , _   _) //45 ==> 6   15   24 = 45
//10表示初始值,每个分区有初始值,区间聚合的时候也有初始值
val result2: Int = rdd1.aggregate(10)( _   _ , _   _) //85 ==> 10  (10 6   10 15   10 24)=85

扩展：combineByKey

代码语言：javascript复制

val rdd1 = sc.textFile(“hdfs://node01:8020/wordcount/input/words.txt”).flatMap(.split(" ")).map((, 1))
//Array((hello,1), (me,1), (hello,1), (you,1), (hello,1), (her,1))

//x => x,表示key不变
//(a: Int, b: Int) => a   b:表示区内聚合
//(m: Int, n: Int) => m   n:表示区间聚合

val rdd2 = rdd1.combineByKey(x => x, (a: Int, b: Int) => a   b, (m: Int, n: Int) => m   n)
//val rdd2 = rdd1.combineByKey(x => x, _   _ , _   _ )//注意这里简写错误,原则:能省则省,不能省则不要偷懒
rdd2.collect
//Array[(String, Int)] = Array((hello,3), (me,1), (you,1), (her,1))
val rddData1: RDD[(String, Float)] = sc.parallelize(
Array(
(“班级1”, 95f),
(“班级2”, 80f),
(“班级1”, 75f),
(“班级3”, 97f),
(“班级2”, 88f)),
2)
val rddData2 = rddData1.combineByKey(
grade => (grade, 1),
(gc: (Float, Int), grade) => (gc._1   grade, gc._2   1),
(gc1: (Float, Int), gc2: (Float, Int)) => (gc1._1   gc2._1, gc1._2   gc2._2)
)
val rddData3 = rddData2.map(t => (t._1, t._2._1 / t._2._2))
rddData3.collect

扩展：aggregateByKey

代码语言：javascript复制

val pairRDD = sc.parallelize(List( (“cat”,2), (“cat”, 5), (“mouse”, 4),(“cat”, 12), (“dog”, 12), (“mouse”, 2)), 2)

def func(index: Int, iter: Iterator[(String, Int)]) : Iterator[String] = {
iter.map(x => “[partID:”   index   ", val: "   x   “]”)
}
pairRDD.mapPartitionsWithIndex(func).collect

//Array(
[partID:0, val: (cat,2)], [partID:0, val: (cat,5)], [partID:0, val: (mouse,4)],
[partID:1, val: (cat,12)], [partID:1, val: (dog,12)], [partID:1, val: (mouse,2)]
)

pairRDD.aggregateByKey(0)(math.max( _ , _ ), _   _ ).collect
// Array[(String, Int)] = Array((dog,12), (cat,17), (mouse,6))
//100表示区内初始值,区间聚合没有

pairRDD.aggregateByKey(100)(math.max(_, _), _   _).collect
//Array[(String, Int)] = Array((dog,100), (cat,200), (mouse,200))

pairRDD.aggregateByKey(5)(math.max(_, _), _   _).collect
//Array[(String, Int)] = Array((dog,12), (cat,17), (mouse,10))

pairRDD.aggregateByKey(10)(math.max(_, _), _   _).collect
//Array[(String, Int)] = Array((dog,12), (cat,22), (mouse,20))

val rddData1 = sc.parallelize(
Array(
(“用户1”, “接口1”),
(“用户2”, “接口1”),
(“用户1”, “接口1”),
(“用户1”, “接口2”),
(“用户2”, “接口3”)),
2)
val rddData2 = rddData1.aggregateByKey(collection.mutable.SetString)(
(urlSet, url) => urlSet  = url,
(urlSet1, urlSet2) => urlSet1   = urlSet2)
rddData2.collect

小练习

代码语言：javascript复制

需求

给定一个键值对RDD
val rdd = sc.parallelize(Array((“spark”,2),(“hadoop”,6),(“hadoop”,4),(“spark”,6)))
key表示图书名称，
value表示某天图书销量，
请计算每个键对应的平均值，也就是计算每种图书的每天平均销量。
最终结果:(“spark”,4),(“hadoop”,5)

val rdd1 = rdd.groupByKey
rdd1.collect
//Array((spark,CompactBuffer(6, 2)), (hadoop,CompactBuffer(4, 6)))
val rdd2 = rdd1.mapValues(v => v.sum / v.size)
rdd2.collect
答案

val rdd = sc.parallelize(Array((“spark”,2),(“hadoop”,6),(“hadoop”,4),(“spark”,6)))
val rdd2 = rdd.groupByKey()
rdd2.collect

//Array[(String, Iterable[Int])] = Array((spark,CompactBuffer(2, 6)), (hadoop,CompactBuffer(6, 4)))

val rdd3 = rdd2.map(t=>(t._1,t._2.sum /t._2.size))
rdd3.collect

//Array[(String, Int)] = Array((spark,4), (hadoop,5))

总结

1)分类

代码语言：javascript复制

RDD的算子分为两类，一类是Transformation转换操作，一类是Action动作操作

2)如何区分 Transformation 和 Action

代码语言：javascript复制

返回值是RDD的为Transformation转换操作,延迟执行/懒执行/惰性执行
返回值不是RDD(如Unit、Array、Int)的为Action动作操作

3)面试题：

代码语言：javascript复制

1.Transformation操作的API有哪些？ --map/flatMap/filter…
2.Action操作的API有哪些？ --collect/reduce/saveAsTextFile…
3.reduceByKey是Transformation还是Action？ --Transformation
4.reduce是Transformation还是Action？ – Action
5.foreach和foreachPartition的区别? foreach作用于每个元素,foreachPartition作用于每个分区

4)注意:

代码语言：javascript复制

RDD不实际存储真正要计算的数据，而只是记录了RDD的转换关系(调用了什么方法，传入什么函数，依赖哪些RDD，分区器是什么，数量块来源机器列表)
RDD中的所有转换操作都是延迟执行(懒执行)的，也就是说并不会直接计算。只有当发生Action操作的时候，这些转换才会真正运行。

3、RDD 的持久化/缓存

3.1 引入

在实际开发中某些 RDD 的计算或转换可能会比较耗费时间，如果这些 RDD 后续还会频繁的被使用到，那么可以将这些 RDD 进行持久化/缓存，这样下次再使用到的时候就不用再重新计算了，提高了程序运行的效率。

3.2 持久化/缓存 API 详解

persist 方法和 cache 方法

代码语言：javascript复制

RDD通过persist或cache方法可以将前面的计算结果缓存，但是并不是这两个方法被调用时立即缓存，而是触发后面的action时，该RDD将会被缓存在计算节点的内存中，并供后面重用。

通过查看RDD的源码发现cache最终也是调用了persist无参方法(默认存储只存在内存中)

3.3 代码演示

1）启动集群和 spark-shell

代码语言：javascript复制

/export/servers/spark/sbin/start-all.sh
/export/servers/spark/bin/spark-shell 
--master spark://node01:7077,node02:7077 
--executor-memory 1g 
--total-executor-cores 2

2）将一个 RDD 持久化，后续操作该 RDD 就可以直接从缓存中拿

代码语言：javascript复制

val rdd1 = sc.textFile("hdfs://node01:8020/wordcount/input/words.txt")
val rdd2 = rdd1.flatMap(x=>x.split(" ")).map((_,1)).reduceByKey(_ _)
rdd2.cache //缓存/持久化
rdd2.sortBy(_._2,false).collect//触发action,会去读取HDFS的文件,rdd2会真正执行持久化
rdd2.sortBy(_._2,false).collect//触发action,会去读缓存中的数据,执行速度会比之前快,因为rdd2已经持久化到内存中了

3）存储级别

代码语言：javascript复制

默认的存储级别都是仅在内存存储一份，Spark的存储级别还有好多种，存储级别在object StorageLevel中定义的

总结

3.4 总结

代码语言：javascript复制

1.RDD持久化/缓存的目的是为了提高后续操作的速度
2.缓存的级别有很多，默认只存在内存中,开发中使用memory_and_disk
3.只有执行action操作的时候才会真正将RDD数据进行持久化/缓存
4.实际开发中如果某一个RDD后续会被频繁的使用，可以将该RDD进行持久化/缓存

4、RDD 容错机制 Checkpoint

4.1 引入

1）持久化的局限

代码语言：javascript复制

持久化/缓存可以把数据放在内存中，虽然是快速的，但是也是最不可靠的；也可以把数据放在磁盘上，也不是完全可靠的！例如磁盘会损坏等。

2）问题解决

代码语言：javascript复制

Checkpoint的产生就是为了更加可靠的数据持久化，在Checkpoint的时候一般把数据放在在HDFS上，这就天然的借助了HDFS天生的高容错、高可靠来实现数据最大程度上的安全，实现了RDD的容错和高可用

3）使用步骤

代码语言：javascript复制

1.SparkContext.setCheckpointDir("目录") //HDFS的目录
2.RDD.checkpoint()

4.2 代码演示

代码语言：javascript复制

sc.setCheckpointDir(“hdfs://node01:8020/ckpdir”)
//设置检查点目录,会立即在HDFS上创建一个空目录

val rdd1 = sc.textFile(“hdfs://node01:8020/wordcount/input/words.txt”).flatMap(.split(" ")).map(( _ , 1)).reduceByKey( _  )
rdd1.checkpoint() //对rdd1进行检查点保存
rdd1.collect //Action操作才会真正执行checkpoint
//后续如果要使用到rdd1可以从checkpoint中读取

查看结果

代码语言：javascript复制

hdfs dfs -ls /
或者通过web界面查看
http://192.168.1.101:50070/dfshealth.html#tab-overview

4.3 总结

1)开发中如何保证数据的安全性性及读取效率

代码语言：javascript复制

可以对频繁使用且重要的数据，先做缓存/持久化，再做checkpint操作

2)持久化和 Checkpoint 的区别

代码语言：javascript复制

1.位置
Persist 和 Cache 只能保存在本地的磁盘和内存中(或者堆外内存–实验中)
Checkpoint 可以保存数据到 HDFS 这类可靠的存储上

2.生命周期
Cache和Persist的RDD会在程序结束后会被清除或者手动调用unpersist方法
Checkpoint的RDD在程序结束后依然存在，不会被删除

3.Lineage(血统、依赖链–其实就是依赖关系)
Persist和Cache，不会丢掉RDD间的依赖链/依赖关系，因为这种缓存是不可靠的，如果出现了一些错误(例如 Executor 宕机)，需要通过回溯依赖链重新计算出来

Checkpoint 会斩断依赖链，因为 Checkpoint 会把结果保存在 HDFS 这类存储中，更加的安全可靠，一般不需要回溯依赖链。

代码语言：javascript复制

补充：Lineage RDD的Lineage(血统、依赖链)会记录RDD的元数据信息和转换行为，当该RDD的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据分区。

在进行故障恢复时，Spark会对读取Checkpoint的开销和重新计算RDD分区的开销进行比较，从而自动选择最优的恢复策略。

5、RDD 依赖关系

5.1. 宽窄依赖

1）两种依赖关系类型

代码语言：javascript复制

RDD和它依赖的父RDD的关系有两种不同的类型，即
宽依赖(wide dependency/shuffle dependency)
窄依赖(narrow dependency)

2）图解

3）如何区分宽窄依赖

代码语言：javascript复制

窄依赖:父RDD的一个分区只会被子RDD的一个分区依赖
宽依赖:父RDD的一个分区会被子RDD的多个分区依赖(涉及到shuffle)

4）面试题

代码语言：javascript复制

子RDD的一个分区依赖多个父RDD是宽依赖还是窄依赖？

不能确定,也就是宽窄依赖的划分依据是父RDD的一个分区是否被子RDD的多个分区所依赖,是,就是宽依赖,或者从shuffle的角度去判断,有shuffle就是宽依赖

5.2 为什么要设计宽窄依赖

代码语言：javascript复制

1）对于窄依赖
Spark可以并行计算
如果有一个分区数据丢失，只需要从父RDD的对应1个分区重新计算即可，不需要重新计算整个任务，提高容错。

2）对于宽依赖
是划分Stage的依据

6、DAG 的生成和划分 Stage（上面也有提到 DAG）

6.1 为什么要划分 Stage? --并行计算

代码语言：javascript复制

一个复杂的业务逻辑如果有shuffle，那么就意味着前面阶段产生结果后，才能执行下一个阶段，即下一个阶段的计算要依赖上一个阶段的数据。那么我们按照shuffle进行划分(也就是按照宽依赖就行划分)，就可以将一个DAG划分成多个Stage/阶段，在同一个Stage中，会有多个算子操作，可以形成一个pipeline流水线，流水线内的多个平行的分区可以并行执行

6.2 如何划分 DAG 的 stage

代码语言：javascript复制

对于窄依赖，partition的转换处理在stage中完成计算，不划分(将窄依赖尽量放在在同一个stage中，可以实现流水线计算)
对于宽依赖，由于有shuffle的存在，只能在父RDD处理完成后，才能开始接下来的计算，也就是说需要要划分stage（出现宽依赖即拆分）

6.3 总结

代码语言：javascript复制

Spark会根据shuffle/宽依赖使用回溯算法来对DAG进行Stage划分，从后往前，遇到宽依赖就断开，遇到窄依赖就把当前的RDD加入到当前的stage/阶段中

具体的划分算法请参见AMP实验室发表的论文

《Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing》

http://xueshu.baidu.com/usercenter/paper/show?paperid=b33564e60f0a7e7a1889a9da10963461&site=xueshu_se

7、Spark 运行原理及流程

7.1. 基本流程

Spark 运行基本流程

代码语言：javascript复制

1.当一个Spark应用被提交时，首先需要为这个Spark Application构建基本的运行环境，即由任务控制节点(Driver)创建一个SparkContext，

2.SparkContext向资源管理器注册并申请运行Executor资源；

3.资源管理器为Executor分配资源并启动Executor进程，Executor运行情况将随着心跳发送到资源管理器上；

4.SparkContext根据RDD的依赖关系构建成DAG图，并提交给DAGScheduler进行解析划分成Stage，并把该Stage中的Task组成Taskset发送给TaskScheduler。

5.TaskScheduler将Task发放给Executor运行，同时SparkContext将应用程序代码发放给Executor。

6.Executor将Task丢入到线程池中执行，把执行结果反馈给任务调度器，然后反馈给DAG调度器，运行完毕后写入数据并释放所有资源。

7.2 流程图解

7.3 总结

代码语言：javascript复制

1.Spark应用被提交–>SparkContext向资源管理器注册并申请资源–>启动Executor

2.RDD–>构建DAG–>DAGScheduler划分Stage形成TaskSet–>TaskScheduler提交Task–>Worker上的Executor执行Task

8、RDD 累加器和广播变量

代码语言：javascript复制

在默认情况下，当Spark在集群的多个不同节点的多个任务上并行运行一个函数时，它会把函数中涉及到的每个变量，在每个任务上都生成一个副本。但是，有时候需要在多个任务之间共享变量，或者在任务(Task)和任务控制节点(Driver Program)之间共享变量。

为了满足这种需求，Spark 提供了两种类型的变量：

代码语言：javascript复制

1.累加器accumulators:累加器支持在所有不同节点之间进行累加计算(比如计数或者求和)
2.广播变量broadcast variables:广播变量用来把变量在所有节点的内存之间进行共享，在每个机器上缓存一个只读的变量，而不是为机器上的每个任务都生成一个副本。

8.1 累加器

8.1.1 不使用累加器

8.1.2 使用累加器

代码语言：javascript复制

通常在向 Spark 传递函数时，比如使用 map() 函数或者用 filter() 传条件时，可以使用驱动器程序中定义的变量，但是集群中运行的每个任务都会得到这些变量的一份新的副本，更新这些副本的值也不会影响驱动器中的对应变量。这时使用累加器就可以实现我们想要的效果。

val xx: Accumulator[Int] = sc.accumulator(0)

8.1.3 代码演示

代码语言：javascript复制

package cn.itcast.core

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

object AccumulatorTest {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc: SparkContext = new SparkContext(conf)
    sc.setLogLevel("WARN")

    //使用scala集合完成累加
    var counter1: Int = 0;
    var data = Seq(1,2,3)
    data.foreach(x => counter1  = x )
    println(counter1)//6

    println("                         ")

    //使用RDD进行累加
    var counter2: Int = 0;
    val dataRDD: RDD[Int] = sc.parallelize(data) //分布式集合的[1,2,3]
    dataRDD.foreach(x => counter2  = x)
    println(counter2)//0
    //注意：上面的RDD操作运行结果是0
    //因为foreach中的函数是传递给Worker中的Executor执行,用到了counter2变量
    //而counter2变量在Driver端定义的,在传递给Executor的时候,各个Executor都有了一份counter2
    //最后各个Executor将各自个x加到自己的counter2上面了,和Driver端的counter2没有关系

    //那这个问题得解决啊!不能因为使用了Spark连累加都做不了了啊!
    //如果解决?---使用累加器
    val counter3: Accumulator[Int] = sc.accumulator(0)
    dataRDD.foreach(x => counter3  = x)
    println(counter3)//6
  }
}

8.2 广播变量

8.2.1 不使用广播变量

8.2.2 使用广播变量

8.2.3 代码演示

代码语言：javascript复制

package cn.itcast.core

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

object BroadcastVariablesTest {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc: SparkContext = new SparkContext(conf)
    sc.setLogLevel("WARN")

    //不使用广播变量
    val kvFruit: RDD[(Int, String)] = sc.parallelize(List((1,"apple"),(2,"orange"),(3,"banana"),(4,"grape")))
    val fruitMap: collection.Map[Int, String] =kvFruit.collectAsMap
    //scala.collection.Map[Int,String] = Map(2 -> orange, 4 -> grape, 1 -> apple, 3 -> banana)
    val fruitIds: RDD[Int] = sc.parallelize(List(2,4,1,3))
    //根据水果编号取水果名称
    val fruitNames: RDD[String] = fruitIds.map(x=>fruitMap(x))
    fruitNames.foreach(println)
    //注意:以上代码看似一点问题没有,但是考虑到数据量如果较大,且Task数较多,
    //那么会导致,被各个Task共用到的fruitMap会被多次传输
    //应该要减少fruitMap的传输,一台机器上一个,被该台机器中的Task共用即可
    //如何做到?---使用广播变量
    println("=====================")
    val BroadcastFruitMap: Broadcast[collection.Map[Int, String]] = sc.broadcast(fruitMap)
    val fruitNames2: RDD[String] = fruitIds.map(x=>BroadcastFruitMap.value(x))
    fruitNames2.foreach(println)

  }
}

9、RDD 数据源

9.1 普通文本文件

代码语言：javascript复制

sc.textFile("./dir/*.txt")
如果传递目录，则将目录下的所有文件读取作为RDD。文件路径支持通配符。
但是这样对于大量的小文件读取效率并不高，应该使用wholeTextFiles
def wholeTextFiles(path: String, minPartitions: Int = defaultMinPartitions): RDD[(String, String)])

返回值RDD[(String, String)]，其中Key是文件的名称，Value是文件的内容。

9.2 JDBC[掌握]

Spark 支持通过 Java JDBC 访问关系型数据库。需要使用 JdbcRDD

代码演示

代码语言：javascript复制

package cn.itcast.core

import java.sql.{Connection, DriverManager, PreparedStatement}
import org.apache.spark.rdd.{JdbcRDD, RDD}
import org.apache.spark.{SparkConf, SparkContext}

/**
  * Desc 演示使用Spark操作JDBC-API实现将数据存入到MySQL并读取出来
  */
object JDBCDataSourceTest {

  def main(args: Array[String]): Unit = {
    //1.创建SparkContext
    val config = new SparkConf().setAppName("JDBCDataSourceTest").setMaster("local[*]")
    val sc = new SparkContext(config)
    sc.setLogLevel("WARN")
    //2.插入数据
    val data: RDD[(String, Int)] = sc.parallelize(List(("jack", 18), ("tom", 19), ("rose", 20)))
    //调用foreachPartition针对每一个分区进行操作
    //data.foreachPartition(saveToMySQL)
    //3.读取数据
    def getConn():Connection={
DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "root")
    }

    val studentRDD: JdbcRDD[(Int, String, Int)] = new JdbcRDD(sc,
      getConn,
   "select * from t_student where id >= ? and id <= ? ",
      4,
      6,
      2,
      rs => {
        val id: Int = rs.getInt("id")
        val name: String = rs.getString("name")
        val age: Int = rs.getInt("age")
        (id, name, age)
      }
    )
    println(studentRDD.collect().toBuffer)
 }
  /*
      CREATE TABLE `t_student` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(255) DEFAULT NULL,
      `age` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
   */
  def saveToMySQL(partitionData:Iterator[(String, Int)] ):Unit = {
    //将数据存入到MySQL
    //获取连接
    val conn: Connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "root")
    partitionData.foreach(data=>{
      //将每一条数据存入到MySQL
      val sql = "INSERT INTO `t_student` (`id`, `name`, `age`) VALUES (NULL, ?, ?);"
      val ps: PreparedStatement = conn.prepareStatement(sql)
      ps.setString(1,data._1)
      ps.setInt(2,data._2)
      ps.execute()//preparedStatement.addBatch()
    })
//ps.executeBatch()
    conn.close()
  }
}

9.3 HadoopAPI[了解]

代码语言：javascript复制

https://blog.csdn.net/leen0304/article/details/78854530

Spark的整个生态系统与Hadoop是完全兼容的，所以对于Hadoop所支持的文件类型或者数据库类型，Spark也同样支持。

HadoopRDD、newAPIHadoopRDD、saveAsHadoopFile、saveAsNewAPIHadoopFile 是底层API

其他的API接口都是为了方便最终的Spark程序开发者而设置的，是这两个接口的高效实现版本.

9.4 SequenceFile 文件[了解]

代码语言：javascript复制

SequenceFile文件是Hadoop用来存储二进制形式的key-value对而设计的一种平面文件(Flat File)。

https://blog.csdn.net/bitcarmanlee/article/details/78111289

代码语言：javascript复制

读sc.sequenceFile keyClass, valueClass
写RDD.saveAsSequenceFile(path)
要求键和值能够自动转为Writable类型。

9.5 对象文件[了解]

代码语言：javascript复制

对象文件是将对象序列化后保存的文件
读sc.objectFilek,v //因为是序列化所以要指定类型
写RDD.saveAsObjectFile()

9.6 HBase[了解]

代码语言：javascript复制

由于 org.apache.hadoop.hbase.mapreduce.TableInputFormat 类的实现，Spark 可以通过Hadoop输入格式访问HBase。
这个输入格式会返回键值对数据，
其中键的类型为org. apache.hadoop.hbase.io.ImmutableBytesWritable，
而值的类型为org.apache.hadoop.hbase.client.Result。

https://github.com/teeyog/blog/issues/22

9.7 扩展阅读

代码语言：javascript复制

package cn.itcast.core

import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object DataSourceTest {
  def main(args: Array[String]): Unit = {
    val config = new SparkConf().setAppName("DataSourceTest").setMaster("local[*]")
    val sc = new SparkContext(config)
    sc.setLogLevel("WARN")

    System.setProperty("HADOOP_USER_NAME", "root")

    //1.HadoopAPI
    println("HadoopAPI")
    val dataRDD = sc.parallelize(Array((1,"hadoop"), (2,"hive"), (3,"spark")))

    dataRDD.saveAsNewAPIHadoopFile("hdfs://node01:8020/spark_hadoop/",
      classOf[LongWritable],
      classOf[Text],
      classOf[TextOutputFormat[LongWritable, Text]])

    val inputRDD: RDD[(LongWritable, Text)] = sc.newAPIHadoopFile(
      "hdfs://node01:8020/spark_hadoop/*",
      classOf[TextInputFormat],
      classOf[LongWritable],
      classOf[Text],
      conf = sc.hadoopConfiguration
    )
    inputRDD.map(_._2.toString).foreach(println)

    //2.读取小文件
    println("读取小文件")
    val filesRDD: RDD[(String, String)] = sc.wholeTextFiles("D:\data\spark\files", minPartitions = 3)
    val linesRDD: RDD[String] = filesRDD.flatMap(_._2.split("\r\n"))
    val wordsRDD: RDD[String] = linesRDD.flatMap(_.split(" "))
    wordsRDD.map((_, 1)).reduceByKey(_   _).collect().foreach(println)

    //3.操作SequenceFile
    println("SequenceFile")
    val dataRDD2: RDD[(Int, String)] = sc.parallelize(List((2, "aa"), (3, "bb"), (4, "cc"), (5, "dd"), (6, "ee")))
    dataRDD2.saveAsSequenceFile("D:\data\spark\SequenceFile")
    val sdata: RDD[(Int, String)] = sc.sequenceFile[Int, String]("D:\data\spark\SequenceFile\*")
    sdata.collect().foreach(println)

    //4.操作ObjectFile
    println("ObjectFile")
    val dataRDD3 = sc.parallelize(List((2, "aa"), (3, "bb"), (4, "cc"), (5, "dd"), (6, "ee")))
    dataRDD3.saveAsObjectFile("D:\data\spark\ObjectFile")
    val objRDD = sc.objectFile[(Int, String)]("D:\data\spark\ObjectFile\*")
    objRDD.collect().foreach(println)

    sc.stop()
  }
}




package cn.itcast.core

import org.apache.hadoop.hbase.client.{HBaseAdmin, Put, Result}
import org.apache.hadoop.hbase.io.ImmutableBytesWritable
import org.apache.hadoop.hbase.{HBaseConfiguration, HColumnDescriptor, HTableDescriptor, TableName}
import org.apache.hadoop.hbase.mapred.TableOutputFormat
import org.apache.hadoop.hbase.mapreduce.TableInputFormat
import org.apache.hadoop.hbase.util.Bytes
import org.apache.hadoop.mapred.JobConf
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object DataSourceTest2 {
  def main(args: Array[String]): Unit = {
    val config = new SparkConf().setAppName("DataSourceTest").setMaster("local[*]")
    val sc = new SparkContext(config)
    sc.setLogLevel("WARN")

    val conf = HBaseConfiguration.create()
    conf.set("hbase.zookeeper.quorum", "node01:2181,node02:2181,node03:2181")

    val fruitTable = TableName.valueOf("fruit")
    val tableDescr = new HTableDescriptor(fruitTable)
    tableDescr.addFamily(new HColumnDescriptor("info".getBytes))

    val admin = new HBaseAdmin(conf)
    if (admin.tableExists(fruitTable)) {
      admin.disableTable(fruitTable)
      admin.deleteTable(fruitTable)
    }
    admin.createTable(tableDescr)

    def convert(triple: (String, String, String)) = {
      val put = new Put(Bytes.toBytes(triple._1))
      put.addImmutable(Bytes.toBytes("info"), Bytes.toBytes("name"), Bytes.toBytes(triple._2))
      put.addImmutable(Bytes.toBytes("info"), Bytes.toBytes("price"), Bytes.toBytes(triple._3))
      (new ImmutableBytesWritable, put)
    }
    val dataRDD: RDD[(String, String, String)] = sc.parallelize(List(("1","apple","11"), ("2","banana","12"), ("3","pear","13")))
    val targetRDD: RDD[(ImmutableBytesWritable, Put)] = dataRDD.map(convert)

    val jobConf = new JobConf(conf)
    jobConf.setOutputFormat(classOf[TableOutputFormat])
    jobConf.set(TableOutputFormat.OUTPUT_TABLE, "fruit")

    //写入数据
    targetRDD.saveAsHadoopDataset(jobConf)
    println("写入数据成功")

    //读取数据
    conf.set(TableInputFormat.INPUT_TABLE, "fruit")
    val hbaseRDD: RDD[(ImmutableBytesWritable, Result)] = sc.newAPIHadoopRDD(conf, classOf[TableInputFormat],
      classOf[org.apache.hadoop.hbase.io.ImmutableBytesWritable],
      classOf[org.apache.hadoop.hbase.client.Result])

    val count: Long = hbaseRDD.count()
    println("hBaseRDD RDD Count:"  count)
    hbaseRDD.foreach {
      case (_, result) =>
        val key = Bytes.toString(result.getRow)
        val name = Bytes.toString(result.getValue("info".getBytes, "name".getBytes))
        val color = Bytes.toString(result.getValue("info".getBytes, "price".getBytes))
        println("Row key:"   key   " Name:"   name   " Color:"   color)
    }
    sc.stop()
  }
}

四、SparkSQL 入门详解

1、Spark SQL概述

1.1 Spark SQL官方介绍

官网

http://spark.apache.org/sql/

代码语言：javascript复制

Spark SQL是Spark用来处理结构化数据的一个模块。

Spark SQL还提供了多种使用方式，包括DataFrames API和Datasets API。但无论是哪种API或者是编程语言，它们都是基于同样的执行引擎，因此你可以在不同的API之间随意切换，它们各有各的特点。

1.2 Spark SQL 的特点

代码语言：javascript复制

1.易整合
可以使用java、scala、python、R等语言的API操作。

2.统一的数据访问
连接到任何数据源的方式相同。

3.兼容Hive
支持hiveHQL的语法。
兼容hive(元数据库、SQL语法、UDF、序列化、反序列化机制)

4.标准的数据连接
可以使用行业标准的JDBC或ODBC连接。

1.3 SQL优缺点

代码语言：javascript复制

1）SQL的优点
表达非常清晰, 比如说这段 SQL 明显就是为了查询三个字段，条件是查询年龄大于 10 岁的
难度低、易学习。
     
2）SQL的缺点
复杂分析,SQL嵌套较多：试想一下3层嵌套的 SQL维护起来应该挺力不从心的吧
机器学习较难：试想一下如果使用SQL来实现机器学习算法也挺为难的吧

1.4 Hive和SparkSQL

代码语言：javascript复制

Hive是将SQL转为MapReduce
SparkSQL可以理解成是将SQL解析成'RDD'   优化再执行

1.5 Spark SQL数据抽象

1.5.1 DataFrame

什么是DataFrame?

代码语言：javascript复制

DataFrame是一种以RDD为基础的带有Schema元信息的分布式数据集，类似于传统数据库的二维表格 。

1.5.2 DataSet

什么是DataSet?

代码语言：javascript复制

DataSet是保存了更多的描述信息，类型信息的分布式数据集。

与RDD相比，保存了更多的描述信息，概念上等同于关系型数据库中的二维表。
与DataFrame相比，保存了类型信息，是强类型的，提供了编译时类型检查，
调用Dataset的方法先会生成逻辑计划，然后被spark的优化器进行优化，最终生成物理计划，然后提交到集群中运行！

代码语言：javascript复制

DataSet包含了DataFrame的功能，
Spark2.0中两者统一，DataFrame表示为DataSet[Row]，即DataSet的子集。
DataFrame其实就是Dateset[Row]

1.5.3 RDD、DataFrame、DataSet的区别结构图解

代码语言：javascript复制

RDD[Person]
以Person为类型参数，但不了解 其内部结构。

DataFrame
提供了详细的结构信息schema列的名称和类型。这样看起来就像一张表了

DataSet[Person]

![](https://files.mdnice.com/user/37735/a21c2a86-9dbc-41cc-837f-2ff8c538d01a.png)
不光有schema信息，还有类型信息

2、Spark SQL初体验

2.1 入口-SparkSession

代码语言：javascript复制

在spark2.0版本之前
SQLContext是创建DataFrame和执行SQL的入口
HiveContext通过hive sql语句操作hive表数据，兼容hive操作，hiveContext继承自SQLContext。
在spark2.0之后
SparkSession 封装了SqlContext及HiveContext所有功能。通过SparkSession还可以获取到SparkConetxt。
SparkSession可以执行SparkSQL也可以执行HiveSQL.

2.2. 创建DataFrame

2.2.1. 创读取文本文件

代码语言：javascript复制

1.在本地创建一个文件，有id、name、age三列，用空格分隔，然后上传到hdfs上

vim /root/person.txt

1 zhangsan 20
2 lisi 29
3 wangwu 25
4 zhaoliu 30
5 tianqi 35
6 kobe 40

上传数据文件到HDFS上：

hadoop fs -put /root/person.txt  /


2.在spark shell执行下面命令，读取数据，将每一行的数据使用列分隔符分割

打开spark-shell 
/export/servers/spark/bin/spark-shell 

创建RDD
val lineRDD= sc.textFile("hdfs://node01:8020/person.txt").map(_.split(" ")) 

//RDD[Array[String]]


3.定义case class(相当于表的schema)
case class Person(id:Int, name:String, age:Int)


4.将RDD和case class关联
val personRDD = lineRDD.map(x => Person(x(0).toInt, x(1), x(2).toInt)) 

//RDD[Person]


5.将RDD转换成DataFrame
val personDF = personRDD.toDF 

//DataFrame

6.查看数据和schema
personDF.show
 --- -------- --- 
| id|    name|age|
 --- -------- --- 
|  1|zhangsan| 20|
|  2|    lisi| 29|
|  3|  wangwu| 25|
|  4| zhaoliu| 30|
|  5|  tianqi| 35|
|  6|    kobe| 40|
 --- -------- --- 
personDF.printSchema


7.注册表
personDF.createOrReplaceTempView("t_person")
 

8.执行SQL
spark.sql("select id,name from t_person where id > 3").show


9.也可以通过SparkSession构建DataFrame
val dataFrame=spark.read.text("hdfs://node01:8020/person.txt") 
dataFrame.show //注意：直接读取的文本文件没有完整schema信息
dataFrame.printSchema

2.2.2 读取json文件

代码语言：javascript复制

1.数据文件
使用spark安装包下的json文件
more /export/servers/spark/examples/src/main/resources/people.json
{"name":"Michael"}
{"name":"Andy", "age":30}
{"name":"Justin", "age":19}

2.在spark shell执行下面命令，读取数据
val jsonDF= spark.read.json("file:///export/servers/spark/examples/src/main/resources/people.json")
  
3.接下来就可以使用DataFrame的函数操作
jsonDF.show 
//注意:直接读取json文件有schema信息，因为json文件本身含有Schema信息，SparkSQL可以自动解析

2.2.3. 读取parquet文件

代码语言：javascript复制

1.数据文件
使用spark安装包下的parquet文件
more /export/servers/spark/examples/src/main/resources/users.parquet
  
2.在spark shell执行下面命令，读取数据
val parquetDF=spark.read.parquet("file:///export/servers/spark/examples/src/main/resources/users.parquet")

3.接下来就可以使用DataFrame的函数操作
parquetDF.show 
//注意：直接读取parquet文件有schema信息，因为parquet文件中保存了列的信息

2.3 创建DataSet

代码语言：javascript复制

1.通过spark.createDataset创建Dataset
val fileRdd = sc.textFile("hdfs://node01:8020/person.txt") //RDD[String]
val ds1 = spark.createDataset(fileRdd)  //DataSet[String] 
ds1.show

2.通RDD.toDS方法生成DataSet
case class Person(name:String, age:Int)
val data = List(Person("zhangsan",20),Person("lisi",30)) //List[Person]
val dataRDD = sc.makeRDD(data)
val ds2 = dataRDD.toDS  //Dataset[Person]
ds2.show

3.通过DataFrame.as[泛型]转化生成DataSet
case class Person(name:String, age:Long)
val jsonDF= spark.read.json("file:///export/servers/spark/examples/src/main/resources/people.json")
val jsonDS = jsonDF.as[Person] //DataSet[Person]
jsonDS.show

4.DataSet也可以注册成表进行查询
jsonDS.createOrReplaceTempView("t_person")
spark.sql("select * from t_person").show

2.4 两种查询风格[先了解]

2.4.1 准备工作

代码语言：javascript复制

读取文件并转换为DataFrame或DataSet
val lineRDD= sc.textFile("hdfs://node01:8020/person.txt").map(_.split(" "))
case class Person(id:Int, name:String, age:Int)
val personRDD = lineRDD.map(x => Person(x(0).toInt, x(1), x(2).toInt))
val personDF = personRDD.toDF
personDF.show
//val personDS = personRDD.toDS
//personDS.show

2.4.2 DSL风格

SparkSQL提供了一个领域特定语言(DSL)以方便操作结构化数据

代码语言：javascript复制

1.查看name字段的数据
personDF.select(personDF.col("name")).show
personDF.select(personDF("name")).show
personDF.select(col("name")).show
personDF.select("name").show

2.查看name和age字段数据
personDF.select("name", "age").show

3.查询所有的name和age，并将age 1
personDF.select(personDF.col("name"), personDF.col("age")   1).show
personDF.select(personDF("name"), personDF("age")   1).show
personDF.select(col("name"), col("age")   1).show
personDF.select("name","age").show
//personDF.select("name", "age" 1).show 
personDF.select($"name",$"age",$"age" 1).show

4.过滤age大于等于25的，使用filter方法过滤
personDF.filter(col("age") >= 25).show
personDF.filter($"age" >25).show

5.统计年龄大于30的人数
personDF.filter(col("age")>30).count()
personDF.filter($"age" >30).count()

6.按年龄进行分组并统计相同年龄的人数
personDF.groupBy("age").count().show

2.4.3 SQL风格

DataFrame的一个强大之处就是我们可以将它看作是一个关系型数据表，然后可以通过在程序中使用spark.sql() 来执行SQL查询，结果将作为一个DataFrame返回

代码语言：javascript复制

如果想使用SQL风格的语法，需要将DataFrame注册成表,采用如下的方式：
personDF.createOrReplaceTempView("t_person")
spark.sql("select * from t_person").show
1.显示表的描述信息
spark.sql("desc t_person").show

2.查询年龄最大的前两名
spark.sql("select * from t_person order by age desc limit 2").show

3.查询年龄大于30的人的信息
spark.sql("select * from t_person where age > 30 ").show

4.使用SQL风格完成DSL中的需求
spark.sql("select name, age   1 from t_person").show
spark.sql("select name, age from t_person where age > 25").show
spark.sql("select count(age) from t_person where age > 30").show
spark.sql("select age, count(age) from t_person group by age").show

2.5 总结

代码语言：javascript复制

1.DataFrame和DataSet都可以通过RDD来进行创建
2.也可以通过读取普通文本创建–注意:直接读取没有完整的约束,需要通过RDD Schema
3.通过josn/parquet会有完整的约束
4.不管是DataFrame还是DataSet都可以注册成表，之后就可以使用SQL进行查询了! 也可以使用DSL!

3、使用IDEA开发Spark SQL

3.1 创建DataFrame/DataSet

Spark会根据文件信息尝试着去推断DataFrame/DataSet的Schema，当然我们也可以手动指定，手动指定的方式有以下几种：

代码语言：javascript复制

第1种：指定列名添加Schema
第2种：通过StructType指定Schema
第3种：编写样例类，利用反射机制推断Schema

3.1.1 指定列名添加Schema

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SparkSession}


object CreateDFDS {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileRDD: RDD[String] = sc.textFile("D:\data\person.txt")
    val linesRDD: RDD[Array[String]] = fileRDD.map(_.split(" "))
    val rowRDD: RDD[(Int, String, Int)] = linesRDD.map(line =>(line(0).toInt,line(1),line(2).toInt))
    //3.将RDD转成DF
    //注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
    import spark.implicits._
    val personDF: DataFrame = rowRDD.toDF("id","name","age")
    personDF.show(10)
    personDF.printSchema()
    sc.stop()
    spark.stop()
  }
}

3.1.2 StructType指定Schema-了解

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types._
import org.apache.spark.sql.{DataFrame, Row, SparkSession}


object CreateDFDS2 {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileRDD: RDD[String] = sc.textFile("D:\data\person.txt")
    val linesRDD: RDD[Array[String]] = fileRDD.map(_.split(" "))
    val rowRDD: RDD[Row] = linesRDD.map(line =>Row(line(0).toInt,line(1),line(2).toInt))
    //3.将RDD转成DF
    //注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
    //import spark.implicits._
    val schema: StructType = StructType(Seq(
      StructField("id", IntegerType, true),//允许为空
      StructField("name", StringType, true),
      StructField("age", IntegerType, true))
    )
    val personDF: DataFrame = spark.createDataFrame(rowRDD,schema)
    personDF.show(10)
    personDF.printSchema()
    sc.stop()
    spark.stop()
  }
}

3.1.3 反射推断Schema–掌握

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SparkSession}


object CreateDFDS3 {
case class Person(id:Int,name:String,age:Int)
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL")
.getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileRDD: RDD[String] = sc.textFile("D:\data\person.txt")
    val linesRDD: RDD[Array[String]] = fileRDD.map(_.split(" "))
    val rowRDD: RDD[Person] = linesRDD.map(line =>Person(line(0).toInt,line(1),line(2).toInt))
    //3.将RDD转成DF
    //注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
    import spark.implicits._
    //注意:上面的rowRDD的泛型是Person,里面包含了Schema信息
    //所以SparkSQL可以通过反射自动获取到并添加给DF
    val personDF: DataFrame = rowRDD.toDF
    personDF.show(10)
    personDF.printSchema()
    sc.stop()
    spark.stop()
  }
}

3.2 花式查询

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SparkSession}


object QueryDemo {
case class Person(id:Int,name:String,age:Int)
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL")
.getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileRDD: RDD[String] = sc.textFile("D:\data\person.txt")
    val linesRDD: RDD[Array[String]] = fileRDD.map(_.split(" "))
    val rowRDD: RDD[Person] = linesRDD.map(line =>Person(line(0).toInt,line(1),line(2).toInt))
    //3.将RDD转成DF
    //注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
    import spark.implicits._
    //注意:上面的rowRDD的泛型是Person,里面包含了Schema信息
    //所以SparkSQL可以通过反射自动获取到并添加给DF
    val personDF: DataFrame = rowRDD.toDF
    personDF.show(10)
    personDF.printSchema()
    //=======================SQL方式查询=======================
    //0.注册表
    personDF.createOrReplaceTempView("t_person")
    //1.查询所有数据
    spark.sql("select * from t_person").show()
    //2.查询age 1
    spark.sql("select age,age 1 from t_person").show()
    //3.查询age最大的两人
    spark.sql("select name,age from t_person order by age desc limit 2").show()
    //4.查询各个年龄的人数
    spark.sql("select age,count(*) from t_person group by age").show()
    //5.查询年龄大于30的
    spark.sql("select * from t_person where age > 30").show()

    //=======================DSL方式查询=======================
    //1.查询所有数据
    personDF.select("name","age")
    //2.查询age 1
    personDF.select($"name",$"age"   1)
    //3.查询age最大的两人
    personDF.sort($"age".desc).show(2)
    //4.查询各个年龄的人数
    personDF.groupBy("age").count().show()
    //5.查询年龄大于30的
    personDF.filter($"age" > 30).show()

    sc.stop()
    spark.stop()
  }
  }

3.3 相互转化

代码语言：javascript复制

RDD、DF、DS之间的相互转换有很多(6种)，但是我们实际操作就只有2类:
1)使用RDD算子操作
2)使用DSL/SQL对表操作
package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession}

object TransformDemo {
case class Person(id:Int,name:String,age:Int)

  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileRDD: RDD[String] = sc.textFile("D:\data\person.txt")
    val linesRDD: RDD[Array[String]] = fileRDD.map(_.split(" "))
    val personRDD: RDD[Person] = linesRDD.map(line =>Person(line(0).toInt,line(1),line(2).toInt))
    //3.将RDD转成DF
    //注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
    import spark.implicits._
    //注意:上面的rowRDD的泛型是Person,里面包含了Schema信息
    //所以SparkSQL可以通过反射自动获取到并添加给DF
    //=========================相互转换======================
    //1.RDD-->DF
    val personDF: DataFrame = personRDD.toDF
    //2.DF-->RDD
    val rdd: RDD[Row] = personDF.rdd
    //3.RDD-->DS
    val DS: Dataset[Person] = personRDD.toDS()
    //4.DS-->RDD
    val rdd2: RDD[Person] = DS.rdd
    //5.DF-->DS
    val DS2: Dataset[Person] = personDF.as[Person]
    //6.DS-->DF
    val DF: DataFrame = DS2.toDF()

    sc.stop()
    spark.stop()
  }
  }

3.4 Spark SQL完成WordCount

3.4.1 SQL风格

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}


object WordCount {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileDF: DataFrame = spark.read.text("D:\data\words.txt")
    val fileDS: Dataset[String] = spark.read.textFile("D:\data\words.txt")
    //fileDF.show()
    //fileDS.show()
    //3.对每一行按照空格进行切分并压平
    //fileDF.flatMap(_.split(" ")) //注意:错误,因为DF没有泛型,不知道_是String
    import spark.implicits._
    val wordDS: Dataset[String] = fileDS.flatMap(_.split(" "))//注意:正确,因为DS有泛型,知道_是String
    //wordDS.show()
    /*
     ----- 
    |value|
     ----- 
    |hello|
    |   me|
    |hello|
    |  you|
      ...
     */
    //4.对上面的数据进行WordCount
    wordDS.createOrReplaceTempView("t_word")
    val sql =
      """
        |select value ,count(value) as count
        |from t_word
        |group by value
        |order by count desc
      """.stripMargin
    spark.sql(sql).show()

    sc.stop()
    spark.stop()
  }
}

3.4.2 DSL风格

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}


object WordCount2 {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileDF: DataFrame = spark.read.text("D:\data\words.txt")
    val fileDS: Dataset[String] = spark.read.textFile("D:\data\words.txt")
    //fileDF.show()
    //fileDS.show()
    //3.对每一行按照空格进行切分并压平
    //fileDF.flatMap(_.split(" ")) //注意:错误,因为DF没有泛型,不知道_是String
    import spark.implicits._
    val wordDS: Dataset[String] = fileDS.flatMap(_.split(" "))//注意:正确,因为DS有泛型,知道_是String
    //wordDS.show()
    /*
     ----- 
    |value|
     ----- 
    |hello|
    |   me|
    |hello|
    |  you|
      ...
     */
    //4.对上面的数据进行WordCount
    wordDS.groupBy("value").count().orderBy($"count".desc).show()

    sc.stop()
    spark.stop()
  }
}

4、Spark SQL多数据源交互

代码语言：javascript复制

Spark SQL可以与多种数据源交互，如普通文本、json、parquet、csv、MySQL等

1.写入不同数据源
2.读取不同数据源

4.1 写数据

代码语言：javascript复制

package cn.itcast.sql

import java.util.Properties

import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}


object WriterDataSourceDemo {
case class Person(id:Int,name:String,age:Int)

  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL")
.getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileRDD: RDD[String] = sc.textFile("D:\data\person.txt")
    val linesRDD: RDD[Array[String]] = fileRDD.map(_.split(" "))
    val rowRDD: RDD[Person] = linesRDD.map(line =>Person(line(0).toInt,line(1),line(2).toInt))
    //3.将RDD转成DF
    //注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
    import spark.implicits._
    //注意:上面的rowRDD的泛型是Person,里面包含了Schema信息
    //所以SparkSQL可以通过反射自动获取到并添加给DF
    val personDF: DataFrame = rowRDD.toDF
    //==================将DF写入到不同数据源===================
    //Text data source supports only a single column, and you have 3 columns.;
    //personDF.write.text("D:\data\output\text")
    personDF.write.json("D:\data\output\json")
    personDF.write.csv("D:\data\output\csv")
    personDF.write.parquet("D:\data\output\parquet")
    val prop = new Properties()
    prop.setProperty("user","root")
    prop.setProperty("password","root")
    personDF.write.mode(SaveMode.Overwrite).jdbc(
"jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8","person",prop)
    println("写入成功")
    sc.stop()
    spark.stop()
  }
 }

4.2 读数据

代码语言：javascript复制

package cn.itcast.sql

import java.util.Properties

import org.apache.spark.SparkContext
import org.apache.spark.sql.SparkSession


object ReadDataSourceDemo {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL")
.getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    spark.read.json("D:\data\output\json").show()
    spark.read.csv("D:\data\output\csv").toDF("id","name","age").show()
    spark.read.parquet("D:\data\output\parquet").show()
    val prop = new Properties()
    prop.setProperty("user","root")
    prop.setProperty("password","root")
    spark.read.jdbc(
"jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8","person",prop).show()
    sc.stop()
    spark.stop()
  }
}

4.3 总结

代码语言：javascript复制

1.SparkSQL写数据:
DataFrame/DataSet.write.json/csv/jdbc

2.SparkSQL读数据:
SparkSession.read.json/csv/text/jdbc/format

5、Spark SQL自定义函数

5.1 自定义函数分类

类似于hive当中的自定义函数， spark同样可以使用自定义函数来实现新的功能。

spark中的自定义函数有如下3类

代码语言：javascript复制

1.UDF(User-Defined-Function)
输入一行，输出一行 

2.UDAF(User-Defined Aggregation Funcation)
输入多行，输出一行

3.UDTF(User-Defined Table-Generating Functions)
输入一行，输出多行

5.2 自定义UDF

需求

代码语言：javascript复制

有udf.txt数据格式如下：
Hello
abc
study
small

通过自定义UDF函数将每一行数据转换成大写

代码语言：javascript复制

select value,smallToBig(value) from t_word

代码演示

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.sql.{Dataset, SparkSession}


object UDFDemo {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileDS: Dataset[String] = spark.read.textFile("D:\data\udf.txt")
    fileDS.show()
    /*
     ---------- 
    |     value|
     ---------- 
    |helloworld|
    |       abc|
    |     study|
    | smallWORD|
     ---------- 
     */
   /*
    将每一行数据转换成大写
    select value,smallToBig(value) from t_word
    */
    //注册一个函数名称为smallToBig,功能是传入一个String,返回一个大写的String
    spark.udf.register("smallToBig",(str:String) => str.toUpperCase())
    fileDS.createOrReplaceTempView("t_word")
    //使用我们自己定义的函数
    spark.sql("select value,smallToBig(value) from t_word").show()
    /*
     ---------- --------------------- 
    |     value|UDF:smallToBig(value)|
     ---------- --------------------- 
    |helloworld|           HELLOWORLD|
    |       abc|                  ABC|
    |     study|                STUDY|
    | smallWORD|            SMALLWORD|
     ---------- --------------------- 
     */
    sc.stop()
    spark.stop()
  }
}

5.3 自定义UDAF[了解]

代码语言：javascript复制

需求
  
有udaf.json数据内容如下
{"name":"Michael","salary":3000}
{"name":"Andy","salary":4500}
{"name":"Justin","salary":3500}
{"name":"Berta","salary":4000}
求取平均工资

继承UserDefinedAggregateFunction方法重写说明

代码语言：javascript复制

inputSchema：输入数据的类型
bufferSchema：产生中间结果的数据类型
dataType：最终返回的结果类型
deterministic：确保一致性，一般用true
initialize：指定初始值
update：每有一条数据参与运算就更新一下中间结果(update相当于在每一个分区中的运算)
merge：全局聚合(将每个分区的结果进行聚合)
evaluate：计算最终的结果

代码演示

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.SparkContext    
importorg.apache.spark.sql.expressions{MutableAggregationBuffer,UserDefinedAggregateFunction}
import org.apache.spark.sql.types._
import org.apache.spark.sql.{DataFrame, Row, SparkSession}


object UDAFDemo {
  def main(args: Array[String]): Unit = {
    //1.获取sparkSession
    val spark: SparkSession = SparkSession.builder().appName("SparkSQL").master("local[*]").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val employeeDF: DataFrame = spark.read.json("D:\data\udaf.json")
    //3.创建临时表
    employeeDF.createOrReplaceTempView("t_employee")
    //4.注册UDAF函数
    spark.udf.register("myavg",new MyUDAF)
    //5.使用自定义UDAF函数
    spark.sql("select myavg(salary) from t_employee").show()
    //6.使用内置的avg函数
    spark.sql("select avg(salary) from t_employee").show()
  }
}
class MyUDAF extends UserDefinedAggregateFunction{
  //输入的数据类型的schema
  override def inputSchema: StructType = {
     StructType(StructField("input",LongType)::Nil)
  }
  //缓冲区数据类型schema，就是转换之后的数据的schema
  override def bufferSchema: StructType = {
    StructType(StructField("sum",LongType)::StructField("total",LongType)::Nil)
  }
  //返回值的数据类型
  override def dataType: DataType = {
    DoubleType
  }
  //确定是否相同的输入会有相同的输出
  override def deterministic: Boolean = {
    true
  }
  //初始化内部数据结构
  override def initialize(buffer: MutableAggregationBuffer): Unit = {
    buffer(0) = 0L
    buffer(1) = 0L
  }
  //更新数据内部结构,区内计算
  override def update(buffer: MutableAggregationBuffer, input: Row): Unit = {
    //所有的金额相加
    buffer(0) = buffer.getLong(0)   input.getLong(0)
    //一共有多少条数据
    buffer(1) = buffer.getLong(1)   1
  }
  //来自不同分区的数据进行合并,全局合并
  override def merge(buffer1: MutableAggregationBuffer, buffer2: Row): Unit = {
    buffer1(0) =buffer1.getLong(0)   buffer2.getLong(0)
    buffer1(1) = buffer1.getLong(1)   buffer2.getLong(1)
  }
  //计算输出数据值
  override def evaluate(buffer: Row): Any = {
    buffer.getLong(0).toDouble / buffer.getLong(1)
  }
}

6、扩展：开窗函数

6.1 概述

https://www.cnblogs.com/qiuting/p/7880500.html

介绍

代码语言：javascript复制

开窗函数的引入是为了既显示聚集前的数据，又显示聚集后的数据。即在每一行的最后一列添加聚合函数的结果。

开窗用于为行定义一个窗口(这里的窗口是指运算将要操作的行的集合)，它对一组值进行操作，不需要使用 GROUP BY 子句对数据进行分组，能够在同一行中同时返回基础行的列和聚合列。

聚合函数和开窗函数

代码语言：javascript复制

聚合函数是将多行变成一行，count,avg…
开窗函数是将一行变成多行；

聚合函数如果要显示其他的列必须将列加入到group by中
开窗函数可以不使用group by，直接将所有信息显示出来

开窗函数分类

代码语言：javascript复制

1.聚合开窗函数
聚合函数(列) OVER(选项)，这里的选项可以是PARTITION BY 子句，但不可以是 ORDER BY 子句。

2.排序开窗函数
排序函数(列) OVER(选项)，这里的选项可以是ORDER BY 子句，也可以是 OVER(PARTITION BY 子句 ORDER BY 子句)，但不可以是 PARTITION BY 子句。

6.2 准备工作

代码语言：javascript复制

/export/servers/spark/bin/spark-shell --master 
spark://node01:7077,node02:7077
 
case class Score(name: String, clazz: Int, score: Int)
val scoreDF = spark.sparkContext.makeRDD(Array(
Score("a1", 1, 80),
Score("a2", 1, 78),
Score("a3", 1, 95),
Score("a4", 2, 74),
Score("a5", 2, 92),
Score("a6", 3, 99),
Score("a7", 3, 99),
Score("a8", 3, 45),
Score("a9", 3, 55),
Score("a10", 3, 78),
Score("a11", 3, 100))
).toDF("name", "class", "score")
scoreDF.createOrReplaceTempView("scores")
scoreDF.show()
 ---- ----- ----- 
|name|class|score|
 ---- ----- ----- 
|  a1|    1|   80|
|  a2|    1|   78|
|  a3|    1|   95|
|  a4|    2|   74|
|  a5|    2|   92|
|  a6|    3|   99|
|  a7|    3|   99|
|  a8|    3|   45|
|  a9|    3|   55|
| a10|    3|   78|
| a11|    3|  100|
 ---- ----- -----

6.3 聚合开窗函数

示例1

OVER 关键字表示把聚合函数当成聚合开窗函数而不是聚合函数。SQL标准允许将所有聚合函数用做聚合开窗函数。

代码语言：javascript复制

spark.sql("select  count(name)  from scores").show
spark.sql("select name, class, score, count(name) over() name_count from scores").show

查询结果如下所示：
 ---- ----- ----- ----------                                                    
|name|class|score|name_count|
 ---- ----- ----- ---------- 
|  a1|    1|   80|        11|
|  a2|    1|   78|        11|
|  a3|    1|   95|        11|
|  a4|    2|   74|        11|
|  a5|    2|   92|        11|
|  a6|    3|   99|        11|
|  a7|    3|   99|        11|
|  a8|    3|   45|        11|
|  a9|    3|   55|        11|
| a10|    3|   78|        11|
| a11|    3|  100|        11|
 ---- ----- ----- ----------

示例2

代码语言：javascript复制

OVER 关键字后的括号中还可以添加选项用以改变进行聚合运算的窗口范围。
如果 OVER 关键字后的括号中的选项为空，则开窗函数会对结果集中的所有行进行聚合运算。

开窗函数的 OVER 关键字后括号中的可以使用 PARTITION BY 子句来定义行的分区来供进行聚合计算。与 GROUP BY 子句不同，PARTITION BY 子句创建的分区是独立于结果集的，创建的分区只是供进行聚合计算的，而且不同的开窗函数所创建的分区也不互相影响。

下面的 SQL 语句用于显示按照班级分组后每组的人数：

OVER(PARTITION BY class)表示对结果集按照 class 进行分区，并且计算当前行所属的组的聚合计算结果。
spark.sql(“select name, class, score, count(name) over(partition by class) name_count from scores”).show
查询结果如下所示： 
 ---- ----- ----- ----------                                                    
|name|class|score|name_count|
 ---- ----- ----- ---------- 
|  a1|    1|   80|         3|
|  a2|    1|   78|         3|
|  a3|    1|   95|         3|
|  a6|    3|   99|         6|
|  a7|    3|   99|         6|
|  a8|    3|   45|         6|
|  a9|    3|   55|         6|
| a10|    3|   78|         6|
| a11|    3|  100|         6|
|  a4|    2|   74|         2|
|  a5|    2|   92|         2|
 ---- ----- ----- ----------

6.4 排序开窗函数

6.4.1 ROW_NUMBER顺序排序row_number() over(order by score) as rownum 表示按score 升序的方式来排序，并得出排序结果的序号

注意：在排序开窗函数中使用 PARTITION BY 子句需要放置在ORDER BY 子句之前。

示例1

代码语言：javascript复制

spark.sql("select name, class, score, row_number() over(order by score) rank from scores").show()
 ---- ----- ----- ---- 
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
|  a4|    2|   74|   3|
|  a2|    1|   78|   4|
| a10|    3|   78|   5|
|  a1|    1|   80|   6|
|  a5|    2|   92|   7|
|  a3|    1|   95|   8|
|  a6|    3|   99|   9|
|  a7|    3|   99|  10|
| a11|    3|  100|  11|
 ---- ----- ----- ---- 

spark.sql("select name, class, score, row_number() over(partition by class order by score) rank from scores").show()
 ---- ----- ----- ----                                                          
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   5|
| a11|    3|  100|   6|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
 ---- ----- ----- ----

6.4.2 RANK跳跃排序

代码语言：javascript复制

rank() over(order by score) as rank表示按 score升序的方式来排序，并得出排序结果的排名号。

这个函数求出来的排名结果可以并列（并列第一/并列第二），并列排名之后的排名将是并列的排名加上并列数

简单说每个人只有一种排名，然后出现两个并列第一名的情况，这时候排在两个第一名后面的人将是第三名，也就是没有了第二名，但是有两个第一名

示例2

代码语言：javascript复制

spark.sql("select name, class, score, rank() over(order by score) rank from scores").show()    
 ---- ----- ----- ---- 
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
|  a4|    2|   74|   3|
| a10|    3|   78|   4|
|  a2|    1|   78|   4|
|  a1|    1|   80|   6|
|  a5|    2|   92|   7|
|  a3|    1|   95|   8|
|  a6|    3|   99|   9|
|  a7|    3|   99|   9|
| a11|    3|  100|  11|
 ---- ----- ----- ---- 

spark.sql("select name, class, score, rank() over(partition by class order by score) rank from scores").show()
 ---- ----- ----- ----                                                          
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   4|
| a11|    3|  100|   6|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
 ---- ----- ----- ----

6.4.3 DENSE_RANK连续排序

代码语言：javascript复制

dense_rank() over(order by score) as dense_rank 表示按score 升序的方式来排序，并得出排序结果的排名号。

这个函数并列排名之后的排名是并列排名加１

简单说每个人只有一种排名，然后出现两个并列第一名的情况，这时候排在两个第一名后面的人将是第二名，也就是两个第一名，一个第二名

示例3

代码语言：javascript复制

spark.sql("select name, class, score, dense_rank() over(order by score) rank from scores").show()
 ---- ----- ----- ---- 
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
|  a4|    2|   74|   3|
|  a2|    1|   78|   4|
| a10|    3|   78|   4|
|  a1|    1|   80|   5|
|  a5|    2|   92|   6|
|  a3|    1|   95|   7|
|  a6|    3|   99|   8|
|  a7|    3|   99|   8|
| a11|    3|  100|   9|
 ---- ----- ----- ---- 

spark.sql("select name, class, score, dense_rank() over(partition by class order by score) rank from scores").show()
 ---- ----- ----- ----                                                          
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   4|
| a11|    3|  100|   5|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
 ---- ----- ----- ----

6.4.4 NTILE分组排名[了解]

代码语言：javascript复制

ntile(6) over(order by score)as ntile表示按 score 升序的方式来排序，然后 6 等分成 6 个组，并显示所在组的序号。

示例4

代码语言：javascript复制

spark.sql("select name, class, score, ntile(6) over(order by score) rank from scores").show()
 ---- ----- ----- ---- 
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a8|    3|   45|   1|
|  a9|    3|   55|   1|
|  a4|    2|   74|   2|
|  a2|    1|   78|   2|
| a10|    3|   78|   3|
|  a1|    1|   80|   3|
|  a5|    2|   92|   4|
|  a3|    1|   95|   4|
|  a6|    3|   99|   5|
|  a7|    3|   99|   5|
| a11|    3|  100|   6|
 ---- ----- ----- ---- 

spark.sql("select name, class, score, ntile(6) over(partition by class order by score) rank from scores").show()
 ---- ----- ----- ----                                                          
|name|class|score|rank|
 ---- ----- ----- ---- 
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   5|
| a11|    3|  100|   6|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
 ---- ----- ----- ----

7、Spark-On-Hive

7.1 概述

官网

http://spark.apache.org/docs/latest/sql-data-sources-hive-tables.html

Configuration of Hive is done by placing your hive-site.xml, core-site.xml (for security configuration), and hdfs-site.xml (for HDFS configuration) file in conf/.

代码语言：javascript复制

Hive查询流程及原理
  
执行HQL时，先到MySQL元数据库中查找描述信息，然后解析HQL并根据描述信息生成MR任务
Hive将SQL转成MapReduce执行速度慢
  
使用SparkSQL整合Hive其实就是让SparkSQL去加载Hive 的元数据库，然后通过SparkSQL执行引擎去操作Hive表内的数据

所以首先需要开启Hive的元数据库服务，让SparkSQL能够加载元数据

7.2 Hive开启MetaStore服务

代码语言：javascript复制

1: 修改 hive/conf/hive-site.xml 新增如下配置
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
    <property>
      <name>hive.metastore.warehouse.dir</name>
      <value>/user/hive/warehouse</value>
    </property>
    <property>
      <name>hive.metastore.local</name>
      <value>false</value>
    </property>
    <property>
      <name>hive.metastore.uris</name>
      <value>thrift://node01:9083</value>
    </property>
 </configuration>
  
2: 后台启动 Hive MetaStore服务
nohup /export/servers/hive/bin/hive --service metastore 2>&1 >> /var/log.log &

7.3 SparkSQL整合Hive MetaStore

代码语言：javascript复制

Spark 有一个内置的 MateStore，使用 Derby 嵌入式数据库保存数据，但是这种方式不适合生产环境，因为这种模式同一时间只能有一个 SparkSession 使用，所以生产环境更推荐使用 Hive 的 MetaStore
SparkSQL 整合 Hive 的 MetaStore 主要思路就是要通过配置能够访问它， 并且能够使用 HDFS 保存 WareHouse，所以可以直接拷贝 Hadoop 和 Hive 的配置文件到 Spark 的配置目录

hive-site.xml 元数据仓库的位置等信息
core-site.xml 安全相关的配置
hdfs-site.xml HDFS 相关的配置

使用IDEA本地测试直接把以上配置文件放在resources目录即可

7.4 使用SparkSQL操作Hive表

代码语言：javascript复制

package cn.itcast.sql

import org.apache.spark.sql.SparkSession

object HiveSupport {
  def main(args: Array[String]): Unit = {
    //创建sparkSession
    val spark = SparkSession
      .builder()
      .appName("HiveSupport")
      .master("local[*]")
      //.config("spark.sql.warehouse.dir", "hdfs://node01:8020/user/hive/warehouse")
      //.config("hive.metastore.uris", "thrift://node01:9083")
      .enableHiveSupport()//开启hive语法的支持
      .getOrCreate()
    spark.sparkContext.setLogLevel("WARN")

    //查看有哪些表
    spark.sql("show tables").show()

    //创建表
    spark.sql("CREATE TABLE person (id int, name string, age int) row format delimited fields terminated by ' '")

    //加载数据,数据为当前SparkDemo项目目录下的person.txt(和src平级)
    spark.sql("LOAD DATA LOCAL INPATH 'SparkDemo/person.txt' INTO TABLE person")

    //查询数据
    spark.sql("select * from person ").show()

    spark.stop()
  }
}

五、Spark Streaming引入详解

1、新的场景需求

集群监控

代码语言：javascript复制

一般的大型集群和平台, 都需要对其进行监控的需求。
要针对各种数据库, 包括 MySQL, HBase 等进行监控
要针对应用进行监控, 例如 Tomcat, Nginx, Node.js 等
要针对硬件的一些指标进行监控, 例如 CPU, 内存, 磁盘 等

还有很多很多

2、Spark Streaming介绍

官网

http://spark.apache.org/streaming/

概述

代码语言：javascript复制

Spark Streaming是一个基于Spark Core之上的实时计算框架，
可以从很多数据源消费数据并对数据进行实时的处理，
具有高吞吐量和容错能力强等特点。

Spark Streaming的特点

代码语言：javascript复制

1.易用
可以像编写离线批处理一样去编写流式程序，支持java/scala/python语言。

2.容错
SparkStreaming在没有额外代码和配置的情况下可以恢复丢失的工作。

3.易整合到Spark体系
流式处理与批处理和交互式查询相结合。

3、实时计算所处的位置

六、Spark Streaming原理

1、SparkStreaming原理

1.1 整体流程

代码语言：javascript复制

Spark Streaming中，会有一个接收器组件Receiver，作为一个长期运行的task跑在一个Executor上。Receiver接收外部的数据流形成input DStream

DStream会被按照时间间隔划分成一批一批的RDD，当批处理间隔缩短到秒级时，便可以用于处理实时数据流。时间间隔的大小可以由参数指定，一般设在500毫秒到几秒之间。
对DStream进行操作就是对RDD进行操作，计算处理的结果可以传给外部系统。
Spark Streaming的工作流程像下面的图所示一样，接收到实时数据后，给数据分批次，然后传给Spark Engine（引擎）处理最后生成该批次的结果。

1.2 数据抽象

代码语言：javascript复制

Spark Streaming的基础抽象是DStream(Discretized Stream，离散化数据流，连续不断的数据流)，代表持续性的数据流和经过各种Spark算子操作后的结果数据流

可以从以下多个角度深入理解DStream

代码语言：javascript复制

1.DStream本质上就是一系列时间上连续的RDD

代码语言：javascript复制

2.对DStream的数据的进行操作也是按照RDD为单位来进行的

代码语言：javascript复制

3.容错性

底层RDD之间存在依赖关系，DStream直接也有依赖关系，RDD具有容错性，那么DStream也具有容错性

如图:每一个椭圆形表示一个RDD
椭圆形中的每个圆形代表一个RDD中的一个Partition分区
每一列的多个RDD表示一个DStream(图中有三列所以有三个DStream)
每一行最后一个RDD则表示每一个Batch Size所产生的中间结果RDD

代码语言：javascript复制

4.准实时性/近实时性

Spark Streaming将流式计算分解成多个Spark Job，对于每一时间段数据的处理都会经过Spark DAG图分解以及Spark的任务集的调度过程。
对于目前版本的Spark Streaming而言，其最小的Batch Size的选取在0.5~5秒钟之间
所以Spark Streaming能够满足流式准实时计算场景，对实时性要求非常高的如高频实时交易场景则不太适合

总结

代码语言：javascript复制

简单来说DStream就是对RDD的封装，你对DStream进行操作，就是对RDD进行操作
对于DataFrame/DataSet/DStream来说本质上都可以理解成RDD

2、DStream相关操作

DStream上的操作与RDD的类似，分为以下两种：

代码语言：javascript复制

Transformations(转换)
Output Operations(输出)/Action

2.1 Transformations

代码语言：javascript复制

常见Transformation—无状态转换：每个批次的处理不依赖于之前批次的数据

Transformation Meaning

map(func) 对DStream中的各个元素进行func函数操作，然后返回一个新的DStream flatMap(func) 与map方法类似，只不过各个输入项可以被输出为零个或多个输出项 filter(func) 过滤出所有函数func返回值为true的DStream元素并返回一个新的DStream union(otherStream) 将源DStream和输入参数为otherDStream的元素合并，并返回一个新的DStream. reduceByKey(func, [numTasks]) 利用func函数对源DStream中的key进行聚合操作，然后返回新的(K，V)对构成的DStream join(otherStream, [numTasks]) 输入为(K,V)、(K,W)类型的DStream，返回一个新的(K，(V，W)类型的DStream transform(func) 通过RDD-to-RDD函数作用于DStream中的各个RDD，可以是任意的RDD操作，从而返回一个新的RDD

特殊的Transformations—有状态转换：当前批次的处理需要使用之前批次的数据或者中间结果。

有状态转换包括基于追踪状态变化的转换(updateStateByKey)和滑动窗口的转换

代码语言：javascript复制

1.UpdateStateByKey(func)
2.Window Operations 窗口操作

2.2 Output/Action

代码语言：javascript复制

Output Operations可以将DStream的数据输出到外部的数据库或文件系统
当某个Output Operations被调用时，spark streaming程序才会开始真正的计算过程(与RDD的Action类似)

Output Operation Meaning

print() 打印到控制台 saveAsTextFiles(prefix, [suffix]) 保存流的内容为文本文件，文件名为"prefix-TIME_IN_MS[.suffix]“. saveAsObjectFiles(prefix,[suffix]) 保存流的内容为SequenceFile，文件名为 “prefix-TIME_IN_MS[.suffix]”. saveAsHadoopFiles(prefix,[suffix]) 保存流的内容为hadoop文件，文件名为"prefix-TIME_IN_MS[.suffix]”. foreachRDD(func) 对Dstream里面的每个RDD执行func

3、总结

七、Spark Streaming实战

1、WordCount

1.1 需求&准备

图解

首先在linux服务器上安装nc工具

代码语言：javascript复制

nc是netcat的简称，原本是用来设置路由器,我们可以利用它向某个端口发送数据
yum install -y nc

启动一个服务端并开放9999端口,等一下往这个端口发数据

代码语言：javascript复制

nc -lk 9999

发送数据

1.2 代码演示

代码语言：javascript复制

package cn.itcast.streaming

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

object WordCount {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中对数据进行切分形成一个RDD
    //2.监听Socket接收数据
    //ReceiverInputDStream就是接收到的所有的数据组成的RDD,封装成了DStream,接下来对DStream进行操作就是对RDD进行操作
    val dataDStream: ReceiverInputDStream[String] = ssc.socketTextStream("node01",9999)
    //3.操作数据
    val wordDStream: DStream[String] = dataDStream.flatMap(_.split(" "))
    val wordAndOneDStream: DStream[(String, Int)] = wordDStream.map((_,1))
    val wordAndCount: DStream[(String, Int)] = wordAndOneDStream.reduceByKey(_ _)
    wordAndCount.print()
    ssc.start()//开启
    ssc.awaitTermination()//等待停止
  }
}

1.1.3 执行

代码语言：javascript复制

1.先执行nc -lk 9999 
2.然后执行代码
3.不断的在1中输入不同的单词
hadoop spark sqoop hadoop spark hive hadoop
4.观察IDEA控制台输出
sparkStreaming每隔5s计算一次当前5s内的数据，然后将每个批次的数据输出

2、updateStateByKey

2.1 问题

代码语言：javascript复制

在上面的那个案例中存在这样一个问题：
每个批次的单词次数都被正确的统计出来，但是结果不能累加！

如果需要累加需要使用 updateStateByKey(func) 来更新状态.

2.2 代码演示

代码语言：javascript复制

package cn.itcast.streaming

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


object WordCount2 {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中对数据进行切分形成一个RDD
    //requirement failed: ....Please set it by StreamingContext.checkpoint().
    //注意:我们在下面使用到了updateStateByKey对当前数据和历史数据进行累加
    //那么历史数据存在哪?我们需要给他设置一个checkpoint目录
    ssc.checkpoint("./wc")//开发中HDFS
    //2.监听Socket接收数据
    //ReceiverInputDStream就是接收到的所有的数据组成的RDD,封装成了DStream,接下来对DStream进行操作就是对RDD进行操作
    val dataDStream: ReceiverInputDStream[String] = ssc.socketTextStream("node01",9999)
    //3.操作数据
    val wordDStream: DStream[String] = dataDStream.flatMap(_.split(" "))
    val wordAndOneDStream: DStream[(String, Int)] = wordDStream.map((_,1))
    //val wordAndCount: DStream[(String, Int)] = wordAndOneDStream.reduceByKey(_ _)
    //====================使用updateStateByKey对当前数据和历史数据进行累加====================
    val wordAndCount: DStream[(String, Int)] =wordAndOneDStream.updateStateByKey(updateFunc)
    wordAndCount.print()
    ssc.start()//开启
    ssc.awaitTermination()//等待优雅停止
  }
  //currentValues:当前批次的value值,如:1,1,1 (以测试数据中的hadoop为例)
  //historyValue:之前累计的历史值,第一次没有值是0,第二次是3
  //目标是把当前数据 历史数据返回作为新的结果(下次的历史数据)
  def updateFunc(currentValues:Seq[Int], historyValue:Option[Int] ):Option[Int] ={
// currentValues当前值
// historyValue历史值
    val result: Int = currentValues.sum   historyValue.getOrElse(0)
    Some(result)
  }
}

2.3 执行

代码语言：javascript复制

1.先执行nc -lk 9999 
2.然后执行以上代码
3.不断的在1中输入不同的单词，
hadoop spark sqoop hadoop spark hive hadoop
4.观察IDEA控制台输出
sparkStreaming每隔5s计算一次当前5s内的数据，然后将每个批次的结果数据累加输出。

3、reduceByKeyAndWindow

3.1 图解

代码语言：javascript复制

在短时间范围内去计算一个周期性频繁的一个大的时间段的这样的一个结果，这样的一个需求，用窗口函数很快就可以解决了。
滑动窗口转换操作的计算过程如下图所示，
我们可以事先设定一个滑动窗口的长度(也就是窗口的持续时间)，并且设定滑动窗口的时间间隔(每隔多长时间执行一次计算)，
比如设置滑动窗口的长度(也就是窗口的持续时间)为24H,设置滑动窗口的时间间隔(每隔多长时间执行一次计算)为1H
那么意思就是:每隔1H计算最近24H的数据

3.2 代码演示

代码语言：javascript复制

package cn.itcast.streaming

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

object WordCount3 {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中对数据进行切分形成一个RDD
    //2.监听Socket接收数据
    //ReceiverInputDStream就是接收到的所有的数据组成的RDD,封装成了DStream,接下来对DStream进行操作就是对RDD进行操作
    val dataDStream: ReceiverInputDStream[String] = ssc.socketTextStream("node01",9999)
    //3.操作数据
    val wordDStream: DStream[String] = dataDStream.flatMap(_.split(" "))
    val wordAndOneDStream: DStream[(String, Int)] = wordDStream.map((_,1))
 
    val wordAndCount: DStream[(String, Int)] = wordAndOneDStream.reduceByKeyAndWindow((a:Int,b:Int)=>a b,Seconds(10),Seconds(5))
   //4.使用窗口函数进行WordCount计数
    //reduceFunc: (V, V) => V,集合函数
    //windowDuration: Duration,窗口长度/宽度
    //slideDuration: Duration,窗口滑动间隔
    //注意:windowDuration和slideDuration必须是batchDuration的倍数
    //windowDuration=slideDuration:数据不会丢失也不会重复计算==开发中会使用
    //windowDuration>slideDuration:数据会重复计算==开发中会使用
    //windowDuration<slideDuration:数据会丢失
    //代码表示:
    //windowDuration=10
    //slideDuration=5
    //那么执行结果就是每隔5s计算最近10s的数据
    //比如开发中让你统计最近1小时的数据,每隔1分钟计算一次,那么参数该如何设置?

    wordAndCount.print()
    ssc.start()//开启
    ssc.awaitTermination()//等待优雅停止
  }
}

3.3 执行

代码语言：javascript复制

1.先执行nc -lk 9999 
2.然后执行以上代码
3.不断的在1中输入不同的单词
hadoop spark sqoop hadoop spark hive hadoop
4.观察IDEA控制台输出
现象：sparkStreaming每隔5s计算一次当前在窗口大小为10s内的数据，然后将结果数据输出。

4、统计一定时间内的热门词汇TopN

4.1 需求

代码语言：javascript复制

模拟百度热搜排行榜
统计最近10s的热搜词Top3，每隔5秒计算一次
WindowDuration = 10s
SlideDuration = 5s

4.2 代码演示

代码语言：javascript复制

package cn.itcast.streaming

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

 /*
  * Desc 我们要模拟百度热搜排行榜统计最近10s的热搜词Top3,每隔5秒计算一次
  */
object WordCount4 {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中对数据进行切分形成一个RDD
    //2.监听Socket接收数据
    //ReceiverInputDStream就是接收到的所有的数据组成的RDD,封装成了DStream,接下来对DStream进行操作就是对RDD进行操作
    val dataDStream: ReceiverInputDStream[String] = ssc.socketTextStream("node01",9999)
    //3.操作数据
    val wordDStream: DStream[String] = dataDStream.flatMap(_.split(" "))
    val wordAndOneDStream: DStream[(String, Int)] = wordDStream.map((_,1))
    //4.使用窗口函数进行WordCount计数
    val wordAndCount: DStream[(String, Int)] = wordAndOneDStream.reduceByKeyAndWindow((a:Int,b:Int)=>a b,Seconds(10),Seconds(5))
    val sorteDStream: DStream[(String, Int)] = wordAndCount.transform(rdd => {
      val sortedRDD: RDD[(String, Int)] = rdd.sortBy(_._2, false) //逆序/降序
      println("===============top3==============")
      sortedRDD.take(3).foreach(println)
      println("===============top3==============")
      sortedRDD
    }
    )
    //No output operations registered, so nothing to execute
    sorteDStream.print
    ssc.start()//开启
    ssc.awaitTermination()//等待优雅停止
  }
}

4.3 执行

代码语言：javascript复制

1.先执行nc -lk 9999 
2.然后在执行以上代码
3.不断的在1中输入不同的单词
hadoop spark sqoop hadoop spark hive hadoop
4.观察IDEA控制台输出

八、整合kafka

1、Kafka快速回顾

1.1 核心概念图解

代码语言：javascript复制

Broker ： 安装Kafka服务的机器就是一个broker
Producer ：消息的生产者，负责将数据写入到broker中(push)
Consumer：消息的消费者，负责从kafka中拉取数据(pull)，老版本的消费者需要依赖zk，新版本的不需要
Topic: 主题，相当于是数据的一个分类，不同topic存放不同业务的数据 --主题:区分业务
Replication:副本，数据保存多少份(保证数据不丢失) --副本:数据安全
Partition:分区，是一个物理的分区,一个分区就是一个文件,一个Topic可以有1~n个分区,每个分区都有自己的副本 --分区:并发读写
Consumer Group：消费者组，一个topic可以有多个消费者/组同时消费，多个消费者如果在一个消费者组中，那么他们不能重复消费数据 --消费者组:提高消费者消费速度、方便统一管理
注意：一个Topic可以被多个消费者或者组订阅，一个消费者/组也可以订阅多个主题
注意：读数据只能从Leader读， 写数据也只能往Leader写，Follower会从Leader那里同步数据过来做副本！！！

1.2 常用命令

代码语言：javascript复制

#启动kafka
/export/servers/kafka/bin/kafka-server-start.sh -daemon 
/export/servers/kafka/config/server.properties 

#停止kafka
/export/servers/kafka/bin/kafka-server-stop.sh 

#查看topic信息
/export/servers/kafka/bin/kafka-topics.sh --list --zookeeper node01:2181
 
#创建topic
/export/servers/kafka/bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 3 --partitions 3 --topic test

#查看某个topic信息
/export/servers/kafka/bin/kafka-topics.sh --describe --zookeeper node01:2181 --topic test
 
#删除topic
/export/servers/kafka/bin/kafka-topics.sh --zookeeper node01:2181 --delete --topic test

#启动生产者--控制台的生产者一般用于测试
/export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092 --topic spark_kafka
 
#启动消费者--控制台的消费者一般用于测试
/export/servers/kafka/bin/kafka-console-consumer.sh --zookeeper node01:2181 --topic spark_kafka--from-beginning
 
消费者连接到borker的地址
/export/servers/kafka/bin/kafka-console-consumer.sh --bootstrap-server node01:9092,node02:9092,node03:9092 --topic spark_kafka --from-beginning

2、整合Kafka两种模式说明

2.1 ★面试题：Receiver & Direct

开发中我们经常会利用SparkStreaming实时地读取kafka中的数据然后进行处理，在spark1.3版本后，kafkaUtils里面提供了两种创建DStream的方法:

代码语言：javascript复制

1.Receiver接收方式：

KafkaUtils.createDstream(开发中不用，了解即可，但是面试可能会问)
Receiver作为常驻的Task运行在Executor等待数据，但是一个Receiver效率低，需要开启多个，再手动合并数据(union)，再进行处理，很麻烦
Receiver哪台机器挂了，可能会丢失数据，所以需要开启WAL(预写日志)保证数据安全，那么效率又会降低!
Receiver方式是通过zookeeper来连接kafka队列，调用Kafka高阶API，offset存储在zookeeper，由Receiver维护，
spark在消费的时候为了保证数据不丢也会在Checkpoint中存一份offset，可能会出现数据不一致
所以不管从何种角度来说，Receiver模式都不适合在开发中使用了,已经淘汰了

2.Direct直连方式：

KafkaUtils.createDirectStream(开发中使用，要求掌握)
Direct方式是直接连接kafka分区来获取数据，从每个分区直接读取数据大大提高了并行能力

Direct方式调用Kafka低阶API(底层API)，offset自己存储和维护，默认由Spark维护在checkpoint中，消除了与zk不一致的情况
当然也可以自己手动维护，把offset存在mysql、redis中
所以基于Direct模式可以在开发中使用，且借助Direct模式的特点 手动操作可以保证数据的Exactly once 精准一次

2.2 总结：

代码语言：javascript复制

Receiver接收方式
1、 多个Receiver接受数据效率高，但有丢失数据的风险。
2、 开启日志（WAL）可防止数据丢失，但写两遍数据效率低。
3、 Zookeeper维护offset有重复消费数据可能。
4、 使用高层次的API
Direct直连方式
1、 不使用Receiver，直接到kafka分区中读取数据
2、 不使用日志（WAL）机制。
3、 Spark自己维护offset
4、 使用低层次的API

扩展：关于消息语义

注意:

代码语言：javascript复制

开发中SparkStreaming和kafka集成有两个版本：0.8及0.10 
0.8版本有Receiver和Direct模式(但是0.8版本生产环境问题较多，在Spark2.3之后不支持0.8版本了)
0.10以后只保留了direct模式(Reveiver模式不适合生产环境)，并且0.10版本API有变化(更加强大)

结论：

代码语言：javascript复制

我们学习和开发都直接使用0.10版本中的direct模式
但是关于Receiver和Direct的区别面试的时候要能够答得上来

3、spark-streaming-kafka-0-8(了解)

3.1 Receiver

代码语言：javascript复制

KafkaUtils.createDstream使用了receivers来接收数据，利用的是Kafka高层次的消费者api，偏移量由Receiver维护在zk中，对于所有的receivers接收到的数据将会保存在Spark executors中，然后通过Spark Streaming启动job来处理这些数据，默认会丢失，可启用WAL日志，它同步将接受到数据保存到分布式文件系统上比如HDFS。保证数据在出错的情况下可以恢复出来。尽管这种方式配合着WAL机制可以保证数据零丢失的高可靠性，但是启用了WAL效率会较低，且无法保证数据被处理一次且仅一次，可能会处理两次。因为Spark和ZooKeeper之间可能是不同步的。

官方现在已经不推荐这种整合方式

准备工作

代码语言：javascript复制

1.启动zookeeper集群
zkServer.sh start

2.启动kafka集群
kafka-server-start.sh  /export/servers/kafka/config/server.properties

3.创建topic
kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 1 --partitions 3 --topic spark_kafka

4.通过shell命令向topic发送消息
kafka-console-producer.sh --broker-list node01:9092 --topic  spark_kafka
hadoop spark sqoop hadoop spark hive hadoop

5.添加kafka的pom依赖
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
    <version>2.2.0</version>
</dependency>

API

通过receiver接收器获取kafka中topic数据，可以并行运行更多的接收器读取kafak topic中的数据，这里为3个

代码语言：javascript复制

val receiverDStream: immutable.IndexedSeq[ReceiverInputDStream[(String, String)]] = (1 to 3).map(x => {
  val stream: ReceiverInputDStream[(String, String)] = KafkaUtils.createStream(ssc, zkQuorum, groupId, topics)
  stream
})

如果启用了WAL(spark.streaming.receiver.writeAheadLog.enable=true)可以设置存储级别(默认StorageLevel.MEMORY_AND_DISK_SER_2)

代码演示

代码语言：javascript复制

package cn.itcast.streaming

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

import scala.collection.immutable

object SparkKafka {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    val config: SparkConf = 
new SparkConf().setAppName("SparkStream").setMaster("local[*]")
      .set("spark.streaming.receiver.writeAheadLog.enable", "true")
//开启WAL预写日志，保证数据源端可靠性
    val sc = new SparkContext(config)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))
    ssc.checkpoint("./kafka")
//==============================================
    //2.准备配置参数
    val zkQuorum = "node01:2181,node02:2181,node03:2181"
    val groupId = "spark"
    val topics = Map("spark_kafka" -> 2)//2表示每一个topic对应分区都采用2个线程去消费,
//ssc的rdd分区和kafka的topic分区不一样，增加消费线程数，并不增加spark的并行处理数据数量
    //3.通过receiver接收器获取kafka中topic数据，可以并行运行更多的接收器读取kafak topic中的数据，这里为3个
    val receiverDStream: immutable.IndexedSeq[ReceiverInputDStream[(String, String)]] = (1 to 3).map(x => {
      val stream: ReceiverInputDStream[(String, String)] = KafkaUtils.createStream(ssc, zkQuorum, groupId, topics)
      stream
    })
    //4.使用union方法，将所有receiver接受器产生的Dstream进行合并
    val allDStream: DStream[(String, String)] = ssc.union(receiverDStream)
    //5.获取topic的数据(String, String) 第1个String表示topic的名称，第2个String表示topic的数据
    val data: DStream[String] = allDStream.map(_._2)
//==============================================
    //6.WordCount
    val words: DStream[String] = data.flatMap(_.split(" "))
    val wordAndOne: DStream[(String, Int)] = words.map((_, 1))
    val result: DStream[(String, Int)] = wordAndOne.reduceByKey(_   _)
    result.print()
    ssc.start()
    ssc.awaitTermination()
  }
}

3.2 Direct

Direct方式会定期地从kafka的topic下对应的partition中查询最新的偏移量，再根据偏移量范围在每个batch里面处理数据，Spark通过调用kafka简单的消费者API读取一定范围的数据。

代码语言：javascript复制

Direct的缺点是无法使用基于zookeeper的kafka监控工具

Direct相比基于Receiver方式有几个优点
 1)简化并行
 不需要创建多个kafka输入流，然后union它们，sparkStreaming将会创建和kafka分区数一样的rdd的分区数，而且会从kafka中并行读取数据，spark中RDD的分区数和kafka中的分区数据是一一对应的关系。
 2)高效
 Receiver实现数据的零丢失是将数据预先保存在WAL中，会复制一遍数据，会导致数据被拷贝两次，第一次是被kafka复制，另一次是写到WAL中。而Direct不使用WAL消除了这个问题。
 3)恰好一次语义(Exactly-once-semantics)
 Receiver读取kafka数据是通过kafka高层次api把偏移量写入zookeeper中，虽然这种方法可以通过数据保存在WAL中保证数据不丢失，但是可能会因为sparkStreaming和ZK中保存的偏移量不一致而导致数据被消费了多次。
Direct的Exactly-once-semantics(EOS)通过实现kafka低层次api，偏移量仅仅被ssc保存在checkpoint中，消除了zk和ssc偏移量不一致的问题。
 4)API
KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)

代码演示

代码语言：javascript复制

package cn.itcast.streaming

import kafka.serializer.StringDecoder
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}


object SparkKafka2 {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    val config: SparkConf = 
new SparkConf().setAppName("SparkStream").setMaster("local[*]")
    val sc = new SparkContext(config)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))
    ssc.checkpoint("./kafka")
    //==============================================
    //2.准备配置参数
    val kafkaParams = Map("metadata.broker.list" -> "node01:9092,node02:9092,node03:9092", "group.id" -> "spark")
    val topics = Set("spark_kafka")
    val allDStream: InputDStream[(String, String)] = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)
    //3.获取topic的数据
    val data: DStream[String] = allDStream.map(_._2)
    //==============================================
    //WordCount
    val words: DStream[String] = data.flatMap(_.split(" "))
    val wordAndOne: DStream[(String, Int)] = words.map((_, 1))
    val result: DStream[(String, Int)] = wordAndOne.reduceByKey(_   _)
    result.print()
    ssc.start()
    ssc.awaitTermination()
  }
}

4、spark-streaming-kafka-0-10

说明

代码语言：javascript复制

spark-streaming-kafka-0-10版本中，API有一定的变化，操作更加灵活，开发中使用

pom.xml

代码语言：javascript复制

<!--<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
    <version>${spark.version}</version>
</dependency>-->
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
    <version>${spark.version}</version>
</dependency>

APIhttp://spark.apache.org/docs/latest/streaming-kafka-0-10-integration.html创建topic

代码语言：javascript复制

/export/servers/kafka/bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 3 --partitions 3 --topic spark_kafka

启动生产者

代码语言：javascript复制

/export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092,node01:9092,node01:9092 --topic spark_kafka

代码演示

代码语言：javascript复制

package cn.itcast.streaming

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

object SparkKafkaDemo {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)3
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中对数据进行切分形成一个RDD
    //准备连接Kafka的参数
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "node01:9092,node02:9092,node03:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "SparkKafkaDemo",
      //earliest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
      //latest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
      //none:topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
      //这里配置latest自动重置偏移量为最新的偏移量,即如果有偏移量从偏移量位置开始消费,没有偏移量从新来的数据开始消费
      "auto.offset.reset" -> "latest",
      //false表示关闭自动提交.由spark帮你提交到Checkpoint或程序员手动维护
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )
    val topics = Array("spark_kafka")
    //2.使用KafkaUtil连接Kafak获取数据
    val recordDStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](ssc,
      LocationStrategies.PreferConsistent,//位置策略,源码强烈推荐使用该策略,会让Spark的Executor和Kafka的Broker均匀对应
      ConsumerStrategies.Subscribe[String, String](topics, kafkaParams))//消费策略,源码强烈推荐使用该策略
    //3.获取VALUE数据
    val lineDStream: DStream[String] = recordDStream.map(_.value())//_指的是ConsumerRecord
    val wrodDStream: DStream[String] = lineDStream.flatMap(_.split(" ")) //_指的是发过来的value,即一行数据
    val wordAndOneDStream: DStream[(String, Int)] = wrodDStream.map((_,1))
    val result: DStream[(String, Int)] = wordAndOneDStream.reduceByKey(_ _)
    result.print()
    ssc.start()//开启
    ssc.awaitTermination()//等待优雅停止
  }
}

5、扩展：Kafka手动维护偏移量

APIhttp://spark.apache.org/docs/latest/streaming-kafka-0-10-integration.html

启动生产者

代码语言：javascript复制

/export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092,node01:9092,node01:9092 --topic spark_kafka

代码演示

代码语言：javascript复制

package cn.itcast.streaming

import java.sql.{DriverManager, ResultSet}

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.TopicPartition
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{OffsetRange, _}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.mutable

object SparkKafkaDemo2 {
  def main(args: Array[String]): Unit = {
    //1.创建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中对数据进行切分形成一个RDD
    //准备连接Kafka的参数
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "node01:9092,node02:9092,node03:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "SparkKafkaDemo",
      "auto.offset.reset" -> "latest",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )
    val topics = Array("spark_kafka")
    //2.使用KafkaUtil连接Kafak获取数据
    //注意:
    //如果MySQL中没有记录offset,则直接连接,从latest开始消费
    //如果MySQL中有记录offset,则应该从该offset处开始消费
    val offsetMap: mutable.Map[TopicPartition, Long] = OffsetUtil.getOffsetMap("SparkKafkaDemo","spark_kafka")
    val recordDStream: InputDStream[ConsumerRecord[String, String]] = if(offsetMap.size > 0){//有记录offset
      println("MySQL中记录了offset,则从该offset处开始消费")
      KafkaUtils.createDirectStream[String, String](ssc,
      LocationStrategies.PreferConsistent,//位置策略,源码强烈推荐使用该策略,会让Spark的Executor和Kafka的Broker均匀对应
      ConsumerStrategies.Subscribe[String, String](topics, kafkaParams,offsetMap))//消费策略,源码强烈推荐使用该策略
    }else{//没有记录offset
      println("没有记录offset,则直接连接,从latest开始消费")
      // /export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092 --topic  spark_kafka
      KafkaUtils.createDirectStream[String, String](ssc,
      LocationStrategies.PreferConsistent,//位置策略,源码强烈推荐使用该策略,会让Spark的Executor和Kafka的Broker均匀对应
      ConsumerStrategies.Subscribe[String, String](topics, kafkaParams))//消费策略,源码强烈推荐使用该策略
    }
    //3.操作数据
    //注意:我们的目标是要自己手动维护偏移量,也就意味着,消费了一小批数据就应该提交一次offset
    //而这一小批数据在DStream的表现形式就是RDD,所以我们需要对DStream中的RDD进行操作
    //而对DStream中的RDD进行操作的API有transform(转换)和foreachRDD(动作)
    recordDStream.foreachRDD(rdd=>{
      if(rdd.count() > 0){//当前这一时间批次有数据
        rdd.foreach(record => println("接收到的Kafk发送过来的数据为:"   record))
        //接收到的Kafk发送过来的数据为:ConsumerRecord(topic = spark_kafka, partition = 1, offset = 6, CreateTime = 1565400670211, checksum = 1551891492, serialized key size = -1, serialized value size = 43, key = null, value = hadoop spark ...)
        //注意:通过打印接收到的消息可以看到,里面有我们需要维护的offset,和要处理的数据
        //接下来可以对数据进行处理....或者使用transform返回和之前一样处理
        //处理数据的代码写完了,就该维护offset了,那么为了方便我们对offset的维护/管理,spark提供了一个类,帮我们封装offset的数据
        val offsetRanges: Array[OffsetRange] = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
        for (o <- offsetRanges){
          println(s"topic=${o.topic},partition=${o.partition},fromOffset=${o.fromOffset},untilOffset=${o.untilOffset}")
        }
        //手动提交offset,默认提交到Checkpoint中
        //recordDStream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
        //实际中偏移量可以提交到MySQL/Redis中
        OffsetUtil.saveOffsetRanges("SparkKafkaDemo",offsetRanges)
      }
    })

   /* val lineDStream: DStream[String] = recordDStream.map(_.value())//_指的是ConsumerRecord
    val wrodDStream: DStream[String] = lineDStream.flatMap(_.split(" ")) //_指的是发过来的value,即一行数据
    val wordAndOneDStream: DStream[(String, Int)] = wrodDStream.map((_,1))
    val result: DStream[(String, Int)] = wordAndOneDStream.reduceByKey(_ _)
    result.print()*/
    ssc.start()//开启
    ssc.awaitTermination()//等待优雅停止
  }

  /*
  手动维护offset的工具类
  首先在MySQL创建如下表
    CREATE TABLE `t_offset` (
      `topic` varchar(255) NOT NULL,
      `partition` int(11) NOT NULL,
      `groupid` varchar(255) NOT NULL,
      `offset` bigint(20) DEFAULT NULL,
      PRIMARY KEY (`topic`,`partition`,`groupid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   */
  object OffsetUtil {

    //从数据库读取偏移量
    def getOffsetMap(groupid: String, topic: String) = {
      val connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "root")
      val pstmt = connection.prepareStatement("select * from t_offset where groupid=? and topic=?")
      pstmt.setString(1, groupid)
      pstmt.setString(2, topic)
      val rs: ResultSet = pstmt.executeQuery()
      val offsetMap = mutable.Map[TopicPartition, Long]()
      while (rs.next()) {
        offsetMap  = new TopicPartition(rs.getString("topic"), rs.getInt("partition")) -> rs.getLong("offset")
      }
      rs.close()
      pstmt.close()
      connection.close()
      offsetMap
    }

    //将偏移量保存到数据库
    def saveOffsetRanges(groupid: String, offsetRange: Array[OffsetRange]) = {
      val connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "root")
      //replace into表示之前有就替换,没有就插入
      val pstmt = connection.prepareStatement("replace into t_offset (`topic`, `partition`, `groupid`, `offset`) values(?,?,?,?)")
      for (o <- offsetRange) {
        pstmt.setString(1, o.topic)
        pstmt.setInt(2, o.partition)
        pstmt.setString(3, groupid)
        pstmt.setLong(4, o.untilOffset)
        pstmt.executeUpdate()
      }
      pstmt.close()
      connection.close()
  
  }
}

九、Structured Streaming曲折发展史

1、Spark Streaming

代码语言：javascript复制

Spark Streaming针对实时数据流，提供了一套可扩展、高吞吐、可容错的流式计算模型。Spark Streaming接收实时数据源的数据，切分成很多小的batches，然后被Spark Engine执行，产出同样由很多小的batchs组成的结果流。本质上，这是一种micro-batch（微批处理）的方式处理

不足在于处理延时较高（无法优化到秒以下的数量级）， 无法支持基于event_time的时间窗口做聚合逻辑。

2、Structured Streaming

2.1 介绍

官网

http://spark.apache.org/docs/latest/structured-streaming-programming-guide.html

简介

代码语言：javascript复制

spark在2.0版本中发布了新的流计算的API，Structured Streaming/结构化流。
Structured Streaming是一个基于Spark SQL引擎的可扩展、容错的流处理引擎。统一了流、批的编程模型，可以使用静态数据批处理一样的方式来编写流式计算操作。并且支持基于event_time的时间窗口的处理逻辑。

随着数据不断地到达，Spark 引擎会以一种增量的方式来执行这些操作，并且持续更新结算结果。可以使用Scala、Java、Python或R中的DataSet／DataFrame API来表示流聚合、事件时间窗口、流到批连接等。此外，Structured Streaming会通过checkpoint和预写日志等机制来实现Exactly-Once语义。
简单来说，对于开发人员来说，根本不用去考虑是流式计算，还是批处理，只要使用同样的方式来编写计算操作即可，Structured Streaming提供了快速、可扩展、容错、端到端的一次性流处理，而用户无需考虑更多细节

默认情况下，结构化流式查询使用微批处理引擎进行处理，该引擎将数据流作为一系列小批处理作业进行处理，从而实现端到端的延迟，最短可达100毫秒，并且完全可以保证一次容错。自Spark 2.3以来，引入了一种新的低延迟处理模式，称为连续处理，它可以在至少一次保证的情况下实现低至1毫秒的端到端延迟。也就是类似于 Flink 那样的实时流，而不是小批量处理。实际开发可以根据应用程序要求选择处理模式，但是连续处理在使用的时候仍然有很多限制，目前大部分情况还是应该采用小批量模式。

2.2 API

1.Spark Streaming 时代 -DStream-RDD

代码语言：javascript复制

Spark Streaming 采用的数据抽象是DStream，而本质上就是时间上连续的RDD，
对数据流的操作就是针对RDD的操作

2.Structured Streaming 时代 - DataSet/DataFrame -RDD

代码语言：javascript复制

Structured Streaming是Spark2.0新增的可扩展和高容错性的实时计算框架，它构建于Spark SQL引擎，把流式计算也统一到DataFrame/Dataset里去了。
Structured Streaming 相比于 Spark Streaming 的进步就类似于 Dataset 相比于 RDD 的进步

2.3 主要优势

代码语言：javascript复制

1.简洁的模型。Structured Streaming 的模型很简洁，易于理解。用户可以直接把一个流想象成是无限增长的表格。

2.一致的 API。由于和 Spark SQL 共用大部分 API，对 Spaprk SQL 熟悉的用户很容易上手，代码也十分简洁。font color=red>同时批处理和流处理程序还可以共用代码，不需要开发两套不同的代码，显著提高了开发效率。

3.卓越的性能。Structured Streaming 在与 Spark SQL 共用 API 的同时，也直接使用了 Spark SQL 的 Catalyst 优化器和 Tungsten，数据处理性能十分出色。此外，Structured Streaming 还可以直接从未来 Spark SQL 的各种性能优化中受益。

4.多语言支持。Structured Streaming 直接支持目前 Spark SQL 支持的语言，包括 Scala，Java，Python，R 和 SQL。用户可以选择自己喜欢的语言进行开发。

2.4 编程模型

编程模型概述

代码语言：javascript复制

一个流的数据源从逻辑上来说就是一个不断增长的动态表格，随着时间的推移，新数据被持续不断地添加到表格的末尾。

对动态数据源进行实时查询，就是对当前的表格内容执行一次 SQL 查询。
数据查询，用户通过触发器（Trigger）设定时间(毫秒级)。也可以设定执行周期。

一个流的输出有多种模式，既可以是基于整个输入执行查询后的完整结果，也可以选择只输出与上次查询相比的差异，或者就是简单地追加最新的结果。

这个模型对于熟悉 SQL 的用户来说很容易掌握，对流的查询跟查询一个表格几乎完全一样，十分简洁，易于理解。

核心思想

代码语言：javascript复制

Structured Streaming最核心的思想就是将实时到达的数据不断追加到unbound table无界表，到达流的每个数据项(RDD)就像是表中的一个新行被附加到无边界的表中.这样用户就可以用静态结构化数据的批处理查询方式进行流计算，如可以使用SQL对到来的每一行数据进行实时查询处理；(SparkSQL SparkStreaming=StructuredStreaming)

应用场景

代码语言：javascript复制

Structured Streaming将数据源映射为类似于关系数据库中的表，然后将经过计算得到的结果映射为另一张表，完全以结构化的方式去操作流式数据，这种编程模型非常有利于处理分析结构化的实时数据；

WordCount图解

如图所示

代码语言：javascript复制

第一行表示从socket不断接收数据，
第二行可以看成是之前提到的“unbound table"，
第三行为最终的wordCounts是结果集。
当有新的数据到达时，Spark会执行“增量"查询，并更新结果集；
该示例设置为Complete Mode（输出所有数据），因此每次都将所有数据输出到控制台；

1.在第1秒时，此时到达的数据为"cat dog"和"dog dog"，因此我们可以得到第1秒时的结果集cat=1 dog=3，并输出到控制台；

2.当第2秒时，到达的数据为"owl cat"，此时"unbound table"增加了一行数据"owl cat"，执行word count查询并更新结果集，可得第2秒时的结果集为cat=2 dog=3 owl=1，并输出到控制台；

3.当第3秒时，到达的数据为"dog"和"owl"，此时"unbound table"增加两行数据"dog"和"owl"，执行word count查询并更新结果集，可得第3秒时的结果集为cat=2 dog=4 owl=2；

这种模型跟其他很多流式计算引擎都不同。大多数流式计算引擎都需要开发人员自己来维护新数据与历史数据的整合并进行聚合操作。
然后我们就需要自己去考虑和实现容错机制、数据一致性的语义等。
然而在structured streaming的这种模式下，spark会负责将新到达的数据与历史数据进行整合，并完成正确的计算操作，同时更新result table，不需要我们去考虑这些事情。

十、Structured Streaming实战

1、创建Source

代码语言：javascript复制

spark 2.0中初步提供了一些内置的source支持。

Socket source (for testing): 从socket连接中读取文本内容。
File source: 以数据流的方式读取一个目录中的文件。支持text、csv、json、parquet等文件类型。
Kafka source: 从Kafka中拉取数据,与0.10或以上的版本兼容，后面单独整合Kafka。

2、读取Socket数据

准备工作

代码语言：javascript复制

nc -lk 9999
hadoop spark sqoop hadoop spark hive hadoop

代码演示

代码语言：javascript复制

package cn.itcast.structedstreaming

import org.apache.spark.SparkContext
import org.apache.spark.sql.streaming.Trigger
import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession}

object WordCount {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession,因为StructuredStreaming的数据模型也是DataFrame/DataSet
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.接收数据
    val dataDF: DataFrame = spark.readStream
      .option("host", "node01")
      .option("port", 9999)
      .format("socket")
      .load()
    //3.处理数据
    import spark.implicits._
    val dataDS: Dataset[String] = dataDF.as[String]
    val wordDS: Dataset[String] = dataDS.flatMap(_.split(" "))
    val result: Dataset[Row] = wordDS.groupBy("value").count().sort($"count".desc)
    //result.show()
    //Queries with streaming sources must be executed with writeStream.start();
    result.writeStream
      .format("console")//往控制台写
      .outputMode("complete")//每次将所有的数据写出
      .trigger(Trigger.ProcessingTime(0))//触发时间间隔,0表示尽可能的快
      //.option("checkpointLocation","./ckp")//设置checkpoint目录,socket不支持数据恢复,所以第二次启动会报错,需要注掉
      .start()//开启
      .awaitTermination()//等待停止
  }
}

3、读取目录下文本数据

代码语言：javascript复制

spark应用可以监听某一个目录，而web服务在这个目录上实时产生日志文件，这样对于spark应用来说，日志文件就是实时数据
Structured Streaming支持的文件类型有text，csv，json，parquet

准备工作

代码语言：javascript复制

在people.json文件输入如下数据:
{"name":"json","age":23,"hobby":"running"}
{"name":"charles","age":32,"hobby":"basketball"}
{"name":"tom","age":28,"hobby":"football"}
{"name":"lili","age":24,"hobby":"running"}
{"name":"bob","age":20,"hobby":"swimming"}
注意:文件必须是被移动到目录中的，且文件名不能有特殊字符

需求

代码语言：javascript复制

使用Structured Streaming统计年龄小于25岁的人群的爱好排行榜

代码演示

代码语言：javascript复制

package cn.itcast.structedstreaming

import org.apache.spark.SparkContext import org.apache.spark.sql.streaming.Trigger import org.apache.spark.sql.types.StructType import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession} /**

代码语言：javascript复制

  * {"name":"json","age":23,"hobby":"running"}
  * {"name":"charles","age":32,"hobby":"basketball"}
  * {"name":"tom","age":28,"hobby":"football"}
  * {"name":"lili","age":24,"hobby":"running"}
  * {"name":"bob","age":20,"hobby":"swimming"}
  * 统计年龄小于25岁的人群的爱好排行榜
    */
    object WordCount2 {
      def main(args: Array[String]): Unit = {
    //1.创建SparkSession,因为StructuredStreaming的数据模型也是DataFrame/DataSet
    val spark: SparkSession = 
    SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    val Schema: StructType = new StructType()
      .add("name","string")
      .add("age","integer")
      .add("hobby","string")
    //2.接收数据
  import spark.implicits._
    // Schema must be specified when creating a streaming source DataFrame.
    val dataDF: DataFrame = 
    spark.readStream.schema(Schema).json("D:\data\spark\data")
    //3.处理数据
    val result: Dataset[Row] =
     dataDF.filter($"age" < 25).groupBy("hobby").count().sort($"count".desc)
    //4.输出结果
    result.writeStream
      .format("console")
      .outputMode("complete")
      .trigger(Trigger.ProcessingTime(0))
      .start()
      .awaitTermination()
      }
    }
```

4、计算操作

代码语言：javascript复制

获得到Source之后的基本数据处理方式和之前学习的DataFrame、DataSet一致，不再赘述

5、输出

代码语言：javascript复制

计算结果可以选择输出到多种设备并进行如下设定
1.output mode：以哪种方式将result table的数据写入sink
2.format/output sink的一些细节：数据格式、位置等。
3.query name：指定查询的标识。类似tempview的名字
4.trigger interval：触发间隔，如果不指定，默认会尽可能快速地处理数据
5.checkpoint地址：一般是hdfs上的目录。注意：Socket不支持数据恢复，如果设置了，第二次启动会报错 ,Kafka支持

6、output mode

代码语言：javascript复制

每当结果表更新时，我们都希望将更改后的结果行写入外部接收器。

这里有三种输出模型:
1.Append mode:输出新增的行，默认模式。每次更新结果集时，只将新添加到结果集的结果行输出到接收器。仅支持添加到结果表中的行永远不会更改的查询。因此，此模式保证每行仅输出一次。例如，仅查询select，where，map，flatMap，filter，join等会支持追加模式。不支持聚合

2.Complete mode: 所有内容都输出，每次触发后，整个结果表将输出到接收器。聚合查询支持此功能。仅适用于包含聚合操作的查询。

3.Update mode: 输出更新的行，每次更新结果集时，仅将被更新的结果行输出到接收器(自Spark 2.1.1起可用)，不支持排序。

7、output sink

使用说明

File sink 输出到路径支持parquet文件,以及append模式

代码语言：javascript复制

writeStream
    .format("parquet")        // can be "orc", "json", "csv", etc.
    .option("path", "path/to/destination/dir")
    .start()

Kafka sink 输出到kafka内的一到多个topic

代码语言：javascript复制

writeStream
    .format("kafka")
    .option("kafka.bootstrap.servers", "host1:port1,host2:port2")
    .option("topic", "updates")
    .start()

Foreach sink 对输出中的记录运行任意计算。

代码语言：javascript复制

writeStream
    .foreach(...)
    .start()

Console sink (for debugging) 当有触发器时，将输出打印到控制台。

代码语言：javascript复制

writeStream
    .format("console")
    .start()

Memory sink (for debugging) - 输出作为内存表存储在内存中

代码语言：javascript复制

writeStream
    .format("memory")
    .queryName("tableName")
    .start()

官网示例代码

代码语言：javascript复制

// ========== DF with no aggregations ==========

val noAggDF = deviceDataDf.select("device").where("signal > 10")   

// Print new data to console

noAggDF.writeStream.format("console").start()

// Write new data to Parquet files

noAggDF.writeStream.format("parquet").option("checkpointLocation", 
"path/to/checkpoint/dir").option("path", "path/to/destination/dir").start()



// ========== DF with aggregation ==========

val aggDF = df.groupBy("device").count()

// Print updated aggregations to console

aggDF.writeStream.outputMode("complete").format("console").start()

// Have all the aggregates in an in-memory table

aggDF.writeStream.queryName("aggregates").outputMode("complete").format("memory").start()

spark.sql("select * from aggregates").show()   

// interactively query in-memory table

十一、StructuredStreaming与其他技术整合

1、整合Kafka

1.1 官网介绍

http://spark.apache.org/docs/latest/structured-streaming-kafka-integration.html

Creating a Kafka Source for Streaming Queries

代码语言：javascript复制

// Subscribe to 1 topic
val df = spark
  .readStream
  .format("kafka")
  .option("kafka.bootstrap.servers", "host1:port1,host2:port2")
  .option("subscribe", "topic1")
  .load()
df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)")
  .as[(String, String)]
// Subscribe to multiple topics(多个topic)
val df = spark
  .readStream
  .format("kafka")
  .option("kafka.bootstrap.servers", "host1:port1,host2:port2")
  .option("subscribe", "topic1,topic2")
  .load()
df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)")
  .as[(String, String)]
// Subscribe to a pattern（订阅通配符topic）
val df = spark
  .readStream
  .format("kafka")
  .option("kafka.bootstrap.servers", "host1:port1,host2:port2")
  .option("subscribePattern", "topic.*")
  .load()
df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)")
  .as[(String, String)]

Creating a Kafka Source for Batch Queries（kafka批处理查询）

代码语言：javascript复制

// Subscribe to 1 topic 
//defaults to the earliest and latest offsets(默认为最早和最新偏移)
val df = spark
  .read
  .format("kafka")
  .option("kafka.bootstrap.servers", "host1:port1,host2:port2")
  .option("subscribe", "topic1")
  .load()df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)")
  .as[(String, String)]
// Subscribe to multiple topics, (多个topic)
//specifying explicit Kafka offsets(指定明确的偏移量)
val df = spark
  .read
  .format("kafka")
  .option("kafka.bootstrap.servers", "host1:port1,host2:port2")
  .option("subscribe", "topic1,topic2")
  .option("startingOffsets", """{"topic1":{"0":23,"1":-2},"topic2":{"0":-2}}""")
  .option("endingOffsets", """{"topic1":{"0":50,"1":-1},"topic2":{"0":-1}}""")
  .load()df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)")
  .as[(String, String)]
// Subscribe to a pattern, (订阅通配符topic)at the earliest and latest offsets
val df = spark
  .read
  .format("kafka")
  .option("kafka.bootstrap.servers", "host1:port1,host2:port2")
  .option("subscribePattern", "topic.*")
  .option("startingOffsets", "earliest")
  .option("endingOffsets", "latest")
  .load()df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)")
  .as[(String, String)]

注意：读取后的数据的Schema是固定的，包含的列如下：

注意：下面的参数是不能被设置的，否则kafka会抛出异常：

代码语言：javascript复制

group.id:kafka的source会在每次query的时候自定创建唯一的group id。

auto.offset.reset :为了避免每次手动设置startingoffsets的值，structured streaming在内部消费时会自动管理offset。这样就能保证订阅动态的topic时不会丢失数据。startingOffsets在流处理时，只会作用于第一次启动时，之后的处理都会自动的读取保存的offset。

key.deserializer，value.deserializer，key.serializer，value.serializer 序列化与反序列化，都ByteArraySerializer。

enable.auto.commit:Kafka源不支持提交任何偏移量。

1.2 整合环境准备

启动kafka

代码语言：javascript复制

/export/servers/kafka/bin/kafka-server-start.sh -daemon 
/export/servers/kafka/config/server.properties

向topic中生产数据

代码语言：javascript复制

/export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092 --topic  spark_kafka

代码实现

代码语言：javascript复制

package cn.itcast.structedstreaming

import org.apache.spark.SparkContext
import org.apache.spark.sql.streaming.Trigger
import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession}

object KafkaStructuredStreamingDemo {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = 
SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    import spark.implicits._
    //2.连接Kafka消费数据
    val dataDF: DataFrame = spark.readStream
      .format("kafka")
      .option("kafka.bootstrap.servers", "node01:9092")
      .option("subscribe", "spark_kafka")
      .load()
    //3.处理数据
    //注意:StructuredStreaming整合Kafka获取到的数据都是字节类型,所以需要按照官网要求,
//转成自己的实际类型
    val dataDS: Dataset[String] = dataDF.selectExpr("CAST(value AS STRING)").as[String]
    val wordDS: Dataset[String] = dataDS.flatMap(_.split(" "))
    val result: Dataset[Row] = wordDS.groupBy("value").count().sort($"count".desc)
    result.writeStream
      .format("console")
      .outputMode("complete")
      .trigger(Trigger.ProcessingTime(0))
      .option("truncate",false)//超过长度的列不截断显示,即完全显示
      .start()
      .awaitTermination()
  }
}

2、整合MySQL

2.1 简介

需求

代码语言：javascript复制

我们开发中经常需要将流的运算结果输出到外部数据库，例如MySQL中，但是比较遗憾Structured Streaming API不支持外部数据库作为接收器

如果将来加入支持的话，它的API将会非常的简单比如：
format(“jdbc”).option(“url”,“jdbc:mysql://…”).start()
但是目前我们只能自己自定义一个JdbcSink，继承ForeachWriter并实现其方法

参考网站

https://databricks.com/blog/2017/04/04/real-time-end-to-end-integration-with-apache-kafka-in-apache-sparks-structured-streaming.html

2.2 代码演示

代码语言：javascript复制

package cn.itcast.structedstreaming

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

import org.apache.spark.SparkContext
import org.apache.spark.sql._
import org.apache.spark.sql.streaming.Trigger


object JDBCSinkDemo {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = 
SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    import spark.implicits._
    //2.连接Kafka消费数据
    val dataDF: DataFrame = spark.readStream
      .format("kafka")
      .option("kafka.bootstrap.servers", "node01:9092")
      .option("subscribe", "spark_kafka")
      .load()
    //3.处理数据
    //注意:StructuredStreaming整合Kafka获取到的数据都是字节类型,所以需要按照官网要求,转成自己的实际类型
    val dataDS: Dataset[String] = dataDF.selectExpr("CAST(value AS STRING)").as[String]
    val wordDS: Dataset[String] = dataDS.flatMap(_.split(" "))
    val result: Dataset[Row] = wordDS.groupBy("value").count().sort($"count".desc)
    val writer = new JDBCSink("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "root")
    result.writeStream
      .foreach(writer)
      .outputMode("complete")
      .trigger(Trigger.ProcessingTime(0))
      .start()
      .awaitTermination()
  }

  class JDBCSink(url:String,username:String,password:String) extends ForeachWriter[Row] with Serializable{
    var connection:Connection = _ //_表示占位符,后面会给变量赋值
    var preparedStatement: PreparedStatement = _
    //开启连接
    override def open(partitionId: Long, version: Long): Boolean = {
      connection = DriverManager.getConnection(url, username, password)
      true
    }

    /*
    CREATE TABLE `t_word` (
        `id` int(11) NOT NULL AUTO_INCREMENT,
        `word` varchar(255) NOT NULL,
        `count` int(11) DEFAULT NULL,
        PRIMARY KEY (`id`),
        UNIQUE KEY `word` (`word`)
      ) ENGINE=InnoDB AUTO_INCREMENT=26 DEFAULT CHARSET=utf8;
     */
    //replace INTO `bigdata`.`t_word` (`id`, `word`, `count`) VALUES (NULL, NULL, NULL);
    //处理数据--存到MySQL
    override def process(row: Row): Unit = {
      val word: String = row.get(0).toString
      val count: String = row.get(1).toString
      println(word ":" count)
      //REPLACE INTO:表示如果表中没有数据这插入,如果有数据则替换
      //注意:REPLACE INTO要求表有主键或唯一索引
      val sql = "REPLACE INTO `t_word` (`id`, `word`, `count`) VALUES (NULL, ?, ?);"
      preparedStatement = connection.prepareStatement(sql)
      preparedStatement.setString(1,word)
      preparedStatement.setInt(2,Integer.parseInt(count))
      preparedStatement.executeUpdate()
    }
    
    //关闭资源
    override def close(errorOrNull: Throwable): Unit = {
      if (connection != null){
        connection.close()
      }
      if(preparedStatement != null){
        preparedStatement.close()
      }
    }

  }
}

spark sql 数据库云数据库SQLServer c语言

0 人点赞