Spark Core

Spark Core

第1章 Spark 概述

Learn Roadmap：https://www.bilibili.com/video/BV11A411L7CK

环境：

• spark3.0.0-bin-hadoop3.2.0.tgz
• scala 2.12.10
• hadoop-3.1.3.tar.gz
• hbase-2.0.5-bin.tar.gz
• zookeeper-3.5.7-bin.tar.gz
• flume-1.9.0-bin.tar.gz
• hive-3.1.2-bin.tar.gz
• phoenix-5.0.0-HBase-2.0-bin.tar.gz
• jdk-8u212-linux-x64.tar.gz

1.1 Spark 是什么

Spark 是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。

1.2 Spark and Hadoop

首先从时间节点上来看:

• Hadoop

  • 2006 年 1 月，Doug Cutting 加入 Yahoo，领导 Hadoop 的开发
  • 2008 年 1 月，Hadoop 成为 Apache 顶级项目
  • 2011 年 1.0 正式发布
  • 2012 年 3 月稳定版发布
  • 2013 年 10 月发布 2.X (Yarn)版本

• Spark

  • 2009 年，Spark 诞生于伯克利大学的 AMPLab 实验室
  • 2010 年，伯克利大学正式开源了 Spark 项目
  • 2013 年 6 月，Spark 成为了 Apache 基金会下的项目
  • 2014 年 2 月，Spark 以飞快的速度成为了 Apache 的顶级项目
  • 2015 年至今，Spark 变得愈发火爆，大量的国内公司开始重点部署或者使用 Spark

然后我们再从功能上来看:

• Hadoop

  • Hadoop 是由 java 语言编写的，在分布式服务器集群上存储海量数据并运行分布式分析应用的开源框架
  • 作为 Hadoop 分布式文件系统，HDFS 处于 Hadoop 生态圈的最下层，存储着所有的数据 ， 支持着 Hadoop 的所有服务 。 它的 理论基础 源于 Google 的 TheGoogleFileSystem 这篇论文，它是 GFS 的开源实现。
  • MapReduce 是一种编程模型，Hadoop 根据 Google 的 MapReduce 论文将其实现，作为 Hadoop 的分布式计算模型，是 Hadoop 的核心。基于这个框架，分布式并行程序的编写变得异常简单。综合了 HDFS 的分布式存储和 MapReduce 的分布式计算，Hadoop 在处理海量数据时，性能横向扩展变得非常容易。
  • HBase 是对 Google 的 Bigtable 的开源实现，但又和 Bigtable 存在许多不同之处。HBase 是一个基于 HDFS 的分布式数据库，擅长实时地随机读/写超大规模数据集。它也是 Hadoop 非常重要的组件。

• Spark

  • Spark 是一种由 Scala 语言开发的快速、通用、可扩展的大数据分析引擎
  • Spark Core 中提供了 Spark 最基础与最核心的功能
  • Spark SQL 是 Spark 用来操作结构化数据的组件。通过 Spark SQL，用户可以使用SQL 或者 Apache Hive 版本的 SQL 方言（HQL）来查询数据。
  • Spark Streaming 是 Spark 平台上针对实时数据进行流式计算的组件，提供了丰富的处理数据流的 API。

  由上面的信息可以获知，Spark 出现的时间相对较晚，并且主要功能主要是用于数据计算，所以其实 Spark 一直被认为是 Hadoop 框架的升级版

1.3 Spark or Hadoop

Hadoop 的 MR 框架和 Spark 框架都是数据处理框架，那么我们在使用时如何选择呢？

• Hadoop MapReduce 由于其设计初衷并不是为了满足循环迭代式数据流处理，因此在多并行运行的数据可复用场景（如：机器学习、图挖掘算法、交互式数据挖掘算法）中存在诸多计算效率等问题。所以 Spark 应运而生，Spark 就是在传统的 MapReduce 计算框架的基础上，利用其计算过程的优化，从而大大加快了数据分析、挖掘的运行和读写速度，并将计算单元缩小到更适合并行计算和重复使用的 RDD 计算模型。

• 机器学习中 ALS、凸优化梯度下降等。这些都需要基于数据集或者数据集的衍生数据反复查询反复操作。MR 这种模式不太合适，即使多 MR 串行处理，性能和时间也是一个问题。数据的共享依赖于磁盘。另外一种是交互式数据挖掘，MR 显然不擅长。而Spark 所基于的 scala 语言恰恰擅长函数的处理。

• Spark 是一个分布式数据快速分析项目。它的核心技术是弹性分布式数据集（Resilient Distributed Datasets），提供了比 MapReduce 丰富的模型，可以快速在内存中对数据集进行多次迭代，来支持复杂的数据挖掘算法和图形计算算法。

• Spark 和Hadoop 的根本差异是多个作业之间的数据通信问题 : Spark 多个作业之间数据通信是基于内存，而 Hadoop 是基于磁盘。

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

• Spark 只有在 shuffle 的时候将数据写入磁盘，而 Hadoop 中多个 MR 作业之间的数据交互都要依赖于磁盘交互。

• Spark 的缓存机制比 HDFS 的缓存机制高效。

经过上面的比较，我们可以看出在绝大多数的数据计算场景中，Spark 确实会比 MapReduce更有优势。但是 Spark 是基于内存的，所以在实际的生产环境中，由于内存的限制，可能会由于内存资源不够导致 Job 执行失败，此时，MapReduce 其实是一个更好的选择，所以 Spark并不能完全替代 MR。

1.4 Spark 核心模块

• Spark Core
  Spark Core 中提供了 Spark 最基础与最核心的功能，Spark 其他的功能如：Spark SQL，Spark Streaming，GraphX, MLlib 都是在 Spark Core 的基础上进行扩展的
• Spark SQL
  Spark SQL 是 Spark 用来操作结构化数据的组件。通过 Spark SQL，用户可以使用 SQL或者 Apache Hive 版本的 SQL 方言（HQL）来查询数据。
• Spark Streaming
  Spark Streaming 是 Spark 平台上针对实时数据进行流式计算的组件，提供了丰富的处理数据流的 API。
• Spark MLlib
  MLlib 是 Spark 提供的一个机器学习算法库。MLlib 不仅提供了模型评估、数据导入等额外的功能，还提供了一些更底层的机器学习原语。
• Spark GraphX
  GraphX 是 Spark 面向图计算提供的框架与算法库。

第2章 Spark 快速上手

2.1 创建 Maven 项目

2.1.1 增加 Scala 插件

​ Spark 由 Scala 语言开发的，所以本课件接下来的开发所使用的语言也为 Scala，当前使用的 Spark 版本为 3.0.0，默认采用的 Scala 编译版本为 2.12.10，所以后续开发时。我们依然采用这个版本。开发前请保证 IDEA 开发工具中含有 Scala 开发插件

2.1.2 增加依赖关系

修改 Maven 项目中的 POM 文件，增加 Spark 框架的依赖关系。本课件基于 Spark3.0 版本，使用时请注意对应版本。

<properties>
	<maven.compiler.source>1.8</maven.compiler.source>
	<maven.compiler.target>1.8</maven.compiler.target>
	<encoding>UTF-8</encoding>
	<scala.version>2.12.10</scala.version>
	<scala.compat.version>2.12</scala.compat.version>
	<!--<hadoop.version>3.1.3</hadoop.version>-->
	<spark.version>3.0.0</spark.version>
</properties>

<dependencies>
	<dependency>
		<groupId>org.scala-lang</groupId>
		<artifactId>scala-library</artifactId>
		<version>${scala.version}</version>
	</dependency>

	<!--        <dependency>-->
	<!--            <groupId>org.apache.hadoop</groupId>-->
	<!--            <artifactId>hadoop-common</artifactId>-->
	<!--            <version>3.1.3</version>-->
	<!--        </dependency>-->

	<!--        <dependency>-->
	<!--            <groupId>org.apache.hadoop</groupId>-->
	<!--            <artifactId>hadoop-client</artifactId>-->
	<!--            <version>3.1.3</version>-->
	<!--        </dependency>-->

	<!--        <dependency>-->
	<!--            <groupId>org.apache.hadoop</groupId>-->
	<!--            <artifactId>hadoop-hdfs</artifactId>-->
	<!--            <version>3.1.3</version>-->
	<!--        </dependency>-->

	<!--        <dependency>-->
	<!--            <groupId>org.apache.hbase</groupId>-->
	<!--            <artifactId>hbase-client</artifactId>-->
	<!--            <version>2.0.3</version>-->
	<!--        </dependency>-->

	<!--        <dependency>-->
	<!--            <groupId>org.apache.hbase</groupId>-->
	<!--            <artifactId>hbase-server</artifactId>-->
	<!--            <version>2.0.3</version>-->
	<!--        </dependency>-->

	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-yarn_2.12</artifactId>
		<version>${spark.version}</version>
	</dependency>

	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-core_2.12</artifactId>
		<version>${spark.version}</version>
	</dependency>

	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-sql_2.12</artifactId>
		<version>${spark.version}</version>
	</dependency>

	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-hive_2.12</artifactId>
		<version>${spark.version}</version>
	</dependency>

	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-hive-thriftserver_2.12</artifactId>
		<version>${spark.version}</version>
	</dependency>

	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-streaming_2.12</artifactId>
		<version>${spark.version}</version>
	</dependency>

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

	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-sql-kafka-0-10_2.12</artifactId>
		<version>${spark.version}</version>
	</dependency>

	<dependency>
		<groupId>com.typesafe</groupId>
		<artifactId>config</artifactId>
		<version>1.3.3</version>
	</dependency>

	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.46</version>
	</dependency>

	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>fastjson</artifactId>
		<version>1.2.44</version>
	</dependency>
</dependencies>

<build>
	<sourceDirectory>src/main/scala</sourceDirectory>
	<testSourceDirectory>src/test/scala</testSourceDirectory>

	<plugins>
		<!-- 指定编译java的插件 -->
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.5.1</version>
		</plugin>

		<!-- 指定编译scala的插件 -->
		<plugin>
			<groupId>net.alchim31.maven</groupId>
			<artifactId>scala-maven-plugin</artifactId>
			<version>3.2.2</version>
			<executions>
				<execution>
					<goals>
						<goal>compile</goal>
						<goal>testCompile</goal>
					</goals>
					<configuration>
						<args>
							<arg>-dependencyfile</arg>
							<arg>${project.build.directory}/.scala_dependencies</arg>
						</args>
					</configuration>
				</execution>
			</executions>
		</plugin>

		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-surefire-plugin</artifactId>
			<version>2.18.1</version>
			<configuration>
				<useFile>false</useFile>
				<disableXmlReport>true</disableXmlReport>
				<includes>
					<include>**/*Test.*</include>
					<include>**/*Suite.*</include>
				</includes>
			</configuration>
		</plugin>

		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-shade-plugin</artifactId>
			<version>2.3</version>
			<executions>
				<execution>
					<phase>package</phase>
					<goals>
						<goal>shade</goal>
					</goals>
					<configuration>
						<filters>
							<filter>
								<artifact>*:*</artifact>
								<excludes>
									<exclude>META-INF/*.SF</exclude>
									<exclude>META-INF/*.DSA</exclude>
									<exclude>META-INF/*.RSA</exclude>
								</excludes>
							</filter>
						</filters>
						<transformers>
							<transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
								<mainClass/>
							</transformer>
						</transformers>
					</configuration>
				</execution>
			</executions>
		</plugin>
	</plugins>
</build>

2.1.3 WordCount

Spark 框架入门案例 WordCount

// 创建 Spark 运行配置对象
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")
// 创建 Spark 上下文环境对象（连接对象）
val sc : SparkContext = new SparkContext(sparkConf)
// 读取文件数据
val fileRDD: RDD[String] = sc.textFile("input/word.txt")
// 将文件中的数据进行分词
val wordRDD: RDD[String] = fileRDD.flatMap( _.split(" ") )
// 转换数据结构 word => (word, 1)
val word2OneRDD: RDD[(String, Int)] = wordRDD.map((_,1))
// 将转换结构后的数据按照相同的单词进行分组聚合
val word2CountRDD: RDD[(String, Int)] = word2OneRDD.reduceByKey(_+_)
// 将数据聚合结果采集到内存中
val word2Count: Array[(String, Int)] = word2CountRDD.collect()
// 打印结果
word2Count.foreach(println)
//关闭 Spark 连接
sc.stop()

执行过程中，会产生大量的执行日志，如果为了能够更好的查看程序的执行结果，可以在项目的 resources 目录中创建 log4j.properties 文件，并添加日志配置信息：

log4j.rootCategory=ERROR, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n
# Set the default spark-shell log level to ERROR. When running the spark-shell, the
# log level for this class is used to overwrite the root logger's log level, so that
# the user can have different defaults for the shell and regular Spark apps.
log4j.logger.org.apache.spark.repl.Main=ERROR
# Settings to quiet third party logs that are too verbose
log4j.logger.org.spark_project.jetty=ERROR
log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=ERROR
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=ERROR
log4j.logger.org.apache.parquet=ERROR
log4j.logger.parquet=ERROR
# SPARK-9183: Settings to avoid annoying messages when looking up nonexistent 
UDFs in SparkSQL with Hive support
log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=FATAL
log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR

第3章 Spark 运行环境

​ Spark 作为一个数据处理框架和计算引擎，被设计在所有常见的集群环境中运行, 在国内工作中主流的环境为 Yarn，不过逐渐容器式环境也慢慢流行起来。接下来，我们就分别看看不同环境下 Spark 的运行
在这里插入图片描述

3.1 Local 模式

​ Local 模式就是不需要其他任何节点资源就可以在本地执行 Spark 代码的环境，一般用于教学，调试，演示等，在 IDEA 中运行代码的环境我们称之为开发环境，不太一样。

3.1.1 解压缩文件

​ 将 spark-3.0.0-bin-hadoop3.2.tgz 文件上传到 Linux 并解压缩，放置在指定位置，路径中不要包含中文或空格，课件后续如果涉及到解压缩操作，不再强调。

tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
cd /opt/module 
mv spark-3.0.0-bin-hadoop3.2 spark-local

3.1.2 启动 Local 环境

1. 进入解压缩后的路径，执行如下指令

bin/spark-shell

2. 启动成功后，可以输入网址进行 Web UI 监控页面访问

http://服务器地址:4040

3.1.3 命令行工具

在解压缩文件夹下的 data 目录中，添加 word.txt 文件。在命令行工具中执行如下代码指令（和 IDEA 中代码简化版一致）

sc.textFile("data/word.txt").flatMap(.split(" ")).map((,1)).reduceByKey(+).collect

3.1.4 退出本地模式

按键 Ctrl+C 或输入 Scala 指令 :quit

3.1.5 提交应用

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master local[2] \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

1. --class 表示要执行程序的主类，此处可以更换为咱们自己写的应用程序
2. --master local[2] 部署模式，默认为本地模式，数字表示分配的虚拟 CPU 核数量
3. spark-examples_2.12-3.0.0.jar 运行的应用类所在的 jar 包，实际使用时，可以设定为自己打的 jar 包
4. 数字 10 表示程序的入口参数，用于设定当前应用的任务数量

3.2 Standalone 模式

​ local 本地模式毕竟只是用来进行练习演示的，真实工作中还是要将应用提交到对应的集群中去执行，这里我们来看看只使用 Spark 自身节点运行的集群模式，也就是我们所谓的独立部署（Standalone）模式。Spark 的 Standalone 模式体现了经典的 master-slave 模式。

集群规划：

主机名	Spark组件
Linux1	Worker、Master
Linux2	Worker
Linux3	Worker

3.2.1 解压缩文件

将 spark-3.0.0-bin-hadoop3.2.tgz 文件上传到 Linux 并解压缩在指定位置

tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
cd /opt/module 
mv spark-3.0.0-bin-hadoop3.2 spark-standalone

3.2.2 修改配置文件

1. 进入解压缩后路径的 conf 目录，修改 slaves.template 文件名为 slaves

mv slaves.template slaves

2. 修改 slaves 文件，添加 work 节点

linux1
linux2
linux3

3. 修改 spark-env.sh.template 文件名为 spark-env.sh

mv spark-env.sh.template spark-env.sh

4. 修改 spark-env.sh 文件，添加 JAVA_HOME 环境变量和集群对应的 master 节点

export JAVA_HOME=/opt/module/jdk1.8.0_144
SPARK_MASTER_HOST=linux1
SPARK_MASTER_PORT=7077

5. 分发 spark-standalone 目录

xsync spark-standalone

3.2.3 启动集群

1. 执行脚本命令：

sbin/start-all.sh

2. 查看三台服务器运行进程

================linux1================
3330 Jps
3238 Worker
3163 Master
================linux2================
2966 Jps
2908 Worker
================linux3================
2978 Worker
3036 Jps

3. 查看 Master 资源监控 Web UI 界面: http://linux1:8080

3.2.4 提交应用

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://linux1:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

1. --class 表示要执行程序的主

2. --master spark://linux1:7077 独立部署模式，连接到 Spark 集群

3. spark-examples_2.12-3.0.0.jar 运行类所在的 jar 包

4. 数字 10 表示程序的入口参数，用于设定当前应用的任务数量

执行任务时，会产生多个 Java 进程

执行任务时，默认采用服务器集群节点的总核数，每个节点内存 1024M。

3.2.5 提交参数说明

在提交应用中，一般会同时一些提交参数

bin/spark-submit \
--class <main-class>
--master <master-url> \
... # other options
<application-jar> \
[application-arguments]

参数	解释
–class	Spark 程序中包含主函数的类
–master	Spark 程序运行的模式(环境)
–executor-memory 1G	指定每个 executor 可用内存为 1G
–total-executor-cores 2	指定所有executor使用的cpu核数为 2 个
–executor-cores	指定每个executor使用的cpu核数
application-jar	打包好的应用 jar，包含依赖。这个 URL 在集群中全局可见。 比如 hdfs:// 共享存储系统， 如果是file:// path，那么所有的节点的path 都包含同样的 jar
application-arguments	传给 main()方法的参数

3.2.6 配置历史服务

由于 spark-shell 停止掉后，集群监控 linux1:4040 页面就看不到历史任务的运行情况，所以开发时都配置历史服务器记录任务运行情况。

1. 修改 spark-defaults.conf.template 文件名为 spark-defaults.conf

mv spark-defaults.conf.template spark-defaults.conf

2. 修改 spark-default.conf 文件，配置日志存储路径

spark.eventLog.enabled true
spark.eventLog.dir hdfs://linux1:8020/directory

注意：需要启动 hadoop 集群，HDFS 上的 directory 目录需要提前存在。

sbin/start-dfs.sh
hadoop fs -mkdir /directory

3. 修改 spark-env.sh 文件, 添加日志配置

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://linux1:8020/directory 
-Dspark.history.retainedApplications=30"

参数 1 含义：WEB UI 访问的端口号为 18080

参数 2 含义：指定历史服务器日志存储路径

参数 3 含义：指定保存 Application 历史记录的个数，如果超过这个值，旧的应用程序信息将被删除，这个是内存中的应用数，而不是页面上显示的应用数。

4. 分发配置文件

xsync conf

5. 重新启动集群和历史服务

sbin/start-all.sh
sbin/start-history-server.sh

6. 重新执行任务

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://linux1:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

7. 查看历史服务：http://linux1:18080

3.2.7 配置高可用（HA）

​ 所谓的高可用是因为当前集群中的 Master 节点只有一个，所以会存在单点故障问题。所以为了解决单点故障问题，需要在集群中配置多个 Master 节点，一旦处于活动状态的 Master 发生故障时，由备用 Master 提供服务，保证作业可以继续执行。这里的高可用一般采用Zookeeper 设置。

集群规划:

主机名	Spark组件
Linux1	Zookeeper、Worker、Master
Linux2	Zookeeper、Worker、Master
Linux3	Zookeeper、Worker

1. 停止集群

sbin/stop-all.sh

2. 启动 Zookeeper

xstart zk

3. 修改 spark-env.sh 文件添加如下配置

注释如下内容：

#SPARK_MASTER_HOST=linux1
#SPARK_MASTER_PORT=7077

添加如下内容:

#Master 监控页面默认访问端口为 8080，但是可能会和 Zookeeper 冲突，所以改成 8989，也可以自
定义，访问 UI 监控页面时请注意
SPARK_MASTER_WEBUI_PORT=8989
export SPARK_DAEMON_JAVA_OPTS="
-Dspark.deploy.recoveryMode=ZOOKEEPER 
-Dspark.deploy.zookeeper.url=linux1,linux2,linux3
-Dspark.deploy.zookeeper.dir=/spark"

4. 分发配置文件

xsync conf/

5. 启动集群

# http://linux1:8989
sbin/start-all.sh

6. 启动 linux2 的单独 Master 节点，此时 linux2 节点 Master 状态处于备用状态

# http://linux2:8989
[root@linux2 spark-standalone]# sbin/start-master.sh

7. 提交应用到高可用集群

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://linux1:7077,linux2:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

8. 停止 linux1 的 Master 资源监控进程
   

9. 查看 linux2 的 Master 资源监控 Web UI，稍等一段时间后，linux2 节点的 Master 状态提升为活动状态

​ http://linux2:8989

3.3 Yarn 模式

​ 独立部署（Standalone）模式由 Spark 自身提供计算资源，无需其他框架提供资源。这种方式降低了和其他第三方资源框架的耦合性，独立性非常强。但是，Spark 主要是计算框架，而不是资源调度框架，所以本身提供的资源调度并不是它的强项，所以还是和其他专业的资源调度框架集成会更靠谱一些。所以接下来我们来学习在强大的 Yarn 环境下 Spark 是如何工作的（其实是因为在国内工作中，Yarn 使用的非常多）。

3.3.1 解压缩文件

将 spark-3.0.0-bin-hadoop3.2.tgz 文件上传到 linux 并解压缩，放置在指定位置。

tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
cd /opt/module 
mv spark-3.0.0-bin-hadoop3.2 spark-yarn

3.3.2 修改配置文件

1. 修改 hadoop 配置文件/opt/module/hadoop/etc/hadoop/yarn-site.xml, 并分发

<!--是否启动一个线程检查每个任务正使用的物理内存量，如果任务超出分配值，则直接将其杀掉，默认
是 true -->
<property>
 <name>yarn.nodemanager.pmem-check-enabled</name>
 <value>false</value>
</property>
<!--是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则直接将其杀掉，默认
是 true -->
<property>
 <name>yarn.nodemanager.vmem-check-enabled</name>
 <value>false</value>
</property>

2. 修改 conf/spark-env.sh，添加 JAVA_HOME 和 YARN_CONF_DIR 配置

mv spark-env.sh.template spark-env.sh
vim spark-env.sh

配置以下内容

export JAVA_HOME=/opt/module/jdk1.8.0_144
YARN_CONF_DIR=/opt/module/hadoop/etc/hadoop

3.3.3 启动 HDFS 以及 YARN 集群

3.3.4 提交应用

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode cluster \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

查看 http://linux2:8088 页面，点击 History，查看历史页面

3.3.5 配置历史服务器

1. 修改 spark-defaults.conf.template 文件名为 spark-defaults.conf

mv spark-defaults.conf.template spark-defaults.conf

2. 修改 spark-default.conf 文件，配置日志存储路径

spark.eventLog.enabled true
spark.eventLog.dir hdfs://linux1:8020/directory

注意：需要启动 hadoop 集群，HDFS 上的目录需要提前存在。

[root@linux1 hadoop]# sbin/start-dfs.sh
[root@linux1 hadoop]# hadoop fs -mkdir /directory

3. 修改 spark-env.sh 文件, 添加日志配置

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://linux1:8020/directory 
-Dspark.history.retainedApplications=30"

参数 1 含义：WEB UI 访问的端口号为 18080
参数 2 含义：指定历史服务器日志存储路径
参数 3 含义：指定保存 Application 历史记录的个数，如果超过这个值，旧的应用程序信息将被删除，这个是内存中的应用数，而不是页面上显示的应用数。

4. 修改 spark-defaults.conf

spark.yarn.historyServer.address=linux1:18080
spark.history.ui.port=18080

5. 启动历史服务

sbin/start-history-server.sh 

6. 重新提交应用

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

7. Web 页面查看日志：http://linux2:8088

3.4 K8S & Mesos 模式

​ Mesos 是 Apache 下的开源分布式资源管理框架，它被称为是分布式系统的内核,在Twitter 得到广泛使用,管理着 Twitter 超过 30,0000 台服务器上的应用部署，但是在国内，依然使用着传统的 Hadoop 大数据框架，所以国内使用 Mesos 框架的并不多，但是原理其实都差不多，这里我们就不做过多讲解了。

​ 容器化部署是目前业界很流行的一项技术，基于 Docker 镜像运行能够让用户更加方便地对应用进行管理和运维。容器管理工具中最为流行的就是 Kubernetes（k8s），而 Spark也在最近的版本中支持了 k8s 部署模式。这里我们也不做过多的讲解。给个链接大家自己感受一下：https://spark.apache.org/docs/latest/running-on-kubernetes.html

3.5 Windows 模式

​ Spark 非常暖心地提供了可以在 windows 系统下启动本地集群的方式，这样，在不使用虚拟机的情况下，也能学习 Spark 的基本使用。

3.5.1 解压缩文件

将文件 spark-3.0.0-bin-hadoop3.2.tgz 解压缩到无中文无空格的路径中

3.5.2 启动本地环境

1. 执行解压缩文件路径下 bin 目录中的 spark-shell.cmd 文件，启动 Spark 本地环境

2. 在 bin 目录中创建 input 目录，并添加 word.txt 文件, 在命令行中输入脚本代码

sc.textFile("input/word.txt").flatMap(.split(" ")).map((,1)).reduceByKey(+).collect

3.5.3 命令行提交应用

在 DOS 命令行窗口中执行提交指令

spark-submit --class org.apache.spark.examples.SparkPi --master 
local[2] ../examples/jars/spark-examples_2.12-3.0.0.jar 10

3.6 部署模式对比

模式	Spark 安装机器数	需启动的进程	所属者	应用场景
Local	1	无	Spark	测试
Standalone	3	Master、Worker	Spark	单独部署
Yarn	1	Yarn、HDFS	Hadoop	混合部署

3.7 端口号

• Spark 查看当前 Spark-shell 运行任务情况端口号：4040（计算）
• Spark Master 内部通信服务端口号：7077
• Standalone 模式下，Spark Master Web 端口号：8080（资源）
• Spark 历史服务器端口号：18080
• Hadoop YARN 任务运行情况查看端口号：8088

第4章 Spark运行架构

4.1 运行架构

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

4.2 核心组件

由上图可以看出，对于 Spark 框架有两个核心组件：

4.2.1 Driver

Spark 驱动器节点，用于执行 Spark 任务中的 main 方法，负责实际代码的执行工作。

Driver 在 Spark 作业执行时主要负责：

1. 将用户程序转化为作业（job）
2. 在 Executor 之间调度任务(task)
3. 跟踪 Executor 的执行情况
4. 通过 UI 展示查询运行情况

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

4.2.2 Executor

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

Executor 有两个核心功能：

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

4.2.3 Master & Worker

​ Spark 集群的独立部署环境中，不需要依赖其他的资源调度框架，自身就实现了资源调度的功能，所以环境中还有其他两个核心组件：Master 和 Worker，这里的 Master 是一个进程，主要负责资源的调度和分配，并进行集群的监控等职责，类似于 Yarn 环境中的 RM, 而Worker 呢，也是进程，一个 Worker 运行在集群中的一台服务器上，由 Master 分配资源对数据进行并行的处理和计算，类似于 Yarn 环境中 NM。

4.2.4 ApplicationMaster

​ Hadoop 用户向 YARN 集群提交应用程序时，提交程序中应该包含 ApplicationMaster，用于向资源调度器申请执行任务的资源容器 Container，运行用户自己的程序任务 job，监控整个任务的执行，跟踪整个任务的状态，处理任务失败等异常情况。说的简单点就是，ResourceManager（资源）和Driver（计算）之间的解耦合靠的就是ApplicationMaster。

4.3 核心概念

4.3.1 Executor 与 Core

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

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

名称	说明
–num-executors	配置 Executor 的数量
–executor-memory	配置每个 Executor 的内存大小
–executor-cores	配置每个 Executor 的虚拟 CPU core 数量

4.3.2 并行度（Parallelism）

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

4.3.3 有向无环图（DAG）

​ 大数据计算引擎框架我们根据使用方式的不同一般会分为四类，其中第一类就是Hadoop 所承载的 MapReduce,它将计算分为两个阶段，分别为 Map 阶段 和 Reduce 阶段。对于上层应用来说，就不得不想方设法去拆分算法，甚至于不得不在上层应用实现多个 Job 的串联，以完成一个完整的算法，例如迭代计算。 由于这样的弊端，催生了支持 DAG 框架的产生。因此，支持 DAG 的框架被划分为第二代计算引擎。如 Tez 以及更上层的Oozie。这里我们不去细究各种 DAG 实现之间的区别，不过对于当时的 Tez 和 Oozie 来说，大多还是批处理的任务。接下来就是以 Spark 为代表的第三代的计算引擎。第三代计算引擎的特点主要是 Job 内部的 DAG 支持（不跨越 Job），以及实时计算。

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

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

4.4 提交流程

​ 所谓的提交流程，其实就是我们开发人员根据需求写的应用程序通过 Spark 客户端提交给 Spark 运行环境执行计算的流程。在不同的部署环境中，这个提交过程基本相同，但是又有细微的区别，我们这里不进行详细的比较，但是因为国内工作中，将 Spark 引用部署到Yarn 环境中会更多一些，所以本课程中的提交流程是基于 Yarn 环境的。

​ Spark 应用程序提交到 Yarn 环境中执行的时候，一般会有两种部署执行的方式：Client和 Cluster。两种模式主要区别在于：Driver 程序的运行节点位置。

4.4.1 Yarn Client 模式

Client 模式将用于监控和调度的 Driver 模块在客户端执行，而不是在 Yarn 中，所以一般用于测试。

• Driver 在任务提交的本地机器上运行
• Driver 启动后会和 ResourceManager 通讯申请启动 ApplicationMaster
• ResourceManager 分配 container，在合适的 NodeManager 上启动 ApplicationMaster，负责向 ResourceManager 申请 Executor 内存
• ResourceManager 接到 ApplicationMaster 的资源申请后会分配 container，然后ApplicationMaster 在（资源分配）指定的 NodeManager 上启动 Executor 进程
• Executor 进程启动后会向 Driver 反向注册，Executor 全部注册完成后 Driver 开始执行main 函数
• 之后执行到 Action 算子时，触发一个 Job，并根据宽依赖开始划分 stage，每个 stage 生成对应的 TaskSet，之后将 task 分发到各个 Executor 上执行。

4.4.2 Yarn Cluster 模式

Cluster 模式将用于监控和调度的 Driver 模块启动在 Yarn 集群资源中执行。一般应用于实际生产环境。

• 在 YARN Cluster 模式下，任务提交后会和 ResourceManager 通讯申请启动ApplicationMaster
• 随后 ResourceManager 分配 container，在合适的 NodeManager 上启动 ApplicationMaster，此时的 ApplicationMaster 就是 Driver
• Driver 启动后向 ResourceManager 申请 Executor 内存，ResourceManager 接到ApplicationMaster 的资源申请后会分配 container，然后在合适的 NodeManager 上启动Executor 进程
• Executor 进程启动后会向 Driver 反向注册，Executor 全部注册完成后 Driver 开始执行main 函数
• 之后执行到 Action 算子时，触发一个 Job，并根据宽依赖开始划分 stage，每个 stage 生成对应的 TaskSet，之后将 task 分发到各个 Executor 上执行。

第5章 Spark 核心编程

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

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

接下来我们一起看看这三大数据结构是如何在数据处理中使用的。

5.1 什么是 RDD

    在许多迭代式算法(比如机器学习、图算法等)和交互式数据挖掘中，不同计算阶段之间会重用中间结果，即一个阶段的输出结果会作为下一个阶段的输入。但是，之前的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/reducebykey/fileter…)。

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

• 弹性

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

• 分布式：数据存储在大数据集群不同节点上

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

• 数据抽象：RDD 是一个抽象类，需要子类具体实现

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

• 可分区、并行计算

5.2 RDD的五大特性

来自package org.apache.spark.rdd源码中的注释内容

/**
 * 什么是RDD?
 * A Resilient Distributed Dataset (RDD), the basic abstraction in Spark. Represents an immutable,
 * partitioned collection of elements that can be operated on in parallel. This class contains the
 * basic operations available on all RDDs, such as `map`, `filter`, and `persist`. In addition,
 * [[org.apache.spark.rdd.PairRDDFunctions]] contains operations available only on RDDs of key-value
 * pairs, such as `groupByKey` and `join`;
 * [[org.apache.spark.rdd.DoubleRDDFunctions]] contains operations available only on RDDs of
 * Doubles; and
 * [[org.apache.spark.rdd.SequenceFileRDDFunctions]] contains operations available on RDDs that
 * can be saved as SequenceFiles.
 * All operations are automatically available on any RDD of the right type (e.g. RDD[(Int, Int)]
 * through implicit.
 *
 * RDD的五大特性:
 * Internally, each RDD is characterized by five main properties:
 *  - A list of partitions
 *  - A function for computing each split
 *  - A list of dependencies on other RDDs
 *  - Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
 *  - Optionally, a list of preferred locations to compute each split on (e.g. block locations for
 *    an HDFS file)
 *
 * All of the scheduling and execution in Spark is done based on these methods, allowing each RDD
 * to implement its own way of computing itself. Indeed, users can implement custom RDDs (e.g. for
 * reading data from a new storage system) by overriding these functions. Please refer to the
 * <a href="http://people.csail.mit.edu/matei/papers/2012/nsdi_spark.pdf">Spark paper</a>
 * for more details on RDD internals.
 */

1. 分区列表 A list of partitions

   RDD 数据结构中存在分区列表，每个分区都会被一个计算任务处理，分区数决定任务的并行度。如果没有指定，会采用默认值。
   

2. 作用于每个分片的计算函数 A function for computing each split

   Spark 在计算时，是使用分区函数对每一个分区进行计算
   

3. RDD 之间的依赖关系 A list of dependencies on other RDDs

   RDD 是计算模型的封装，当需求中需要将多个计算模型进行组合时都会生成一个新的RDD，所以RDD之间就会形成类似于流水线一样的前后依赖关系。(Spark的容错机制) 在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD的所有分区进行重新计算。
   

4. 针对KV数据类型的分区器 [可选, 默认: 基于hash分区]。 Optionally, a Partitioner for key-value RDDs

   当数据为 KV 类型时，可通过设定分区器自定义数据的分区。目前Spark中有两种分区器，一是基于哈希的HashPartitioner，一是基于范围的RangePartitioner。只有对于key-value的RDD，才能使用分区器，非key-value的RDD的Parititioner的值是None。Partitioner函数不但决定了RDD的分区数量，也决定了 父RDD Shuffle输出时的分片数量。
   

5. **首选位置 [可选] ** Optionally, a list of preferred locations to compute each split on

   按照"移动数据不如移动计算"的理念，Spark在进行任务调度的时候，会尽可能选择那些存有数据的worker节点来进行任务计算。例如：一个HDFS文件可能有多个block快，Spark会优先选择block所在的服务器上的Executor去执行此block分区中的数据。
   

5.3 RDD的基础编程

5.3.1 RDD 创建

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

1) 从集合(内存)中创建 RDD

// 由一个已经存在的Scala数组|集合创建
val rdd3: RDD[Int] = sc.parallelize(Array(1,2,3,4,5,6,7,8),3)//指定分区数量为3
// 或者 (makeRDD方法底层调用了parallelize方法)
val rdd4: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6))
sc.stop()

2) 从外部存储(文件)创建 RDD

// 由外部存储系统的数据集创建 RDD 包括：本地的文件系统，所有 Hadoop 支持的数据集，比如 HDFS、HBase 等。
val fileRDD: RDD[(String, Int)] = sc.textFile("hdfs://node01:8020/spark/day01/words.txt").flatMap(x => x.split(" ")).map((_, 1)).reduceByKey(_ + _)
fileRDD.foreach(println)
// 补充 sc.wholeTextFile("文件所在的目录")   // 以文件为单位来读取数据

3) 从其他 RDD 创建

// 主要是通过一个 RDD 运算完后，再产生新的 RDD
// 1.由外部存储系统的数据集创建
val fileRDD RDD[String] = sc.textFile("D:\\testDate\\spark\\words.txt")
// 2.通过已有的RDD经过算子转换生成新的RDD
val strArrRDD: RDD[Array[String]] = fileRDD.map(_.split(" "))
strArrRDD.foreach(_.foreach(println))

4) 直接创建 RDD

使用 new 的方式直接构造 RDD，一般由 Spark 框架自身使用。

补充一：JdbcRDD

从下面的数据库中读取数据，封装到RDD当中

CREATE DATABASE IF NOT EXISTS `bitestdb`  DEFAULT CHARACTER SET utf8;
USE `bitestdb`;
DROP TABLE IF EXISTS `emp`;
CREATE TABLE `emp`
(
    `id`          int(11)            DEFAULT NULL,
    `name`        varchar(100)       DEFAULT NULL,
    `deg`         varchar(100)       DEFAULT NULL,
    `salary`      int(11)            DEFAULT NULL,
    `dept`        varchar(10)        DEFAULT NULL,
    `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    `is_delete`   bigint(20)         DEFAULT '1'
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;
insert into `emp`(`id`, `name`, `deg`, `salary`, `dept`, `create_time`, `update_time`, `is_delete`)
values (1005, 'hive', 'manager', 50000, 'TP', '2020-09-24 13:51:57', '2020-09-24 09:02:53', 1),
       (1006, 'hbase', 'hadoop', 20000, 'TP', '2020-09-24 13:52:57', '2020-09-24 09:02:47', 1),
       (1007, 'phoenix', 'manager', 50000, NULL, '2020-09-24 13:53:57', '2020-09-24 09:02:45', 1),
       (1008, 'es', 'hadoop', 20000, 'TP', '2020-09-25 13:54:57', '2020-09-24 09:02:42', 1),
       (1009, 'flume', 'manager', 50000, 'TP', '2020-09-27 13:51:57', '2020-09-27 16:52:56', 1),
       (1010, 'logstath', 'hadoop', 20000, 'TP', '2020-09-27 13:51:57', '2020-09-27 16:52:59', 1),
       (1011, 'datax', 'manager', 50000, 'TP', '2020-09-27 13:51:57', '2020-09-27 16:53:02', 1),
       (1012, 'sqoop', 'hadoop', 20000, 'TP', '2020-09-27 13:51:57', '2020-09-27 16:53:07', 1),
       (1013, 'mysql', 'db', 50000, 'TP', '2020-10-09 13:51:57', '2020-10-09 09:17:20', 1),
       (1014, 'oracle', 'db', 50000, 'TP', '2020-10-09 13:51:57', '2020-10-09 09:17:31', 1),
       (1015, 'sql server', 'db', 20000, 'TP', '2020-10-09 13:51:57', '2020-10-09 09:17:38', 1),
       (1016, 'postgreSQL', 'db', 50000, 'TP', '2020-10-12 13:51:57', '2020-10-12 16:51:31', 1),
       (1017, 'dm', 'db', 40000, 'TP', '2020-10-14 13:51:57', '2020-10-14 09:02:53', 1),
       (1018, 'TiDB', 'db', 30000, 'TP', '2020-10-19 13:22:12', '2020-10-19 13:22:12', 0),
       (1019, 'iotdb', 'db', 30000, 'TP', '2020-10-22 13:22:12', '2020-10-22 13:22:12', 0),
       (1020, 'mogodb', 'db', 4000, 'TP', '2020-10-25 17:38:56', '2020-10-25 17:38:56', 1),
       (1021, 'influxdb', 'db', 50000, 'TP', '2020-11-02 15:51:11', '2020-11-02 15:52:33', 1),
       (1022, 'java', 'lngs', 60000, 'TP', '2020-11-09 15:39:54', '2020-11-09 15:42:42', 1),
       (1023, 'golang', 'lngs', 70000, 'TP', '2020-11-16 18:44:12', '2020-11-17 10:16:59', 1),
       (1024, 'python', 'lngs', 40000, 'TP', '2020-11-18 09:51:23', '2020-11-18 09:51:57', 1),
       (1025, 'C', 'lngs', 30000, 'TP', '2020-11-23 09:14:14', '2020-11-23 09:15:09', 1),
       (1026, 'shell', 'lngs', 40000, 'TP', '2020-12-02 18:14:52', '2020-12-02 18:14:52', 1);

核心代码

import java.sql.{Connection, DriverManager}
import org.apache.spark.rdd.JdbcRDD
import org.apache.spark.{SparkConf, SparkContext}
object MyJdbcRDD {
  case class Emp(id: Int, name: String, deg: String, salary: Int, dept: String, createTime: Long, updateTime: Long)
  // 函数的返回值类型必须为java.sql.Connection
  val getConnect: () => Connection = () => {
    classOf[com.mysql.jdbc.Driver] // DriverManager.registerDriver(new Driver())
    DriverManager.getConnection(
      "jdbc:mysql://localhost:3306/bitestdb?useSSL=false&useUnicode=true&characterEncoding=UTF-8",
      "root",
      "123456")
  }
  def main(args: Array[String]): Unit = {
    // 初始化运行环境
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("getRDD")
    //sparkConf.set("spark.default.parallelism", "5")
    val sc: SparkContext = new SparkContext(sparkConf)
    sc.setLogLevel("ERROR")
    val sqlStr: String =
      """
        |select `id`,`name`,`deg`,`salary`,`dept`,
        |        `create_time`,`update_time`
        |from emp
        |where id > ? and id < ? and `is_delete` = 1
        |""".stripMargin
    
    val rsRDD: JdbcRDD[Emp] = new JdbcRDD(
      sc,
      getConnect,//第二个参数是函数
      sqlStr,
      lowerBound = 1006L, // sqlStr中的第一个？上界占位符的值，只能为Long类型
      upperBound = 1021L, // sqlStr下界占位符的值。只能有两个占位符
      numPartitions = 3, // 设置RDD的分区数
      resultSet => { // 该匿名函数的输入是 java.sql.ResultSet，返回值可以是任意类型
        Emp( // 将SQL查询到的结果封装成样例类Emp的实例
          resultSet.getInt("id"),
          resultSet.getNString("name"),
          resultSet.getString("deg"),
          resultSet.getInt("salary"),
          resultSet.getString("dept"),
          resultSet.getTimestamp("create_time").getTime,
          resultSet.getTimestamp("update_time").getTime
        )
      }
    )
    rsRDD.collect().foreach(println)
    sc.stop()
  }
}

5.3.2 RDD 并行度与分区

​ 默认情况下，Spark 根据RDD的分区数将一个APP切分多个任务后，发送给 Executor 节点进行并行计算，而能够并行计算的任务数量我们称之为并行度。

案例一：makeRDD是如何判断返回值RDD的分区数的？

1. 如果在makeRDD方法的第二个参数中设置了RDD的分区数，那么，RDD的分区数等于设定值。
2. 如果没有指定分区数，那么，makeRDD返回的RDD的默认的分区数 = 并行度
3. 如果没有在运行环境中设置并行度，那么，默认的并行度 = 当前运行环境的最大可用核数

// 如果不指定分区，默认的分区数 = 并行度（如下图源码）。
val dataRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
println(dataRDD.partitions.length) // 结果为：8，我的windows电脑CPU的核数

//如果想在初始化spark运行环境的时候设计并行度，可使用下面两行代码去设置任务的并行度
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("getRDD")
sparkConf.set("spark.default.parallelism","5")

//如果不想使用默认的分区数，可以在方法的第二个参数指定分区数
val dataRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),3)
dataRDD.saveAsTextFile("outpath")  // 将RDD的数据保存为分区文件，RDD有几个分区就会导出几份文件

思考：我们已经知道RDD是如何分区的，那么分区后，List中的元素是按什么样的规则分到每个分区的呢？

方法：在spark源码找到makeRDD方法创建RDD的过程，去分析spark采用了什么样的规则把List的数据分配到各个分区中。

源码：

//第一步：点击makeRDD算子找到SparkContext类 ——> makeRDD方法（如下）
def makeRDD[T: ClassTag](
    seq: Seq[T],
    numSlices: Int = defaultParallelism): RDD[T] = withScope {
  parallelize(seq, numSlices)  // todo:点击parallelize方法，跳转到第二步，去找RDD是如何创建的
}

//第二步：以下parallelize方法源码，方法中使用new创建了一个RDD，点进去继续去找RDD是如何创建的
  def parallelize[T: ClassTag](
      seq: Seq[T],
      numSlices: Int = defaultParallelism): RDD[T] = withScope {
    assertNotStopped()
    new ParallelCollectionRDD[T](this, seq, numSlices, Map[Int, Seq[String]]())
  }
  
//第三步：从第二步跳转到了ParallelCollectionRDD类中，能够找到getPartitions方法（返回值是每个分片组成的数组）
  override def getPartitions: Array[Partition] = {
    // todo: slice方法的两个参数分别是 数据 和 分区数，它的作用就是把数据按规则划分到各RDD的分区中，点击进入第四步查看详细逻辑
    val slices = ParallelCollectionRDD.slice(data, numSlices).toArray
    slices.indices.map(i => new ParallelCollectionPartition(id, i, slices(i))).toArray
  }

//第四步：slice方法中，先执行case_模式匹配的内容，在其中调用了positions这个函数，这个函数就是数据如何分配到各分区的核心代码
    def positions(length: Long, numSlices: Int): Iterator[(Int, Int)] = { // length是指传入的List的长度
      (0 until numSlices).iterator.map { i =>
        val start = ((i * length) / numSlices).toInt
        val end = (((i + 1) * length) / numSlices).toInt
        (start, end)
      }

案例二：textFile读取文件时对RDD的进行分区数的？

读取文件数据时，数据是按照 Hadoop 文件读取的规则进行切片分区，而切片规则和数据读取的规则有些差异，具体 Spark 核心源码如下

public InputSplit[] getSplits(JobConf job, int numSplits) throws IOException {
 long totalSize = 0; // compute total size
 for (FileStatus file: files) { // check we have valid files
 if (file.isDirectory()) {
 throw new IOException("Not a file: "+ file.getPath());
 }
 totalSize += file.getLen();
 }
 long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits);
 long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input.
 FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize);
 
 ...
 
 for (FileStatus file: files) {
 
 ...
 
 if (isSplitable(fs, path)) {
 long blockSize = file.getBlockSize();
 long splitSize = computeSplitSize(goalSize, minSize, blockSize);
 ...
 }
 protected long computeSplitSize(long goalSize, long minSize,
 long blockSize) {
 return Math.max(minSize, Math.min(goalSize, blockSize));
 }

5.3.3 RDD 转换算子

RDD 根据数据处理方式的不同将算子整体上分为 ：

• Value 类型
• 双 Value 类型：两个RDD数据源之间的关联操作
• Key-Value类型

---

以下是处理 Value 类型时使用的算子

01) map

函数签名

def map[U: ClassTag](f: T => U): RDD[U]

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

// 注意：分区内数据的执行是有序的
val dataRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4))
val dataRDD1: RDD[Int] = dataRDD.map(_*2) //对RDD值做转换
val dataRDD2: RDD[String] = dataRDD1.map(_+"") //对RDD类型做转换
dataRDD2.foreach(println)

//keys和values算子都是对map算子进行的封装
//def keys: RDD[K] = self.map(_._1)
//def values: RDD[V] = self.map(_._2)
val inRDD: RDD[(String,Int)] = sc.makeRDD(List(("b",2),("c",3),("c",3),("a",1),("a",1),("a",1)))
val keysRDD: RDD[String] = inRDD.keys
println(keysRDD.collect.mkString(","))
val valuesRDD: RDD[Int] = inRDD.values

02) mapPartitions

函数签名

def mapPartitions[U: ClassTag](
 f: Iterator[T] => Iterator[U], // 注意，传入的是迭代器，返回值必须也是迭代器
 preservesPartitioning: Boolean = false): RDD[U]

函数说明

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

val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
val rsRDD: RDD[String] = rdd1.mapPartitions(
  iter => { //函数的输入和返回值都必须是迭代器
    iter.filter(_ % 2 == 0) //过滤，取偶数
      .map(_ + "a") // 对迭代器中的数据进行类型转换
    // todo 总之，保证返回的结果是一个迭代器对象就行了
  })
rsRDD.foreach(println)

map 和 mapPartitions 的区别

• 数据处理角度
  Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而 mapPartitions 算子是以分区为单位进行批处理操作。

• 功能的角度

  Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。
  MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据

• 性能的角度
  Map 算子因为类似于串行操作，所以性能比较低，而是 mapPartitions 算子类似于批处理，所以性能较高。但是 mapPartitions 算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，推荐使用 map 操作。

03) mapPartitionsWithIndex

函数签名

  def mapPartitionsWithIndex[U: ClassTag](
      f: (Int, Iterator[T]) => Iterator[U], // 传入的函数必须有两个参数，第一个表示RDD的第几个分区，第二个是这个分区对应的数据生成的迭代器
      preservesPartitioning: Boolean = false): RDD[U]

函数说明

将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。

val inRDD: RDD[Int] = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 2)
val func: (Int, Iterator[Int]) => Iterator[String] = (index: Int, iter: Iterator[Int]) => {
  iter.map(x => "[partID:" +  index + ", val: " + x + "]")
}
val rsRDD: RDD[String] = inRDD.mapPartitionsWithIndex(func)
rsRDD.foreach(println)
//只保留第一个分区的数据
val p1RDD: RDD[Int] = inRDD.mapPartitionsWithIndex(
  (pIndex, dataIter) => {
    if (pIndex == 1) {
      dataIter
    } else {
      Nil.iterator
    }
  })
p1RDD.foreach(println)

04) flatMap

函数签名

def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] // 传入的函数的返回值必须是可迭代的集合（TraversableOnce特质）

函数说明

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

val fileRDD: RDD[String] = sc.textFile("D:\\testDate\\spark\\words.txt")
val rsRDD: RDD[String] = fileRDD.flatMap(_.split(" "))
rsRDD.foreach(println)

05) glom

函数签名

def glom(): RDD[Array[T]]

函数说明

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

val intRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
val intArrRDD:RDD[Array[Int]] = intRDD.glom()
println(intRDD.partitions.length + "\t" + intArrRDD.partitions.length) // 分区不变
intArrRDD.foreach(intArr => println(intArr.mkString(",")))

06) groupBy

函数签名

def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]

函数说明

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

//根据指定函数中的规则对key进行分组
val dataRDD = sc.makeRDD(List(1,2,3,4),1)
val dataRDD1 = dataRDD.groupBy(_%2）
//Array[(Int, Iterable[Int])] = Array((0,CompactBuffer(2, 4)), (1,CompactBuffer(1, 3)))
val rdd1= sc.parallelize(List(1,2,3,4,5,6))
rdd1.groupBy(x => {if(x%2 == 0) "even" else "odd"}).collect
//Array((even,CompactBuffer(4, 6, 2)), (odd,CompactBuffer(1, 3, 5)))

07) filter

函数签名

def filter(f: T => Boolean): RDD[T]  // 传入的函数的返回值必须是Boolean类型

函数说明

将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。

val inRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4),1)
val rsRDD: RDD[Int] = inRDD.filter(_%2 == 0)
rsRDD.foreach(println)

08) sample（抽样）

函数签名

def sample(
 withReplacement: Boolean,
 fraction: Double,
 seed: Long = Utils.random.nextLong): RDD[T]

函数说明

根据指定的规则从数据集中抽取数据，作用：通过抽样取出一部分样本，在对样本做wordCount并排序最后取出出现次数最多的key，这个key就是导致数据倾斜的key

val dataRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4),1)
// 抽取数据不放回（伯努利算法）
// 伯努利算法：又叫 0、1 分布。例如扔硬币，要么正面，要么反面。
// 具体实现：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于不要
// 第一个参数：抽取的数据是否放回，false：不放回
// 第二个参数：抽取的几率，范围在[0,1]之间,0：全不取；1：全取；
// 第三个参数：随机数种子，默认是时间戳，这个参数一般用于调试，有时候不知道是程序出问题还是数据出了问题，就可以将这个参数设置为定值
val dataRDD1: RDD[Int] = {
  dataRDD.sample(withReplacement = false, 0.5)
}
// 抽取数据放回（泊松算法）
// 第一个参数：抽取的数据是否放回，true：放回；false：不放回
// 第二个参数：重复数据的几率，范围大于等于0 表示每一个元素被期望抽取到的次数
// 第三个参数：随机数种子
val dataRDD2: RDD[Int] = dataRDD.sample(withReplacement = true, 2)

09) distinct

函数签名

def distinct()(implicit ord: Ordering[T] = null): RDD[T]
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]

函数说明

将数据集中重复的数据去重，会产生shuffle

val inRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4,1,2),1)
val rs01RDD: RDD[Int] = inRDD.distinct()  // 与去重前的分区保持一致
val rs02RDD: RDD[Int] = inRDD.distinct(2) // 参数2指去重后的分区数
println(rs01RDD.collect.mkString(","))
println(rs02RDD.collect.mkString(","))

原理：

1. scala集合的去重是通过HashSet的方式来进行的；
2. spark的distinct算子当不传参数，核心源码是map(x => (x, null)).reduceByKey((x, y) => x, numPartitions).map(_._1)；

10) coalesce

函数签名

def coalesce(numPartitions: Int, shuffle: Boolean = false,   // 默认值：false，将整个分区进行合并，不会产生shuffle
 partitionCoalescer: Option[PartitionCoalescer] = Option.empty)
 (implicit ord: Ordering[T] = null)
 : RDD[T]

函数说明

根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本

val inRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),3)
inRDD.saveAsTextFile("outpath01")        // 1,2    3,4    5,6
val rsRDD: RDD[Int] = inRDD.coalesce(2)//传入的分区数必须小于原分区数，否则分区数不会变
rsRDD.saveAsTextFile("outpath02")        //  1,2    3,4,5,6
val rsShuffleRDD: RDD[Int] = inRDD.coalesce(2,shuffle = true)
rsShuffleRDD.saveAsTextFile("outpath03") // 1,3,5  2,4,6

11) repartition

函数签名

  def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
    coalesce(numPartitions, shuffle = true)  // 底层实际是对coalesce算子的引用
  }

函数说明

该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true。无论是将分区数多的RDD 转换为分区数少的 RDD，还是将分区数少的 RDD 转换为分区数多的 RDD，repartition操作都可以完成，因为无论如何都会经 shuffle 过程。

val inRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4,5,6),2)
inRDD.saveAsTextFile("outpath01")        // 1,2,3   4,5,6
val rsRDD: RDD[Int] = inRDD.repartition(3)  // 等价于 inRDD.coalesce(3,true)
rsRDD.saveAsTextFile("outpath02")        //  3,6  1,4  2,5

总结：

1. 缩减分区，使用coalesce算子，如果想要数据均衡，使用时开启shuffle
2. 扩大分区，使用repartition算子

12) sortBy

函数签名

def sortBy[K](
 f: (T) => K,
 ascending: Boolean = true,  // 默认值: true 表示默认按升序排序，如果传入的第二个参数为false表示按照降序排序
 numPartitions: Int = this.partitions.length)
 (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]

函数说明

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

val inRDD: RDD[Int] = sc.makeRDD(List(1,5,3,4,2,6),2)
inRDD.saveAsTextFile("outpath01")        // 1,5,3   4,2,6
val rsRDD: RDD[Int] = inRDD.sortBy(num=>num,ascending = false)
//排序后新产生的 RDD 的分区数与原 RDD 的分区数一致，但分区内的数据不一样了，说明还是产生了shuffle
rsRDD.saveAsTextFile("outpath02")        // 6,5,4  3,2,1

---

以下是处理 双Value 类型时使用的算子

13) intersection交集

函数签名

def intersection(other: RDD[T]): RDD[T]  // 传入的RDD的类型必须和调用该方法的RDD的类型一致

函数说明

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

14) union并集

函数签名

def union(other: RDD[T]): RDD[T]

函数说明

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

15) subtract差集

函数签名

def subtract(other: RDD[T]): RDD[T]

函数说明

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

16) zip

函数签名

def zipU: ClassTag: RDD[(T, U)]

函数说明

将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的 Key 为第 1 个 RDD 中的元素，Value 为第 2 个 RDD 中的相同位置的元素。

拉链操作的两个RDD的数量类型可以不一致，但是分区数和分区内的元素数量必须保持一致！

val inRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4))
val otherRDD: RDD[Int] = sc.makeRDD(List(3,4,5,6))
// intersection（交集）：3,4
val intersectionRDD: RDD[Int] = inRDD.intersection(otherRDD)
println("intersection（交集）：" + intersectionRDD.collect.mkString(","))
// union（并集）：1,2,3,4,3,4,5,6
val unionRDD: RDD[Int] = inRDD.union(otherRDD)
println("union（并集）：" + unionRDD.collect.mkString(",")) 
// subtract（差集）：1,2
val subtractRDD: RDD[Int] = inRDD.subtract(otherRDD)
println("subtract（差集）：" + subtractRDD.collect.mkString(","))
//求笛卡尔积
val stuRDD: RDD[String] = sc.parallelize(List("jack", "tom"))  //学生
val courseRDD: RDD[String] = sc.parallelize(List("java", "python", "scala")) //课程
val cartesianRDD: RDD[(String, String)] = stuRDD.cartesian(courseRDD) //结果就是所有学生可能的选课情况
println("cartesian（求笛卡尔积）：" + cartesianRDD.collect.mkString("\t"))
// zip（拉链）：(1,3),(2,4),(3,5),(4,6)
val zipRDD: RDD[(Int, Int)] = inRDD.zip(otherRDD)
println("zip（拉链）：" + zipRDD.collect.mkString(","))

---

以下是处理 双Value 类型时使用的算子

17) partitionBy

函数签名 [详情参阅 5.3.9 RDD分区器章节](#5.3.9 RDD 分区器)

//方法位于：org.apache.spark.rdd.PairRDDFunctions[K, V]    通过隐式函数
def partitionBy(partitioner: Partitioner): RDD[(K, V)]

函数说明

将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner。在sortby算子中使用了RangePartitioner

val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1,"aaa"),(2,"bbb"),(3,"ccc")),3)
import org.apache.spark.HashPartitioner
val rdd2: RDD[(Int, String)] = rdd.partitionBy(new HashPartitioner(2))

18) reduceByKey

函数签名

def reduceByKey(func: (V, V) => V): RDD[(K, V)]
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]

函数说明

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

val inList: List[(String, Int)] = List(("tom",1), ("jerry",3), ("kitty",2), ("shuke",1), ("jerry",2), ("tom",3), ("shuke",2), ("kitty",5))
val inRDD: RDD[(String, Int)] = sc.parallelize(inList,3)
val rs01RDD: RDD[(String, Int)] = inRDD.reduceByKey(_+_)
val rs02RDD: RDD[(String, Int)] = inRDD.reduceByKey(_+_,numPartitions = 2)
println(rs01RDD.collect.mkString("\t"))  // (tom,4)	(jerry,5)	(shuke,3)	(kitty,7)

19) groupByKey

函数签名

def groupByKey(): RDD[(K, Iterable[V])]
def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])]
def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]

函数说明

将数据源的数据根据 key 对 value 进行分组

val inList: List[(String, Int)] = List(("tom",1), ("jerry",3), ("kitty",2), ("shuke",1), ("jerry",2), ("tom",3), ("shuke",2), ("kitty",5))
val inRDD: RDD[(String, Int)] = sc.parallelize(inList,3)

val rbkRDD: RDD[(String, Int)] = inRDD.reduceByKey(_+_)
val rbk02RDD: RDD[(String, Int)] = inRDD.reduceByKey(_+_,numPartitions = 2)
println(rbkRDD.collect.mkString("\t"))  // (tom,4)	(jerry,5)	(shuke,3)	(kitty,7)

val gbkRDD: RDD[(String, Iterable[Int])] = inRDD.groupByKey()
val gbk02RDD: RDD[(String, Iterable[Int])] = inRDD.groupByKey(numPartitions = 2)
val gbk03RDD: RDD[(String, Iterable[Int])] = inRDD.groupByKey(new HashPartitioner(2))
println(gbkRDD.collect.mkString("\t"))

val gbRDD: RDD[(Char, Iterable[(String, Int)])] = inRDD.groupBy( x => x._1.charAt(0))
val gb02RDD: RDD[(Char, Iterable[(String, Int)])] = inRDD.groupBy( x => x._1.charAt(0),numPartitions = 2)
println(gbRDD.collect.mkString("\t"))

reduceByKey 和 groupByKey 的区别

• 从 shuffle 的角度：reduceByKey 和 groupByKey 都存在 shuffle 的操作，但是 reduceByKey 可以在 shuffle 前对分区内相同 key 的数据进行预聚合（combine）功能，这样会减少落盘的数据量，而 groupByKey 只是进行分组，不存在数据量减少的问题，reduceByKey 性能比较高。

• 从功能的角度：reduceByKey 其实包含聚合和分组的功能。GroupByKey 只能分组，不能聚合，所以在分组聚合的场合下，推荐使用 reduceByKey，如果仅仅是分组而不需要聚合，那么还是只能使用 groupByKey

20) aggregateByKey

函数签名

// 注意：返回值的数据类型必须和初始化值的类型保持一致
def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]

函数说明

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

val dataRDD1 = sparkContext.makeRDD(List(("a",1),("b",2),("c",3)))
val dataRDD2 = dataRDD1.aggregateByKey(0)(_+_,_+_)

取出每个分区内相同 key 的最大值然后分区间相加

// TODO : 取出每个分区内相同 key 的最大值然后分区间相加
// aggregateByKey 算子是函数柯里化，存在两个参数列表
// 1. 第一个参数列表中只有一个参数，表示初始值（比如两个数比较大小，当取到第一个key对应的value的时候，我们可以与这个初始值比较大小）
// 2. 第二个参数列表中含有两个参数
//    2.1 第一个参数表示分区内的计算规则
//    2.2 第二个参数表示分区间的计算规则
val rdd: RDD[(String, Int)] = sc.makeRDD(
    List( ("a",1),("a",2),("c",3),
          ("b",4),("c",5),("c",6) ),
    numSlices = 2
)
// 0:("a",1),("a",2),("c",3) => (a,10)(c,10)
// 1:("b",4),("c",5),("c",6) => (b,10)(c,10)
// => (a,10)(b,10)(c,20)
val resultRDD: RDD[(String, Int)] =
rdd.aggregateByKey(zeroValue = 10)(
  (x, y) => math.max(x,y),
  (x, y) => x + y
)
println(resultRDD.collect().mkString("\t")) // (b,10)	(a,10)	(c,20)

拓展：求各key对应的平均值，注意与 combineByKey 算子的用法对比

// TODO : 求各key对应的平均值
val inRDD: RDD[(String, Int)] =
  sc.makeRDD(List(
    ("a", 1), ("a", 2), ("c", 3),
    ("b", 4), ("c", 5), ("c", 6)
  ), numSlices = 2)
// aggregateByKey算子返回值的数据类型为 [ RDD[K,V中K的数据类型],初始值的数据类型]
val keySumCountRDD: RDD[(String, (Int, Int))] = inRDD.aggregateByKey((0, 0))( // [K,(sumValueByKey,countByKey)]
  (sumAndCountTuple, valueInt) => { //第一个函数：第一个参数的数据类型 = 初始值数据类型；第二个参数的数据类型 = RDD[K,V]中 V 的数据类型
    (sumAndCountTuple._1 + valueInt, sumAndCountTuple._2 + 1) //第一个函数：返回值数据类型 = 初始值数据类型
  },
  (firstTuple, nextTuple) => { //第二个函数：两个参数的数据类型 = 第一个函数返回值类型 = 初始值数据类型
    (firstTuple._1 + nextTuple._1, firstTuple._2 + nextTuple._2) //第二个函数：返回值数据类型 = 初始值数据类型
  }
)
val keyAndAvgStrRDD: RDD[(String, String)] = keySumCountRDD.mapValues(
  sumAndCountTuple => {
    val avgDouble: Double = sumAndCountTuple._1.toDouble / sumAndCountTuple._2
    avgDouble.formatted("%.2f") // 四舍五入保留小数点后两位数
  }
)
println(keyAndAvgStrRDD.collect.mkString("\t"))  // (b,4.00)	(a,1.50)	(c,4.67)

21) foldByKey

函数签名

def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]

函数说明

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

val inRDD: RDD[(String, Int)] = sc.makeRDD(
  List(
    ("a", 1), ("a", 2), ("c", 3),
    ("b", 4), ("c", 5), ("c", 6)
  ), numSlices = 2
)
val rsRDD: RDD[(String, Int)] = inRDD.foldByKey(0)(_+_)
println(rsRDD.collect.mkString("\t")) //(b,4)	(a,3)	(c,14)
val rs02RDD: RDD[(String, Int)] = inRDD.foldByKey(10)(_+_) 
println(rs02RDD.collect.mkString("\t")) //(b,14)	(a,13)	(c,34)

22) combineByKey

函数签名

def combineByKey[C](
 createCombiner: V => C,
 mergeValue: (C, V) => C,
 mergeCombiners: (C, C) => C): RDD[(K, C)]

函数说明

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

//求各key对应的平均值
val inRDD: RDD[(String, Int)] = sc.makeRDD(
  List(
    ("a", 1), ("a", 2), ("c", 3),
    ("b", 4), ("c", 5), ("c", 6)
  ), numSlices = 2
)
val keySumCountRDD: RDD[(String, (Int, Int))] = inRDD.combineByKey(
  (_, 1), // 将各分区中每个key所对应的第一个值进行转换，作为初始值
  (sumAndCountTuple: (Int, Int), v) => {
    (sumAndCountTuple._1 + v, sumAndCountTuple._2 + 1) // 分区内数据的计算规则
  },
  (firstTuple: (Int, Int), nextTuple: (Int, Int)) => {
    (firstTuple._1 + nextTuple._1, firstTuple._2 + nextTuple._2) // 分区间数据的计算规则
  }
)
val keyAndAvgStrRDD: RDD[(String, String)] = keySumCountRDD.mapValues(
  sumAndCountTuple => {
    val avgDouble: Double = sumAndCountTuple._1.toDouble / sumAndCountTuple._2
    avgDouble.formatted("%.2f") // 四舍五入保留小数点后两位数
  }
)
println(keyAndAvgStrRDD.collect.mkString("\t"))  // (b,4.00)	(a,1.50)	(c,4.67)

reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别？

• reduceByKey：相同 key 的第一个数据不进行任何计算，分区内和分区间计算规则相同
• FoldByKey：各分区内相同 key 的第一个数据和初始值进行计算，分区内和分区间计算规则相同
• AggregateByKey：相同 key 的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同
• CombineByKey：当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同

这几个算子的源码都是在 combineByKeyWithClassTag 方法的基础上进行的封装

@Experimental
def combineByKeyWithClassTag[C](
    createCombiner: V => C,  // 各分区内相同key的第一条数据的处理规则
     mergeValue: (C, V) => C, // 分区内数据处理规则的函数
     mergeCombiners: (C, C) => C, // 分区间数据处理规则的函数
     partitioner: Partitioner,
     mapSideCombine: Boolean = true,
     serializer: Serializer = null)(implicit ct: ClassTag[C]): RDD[(K, C)]

23) sortByKey

函数签名

def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length): RDD[(K, V)]

函数说明

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

// 根据key进行排序
val inRDD: RDD[(Int, String)] = sc.makeRDD(
  List(
    (1, "a"), (6, "c"), (3, "a"),
    (2, "a"), (5, "c"), (4, "c")
  ), numSlices = 2
)
val ascRDD: RDD[(Int, String)] = inRDD.sortByKey(ascending = true)
println("升序： " + ascRDD.collect.mkString("\t")) // 升序： (1,a)	(2,a)	(3,a)	(4,c)	(5,c)	(6,c)
val descRDD: RDD[(Int, String)] = inRDD.sortByKey(ascending = false)
println("降序： " + descRDD.collect.mkString("\t")) // 降序： (6,c)	(5,c)	(4,c)	(3,a)	(2,a)	(1,a)
println(ascRDD.partitions.length + "\t" + descRDD.partitions.length) // 2	2

24) join

函数签名

// 两个RDD的Key的数据类型必须相同
def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

函数说明
在类型为(K,V)和(K,W)的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的 RDD，注意笛卡尔积造成OOM

25) leftOuterJoin

函数签名

// TODO: 注意返回值与join的不同
def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]

函数说明
类似于 SQL 语句的左外连接

//相同的key合并,value合成元组
val rdd1: RDD[(String, Int)] = sc.parallelize(List(("tom", 1), ("jerry", 2), ("kitty", 3)))
val rdd2: RDD[(String, Int)] = sc.parallelize(List(("jerry", 9), ("tom", 8), ("shuke", 7), ("tom", 2)))
//内连接    (tom,(1,8))	(tom,(1,2))	(jerry,(2,9))
val innerJoinRs: RDD[(String, (Int, Int))] = rdd1.join(rdd2)
println(innerJoinRs.collect.mkString("\t"))
//左外连接   (tom,(1,Some(8)))	(tom,(1,Some(2)))	(kitty,(3,None))	(jerry,(2,Some(9)))
val leftJoinRs: RDD[(String, (Int, Option[Int]))] = rdd1.leftOuterJoin(rdd2)
println(leftJoinRs.collect.mkString("\t"))
//右外连接   (tom,(Some(1),8))	(tom,(Some(1),2))	(shuke,(None,7))	(jerry,(Some(2),9))
val rightJoinRs: RDD[(String, (Option[Int], Int))] = rdd1.rightOuterJoin(rdd2)
println(rightJoinRs.collect.mkString("\t"))

26) cogroup

函数签名

def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]

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

//先在RDD内部按照key分组,再在多个RDD间按照key分组
val rdd1: RDD[(String, Int)] = sc.parallelize(List(("tom", 1), ("tom", 2), ("jerry", 3), ("kitty", 2)))
val rdd2: RDD[(String, Int)] = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))
rdd1.cogroup(rdd2).collect.foreach(println)
/*  (tom,(CompactBuffer(1, 2),CompactBuffer(1)))
    (shuke,(CompactBuffer(),CompactBuffer(2)))
    (kitty,(CompactBuffer(2),CompactBuffer()))
    (jerry,(CompactBuffer(3),CompactBuffer(2)))   */

5.3.4 案例练习

• 数据准备
  agent.csv：时间戳，省份，城市，手机号，广告，中间字段使用逗号分隔。

  agent.csv文件链接：https://pan.baidu.com/s/18NU-v_Gv70A3k3FASLHy7A
  提取码：y1s4

• 需求描述
  统计出每一个省份每个广告被点击数量排行的 Top3

val lineRDD: RDD[String] = sc.textFile("datas/agent.csv")

// 1、将每行数据处理成二元组  ((省份,广告),1)
val pvncAdAndOneRDD: RDD[((String, String), Int)] = lineRDD.map(
  line => {
    val wordArr: Array[String] = line.split(",")
    ((wordArr(1), wordArr(4)), 1)
  }
)

// 2、安装key进行分组，统计相同key的个数  ((省份,广告),个数)
val pvncAdAndCountRDD: RDD[((String, String), Int)] = pvncAdAndOneRDD.reduceByKey(_ + _)

// 3、数据类型转换   ((省份,广告),个数)  转换为   (省份,(广告,个数))
val pvncAndAdCountRDD: RDD[(String, (String, Int))] = pvncAdAndCountRDD.map(elem => (elem._1._1, (elem._1._2, elem._2)))

// 4、分组后对分组内的数据进行排序，得到 （省份，Iterable[(广告, 个数)]）
val groupedRDD: RDD[(String, Iterable[(String, Int)])] = pvncAndAdCountRDD.groupByKey()

// 5、对每个省份内的数据进行排序，求Top3，得到  （省份，List[(广告, 个数)]）
val rsRDD: RDD[(String, List[(String, Int)])] = groupedRDD.mapValues(_.toList.sortBy(_._2).reverse.take(3))

// 6、打印结果
val rsArr: Array[(String, List[(String, Int)])] = rsRDD.collect
rsArr.foreach(
  elem => {
    val strBuilder: StringBuilder = new StringBuilder("省份：" + elem._1)
    elem._2.foreach(adRank => {
      strBuilder.append("\t(" + adRank._1 + ", " + adRank._2 + ")")
    })
    println(strBuilder)
  }
)

5.3.5 RDD 行动算子

行动算子的本质是触发任务执行的方法，且返回值类型一定不是RDD类型

行动算子能真正触发任务执行的原因是（源码初步分析）：
    1.行动算子中使用了sc.runJob方法
    2.sc.runJob方法中调用dagScheduler.runJob方法
    3.dagScheduler.runJob方法中又调用了submitJob方法
    4.submitJob方法调用了eventProcessLoop.post(JobSubmitted)提交了一个事件
    5.DAGScheduler类中找到handleJobSubmitted方法，方法内创建new ActiveJob并最终触发执行

01) collect

函数签名

def collect(): Array[T]

函数说明
在驱动程序中，按照分区的顺序将数据采集到Driver端节点的内存中，以数组 Array 的形式返回数据集

02) reduce

函数签名

def reduce(f: (T, T) => T): T

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

03) count

函数签名

def count(): Long

函数说明

返回 RDD 中元素的个数

04) first

函数签名

// first()方法再take()方法上做了封装
def first(): T

函数说明

返回 RDD 中的第一个元素

#####05) take

函数签名

def take(num: Int): Array[T]

函数说明
返回一个由 RDD 的前 n 个元素组成的数组

val inRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 收集数据到 Driver, 可能会造成Driver所在的节点OOM
val rsArr: Array[Int] = inRDD.collect
println(rsArr.mkString(","))

// 聚合数据
val reduceResult: Int = inRDD.reduce(_+_)
println(reduceResult)

// 返回 RDD 中元素的个数
val countResult: Long = inRDD.count()
println(countResult)

// 返回 RDD 中第一个元素
val firstResult: Int = inRDD.first()
println(firstResult)

// 返回 RDD 中元素的个数
val takeResult: Array[Int] = inRDD.take(2)
println(takeResult.mkString(","))

//collectAsMap 将KV类型的数据收集到Driver
val rdd: RDD[(String, Int)] = sc.parallelize(List(("a", 1), ("a",3), ("b", 2)))
val rsMap: collection.Map[String, Int] = rdd.collectAsMap
println(rsMap) //Map(b -> 2, a -> 3)  对于重复的key, 后面的元素覆盖前面的元素

#####06) takeOrdered

函数签名

def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]

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

val inRDD: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 返回 RDD 中元素的个数
val ascRsArr: Array[Int] = inRDD.takeOrdered(2)
// top算子就是对takeOrdered算子的封装
val descRsArr: Array[Int] = inRDD.top(2) // 等价于： inRDD.takeOrdered(2)(Ordering[Int].reverse)
println("升序前2:\t"+ascRsArr.mkString(","))
println("降序前2:\t"+descRsArr.mkString(","))
// 在下面的元组中，以第2个元素基，取出前3大的元组
val array: Array[(Int, Int, Int)] = Array((1, 3, 3), (2, 6, 3), (1, 1, 2), (1, 5, 4), (2, 1, 2))
val rdd1: RDD[(Int, Int, Int)] = sc.parallelize(array)
val top3By2RsArr: Array[(Int, Int, Int)] = rdd1.top(3)(Ordering.by[(Int, Int, Int), Int](_._2))
println(top3By2RsArr.mkString(","))

#####07) aggregate

函数签名

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U

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

val inRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 8)
// 将该 RDD 所有元素相加得到结果
val rs01: Int = inRDD.aggregate(0)(_ + _, _ + _)
println(rs01) //10
// aggregateByKey的初始值只会在分区内生效，不会在分区间生效
// aggregate的初始值在分区内和分区间都会生效
val rs02: Int = inRDD.aggregate(10)(_ + _, _ + _)
println(rs02) // 100
// 当分区间的函数与分区内的函数相同时，使用 fold 算子比 aggregate 更简洁
val rs03: Int = inRDD.fold(10)(_+_)
println(rs03) // 100

#####08) fold

函数签名

def fold(zeroValue: T)(op: (T, T) => T): T

函数说明
折叠操作，aggregate 的简化版操作

返回所有键值对的key

val rdd1 = sc.parallelize(List("dog", "tiger", "lion", "cat", "panther", "eagle"), 2)
val rdd2 = rdd1.map(x => (x.length, x))
rdd2.collect//Array((3,dog), (5,tiger), (4,lion), (3,cat), (7,panther), (5,eagle))

• keys: 返回所有键值对的key

rdd2.keys.collect//Array(3, 5, 4, 3, 7, 5)

• values: 返回所有键值对的value

rdd2.values.collect//Array(dog, tiger, lion, cat, panther, eagle)

• mapValues: 对键值对每个value都应用一个函数，key不会发生变化

val rdd1 = sc.parallelize(List((1,10),(2,20),(3,30)))
rdd1.mapValues(_*2).collect//Array((1,20), (2,40), (3,60))

#####09) countByKey

函数签名

// 只有键值对类型的数据可调用
def countByKey(): Map[K, Long]
def countByValue()(implicit ord: Ordering[T] = null): Map[T, Long]

函数说明
统计每种 key 的个数

val inKvRDD: RDD[(String,Int)] = sc.makeRDD(List(("b",2),("c",3),("c",3),("a",1),("a",1),("a",1)))
// 统计每种 key 的个数
val keyRsMap: collection.Map[String, Long] = inKvRDD.countByKey()
println(keyRsMap)  // Map(a -> 3, b -> 1, c -> 2)

// 统计各种值出现的次数
val inRDD: RDD[String] = sc.makeRDD(List("Hello","world","Spark","Hello"))
val valueRsMap: collection.Map[String, Long] = inRDD.countByValue
println(valueRsMap) //Map(Hello -> 2, world -> 1, Spark -> 1)

可以实现wordcount的8个算子：

• group、groupByKey、reduceByKey、aggregateByKey、flodByKey、combineByKey、countByKey、countByValue

#####10) save 相关算子

函数签名

def saveAsTextFile(path: String): Unit
def saveAsObjectFile(path: String): Unit
def saveAsSequenceFile(
 path: String,
 codec: Option[Class[_ <: CompressionCodec]] = None): Unit

详情参阅 [5.3.10 RDD 文件读取与保存](#5.3.10 RDD 文件读取与保存)

#####11) foreach

函数签名

// Applies a function f to all elements of this RDD. 将函数应用与此RDD的所有元素
def foreach(f: T => Unit): Unit = withScope { // 函数的输入是RDD中元素具体的类型
  val cleanF = sc.clean(f) // 闭包检测，比如：检查对象的序列化
  sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF))
}
// Applies a function f to each partition of this RDD.  将函数应用与此RDD的所有元素
def foreachPartition(f: Iterator[T] => Unit): Unit = withScope {
  val cleanF = sc.clean(f)
  sc.runJob(this, (iter: Iterator[T]) => cleanF(iter))
}

函数说明
分布式遍历 RDD 中的每一个元素，调用指定函数

val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
// 将数据按分区顺序收集后到Driver端后再调用集合的foreach方法去打印，所以打印结果有序
rdd.map(num=>num).collect().foreach(println)
println("****************")
// 对Executer端内存的数据使用foreach算子直接打印，所以打印的结果无序
rdd.foreach(println)

总结：RDD算子和集合对象的方法的区别：

1. 集合对象的方法都是在同一个节点的内存中完成的；
2. RDD的方法可以将计算逻辑发送到Executor端（分布式节点）执行

为了区分不同的处理效果，所以将RDD的方法称之为算子

12) foreachPartition

函数说明

//在spark-shell中执行, 去web页面node01:8088查找
val rdd = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
rdd.foreach(x => println(x*100))//x每个元素,即一个一个的数字
rdd.foreachPartition(x => println(x.reduce(_ + _)))//x是每个分区

以下是在IDEA中操作:

val inRDD: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
//将函数应用于此RDD的每个分区，分布式执行，结果也是无序的
inRDD.foreachPartition(
  (slicesIter: Iterator[Int]) => {
    val slicesSum: Int = slicesIter.sum // slicesIter.reduce(_+_)
    println(slicesSum) //结果分别是	24  15  6
  })

(了解)应用场景: 在函数中要将RDD中的元素保存到数据库

    foreach:会将函数作用到RDD中的每一条数据,那么有多少条数据, 操作数据库连接的开启关闭就得执行多少次

    foreachPartition: 将函数作用到每一个分区, 那么每一个分区执行一次数据库连接的开启关闭, 有几个分区就会执行数据库连接开启关闭

5.3.6 RDD 序列化

1) 闭包检查

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

2) 序列化方法和属性

​ 从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor 端执行，看如下代码：

class CurrentYear{ var year:Int = 2020 }

... ...

/* TODO 报错如下： 
        Task not serializable
        at org.apache.spark.util.ClosureCleaner$.ensureSerializable(ClosureCleaner.scala:298)
        at org.apache.spark.util.ClosureCleaner$.org$apache$spark$util$ClosureCleaner$$clean(ClosureCleaner.scala:288)
	    at org.apache.spark.util.ClosureCleaner$.clean(ClosureCleaner.scala:108)
	    at org.apache.spark.SparkContext.clean(SparkContext.scala:2287)
 */
val birthYearRDD: RDD[Int] = sc.makeRDD(List(1992,1995,2001,2003))
// 注意：currentYear这个对象是在Driver端创建的
val currentYear: CurrentYear = new CurrentYear()
val ageRDD: RDD[Int] = birthYearRDD.map(
  // 匿名函数的执行发生在Executor端，对象是在Driver端创建的
  // 匿名函数使用了函数外的CurrentYear对象，会闭包
  birthYear => currentYear.year - birthYear
)
println(ageRDD.collect.mkString("\t"))

【报错原因分析】

​ 匿名函数 birthYear => currentYear.year - birthYear 使用了函数之外的对象 currentYear，产生了闭包。在map算子的源码第一行val cleanF = sc.clean(f) ，再查看clear()方法源码第一行 ClosureCleaner.clean(f, checkSerializable) … … 最终执行了闭包检测，去检查 currentYear 对象是否已序列化。设置闭包前序列化的原因是：对象是在Driver端的内存中创建的，而这个匿名函数是在Executor端执行的，所有要把这个对象充Driver端传到Executor端，而对象不经过序列化是无法通过IO进行传输的，所以要闭包检测。

解决上述问题的办法：

1.CurrentYear类继承java.io.Serializable

class CurrentYear extends Serializable { var year:Int = 2020 }

2.使用样例类替换原来的CurrentYear类。样例类的编译时会自动混入序列化特质

// case class CurrentYear( year:Int = 2020) //或者使用下面这种写法
case class CurrentYear() {var year:Int = 2020 }

3) Kryo 序列化框架

参考地址: https://github.com/EsotericSoftware/kryo

• Java 的序列化能够序列化任何的类。但是比较重（字节多），序列化后，对象的提交也比较大，IO传输效率低。
• Spark 出于性能的考虑，Spark2.0 开始支持另外一种 Kryo 序列化机制。Kryo 速度是 Serializable 的 10 倍。当 RDD 在 Shuffle 数据的时候，简单数据类型、数组和字符串类型已经在 Spark 内部使用 Kryo 来序列化。

注意：即使使用 Kryo 序列化，也要继承 Serializable 接口。

class CurrentYear extends java.io.Serializable{ var year:Int = 2020 }    

... ...

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

5.3.7 RDD 依赖关系

1) RDD 血缘关系

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

val fileRDD: RDD[String] = sc.textFile("datas/words.txt")
println(fileRDD.toDebugString)
println("----------------------")
val wordRDD: RDD[String] = fileRDD.flatMap(_.split(" "))
println(wordRDD.toDebugString)
println("----------------------")
val mapRDD: RDD[(String, Int)] = wordRDD.map((_,1))
println(mapRDD.toDebugString)
println("----------------------")
val resultRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_)
println(resultRDD.toDebugString)
resultRDD.collect()

打印结果如下：

(2) datas/words.txt MapPartitionsRDD[1] at textFile at MyTestApp.scala:27 []
 |  datas/words.txt HadoopRDD[0] at textFile at MyTestApp.scala:27 []
----------------------
(2) MapPartitionsRDD[2] at flatMap at MyTestApp.scala:30 []
 |  datas/words.txt MapPartitionsRDD[1] at textFile at MyTestApp.scala:27 []
 |  datas/words.txt HadoopRDD[0] at textFile at MyTestApp.scala:27 []
----------------------
(2) MapPartitionsRDD[3] at map at MyTestApp.scala:33 []
 |  MapPartitionsRDD[2] at flatMap at MyTestApp.scala:30 []
 |  datas/words.txt MapPartitionsRDD[1] at textFile at MyTestApp.scala:27 []
 |  datas/words.txt HadoopRDD[0] at textFile at MyTestApp.scala:27 []
----------------------
(2) ShuffledRDD[4] at reduceByKey at MyTestApp.scala:36 []
 +-(2) MapPartitionsRDD[3] at map at MyTestApp.scala:33 []
    |  MapPartitionsRDD[2] at flatMap at MyTestApp.scala:30 []
    |  datas/words.txt MapPartitionsRDD[1] at textFile at MyTestApp.scala:27 []
    |  datas/words.txt HadoopRDD[0] at textFile at MyTestApp.scala:27 []

2) RDD 依赖关系

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

val fileRDD: RDD[String] = sc.textFile("datas/words.txt")
println(fileRDD.dependencies)
val wordRDD: RDD[String] = fileRDD.flatMap(_.split(" "))
println(wordRDD.dependencies)
val mapRDD: RDD[(String, Int)] = wordRDD.map((_,1))
println(mapRDD.dependencies)
val resultRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_)
println(resultRDD.dependencies)
resultRDD.collect()

3) RDD 窄依赖

窄依赖表示每一个父(上游)RDD 的 Partition 最多被子（下游）RDD 的一个 Partition 使用，窄依赖我们形象的比喻为独生子女。

class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd)

4) RDD 宽依赖

宽依赖表示同一个父（上游）RDD 的 Partition 被多个子（下游）RDD 的 Partition 依赖，会引起 Shuffle，总结：宽依赖我们形象的比喻为多生。

class ShuffleDependency[K: ClassTag, V: ClassTag, C: ClassTag](
 @transient private val _rdd: RDD[_ <: Product2[K, V]],
 val partitioner: Partitioner,
 val serializer: Serializer = SparkEnv.get.serializer,
 val keyOrdering: Option[Ordering[K]] = None,
 val aggregator: Option[Aggregator[K, V, C]] = None,
 val mapSideCombine: Boolean = false)
 extends Dependency[Product2[K, V]]

5) RDD 阶段划分

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

6) RDD 阶段划分源码

视频讲解

try {
 // New stage creation may throw an exception if, for example, jobs are run on a HadoopRDD whose underlying HDFS files have been deleted.
 finalStage = createResultStage(finalRDD, func, partitions, jobId, callSite)
} catch {
 case e: Exception =>
 logWarning("Creating new stage failed due to exception - job: " + jobId, e)
 listener.jobFailed(e)
 return
}
……
private def createResultStage(
 rdd: RDD[_],
 func: (TaskContext, Iterator[_]) => _,
 partitions: Array[Int],
 jobId: Int,
 callSite: CallSite): ResultStage = {
val parents = getOrCreateParentStages(rdd, jobId)
val id = nextStageId.getAndIncrement()
val stage = new ResultStage(id, rdd, func, partitions, parents, jobId, callSite)
stageIdToStage(id) = stage
updateJobIdStageIdMaps(jobId, stage)
stage
}
……
private def getOrCreateParentStages(rdd: RDD[_], firstJobId: Int): List[Stage] 
= {
getShuffleDependencies(rdd).map { shuffleDep =>
 getOrCreateShuffleMapStage(shuffleDep, firstJobId)
}.toList
}
……
private[scheduler] def getShuffleDependencies(
 rdd: RDD[_]): HashSet[ShuffleDependency[_, _, _]] = {
val parents = new HashSet[ShuffleDependency[_, _, _]]
val visited = new HashSet[RDD[_]]
val waitingForVisit = new Stack[RDD[_]]
waitingForVisit.push(rdd)
while (waitingForVisit.nonEmpty) {
 val toVisit = waitingForVisit.pop()
 if (!visited(toVisit)) {
 visited += toVisit
 toVisit.dependencies.foreach {
 case shuffleDep: ShuffleDependency[_, _, _] =>
 parents += shuffleDep
 case dependency =>
 waitingForVisit.push(dependency.rdd)
 }
 } }
parents
}

7) RDD 任务划分

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

• Application：初始化一个 SparkContext 即生成一个 Application；
• Job：一个 Action 算子就会生成一个 Job；
• Stage：Stage 等于宽依赖(ShuffleDependency)的个数加 1；
• Task：一个 Stage 阶段中，最后一个 RDD 的分区个数就是 Task 的个数。

注意：Application → Job → Stage → Task 每一层都是 1 对 n 的关系。

8) RDD 任务划分源码

视频讲解

val tasks: Seq[Task[_]] = try {
 stage match {
 case stage: ShuffleMapStage =>
 partitionsToCompute.map { id =>
 val locs = taskIdToLocations(id)
 val part = stage.rdd.partitions(id)
 new ShuffleMapTask(stage.id, stage.latestInfo.attemptId,
 taskBinary, part, locs, stage.latestInfo.taskMetrics, properties, 
Option(jobId),
 Option(sc.applicationId), sc.applicationAttemptId)
 }
 case stage: ResultStage =>
 partitionsToCompute.map { id =>
 val p: Int = stage.partitions(id)
 val part = stage.rdd.partitions(p)
 val locs = taskIdToLocations(id)
 new ResultTask(stage.id, stage.latestInfo.attemptId,
 taskBinary, part, locs, id, properties, stage.latestInfo.taskMetrics,
 Option(jobId), Option(sc.applicationId), sc.applicationAttemptId)
 }
 }
……
val partitionsToCompute: Seq[Int] = stage.findMissingPartitions()
……
override def findMissingPartitions(): Seq[Int] = {
mapOutputTrackerMaster
 .findMissingPartitions(shuffleDep.shuffleId)
 .getOrElse(0 until numPartitions) }

5.3.8 RDD 持久化

1) RDD Cache 缓存

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

val fileRDD: RDD[String] = sc.textFile("datas/words.txt")
val wordRDD: RDD[String] = fileRDD.flatMap(_.split(" "))
/* TODO
    如果先做wordSum（统计所有单词的数量），再做wordCount (统计每个单词的数量)
    就会产生 2 个 Job，且这两个 Job 都使用到 wordRDD 对象。虽然编程时wordRDD
    这个对象在代码中可以复用，但是执行时 RDD 是不存储数据的，在执行第二个 Job
    时，只能从头读取一遍数据。因此，我们要把经过 flapMap 之后的数据持久化
 */
wordRDD.cache() //等价于： persist(StorageLevel.MEMORY_ONLY)
//wordRDD.persist(StorageLevel.MEMORY_AND_DISK_2) // 可以更改存储级别
wordRDD.count
val wordCountRDD: RDD[(String, Int)] = wordRDD.map((_,1)).reduceByKey(_+_)
wordCountRDD.collect.mkString("\t")
println(wordCountRDD.toDebugString)  //缓存操作会增加血缘依赖

存储级别

总结：

​ 缓存有可能丢失，或者存储于内存的数据由于内存不足而被删除，RDD 的缓存容错机制保证了即使缓存丢失也能保证计算的正确执行。通过基于 RDD 的一系列转换，丢失的数据会被重算，由于 RDD 的各个 Partition 是相对独立的，因此只需要计算丢失的部分即可，并不需要重算全部 Partition。
​ RDD对象的持久化操作不一定是为了数据的重用，在数据执行时间较长（shuffle），或数据比较重要的场合也可以持久化操作，这样做的目的是为了防止当一个节点失败了避免重新计算整个输入。

2) RDD CheckPoint 检查点

• 检查点其实就是通过将 RDD 中间结果写入磁盘，所以使用时必须要设置落盘的路径（通常是分布式文件系统），且任务执行完之后检查点内的数据仍会保留。注意：持久化时也可以落盘，但不需要指定落盘路径，因为持久化生成的是临时文件，任务运行结束后会直接删除。
• 由于血缘依赖过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，Checkpoint 检查点切断血缘依赖，如果检查点之后有节点出现问题，可以从检查点开始重做血缘，减少了开销。
• 对 RDD 进行 checkpoint 操作并不会马上被执行，必须执行 Action 操作才能触发。

// 设置检查点路径
sc.setCheckpointDir("./checkpoint1")
val lineRdd: RDD[String] = sc.makeRDD(List("Hello Spark","Hello Scala"),5)
// 业务逻辑
val wordRdd: RDD[String] = lineRdd.flatMap(line => line.split(" "))
val wordToOneRdd: RDD[(String, Long)] = wordRdd.map(
  word => {
    println("------")
    (word,1)
  }
)
// 如果不增加缓存,会再重新跑一个 job 做 checkpoint , 所以 ------ 会被打印 8 次
// 如果增加缓存, checkpoint 会直接从缓存中将数据保存起来，不需在从新跑一个job，所以 ------ 会被打印 4 次
wordToOneRdd.cache()
// 数据检查点：针对 wordToOneRdd 做检查点计算
wordToOneRdd.checkpoint() // 源码中调用了runjob，当使用cache时就不会运行这个runjob了
println(wordToOneRdd.toDebugString) // 注意 wordToOneRdd 的血缘关系的变化
// 触发执行逻辑
val wordCountRDD: RDD[(String, Long)] = wordToOneRdd.reduceByKey(_+_)
wordCountRDD.collect.foreach(println)
println(wordToOneRdd.toDebugString)
val wordSum: Long = wordToOneRdd.count
println(wordSum)

注意一：为了保证数据安全，会单独启动一个 job 执行 checkpoint 任务（在 checkpoint 源码中调用了runjob）。所以 checkpoint 一般要和 cache 联合使用，这样 checkpoint 的 job 会从 Cache 缓存中读取数据（不会去调用源码中的 runjob ），否则需要再从头计算一次 RDD。

注意二：下面是 wordToOneRdd 在不同的持久化情况下，处罚持久化前后的血缘依赖的变化状况

// 一. 既不使用 cache 也不使用 checkpoint 时
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 []
 |  MapPartitionsRDD[1] at flatMap at MyTestApp.scala:28 []
 |  ParallelCollectionRDD[0] at makeRDD at MyTestApp.scala:26 []
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 []
 |  MapPartitionsRDD[1] at flatMap at MyTestApp.scala:28 []
 |  ParallelCollectionRDD[0] at makeRDD at MyTestApp.scala:26 []

// 二. 仅使用 cache 不使用 checkpoint 时，结论：cache 操作执行之后 wordCountRDD 会额外增加一层血缘依赖，之后如果继续使用 wordCountRDD 时会直接从cache缓存中读取。内存数据易丢失，万一丢失，只能从头开始读取数据
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 [Memory Deserialized 1x Replicated]
 |  MapPartitionsRDD[1] at flatMap at MyTestApp.scala:28 [Memory Deserialized 1x Replicated]
 |  ParallelCollectionRDD[0] at makeRDD at MyTestApp.scala:26 [Memory Deserialized 1x Replicated]
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 [Memory Deserialized 1x Replicated]
 |       CachedPartitions: 5; MemorySize: 464.0 B; ExternalBlockStoreSize: 0.0 B; DiskSize: 0.0 B
 |  MapPartitionsRDD[1] at flatMap at MyTestApp.scala:28 [Memory Deserialized 1x Replicated]
 |  ParallelCollectionRDD[0] at makeRDD at MyTestApp.scala:26 [Memory Deserialized 1x Replicated]

// 三. 仅使用 checkpoint 不使用 cache 时, 结论：checkpoint 操作执行之后会切断之前的操作，之后如果继续使用 wordCountRDD 时会直接从checkpoint中读取
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 []
 |  MapPartitionsRDD[1] at flatMap at MyTestApp.scala:28 []
 |  ParallelCollectionRDD[0] at makeRDD at MyTestApp.scala:26 []
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 []
 |  ReliableCheckpointRDD[4] at collect at MyTestApp.scala:43 []

// 四. 同时使用 cache 和 checkpoint 时, 如果继续使用 wordCountRDD 时会先从cache缓存中读取，如果cache缓存的数据丢失，会从checkpoint中读取
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 [Memory Deserialized 1x Replicated]
 |  MapPartitionsRDD[1] at flatMap at MyTestApp.scala:28 [Memory Deserialized 1x Replicated]
 |  ParallelCollectionRDD[0] at makeRDD at MyTestApp.scala:26 [Memory Deserialized 1x Replicated]
(5) MapPartitionsRDD[2] at map at MyTestApp.scala:29 [Memory Deserialized 1x Replicated]
 |       CachedPartitions: 5; MemorySize: 464.0 B; ExternalBlockStoreSize: 0.0 B; DiskSize: 0.0 B
 |  ReliableCheckpointRDD[4] at collect at MyTestApp.scala:43 [Memory Deserialized 1x Replicated]

3) 缓存和检查点区别

1. Cache 缓存只是将数据保存起来，会在血缘关系中添加一层依赖但不切断血缘依赖，Checkpoint 检查点切断血缘依赖；
2. Cache 缓存的数据通常存储在磁盘、内存等地方，可靠性低。Checkpoint 的数据通常存储在 HDFS 等容错、高可用的文件系统，可靠性高；
3. 建议对 checkpoint()的 RDD 使用 Cache 缓存，这样 checkpoint 的 job 只需从 Cache 缓存中读取数据即可，否则需要再从头计算一次 RDD。

5.3.9 RDD 分区器

​ Spark 目前支持 Hash 分区和 Range 分区，和用户自定义分区。Hash 分区为当前的默认分区。分区器直接决定了 RDD 中分区的个数、RDD 中每条数据经过 Shuffle 后进入哪个分区，进而决定了 Reduce 的个数。 [返回 partitionBy算子章节](#17 partitionBy)

• 只有 Key-Value 类型的 RDD 才有分区器，非 Key-Value 类型的 RDD 分区的值是 None
• 每个 RDD 的分区 ID 范围：0 ~ (numPartitions - 1)，决定这个值是属于那个分区的。

1) 自定义分区

/**
 * 自定义分区器
 * @param partitions 传入的参数：分区数
 */
class MyCustomPartitioner(partitions: Int) extends org.apache.spark.Partitioner {
  // numPartitions才是真正执行时的分区数，这里我们不使用传入的参数partitions，将分区数写死为 2
  override def numPartitions: Int = 3
  /**
   * 根据传入的key，返回该元素应该被分配的分区编号
   * @param key
   * @return
   */
  override def getPartition(key: Any): Int = {
    // 通过 numPartitions 方法得知有两个分区
    key match {
      case "BigData" => 0
      case "JavaEE" => 1
      case _ => 2
    }
  }
}

def main(args: Array[String]): Unit = {
  // 初始化运行环境
  val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("CustomPartition")
  val sc: SparkContext = new SparkContext(sparkConf)
  sc.setLogLevel("ERROR")
  val inRDD: RDD[(String, String)] = sc.makeRDD(List(
    ("JavaEE", "SpringBoot"), ("BigData", "Hadoop"),
    ("RMDB", "Access"), ("BigData", "Flink"),
    ("JavaEE", "SpringCloud"), ("RMDB", "TiDB")
  ), 4)
  inRDD.saveAsTextFile("outPut1")
  //TODO: 使用 HashPartitioner 分区器，将key取hash值后的，将hash值和分区数取余，得到分区编号
  val newHashRDD: RDD[(String, String)] = inRDD.partitionBy(new HashPartitioner(3))
  newHashRDD.saveAsTextFile("outPut2")
  /*TODO 自定义分区器,设置3个分区
     将 key = BigData 的元素放入编号为 0 的分区
     将 key = JavaEE  的元素放入编号为 1 的分区
     将 key = RMDB    的元素放入编号为 2 的分区*/
  val newPartitionRDD: RDD[(String, String)] = inRDD.partitionBy(new MyCustomPartitioner(2))
  newPartitionRDD.saveAsTextFile("outPut3")
  sc.stop()
}

2) Hash 分区

对于给定的 key，计算其 hashCode,并除以分区个数取余。

class HashPartitioner(partitions: Int) extends Partitioner {
 require(partitions >= 0, s"Number of partitions ($partitions) cannot be negative.")
 def numPartitions: Int = partitions
 def getPartition(key: Any): Int = key match {
  case null => 0
  case _ => Utils.nonNegativeMod(key.hashCode, numPartitions)
 }
 override def equals(other: Any): Boolean = other match {
  case h: HashPartitioner => h.numPartitions == numPartitions
  case _ => false
 }
 override def hashCode: Int = numPartitions
}

3) Range 分区

将一定范围内的数据映射到一个分区中，尽量保证每个分区数据均匀，而且分区间有序。我们假设待处理的数据的key均为英文大写字母且在A-Z之间，Partition数为3，则RangePartitioner运行时会使用蓄水池抽样算法从A-Z之中选出两个字母作为分隔符，假设选中的字母是为H和S，则key在字母[A,H]之间的，属于Partition 0，[I,S]属于Partition 1，[T,Z] 属于Partition 2。 [返回 partitionBy算子章节](#17 partitionBy)

// 模拟蓄水池抽样算法
import scala.collection.immutable
object ReservoirSampling {
  def main(args: Array[String]): Unit = {
    val intSeq: Range.Inclusive = 65 to 90 // [A,Z]
    val charSeq: immutable.IndexedSeq[Char] = intSeq.map(_.toChar)
    println(charSeq.mkString(" "))
    val iter: Iterator[Char] = charSeq.iterator

    val K: Int = 2 // K表示从[A,Z]数据集中随机抽取的字母 2 个
    val rsArr: Array[Char] = new Array[Char](K) // 存放被抽取的字母
    var i: Int = 0 // i指原数据的索引

    while (iter.hasNext) {
      // 当 i < 2 时，前 2个元素 A、B 一定会被选中
      if (i < K) {
        rsArr(i) = iter.next()
      } else {
        // 当 i>=2 时，我们要处理的是第 i+1 个元素，选中第 i+1 行元素的概率是：  1/(i+1)
        // 例如 i>=2 时，我们要处理的是 C 这个元素，它有 1/(2+1) 的概率被选中放到rsArr
        val ramInt: Int = getIntRangRandom(0, i) // 生成 [0,i]间的整数
        val char: Char = iter.next()
        if (ramInt < K) {
          rsArr(ramInt) = char
        }
      }
      i = i + 1
    }
    println(rsArr.mkString(","))

    // 生成一个 [start,end] 建的整数
    def getIntRangRandom(start: Int, end: Int): Int = {
      (start + math.random * end).toInt
    }
  }
}

5.3.10 RDD 文件读取与保存

• Spark 的数据读取及数据保存可以从两个维度来作区分：文件格式以及文件系统。
• 文件格式分为：text 文件、csv 文件、sequence 文件以及 Object 文件；
• 文件系统分为：本地文件系统、HDFS、HBASE 以及数据库。

text 文件

val dataRDD: RDD[(String, String)] = sc.makeRDD(List(
  ("JavaEE", "SpringBoot"), ("BigData", "Hadoop"), ("RMDB", "Access"),
  ("BigData", "Flink"), ("JavaEE", "SpringCloud"), ("RMDB", "TiDB")), 3)
// 保存数据为 TextFile
dataRDD.saveAsTextFile("output01")
// 保存数据为 TextFile
sc.textFile("output01").collect().foreach(println)

sequence 文件

​ SequenceFile 文件是 Hadoop 用来存储二进制形式的 key-value 对而设计的一种平面文件(Flat File)。在 SparkContext 中，可以调用 sequenceFile[keyClass, valueClass](path)。

// 保存数据为 SequenceFile
dataRDD.saveAsSequenceFile("output02")
// 读取 SequenceFile 文件，注意泛型是 [String, String]
sc.sequenceFile[String, String]("output02").collect().foreach(println)

object 对象文件

​ 对象文件是将对象序列化后保存的文件，采用 Java 的序列化机制。可以通过 objectFile[T: ClassTag](path) 函数接收一个路径，读取对象文件，返回对应的 RDD，也可以通过调用 saveAsObjectFile() 实现对对象文件的输出。因为是序列化所以要指定类型。[返回save算子章节](#10 save 相关算子)

// 保存数据
dataRDD.saveAsObjectFile("output03")
// 读取数据
sc.objectFile[(String,String)]("output03").collect().foreach(println)

case class CustomObj(subject: String, course: String)
dataRDD.map(a => CustomObj(a._1,a._2)).saveAsObjectFile("output04")
sc.objectFile[CustomObj]("output04").collect().foreach(println)

5.4 累加器

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

​ 累加器的本质是分布式共享只写变量（只有driver能读）。

5.4.1 系统累加器

视频讲解

val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5))
//不使用累加器
var sum: Int = 0
rdd.foreach( elem => sum += elem )
println("sum = " + sum) //函数闭包时会传染sum = 0，但计算后没有返回

// 使用累加器
// 创建一个系统累加器对象（源码通过封装替我们完成了向sc中的注册）
val sumAcc: org.apache.spark.util.LongAccumulator = sc.longAccumulator("sumAcc")
rdd.foreach(sumAcc.add(_)) // 将RDD中的每个元素添加给累加器去做累加处理
// 获取累加器的值
println("sumAcc.value = " + sumAcc.value) //sumAcc.value = 15

一般情况下，累加器会被放置在行动算子中进行操作，防止出现多加或少加

5.4.2 自定义累加器

自定义累加器实现wordCount可以避免shuffle

import org.apache.spark.rdd.RDD
import org.apache.spark.util.AccumulatorV2
import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.mutable

object CustomAccumulatorV2App {
  def main(args: Array[String]): Unit = {
    // 初始化运行环境
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("CustomAccumulatorV2")
    val sc: SparkContext = new SparkContext(sparkConf)
    sc.setLogLevel("ERROR")
    //==================================================================================================
    val dataRDD: RDD[String] = sc.makeRDD(List("Hello Spark", "Hello Scala"))
    val wordRDD: RDD[String] = dataRDD.flatMap(_.split(" "))
    //TODO 1. 使用自定义的 MyAccumulator累加器创建一个累加器对象
    val myAcc: MyAccumulatorV2 = new MyAccumulatorV2()
    //TODO 2. 向SparkContext中注册累加器
    sc.register(myAcc, "wordCountAcc")
    //TODO 3. 使用foreach算子遍历wordRDD，将每个单词添加给累加器，通过累加器内的逻辑计算wordCount
    wordRDD.foreach(elem => myAcc.add(elem))
    //TODO 4. 获取累加器的输出结果
    val wordCountMap: mutable.Map[String, Long] = myAcc.value
    println(wordCountMap)
    //==================================================================================================
    sc.stop()
  }

  /* 自定义累加器，实现wordCount功能
      继承 AccumulatorV2[IN,OUT] ，声明泛型:
         IN : 累加器输入的数据类型，输入是每个单词
         OUT: 累加器返回的数据类型，输出是wordCont的结果集
   */
  class MyAccumulatorV2 extends org.apache.spark.util.AccumulatorV2[String, mutable.Map[String, Long]] {
    //TODO 第一步： 声明一个集合（成员变量），用来存储结果
    private var rsMap: mutable.Map[String, Long] = mutable.Map[String, Long]()
    // 判断是否是初始状态
    override def isZero: Boolean = rsMap.isEmpty // 如果结果集没有元素，那么就是初始状态
    // 复制一个累加器
    override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = {
      new MyAccumulatorV2()
    }
    //重置累加器
    override def reset(): Unit = rsMap.clear()
    //TODO 第二步： 各分区的元素传入给分区中的累加器，分区内的累加器拿到每个元素后经过处理，存入到分区累加器的rsMap中
    override def add(word: String): Unit = {
      val value: Long = rsMap.getOrElse(word, 0L)
      rsMap.put(word, value + 1L)
    }
    // TODO 第四步： 分区任务计算完成后，会将分区累加器传给Driver端的merge方法
    //  在merge方法中将各分区的累加的结果取出，经过处理存入Driver端的rsMap中
    override def merge(partitionerAcc: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = {
      val driverRsMap: mutable.Map[String, Long] = this.rsMap
      val partitionerRsMap: mutable.Map[String, Long] = partitionerAcc.value
      partitionerRsMap.foreach { // 依次取出分区rsMap的元素，存入driverRsMap
        case (word, count) =>
          val countInDriver: Long = driverRsMap.getOrElse(word, 0L)
          driverRsMap.put(word, countInDriver + count)
      }
    }
    // TODO 第三步： 返回分区累加器中的结果集rsMap
    // TODO 第五步： 返回Driver端累加器中的结果集rsMap
    override def value: mutable.Map[String, Long] = rsMap
  }

}

5.5 广播变量

5.5.1 实现原理

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

​ 原理：Executor的本质就是一个独立的JVM进程，所以在启动Executor时会自动分配内存。Spark的广播变量就是将任务中的闭包数据放置在Executor的内存中，达到共享的目的。

5.5.2 基础编程

val dataRDD: RDD[(String, Int)] = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3), ("d", 4)), 4)
val dataMap: Map[String, Int] = Map("a" -> 4, "b" -> 5, "c" -> 6, "d" -> 7)
// 使用join求两个数据集中相同的key对应的value有哪些
val dataList: List[(String, Int)] = dataMap.toList
val otherRDD: RDD[(String, Int)] = sc.makeRDD(dataList)
val joinedRDD: RDD[(String, (Int, Int))] = dataRDD.join(otherRDD)
println(joinedRDD.collect.mkString("\t+\t"))
println("------------------------------")
// 优化一：join不仅会产生shuffle，而且极易产生笛卡尔积，所以可以根据key直接在dataMap中查找
val rs01RDD: RDD[(String, (Int, Int))] = dataRDD.map {
  case (key, num) =>
    val num2: Int = dataMap.getOrElse(key, 0)
    (key, (num, num2))
  // 改匿名函数使用到了外部变量dataMap，会产生闭包，所以每个任务都会将dataMap传输一次
  // 如果dataRDD的分区有10个，Executor只有一个，就会出现 10个任务在同一个Executor上执行
  // 所以dataMap向同一个Executor传输10次dataMap数据，造成内存浪费
}
println(rs01RDD.collect.mkString("\t-\t"))
println("============================")
// 优化二：将dataMap使用广播变量发送到Executor的内存中，让在同一个Excutor上执行的变量都能
// 从Executor的内存中获取到dataMap。 注意：广播变量是只读的
val broadcast: org.apache.spark.broadcast.Broadcast[Map[String, Int]] = sc.broadcast(dataMap)
val rs02RDD: RDD[(String, (Int, Int))] = dataRDD.map(
  kv => {
    val key: String = kv._1
    val num: Int = kv._2
    val dataMapFromBC: Map[String, Int] = broadcast.value
    val num2: Int = dataMapFromBC.getOrElse(key,0)
    (key,(num,num2))
  }
)
println(rs02RDD.collect.mkString("\t*\t"))