Spark on boboboker~

spark-submit --name JOB-NAME --master yarn --deploy-mode cluster --conf spark.yarn.submit.waitAppCompletion=false --class com.mxtao.App --jars /xxx/xxx.jar,/xxx/xxxx.jar --queue xx --pincipal xxx@DOMAN --keytab xxx.keytab main-class-in-this-jar.jar args-for-main

Submitting Applications

Running Spark on YARN - Spark Properties

Submitting Applications

Running Spark on YARN - Spark Properties

1. 准备开发环境

Mon, 09 Mar 2020 00:00:00 +0800

准备开发环境

Windows
- JDK
- Scala SDK
- Spark
- IDEA
WSL / Linux
- VSCode Remote

在Windows系统配置开发及测试环境

Windows

JDK

安装

需要下载安装两个版本的JDK：
- JDK 1.7：用于适配公司平台打包程序使用，互联网环境做测试可以先不装。现在很难下到了，内网的话，咱们自己有。
- JDK 1.8：本地运行Spark Shell使用，Oracle现在贼了不少，需要Oracle账户才能下载，百度上有很多分享，搜一个就行
对于我们目前的开发和测试，请使用JDK1.8，先不要使用JDK11(虽然它是LTS)。（测试过JDK11+Scala，有的行为不一致，可能是Scala对高版本JDK的优化？？？）
配置JAVA_HOME环境变量

将JDK 1.8配置到JAVA_HOME作为全局使用

注意：Spark运行的时候是查找JAVA_HOME环境变量然后运行，不是从PATH中的java.exe启动

注意：如果将JDK安装在默认位置，如C:\Program Files\Java\jdk1.8.0_241\，由于路径中的空格问题，将会导致Windows上的Spark Shell启动失败，将JAVA_HOME环境变量修改成：C:\PROGRA~1\Java\jdk1.8.0_241\这种形式

配置PATH环境变量

这个步骤不是必须，但是建议做，环境变量配置完毕后，可以用java -version命令来验证安装

PS C:\Users\mxtao> java -version
java version "1.8.0_241"
Java(TM) SE Runtime Environment (build 1.8.0_241-b07)
Java HotSpot(TM) 64-Bit Server VM (build 25.241-b07, mixed mode)
PS C:\Users\mxtao>

Scala SDK

需要下载安装两个版本的Scala SDK：

Scala 2.10.7: 用于适配公司平台打包程序使用
Scala 2.11.12：面向测试环境开发程序使用

将两个Scala SDK的zip下载并解压到某处即可，如C:\Program Files\Scala\，不需要配置环境变量。安装完毕之后，可以进入安装目录尝试启动一下Scala REPL，可以在这个环境尝试一下Scala语言。

PS C:\Program Files\Scala\scala-2.11.12\bin> .\scala
Welcome to Scala 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_241).
Type in expressions for evaluation. Or try :help.

scala> :quit
PS C:\Program Files\Scala\scala-2.11.12\bin>

如果是互联网环境开发，Scala SDK的手动安装可以跳过，使用IDEA来下载Scala SDK，如下图所示。

Spark

下载安装Spark

建议从Downloads | Apache Spark找到最新稳定版进行下载，建议选择“Pre-build for Apache Hadoop”版本进行下载，这样避免配置Hadoop环境的麻烦。此处附上国内清华镜像的Spark 2.4.5 & Hadoop 2.7。将这个压缩包解压到某处即可，如C:\Software\Spark\

Spark目录下的examples是一些样例代码，包含Spark Core、Spark SQL及其它组件的使用样例，可以直接参考使用
配置WinUtils

若要使Hadoop在Windows上正常运行，需要做些别的事情。从此处cdarlint/winutils找到对应或者更高版本的winutils下载下来。此处附上该项目的完整ZIP。

我们前面下载的Spark附带的是Hadoop 2.7，因此我们选择了适配2.7.7版本的winutils，将所有文件放在C:\Software\Hadoop\bin中，此时winutils.exe完整路径为C:\Software\Hadoop\bin\winutils.exe

现在开始配置环境变量，新增名为HADOOP_HOME的环境变量，其值为C:\Software\Hadoop，然后在PATH环境变量中添加%HADOOP_HOME%\bin\

必须配置HADOOP_HOME环境变量

启动Spark Shell

进入上文Spark的安装目录，尝试启动Spark Shell检查安装情况。按Ctrl+D可退出Spark Shell

PS C:\Software\Spark\spark-2.4.5-bin-hadoop2.7\bin> ./spark-shell
Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
Spark context Web UI available at http://DESKTOP-9LN67TS.mshome.net:4040
Spark context available as 'sc' (master = local[*], app id = local-1581394859054).
Spark session available as 'spark'.
Welcome to
    ____              __
    / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
/___/ .__/\_,_/_/ /_/\_\   version 2.4.5
    /_/

Using Scala version 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_241)
Type in expressions to have them evaluated.
Type :help for more information.

scala>

观察输出的内容，Spark Shell的Application UI开放在本地4040端口，可以访问看看，如下图所示。由于尚未运行任务，所以暂时没太多实质内容

IDEA

安装IDEA，安装Scala插件。这里主要解释如何创建一个方便本地测试的项目。

创建一个Scala项目，JDK版本选择1.8，Scala SDK版本选择2.11.12。创建完毕后，将Spark安装目录下的jars(即C:\Software\Spark\spark-2.4.5-bin-hadoop2.7\jars)设为项目依赖包。到目前为止，项目配置已完毕，可以直接在本地环境调试Spark项目。下面附上一段代码作为本地项目起点

import org.apache.spark.sql.SparkSession

object Application {

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().appName("LocalSparkApp").master("local[*]").getOrCreate()
    val sc = spark.sparkContext
    import spark.implicits._

    // val schema = "a INT, b STRING, c DOUBLE"
    // val df = spark.read.schema(schema).option("sep", "\t").csv("/local-path-to-file/")
    // df.createOrReplaceTempView("t")
    // spark.sql("select * from t where a > 10").show(20)

    // write your code here ...

    spark.close()
  }
}

对于我们面向生产的项目，JDK版本1.7，Scala版本2.10.7，依赖jar用生产环境的，然后编译出jar即可。

WSL / Linux

在纯Windows环境中，无法启动Spark Standalone模式集群，我们尝试从另外的角度解决这一问题。此处假定大家使用Windows10系统。如果是低版本Windows，那也许只能安装虚拟机Linux或者阿里云之类的云服务Linux来启动了。

启用WSL

在“控制面板”-“程序和功能”-“启用或关闭Windows功能”找到“适用于Windows的Linux子系统”并点击启用，如下图所示

或者在管理员权限启动的PowerShell中执行如下命令
1

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
然后重启计算机（界面勾选或者执行命令都需要重启）
安装一个Linux

打开Windows10应用商店(无需微软账户也可使用)，在搜索栏输入Ubuntu，建议选择Ubuntu 18.04 LTS安装。安装完成之后，在Windows开始菜单即可找到这一应用，点击打开。首次启动如下图所示，将会要求创建Unix用户名和密码，创建完毕即可正常使用(有时会卡在take a few minutes...一段时间，可以按一下回车。任何时候出现了问题都可以将这个Ubuntu应用卸载然后重新安装)

配置WSL

在我们安装的这个Ubuntu 18.04 LTS中，依次键入如下命令进行环境配置，不要粘贴一大段执行（尤其前几个sudo执行的命令），因为要输入刚刚设定的Unix密码

sudo apt update
sudo apt upgrade -y # 更新本地现已安装的软件包

sudo apt install openjdk-8-jdk -y # 安装JDK8

cd ~

# 本地盘会自动挂载到Linux子系统中，例如C盘挂载于 /mnt/c/，找到Windows系统的Spark，放到Linux中用
# 也可以将原来的tgz包重新解压到Linux系统某处，作为Linux自己的安装，如/opt/spark/
echo "export SPARK_HOME=/mnt/c/Software/Spark/spark-2.4.5-bin-hadoop2.7/" >> .profile 
echo 'export PATH=$PATH:$SPARK_HOME/bin' >> .profile
source .profile
ln -s /mnt/c/Software/Spark/spark-2.4.5-bin-hadoop2.7/sbin spark-sbin

cd spark-sbin
./start-master.sh # 启动Spark Master，此时可以查看localhost:8080查看Spark Master UI，从此处得到master url
./start-slave.sh spark://DESKTOP-9LN67TS.localdomain:7077 # 启动Spark Worker，刷新MasterUI，看到有了个Worker
cd ~
spark-shell --master spark://DESKTOP-9LN67TS.localdomain:7077   # 启动集群模式的Spark Shell，刷新MasterUI，看到有Application 出现

cd spark-sbin
./stop-slave.sh     # 停止Spark Master
./stop-master.sh    # 停止Spark Worker

# 不要用start-all.sh/stop-all.sh/start-slaves.sh/stop-slaves.sh，在WSL上，没有开启22端口，执行这几个命令会出错

WSL依然存在问题，比如最显著的IO性能问题、某些Linux应用尚不兼容问题(WSL2将着手解决)，但对我们而言，只是构造出一个开发测试环境，我认为这些问题可以不用在意，避免了安装虚拟机的各种麻烦，这点程度的损失是可以接受的。若是无法安装/配置WSL，而是有一个Linux机器，环境配置流程是一样的，按照安装JDK -> 安装Spark -> 启动Spark 的流程进行即可，几个主要Web UI如下所示：

Spark Master Web UI
Spark Worker Web UI
Spark Shell Web UI

至此，我们的已经配置启动了Standalone模式的Spark集群，之后可以向这个集群提交任务并运行。一般的提交命令如下所示：

`1`	`spark-submit --master spark://hostname:port --deploy-mode cluster --class xxx.spark.Application SparkApp.jar`

任务提交运行完毕后，Spark Master UI如下所示，可以通过界面上相应App的链接去查看之前任务运行的日志。

VSCode Remote

需要互联网连接

由于Windows上开发环境配置还是有些麻烦，测试环境/仅尝试下Spark的话，可以考虑使用Visual Studio Code进行远程开发(参考VS Code Remote Development)

Windows上安装好了VSCode后，在WSL/Linux上安装JDK + Spark + Maven即可开始。用到的VSCode插件有Remote WSL/Remote SSH和Scala(Metals)，这种方式的话，对于Windows环境将不再有任何要求

2. Scala Intro

Mon, 09 Mar 2020 00:00:00 +0800

Scala Intro

Scala是一门功能特别丰富的编程语言，我们涉及到的只是其一个较小的子集，此处列出相关文档，可以自行学习

Scala官方文档也提供了中文版，但有的翻译感觉还是有点生硬。此处将仅给出中文版的URL，如果要访问英文版，将URL中zh-cn去掉即可。

可以先看一下A Scala Tutorial for Java Programmers，这篇文档没有简体中文，有繁体中文版，但是很多概念跟我们说的名字不一样，要不直接看英文版得了。

官方提供了Tour of Scala系列文档来介绍语言的核心功能，这里列出这系列文档的子集，因为我们用到的也仅是个子集

基础: 最基本的语言基础，告诉我们表达式怎么写、函数怎么定义、类如何定义等
统一类型: 介绍了Scala类型层次结构
类: 定义一个类及其成员
元组: 需要了解是什么，怎么用
高阶函数: 好像有点厉害，只要能理解了函数可以作为参数和返回值即可
单例对象: 这个概念最好搞明白
泛型类: 泛型使用
类型推断: 由此，我们很多地方不需要写类型
包和导入: 跟java差不多

以上是我们用到的，搞懂以上概念，目前我们写的大部分代码看懂应该没什么问题，如果有时间还是建议把全系列翻一遍

Scala语法速查

3. 使用 Spark 进行数据分析

Mon, 09 Mar 2020 00:00:00 +0800

使用 Spark 进行数据分析

Spark简介
Spark处理数据
- Spark Core
- Spark SQL
开发一个Spark程序
开发常见问题

Spark简介

Apache Spark是个分布式计算框架，其提供了一大批高级API基于批处理或流式处理对大规模数据做ETL、机器学习和图处理等。可以用来开发Spark程序的编程语言有Scala、Python、Java、R和SQL。也可以将其理解成一个具备批处理和流处理能力的分布式数据处理引擎，支持SQL查询、图处理和机器学习等。Spark平台的组件间关系如下图所示：

Spark Core是整个Spark平台的核心部分，实现了重要的基础功能，例如输入输出、任务分发和调度、错误恢复等。Spark Core定义了一个特殊的数据结构RDD，并提供了一系列操作RDD的编程API。

Spark SQL是基于Spark API开发的能进行关系型数据处理的组件。该组件赋予Spark开发者对关系型数据处理的能力，也能让SQL用户能进行基于Spark的复杂分析。与Spark Core相比，Spark SQL是个从关系型视角对(半)结构化数据进行处理的框架，我们可以用SQL及SQL风格API来描述业务逻辑。

Spark Architecture

Spark程序可以看作是一组互相独立地跑在集群上的进程，这组进程接受driver进程(main所处的进程)中的SparkContext对象协调的。其简单结构如下图所示：

Cluster Manger负责为应用分配集群的资源，SparkContext适配了多种类型的集群（如Spark Standalone、Apache Mesos、Hadoop YARN、Kubernetes，我们实际情况是YARN）。Spark程序运行时，SparkContext首先去找Cluster Manager请求资源(executor，可以执行计算及存储应用数据的进程)，然后SparkContext将程序代码分发到各个executor，最后SparkContext把task发送到各个executor去执行。

需要指出以下事项：

每个Spark程序获得的是属于自己的executors，这些executors在整个程序运行过程中保持运行，以多线程方式处理任务。这个特点使多个Spark程序在调度侧（每个driver只调度自己的task）和执行侧（不同程序的task跑在不同的JVM里）都是互相隔离的。当然了，如果不把数据持久化到外部，那么不同的Spark程序也就无法共享数据。
Spark对于集群管理器并不关心，只关心自己要来的executor。
程序整个生命周期内，driver必须一直监听着executor发起的连接，这意味这driver和executors是必须网络通畅的。

`RDD`

RDD(即弹性分布式数据集)是Spark Core中的核心概念之一，是Spark最重要的数据抽象，所有数据处理都是基于对RDD的处理来实现。。从名字上体现出了其一些特点

弹性：这里的意思侧重“可恢复”，而不是“可伸缩”。RDD能从各种意外(比如节点挂掉、executor被误杀等)导致的数据丢失或损坏中进行重新计算，是支持错误恢复的
分布式：数据分布在集群的各个节点中
数据集：数据的集合，数据可以是简单的数值，也可以是更复杂的类型，例如Tuple、List、Map等数据结构，甚至可以是自行定义的类对象

除此之外，RDD有一些其他特点，这里列出几个

内存优先：Spark程序运行时，RDD中的数据会尽可能多且尽可能久地保存在内存中
不可变/只读：RDD一旦创建就不再可变，只能通过变换生成一个新的RDD
延迟计算：在一个action触发了任务实际运行之前，RDD中的数据尚不可及
可缓存：可以将RDD中全部数据持久化到某个存储，例如内存(默认及绝大多数情况)或者硬盘(由于硬盘存取速度问题，一般很少这么做)
并行化：对RDD数据的处理是并行的
类型化：RDD中的数据是有类型的，例如Long类型数据放在RDD[Long]中，Student对象放在RDD[Student]中

RDD支持两种类型的操作：transformation（转换）和action（动作）。从现有RDD生成新RDD的操作称为transformation，从RDD上运行执行计算然后求得一个值的操作称为action。transformation是延迟计算的。当对一个RDD执行了transformation之后，便构造出了一个“RDD血缘图”，记录了对RDD的变换操作和依赖信息。我们需要对依赖情况做到心里有数，宽窄依赖如下所示：

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

`Dataset[T]`&`DataFrame`

对于Spark SQL而言，Dataset[T]是其核心类之一，所有的操作都是对Dataset的处理(提交的SQL也会首先被解析成操作Dataset)。在内部，所有对Dataset的操作最终转换成RDD的操作。

Dataset是个分布式的数据集合。它是Spark1.6新增的接口，综合了RDD的优势(强类型，强大的λ函数能力)和Spark SQL的优化执行引擎优势。DataFrame是个数据已进行字段命名的Dataset。在Spark SQL中DataFrame=Dataset[Row]

对Dataset的操作也可以分transformation和action两类。其中变换操作(transformation)，分为“typed”和“untyped”两类。所谓“typed”，指的是编译时已知要处理的数据的类型(例如操作Dataset[Student])；相对应的，“untyped”指的是编译时不知道要处理的数据的类型（操作DataFrame）。

用Spark处理数据

对于有一些经验的同事，可以考虑深入研究Spark Core部分的算子，对比其使用场景；对于入门且马上要进行数据分析的同事，可以考虑直接使用Spark SQL，只需要一小部分的编程即可，数据分析可以直接以SQL实现。

另一方面，由于Spark Core与Spark SQL可以组合使用(基于Dataset/DataFrame/RDD的互相转换)，有经验的同事可以尝试各种操作，入门的话还是建议一步步来。

获取`SparkContext`&`SparkSession`对象

SparkContext是Spark服务的入口点，堪比Spark程序的心脏；SparkSession是Spark SQL的入口点。

构造/获取SparkContext对象的方式有很多，例如下面通过SparkConf来构造，但这种方式我用得不多了

1
2
3

import org.apache.spark.{SparkConf, SparkContext}
val conf = new SparkConf().setMaster("local[*]").setAppName("LocalSparkApp")
val sc = SparkContext.getOrCreate(conf)

开发应用程序时，一般以如下方式获取两者的对象。

import org.apache.spark.sql.SparkSession

// local spark application
val spark = SparkSession.builder().appName("LocalSparkApp").master("local[*]").getOrCreate()
// spark application
val spark = SparkSession.builder().appName("SparkApp").master("yarn").getOrCreate()
val sc = spark.sparkContext

建议：将SparkSession对象命名为spark、将SparkContext对象命名为sc，使之与Spark-Shell环境保持一致。这样核心逻辑代码可以直接拿到Spark-Shell中使用。

Spark-Shell会直接初始化这两者给我们使用(控制台输出的6-7行)。

PS C:\Software\Spark\spark-2.4.5-bin-hadoop2.7\bin> ./spark-shell
Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
Spark context Web UI available at http://DESKTOP-9LN67TS.mshome.net:4040
Spark context available as 'sc' (master = local[*], app id = local-1581394859054).
Spark session available as 'spark'.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 2.4.5
      /_/

Using Scala version 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_241)
Type in expressions to have them evaluated.
Type :help for more information.

scala>

Spark Core

Spark Core程序始于SparkContext对象sc。RDD是Spark Core的核心类之一，所有数据处理都是基于对RDD的处理来实现。对其操作分为两类：transformation（转换）和action（动作）。transformation是生成新RDD的操作，例如map filter reduceByKey等，action是得出一个非RDD值的操作，比如count collect take saveAsTextFile等。

准备数据(构造RDD)

parallelize方法是从序列创建一个RDD，生产中一般不用，仅作学习和测试使用。

1
2

val rawStr = "Hello World!\naaa bbb ccc ddd\naaa aaa\nbbb\nccc\n"
val lineRdd = sc.parallelize(rawStr.lines.toSeq)

textFile方法是读取文本文件创建RDD，RDD中每个元素都是文件中的一行

`1`	`val fileRdd = sc.textFile("/path-to-file/")`

处理数据(操作RDD)

此处简单介绍下常见的算子，我们目前工作中常用的算子有map filter distinct reduceByKey join

map算子：将RDD中的每个元素转换成另一种状态，目标状态不设限

/* 
 * lineRdd  -> ["Hello World!", "aaa bbb ccc ddd", "aaa aaa", ...]
 * 
 * lowerRdd -> ["hello world!", "aaa bbb ccc ddd", "aaa aaa", ...]
 */
// val lowerRdd = lineRdd.map(line => line.toLowerCase())
val lowerRdd = lineRdd.map(_.toLowerCase)

flatMap算子：将RDD中的每个元素转换成一个可枚举的序列，然后将这些序列“压平”(也可以理解成连接起来)

/* 
 * lineRdd -> ["Hello World!", "aaa bbb ccc ddd", "aaa aaa", ...]
 * 
 * wordRdd -> ["Hello", "World!", "aaa", "bbb", ...]
 */
val wordRdd = lineRdd.flatMap(_.split(" "))

filter算子：检查每个元素，过滤掉不符合条件的元素

/* 
 * wordRdd     -> ["Hello", "World!", "aaa", "bbb", ...]
 * 
 * pureWordRdd -> ["aaa", "bbb", "ccc", "ddd", "aaa", ...]
 */
val pureWordRdd = wordRdd.filter(_.toCharArray.toSet.size == 1)

distinct算子：把数据集中的数据去重

/* 
 * pureWordRdd -> ["aaa", "bbb", "ccc", "ddd", "aaa", ...]
 * 
 * distinctRdd -> ["aaa", "bbb", "ccc", "ddd"]
 */
val distinctRdd = pureWordRdd.distinct()

count算子：统计RDD中数据的条数

`1`	`distinctRdd.count()`

take算子：从RDD中取指定数量的数据放到数组中

`1`	`distinctRdd.take(5).foreach(println)`

collect算子：将RDD中的所有数据收集到数组中（实际不太常用，除非能保证RDD中的数组足够少，能放到一个数组中去）

`1`	`distinctRdd.collect.foreach(println)`

groupBy算子：将RDD中的数据分组

/* 
 * pureWordRdd -> ["aaa", "bbb", "ccc", "ddd", "aaa", ...]
 * 
 * groupedRdd  -> ['a'->["aaa", "aaa",...], 'b'->["bbb",...], 'c'->["ccc"], ...]
 */
val groupedRdd = pureWordRdd.groupBy(_.charAt(0))

归纳类算子：reduce fold aggregate。这组算子的目标是将RDD归纳成一个值。下面演示其各自用法(功能目标一致，求RDD中字符串长度之和)

// def reduce(f: (T, T) => T): T
pureWordRdd.map(_.length).reduce(_ + _)
// def fold(zeroValue: T)(op: (T, T) => T): T
pureWordRdd.map(_.length).fold(0)(_ + _)
// def aggregate[U](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U
pureWordRdd.aggregate(0)((i, s) => i + s.length, _ + _)

交并差算子：intersection union subtract。同数学上交集、并集、差集的概念

val rdd1 = sc.parallelize(Seq("A", "B", "C")) // [A, B, C]
val rdd2 = sc.parallelize(Seq("B", "C", "D")) // [B, C, D]
rdd1.intersection(rdd2) // rdd1 ∩  rdd2 = [B, C]
rdd1 ++ rdd2            // rdd1 ∪ rdd2 = [A, B, C, B, C, D]
rdd1.union(rdd2)        // rdd1 ∪ rdd2 = [A, B, C, B, C, D]
rdd1.subtract(rdd2)     // rdd1 -  rdd2 = [A]

以上算子是操作RDD[T]时常用的，当T是个二元组时，此时RDD[(K, V)]将会被隐式转换成PairRDDFunctions[K, V]对象，此时可以使用一些特殊算子，例如以下介绍的join系算子和xxxByKey系算子

归纳类算子：reduceByKey foldByKey aggregateByKey。下面演示其用法(统计各个Key的个数)

val rdd = sc.parallelize(Seq(("A", "AAA"), ("A", "aaa"), ("B", "bbb")))

// def reduceByKey(func: (V, V) => V): RDD[(K, V)]
rdd.map(t => (t._1, 1)).reduceByKey(_ + _)
// def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
rdd.map(t => (t._1, 1)).foldByKey(0)(_ + _)
// def aggregateByKey[U](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]
rdd.aggregateByKey(0)((i, _) => i + 1, _ + _)

groupByKey算子：该算子不再需要参数，行为与上述groupBy算子行为一致

关联类算子：join leftOuterJoin rightOuterJoin fullOuterJoin，主要区别在于对于关联失败数据的处理方式

val rdd1 = sc.parallelize(Seq(("A", "aaa"), ("B", "bbb"), ("C", "ccc")))
val rdd2 = sc.parallelize(Seq(("B", "BBB"), ("C", "CCC"), ("D", "DDD")))

rdd1.join(rdd2)             // [("B", ("bbb", "BBB")), ("C", ("ccc", "CCC"))]
rdd1.leftOuterJoin(rdd2)    // [("A", ("aaa", None)), ("B", ("bbb" ,Some("BBB"))), ("C", ("ccc",Some("CCC")))]
rdd1.rightOuterJoin(rdd2)   // [("B", (Some("bbb"), "BBB")), ("C", (Some("ccc"), "CCC")), ("D", (None, "DDD"))]
rdd1.fullOuterJoin(rdd2)    // [("A", (Some("aaa"), None)), ("B", (Some("bbb"), Some("BBB"))), ("C", (Some(ccc), Some("CCC"))), ("D", (None, Some("DDD")))]

以上算子便是离线数据分析常用的算子，对于数据进行的分析都是基于这些算子的组合使用，常用才能熟悉。关于以上列出算子的官方文档，请参考ScalaDoc：RDD，PairRDDFunctions

保存数据(保存RDD)

对于结果数据保存，我们常用的是saveAsTextFile方法，在调用此方法之前，需要保证数据已经是\t分隔字段的单行字符串形式，一般需要用map算子转换一下数据的形式，如下所示：

`1`	`rdd.map(_.mkString("\t")).saveAsTextFile("/path-to-result/")`

Spark SQL

此处介绍Spark SQL主要为了降低数据处理的门槛，基于我们已经很熟悉的SQL语言，马上就能进行基本的数据处理工作。因此侧重以SQL方式进行数据处理，对DatasetAPI细节介绍较少，若要以编程方式使用，可参考其文档ScalaDoc - Dataset

同样的逻辑，使用DatasetAPI和SQL表达在性能上没有任何差别。

首先给出一段简单代码，用以揭示使用Spark SQL进行数据分析的一般流程

// --------------- preparing ---------------
// construct schema
val schema = new StructType()
  .add("id", DataTypes.LongType, nullable = true)
  .add("name", DataTypes.StringType, nullable = true)
  .add("age", DataTypes.IntegerType, nullable = true)
  .add("score", DataTypes.DoubleType, nullable = true)

// load file, create dataframe
val df = spark.read
  .schema(schema)
  .option("header", false)      // default is false
  .option("inferSchema", false) // default is false
  .option("sep", "\t")
  .csv("/path-to-bcp-file/")

// register as a temp view/table
df.createOrReplaceTempView("tableName")

// --------------- processing ---------------
// execute sql statement
val result = spark.sql("select * from tableName where name is not null and age > 18 and score > 60")

// --------------- saving ---------------
result.write.option("sep", "\t").csv("/path-to-result-dir/")

// --------------- exit ---------------
spark.close()

我们主要对数据准备、处理、保存阶段进行详细的讨论。

Preparing

数据准备阶段的工作是告知Spark SQL：我们的数据是什么结构，怎么样能拿到。解答这两个问题的办法有很多，我们视情况选择自己用得顺手的即可。此处给出两类办法以供参考。

定义业务数据类型

// define class
case class Student(id: String, name: String, age: Int, score: Double)

// read file
val ds = sc.textFile("/path-to-file/")                          // type: RDD[String]  sample: "001,tom,18,60.0"
  .map(_.split(","))                                            // type: RDD[Array]   sample: ["001","tom","18","60.0"]
  .map(arr => (arr(0), arr(1), arr(2).toInt, arr(3).toDouble))  // type: RDD[Tuple]   sample: ("001","tom",18,60.0)
  .map(t => Student(t._1, t._2, t._3, t._4))                    // type: RDD[Student] sample: Student("001","tom",18,60.0)
  .toDS()                                                       // type: Dataset[Student]

// register as a temp view/table
ds.createOrReplaceTempView("tableName")

分析以上代码，首先定义了一个Student类型，我们读取进来的数据要转换成此类型的一组实例。然后我们用Spark Core的map算子进行数据格式的转换，转换成了一批Student对象放在了RDD中，最后转换成Dataset[Student]类型。此时，Spark SQL的两个问题回答完毕：要操作的数据Student(字段名称和字段类型已知)，要操作的数据从上游RDD直接可取。我们将这个Dataset[Student]类型的对象注册到Spark SQL系统供下面的代码使用

注1：Student类的定义不能放到方法体里

注2：要调用toDS方法，需要在调用前(一般在SparkSession的对象spark构造完毕后)导入一些隐式成员，即加上以下语句import spark.implicits._

构造Schema

Spark SQL使用Schema对数据的结构进行描述，Schema包含列名、数据类型、是否可空。我们可以直接构造出一个Schema告知Spark SQL我们的数据是什么结构。

// construct schema
val schema = new StructType()
  .add("id", DataTypes.LongType)
  .add("name", DataTypes.StringType)
  .add("age", DataTypes.IntegerType)
  .add("score", DataTypes.DoubleType)

// read file
val rdd = sc.textFile("/path-to-file/")                         // type: RDD[String]  sample: "001,tom,18,60.0"
  .map(_.split(","))                                            // type: RDD[Array]   sample: ["001","tom","18","60.0"]
  .map(arr => (arr(0), arr(1), arr(2).toInt, arr(3).toDouble))  // type: RDD[Tuple]   sample: ("001","tom",18,60.0)
  .map(Row.fromSeq(_))                                          // type: RDD[Row]

val df = spark.createDataFrame(rdd, schema)

// register as a temp view/table
df.createOrReplaceTempView("tableName")

分析以上代码，我们首先构造了一个StuctType对象来描述数据结构，然后读取文件，与上面不同的是，最终转换成RDD[Row]类型，然后调用createDataFrame方法。createDataFrame方法的两个参数一个回答了数据来源的问题，另一个回答了数据结构的问题。

注1：文件加载部分可以进行简化

1
2

val df = spark.read.schema(schema).option("sep", "\t").csv("/path-to-bcp-file/")
df.createOrReplaceTempView("tableName")

使用了Spark SQL内置的一些工具进行简化。schema方法指定了要加载的数据的结构，csv方法指出了数据文件的格式，我们通过option方法指定一些选项(此处指定了分隔符以适配bcp文件)。加载选项的详细列表请参考ScalaDoc - DataFrameReader

注2：构造Schema部分可以进行简化

其实DataFrameReader已有类似API，即spark.schema("id LONG, name STRING, ...").option(...)...，其中schema方法接受Schema字符串并自动转换，但这个API是Spark 2.3.0新增，内部平台版本应该是2.1.x，还没有此API

鉴于此，我们可以实现一个SchemaInterpolator使之更易用，最终效果如下所示：

1
2

import SchemaInterpolator._
val schema = schema"id long, name string, age int, score double"

SchemaInterpolator的简易实现已附在本文档

注3：自描述数据源

有些数据源能描述自己的数据结构，例如jdbc json csv parquet等，这种情况我们也可以让Spark SQL自行推断数据结构，以csv文件为例

val df = spark.read
  .option("header", true)
  .option("inferSchema", true)
  .csv("/path-to-bcp-file/")
df.createOrReplaceTempView("tableName")

Processing

准备阶段已经将临时视图注册到了Spark SQL系统中，我们可以直接提交要处理的SQL。此处仅给出一些样例，旨在揭示Spark SQL的各种可能，一般我们能想到的操作，都是可以做到的

spark.sql(sqlText)的执行结果是DataFrame(即Dataset[Row])，可以将结果保存、注册为新视图、替换之前的视图等

val df = ... 
// create view 
df.createOrReplaceTempView("t1")

val df1 = spark.sql("select * from t1 where t1.xxx is not null and ...")
// replace view 
df1.createOrReplaceTempView("t1")

这段代码执行完毕之后，“t1"已经变成了筛选之后的数据，直接用就可以，因此，无需总是为给表取名字挠头

多数据集join是可以的，sql直接能做

import org.apache.spark.sql._
import org.apache.spark.sql.types._

import spark.implicits._ 

val schema = new StructType().add("k", DataTypes.StringType).add("v", DataTypes.StringType)

val rdd1 = sc.parallelize(Seq(("A", "aaa"), ("B", "bbb"), ("C", "ccc"))).map(Row.fromTuple(_))
val rdd2 = sc.parallelize(Seq(("B", "BBB"), ("C", "CCC"), ("D", "DDD"))).map(Row.fromTuple(_))

spark.createDataFrame(rdd1, schema).createOrReplaceTempView("t1")
spark.createDataFrame(rdd2, schema).createOrReplaceTempView("t2")

val df = spark.sql("select t1.k as k, t1.v as v1, t2.v as v2 from t1 join t2 on t1.k = t2.k")

更多JOIN操作请参考：LanguageManual Joins

Spark SQL内置函数和运算符

Spark SQL提供了一批函数和运算符，我们可以直接在SQL里面使用，下面给出两个例子

例子1：过滤掉某字段的字符串长度小于10的数据

`1`	`select * from t1 where length(t1.filed0) >= 10`

例子2：根据出生日期，算出年龄

`1`	`select *, int(date_format(now(), 'yyyy')) - int(year(t.birth)) as age from t`

Spark SQL的内置函数列表请参考：Spark SQL, Built-in Functions

UDF(用户自定义函数)

思考前面的例子2，根据出生日期计算年龄，用代码写我们有无数种实现方式，但是只用内置函数，好像很麻烦，所以我们实现个UDF，如下所示

// define an normal function
val calcAge: String => Int = (birth: String) => {
  import java.text.SimpleDateFormat
  import java.util.Date

  val now = new Date()
  val fmt = new SimpleDateFormat("yyyy")
  val thisYear = fmt.format(now).toInt
  val birthYear = birth.substring(0, 4).toInt
  thisYear - birthYear
}
// register udf
spark.udf.register("calcAge", calcAge)
// use it!
spark.sql("select *, calcAge(t.birth) as age from t")

分析以上代码，流程很清晰，写个普通函数 -> 注册到Spark SQL -> 直接在SQL中使用。

注意：尽量不要用这种方式！UDF对Spark SQL来说就是个黑盒，它无法对此做出优化，复杂UDF很有可能造成性能瓶颈。除非别无选择，否则不要用UDF

一些有用的文档

Spark SQL与Apache Hive的兼容性：Compatibility with Apache Hive

Hive语言手册(我们主要关注SQL部分)：LanguageManual

SELECT：LanguageManual Select

Saving

数据保存的做法依然有很多，考虑到我们的实际需求，此处只推荐一种做法，如下所示

1
2

val df = spark.sql("select field1, field2, ... from t")
df.write.option("sep", "\t").csv("/path-to-result-dir/")

实际进行保存之前，建议执行一次筛选操作，用以确认要保存的字段并且保证字段的顺序，然后执行保存。

更多数据保存的相关选项，请参考ScalaDoc - DataFrameWriter

`SchemaInterpolator`

一个基于StringInterpolator的SchemaInterpolator实现

object SchemaInterpolator {

  import scala.util.{Try, Failure, Success}
  import org.apache.spark.sql.types._

  implicit class SparkSQLSchema(val sc: StringContext) {

    // InnerStructField -> index option, field
    private type InnerStructField = (Option[Int], StructField)

    // val schema = schema"a int, b string false, c double true some-comment"
    // val schema = schema"0 a int, 2 c double true, 3 d string"
    def schema(args: Any*): StructType = {
      val str = sc.s(args: _*).trim
      if (str.isEmpty) throw new IllegalArgumentException("Empty Schema String")

      val innerSeq = str split "," map parseInnerStructField
      innerSeq.head match {
        case (None, _) => StructType(innerSeq.map(_._2))
        case (Some(_), _) =>
          val i2f = innerSeq.map({ case (oi, f) => (oi.get, f) }).toMap
          val fSeq = (0 to i2f.keys.max).map(i => i2f.getOrElse(i, StructField(s"fake_name_$i", StringType)))
          StructType(fSeq)
      }
    }

    private def parseInnerStructField(str: String): InnerStructField = {
      assert(str != null && !str.trim.isEmpty, "this is an empty string!")
      val seq = str.trim.split("\\s+").toSeq
      Try(seq.head.toInt) match {
        case Success(index) => (Some(index), parseStructField(seq.tail))
        case Failure(_) => (None, parseStructField(seq))
      }
    }

    private def parseStructField(seq: Seq[String]): StructField = {
      seq match {
        case name +: typeStr +: Nil =>
          StructField(name, typeStr)
        case name +: typeStr +: nullable +: Nil if Try(nullable.toBoolean).isSuccess =>
          StructField(name, typeStr, nullable.toBoolean)
        case name +: typeStr +: nullable +: tail if Try(nullable.toBoolean).isSuccess =>
          StructField(name, typeStr, nullable.toBoolean).withComment(tail.mkString(" "))
        case name +: typeStr +: tail =>
          StructField(name, typeStr).withComment(tail.mkString(" "))
        case _ => throw new IllegalArgumentException(s"not a valid struct field: '${seq.mkString(" ")}'")
      }
    }

    private implicit def typeStrToDataType(str: String): DataType = {
      str match {
        case "bool" | "boolean" | "Boolean" => DataTypes.BooleanType
        case "byte" | "Byte" => DataTypes.ByteType
        case "short" | "Short" => DataTypes.ShortType
        case "int" | "integer" | "Integer" => DataTypes.IntegerType
        case "long" | "Long" => DataTypes.LongType
        case "float" | "Float" => DataTypes.FloatType
        case "double" | "Double" => DataTypes.DoubleType
        case "decimal" | "bigdecimal" | "BigDecimal" => DataTypes.createDecimalType()
        case "string" | "String" => DataTypes.StringType
        case "timestamp" | "TimeStamp" => DataTypes.TimestampType
        case "calendarinterval" | "CalendarInterval" => DataTypes.CalendarIntervalType
        case "date" | "Date" => DataTypes.DateType
        case "null" | "Null" => DataTypes.NullType
        case "byte[]" | "Byte[]" | "Array[Byte]" => DataTypes.BinaryType
        case _ if str.endsWith("[]") => DataTypes.createArrayType(str.substring(0, str.length-2))
        case _ if str.matches("^Array\\[\\S+\\]$") => DataTypes.createArrayType(str.substring(6, str.length-1))
        // never hit this case, because type string was splited by ',' above
        case _ if str.matches("^Map\\[\\S+,\\S+\\]$") || str.matches("^Map<\\S+,\\S+>$") =>
          val i = str.indexOf(',')
          val kt = str.substring(4, i)
          val vt = str.substring(i+1, str.length-1)
          DataTypes.createMapType(kt, vt)
        case _ => throw new IllegalArgumentException(s"cannot resolve the type: '$str'!!!!")
      }
    }
  }
}

开发一个Spark程序

参考环境准备中IDEA小节创建项目，然后将起始代码复制进去

注意构造SparkSession对象时master()方法接受的参数：如果是要在本地运行，使用"local[*]"；如果是链接Spark Standalone集群调试，使用形如"spark://hostname:port"的Spark Master URL（可以在Spark Master Web UI找到）；如果是要打成jar包放到公司的平台上跑，使用"yarn"参数

选用自己使用顺手的组件进行功能实现和测试，一般现在本地环境以样例数据测试核心逻辑。然后按照部署目标的要求进行打包，部署到实际环境中进行测试。应当注意运行效率方面，有时候还需要进一步优化。

开发常见问题

这里列出几个开发的时候比较常见的问题，此处列出的代码仅供演示，可能不完全正确

数据过滤不严谨

这种情况出现还算比较多，实际处理数据时应认真思考，尽可能筛掉异常数据

case class Student(id: String, name: String, age: Int)

val students = sc.textFile("/path/student-info.nb")
  .map(_.split("\t"))
  .map(a => (a(0), a(1), a(2)))   // 可能出现数组越界异常
  .map(t => Student(t._1, t._2, t._3.toInt))  // 可能出现转换失败异常

// 可以采用以下方式解决

val students = sc.textFile("/path/student-info.nb")
  .map(_.split("\t"))
  .filter(_.length == 3)    // 保证数组长度，消除数组越界异常
  .map(a => (a(0), a(1), a(2)))
  .filter(t => Try(t._3.toInt).isSuccess)   // 保证字段能正常转换
  .map(t => Student(t._1, t._2, t._3.toInt))

以上演示了从数据格式上进行异常数据筛选，但某些数据从业务上也是不合法的，因此后续可能需要更多的filer和map进行数据筛选和变换

过多数据放到一个集合/节点

这种情况一般发生于使用Spark Shell进行快速数据分析时发生

rdd.collect().foreach(println)  // collect算子把rdd中的全部数据放到一个数组了，很容易就会挂掉，这需要我们自行保证rdd中的数据不多

// 可以先统计下数量，如果发现不多，那么可以这么做
rdd.count()

// 也可以使用take
rdd.take(20).foreach(println)

使用外部变量

先看一个反例

val names = new java.util.HashSet[String]()
nameRdd.foreach(n => names.Add(n))    // 使用foreach进行结果整理
someRdd.map(x => {names.Add(x.name); x.other})  // map过程中“顺便”干点别的

// 或者这样
var sum = 0
intRdd.foreach(i => sum += i)

基于我们熟悉的面向对象编程，已经养成了这么一个习惯：遍历一个集合，在遍历过程中提取我们需要的信息放到之前定义的变量里。

在普通单线程Scala程序中，这么做虽然不推荐，但还是正确的；但是在Spark程序中，对RDD的操作如果这么干，是不正确的。要注意我们之前对RDD的并行化特点的介绍，Spark会把我们用λ表达的逻辑及其捕获的自由变量打包分发到每个节点，每个节点上的names sum与driver程序上的不再有任何关系，各节点的子任务运行完毕后，对变量的修改也不会反映到我们期望的变量身上，所以最终得到了错误的结果。

这类问题没什么统一的解决方案，只能是具体问题具体看，算是在强制我们熟悉一下函数式编程。

以上反例，可以这么改

val names = nameRdd.distinct.collect    // 用distinct算子去重 当然也得保证name数量没有太多

// map中不要“顺便”做任何事情了，逻辑分离开单独处理就好

val sum = intRdd.reduce(_ + _)  // 用reduce算子求和

4. 实际开发的注意事项

Mon, 09 Mar 2020 00:00:00 +0800

实际开发的注意事项

自研平台
- 版本
- 认证及资源隔离
- 项目部署
华为
- 版本
- 认证及资源隔离
- 项目部署
阿里云
浪潮

公司平台

1. 版本问题

NS平台基础JDK是1.7 Scala版本2.10.x Spark版本2.1.x 开发时应注意API版本

Spark API应该还好，就我们目前的使用和开发方式，一般不太会撞上恰好2.1.x没有该API的情况，若要保证正常，可以下载spark-2.1.3-bin-hadoop2.6作为测试环境（感觉意义不大，因为Scala版本还是高于平台）

注意对于Scala 和 Java的使用，需要换成适配版本进行开发和打包

2. 认证及资源分离问题

在公司平台上启动任务需要注意指定用户、指定队列

`1`	`spark-shell --master yarn --principal xxx --keytab xxx.keytab --queue xxx`

3. 项目部署

oozie被包装得妈都不认识了，得参考任务调度服务的开发文档。

华为平台

华为平台是堡垒机操作，似乎防火墙只允许有限的几个机器访问运维界面(或者是因为集群在自己的子网中，在集群外根本找不到目标机器)，因此比较强烈依赖命令行操作

操作华为集群要先加载环境（类似这样的命令）

`1`	`source bigdata-env`

有时候环境中的用户身份还不具有操作集群的权限，还需要换个身份

`1`	`kinit -kt xxx.keytab xxx # ???`

1. 版本

印象中华为平台的基础JDK是1.8，Scala版本应该也不是2.10.x这么低，版本问题在华为集群上应该并不严重。印象中不知从哪听了一耳朵，有些地方华为的集群已经是Hadoop3.x，有些应用还需适配

2. 认证及资源分离

华为集群对于动手启动的Spark Shell没有启用dynamic executor，因此启动一般分配有限的几个executor，任务没什么好并行的当然跑的慢了，所以要记得手动指定executor个数，如下所示

注意：手动指定的executor个数必须是基于数据总量和具体任务进行考量，还应当看一下集群当前的状况，是不是资源特别紧张。不能武断地直接指定几百个executor跑自己的事情

`1`	`spark-shell --master yarn --num-executors 32`

3. 部署

我记得是HUE界面上拖出来的进行部署的，也可以直接使用oozie进行定时/周期任务部署。华为集群上任务部署跟业界普遍做法比较一致，华为对这块没有进行特别深入的定制和包装

阿里云

尚未交过学费，似乎变动炒鸡大，貌似只有一个点是这个平台

浪潮

还没亲眼见过，听说直接就是原生的一套跑着

5. 小测试

Mon, 09 Mar 2020 00:00:00 +0800

练手

以下各个问题基于最后附的数据，可以同时尝试下用SQL和RDD API来解决问题。

配置环境，把本地Spark Shell跑起来

能跑起来Spark Shell，说明环境配置正常。这是最基本的前提，可以使用IDEA直接进行本地调试
过滤掉所有不正常数据
按总成绩排名从高到底输出学号和姓名
找出有不及格科目的同学
分别找出各个科目的第一名
分别找出男生和女生的第一名

提供了几个解决思路，但是建议不要马上就看

数据

将数据保存到本地，做成bcp文件

各个字段分别是：学号，姓名，语文，数学，英语

id-1	学生-1	43	30	0
id-2	学生-2	76	83	77
id-3	学生-3	98.5	76	90
id-4	学生-4	100	79	96
id-5	学生-5	59	85	76
id-6	学生-6	69	78	83
id-7	学生-7	75	88	69
id-8	学生-8	94	abc	79
id-9	学生-9		82	91
id-10	学生-10	87	68	85
id-11		84	56	95
	学生-12	99	79	60

字段是：学号，性别

id-1	男
id-2	女
id-3	男
id-4	女
id-5	男
id-6	女
id-7	男
id-8	女
id-9	男
id-10	女
id-11	
	女

6. 小测试参考思路

Mon, 09 Mar 2020 00:00:00 +0800

几个解答思路

提供几个思路以解答前面提出的问题。

其中理解门槛最低的是Spark SQL版，用SQL来描述业务逻辑，应该还是比较友好的。

两个Spark Core版本的解决方案没有这么直观，两者都需要开发者熟悉常用算子。此外，使用基本数据结构的版本，需要把数据结构的变换过程理解吃透；定义业务类的版本理解稍容易些，搞清楚Scala中object、class、case class的概念应该就可以了。

1. Spark SQL

import org.apache.spark.sql.SparkSession

object Application {
  def main(args : Array[String]) {
    val spark = SparkSession.builder().appName("SparkApp").master("local[*]").getOrCreate()
    import spark.implicits._

    val scorebcp = "/mnt/c/Users/mxtao/Desktop/score.nb"
    val genderbcp = "/mnt/c/Users/mxtao/Desktop/gender.nb"

    // 加载数据
    val scoreSchema = "id string, name string, yw float, sx float, yy float"
    spark.read.option("sep", "\t").schema(scoreSchema).csv(scorebcp).createOrReplaceTempView("score")
    val genderSchema = "id string, gender string"
    spark.read.option("sep", "\t").schema(genderSchema).csv(genderbcp).createOrReplaceTempView("gender")

    // 过滤无效数据，顺便求了总成绩放在这
    spark.sql("select *, (yw + sx + yy) as total from score where id is not null and name is not null and yw is not null and sx is not null and yy is not null").createOrReplaceTempView("score")
    spark.sql("select * from gender where id is not null and gender is not null").createOrReplaceTempView("gender")

    // 按总成绩排名从高到底输出学号和姓名
    spark.sql("select id, name, total from score order by total desc").show()
    // 找出有不及格科目的同学
    spark.sql("select * from score where yw < 60 or sx < 60 or yy < 60").show()
    // 分别找出各个科目的第一名
    spark.sql("select * from score order by yw desc limit 1").show()
    spark.sql("select * from score order by sx desc limit 1").show()
    spark.sql("select * from score order by yy desc limit 1").show()
    // 分别找出男生和女生的第一名
    spark.sql("select s.id, s.name, g.gender, s.total from score s join gender g on s.id == g.id").createOrReplaceTempView("gscore")  // 其实也可以不创建临时表，直接作为子查询也可
    spark.sql("select * from gscore where gender == '男' order by total desc limit 1").show()
    spark.sql("select * from gscore where gender == '女' order by total desc limit 1").show()

    spark.stop()
  }
}

2. Spark Core + 定义业务类

import org.apache.spark.sql.SparkSession
import scala.util.Try

// ----------- 定义业务类 ------------
object StudentScore {
  // 尝试从字符串构造业务对象
  def tryApply(str: String): Option[StudentScore] = {
    if (verify(str))
      Some(StudentScore(str))
    else
      None
  }

  // 重载一个apply方法
  def apply(str: String): StudentScore = {
    // require(verify(str), "not a correct string!")
    val arr = str.split("\t")
    StudentScore(arr(0), arr(1), arr(2).toFloat, arr(3).toFloat, arr(4).toFloat)
  }

  // 验证外部输入的字符串或者数组是否合法
  def verify(str: String): Boolean = str!=null && str.nonEmpty && verify(str.split("\t"))
  def verify(arr: Array[String]): Boolean = arr!=null && arr.length==5 && arr.forall(_.nonEmpty) && arr.slice(2, 5).forall(s => Try(s.toFloat).isSuccess)
}
// 注意，这里是一个 case class，要理解清楚它与普通 class 有何不同
case class StudentScore(val id: String, val name: String, val yw: Float, val sx: Float, val yy: Float){
  def total: Float = yw + sx + yy
  def isPassed: Boolean = yw >= 60.0 && sx >= 60.0 && yy >= 60.0
  def notPassed: Boolean = !isPassed
}

// ----------- 主程序本体 --------------
object Application {
  def main(args : Array[String]) {
    val spark = SparkSession.builder().appName("SparkApp").master("local[*]").getOrCreate()
    val sc = spark.sparkContext
    import spark.implicits._

    val scorebcp = "/mnt/c/Users/mxtao/Desktop/score.nb"
    val genderbcp = "/mnt/c/Users/mxtao/Desktop/gender.nb"

    val score = sc.textFile(scorebcp)
      .map(s => StudentScore.tryApply(s))   // 尝试从字符串构造对象
      .filter(_.nonEmpty)                   // 把构造失败的过滤掉
      .map(_.get)                           // 取得对象本体，此时得到RDD[StudentScore]
    // 也可以用另一种处理办法
    // val score = sc.textFile(scorebcp)
    //   .filter(s => StudentScore.verify(s))   // 验证字符串是否正确，把不正确的字符串丢掉
    //   .map(s => StudentScore(s))             // 从字符串构造业务对象
    val gender = sc.textFile(genderbcp)
      .map(_.split("\t"))
      .filter(_.length == 2)
      .map(a => (a(0), a(1)))
      .filter(t => t._1.nonEmpty && t._2.nonEmpty)
    
    // 按总成绩排名从高到底输出学号和姓名
    score.sortBy(_.total, ascending = false)
      .map(s => s"${s.id}\t${s.name}")
      .collect()
      .foreach(println)

    // 找出有不及格科目的同学
    score.filter(_.notPassed).collect.foreach(println)
    
    // 分别找出各个科目的第一名
    score.sortBy(_.yw, ascending = false).take(1).foreach(print)
    score.sortBy(_.sx, ascending = false).take(1).foreach(print)
    score.sortBy(_.yy, ascending = false).take(1).foreach(print)

    // 分别找出男生和女生的第一名
    val score2 = score.map(s => (s.id, s)).join(gender).map(_._2)
    score2.filter(_._2 == "男").map(_._1).sortBy(_.total, ascending = false).take(1).foreach(println)
    score2.filter(_._2 == "女").map(_._1).sortBy(_.total, ascending = false).take(1).foreach(println)

    spark.close()
  }
}

3. Spark Core + 基本数据结构

import org.apache.spark.sql.SparkSession
import scala.util.Try

object Application {
  
  def main(args : Array[String]) {
    val spark = SparkSession.builder().appName("SparkApp").master("local[*]").getOrCreate()
    val sc = spark.sparkContext
    import spark.implicits._

    val scorebcp = "/mnt/c/Users/mxtao/Desktop/score.nb"
    val genderbcp = "/mnt/c/Users/mxtao/Desktop/gender.nb"

    // 读取文件，过滤无效数据
    val score = sc.textFile(scorebcp)
      .map(_.split("\t"))
      .filter(_.length == 5)    // 过滤掉字段有缺失的数据
      .map(a => (a(0), a(1), a(2), a(3), a(4)))     // 把数组转换成元组
      .filter(t => t._1.nonEmpty && t._2.nonEmpty && t._3.nonEmpty && t._4.nonEmpty && t._5.nonEmpty)           // 保证必要字段不为空
      .filter(t => Try(t._3.toFloat).isSuccess && Try(t._4.toFloat).isSuccess && Try(t._5.toFloat).isSuccess)   // 保证成绩字段是合法的
      .map(t => (t._1, t._2, t._3.toFloat, t._4.toFloat, t._5.toFloat))     // 转换成 (学号, 姓名, 语文, 数学, 英语) 形式
    val gender = sc.textFile(genderbcp)
      .map(_.split("\t"))
      .filter(_.length == 2)
      .map(a => (a(0), a(1)))
      .filter(t => t._1.nonEmpty && t._2.nonEmpty)
    
    // 按总成绩排名从高到底输出学号和姓名
    score.map(t => (t._1, t._2, t._3 + t._4 + t._5))    // 转换成 (学号, 姓名, 总成绩) 形式
      .sortBy(_._3, ascending = false)                  // 以总成绩为key，按从低到高排序
      .map(t => s"${t._1}\t${t._2}")                    // 格式化数据，为输出做准备
      .collect()                                        // 将分布在各个节点的数据拿到本地
      .foreach(println)                                 // 打印到控制台

    // 找出有不及格科目的同学
    score.filter(t => t._3 < 60.0 || t._4 < 60.0 || t._5 < 60.0)
      .collect()
      .foreach(println)
    
    // 分别找出各个科目的第一名
    score.sortBy(_._3, ascending = false)
      .take(1)
      .foreach(println)
    score.sortBy(_._4, ascending = false)
      .take(1)
      .foreach(println)
    score.sortBy(_._5, ascending = false)
      .take(1)
      .foreach(println)

    // 分别找出男生和女生的第一名
    val score2 = score.map(t => (t._1, (t._1, t._2, t._3 + t._4 + t._5)))   // 转换成二元组，为join做准备，此处转换成了 (学号, (学号, 姓名, 总成绩)) 形式
      .join(gender)     // 与gender数据集(结构为：(学号,性别))关联碰撞，策略为丢弃所有未关联数据，结果结构为: (学号, ((学号, 姓名, 总成绩), 性别))
      .map(_._2)        // 丢掉不再使用的key，然后结构变为：((学号, 姓名, 总成绩), 性别)
    score2.filter(_._2 == "男")
      .map(_._1)
      .sortBy(_._3, ascending = false)
      .take(1)
      .foreach(println)
    score2.filter(_._2 == "女")
      .map(_._1)
      .sortBy(_._3, ascending = false)
      .take(1)
      .foreach(println)

    spark.close()
  }
}

Spark开发入门-介绍

Mon, 09 Mar 2020 00:00:00 +0800

spark-dev-tour

Spark Application Development Tour

大纲

下方链接可能失效，可尝试系列目录

培训附件

环境准备
- Windows
  - JDK
  - Scala SDK
  - Spark
  - IDEA
- WSL / Linux
  - VSCode Remote
Scala Language

Scala编程语言入门
Spark开发
- Spark简介
- Spark处理数据
  - Spark Core
  - Spark SQL
- 开发一个Spark程序
- 开发常见问题
实际开发的注意事项

主要公司自研平台和华为的平台
练手

几个练习

Spark Release 3.0.0

Spark on boboboker~

Spark相关内容随记

Spark 相关内容随记

Spark SQL - DataSource

Spark SQL - CSV

Spark CLI

1. 准备开发环境

准备开发环境

Windows

JDK

Scala SDK

Spark

IDEA

WSL / Linux

VSCode Remote

2. Scala Intro

Scala Intro

3. 使用 Spark 进行数据分析

使用 Spark 进行数据分析

Spark简介

Spark Architecture

RDD

Dataset[T]&DataFrame

用Spark处理数据

获取SparkContext&SparkSession对象

Spark Core

Spark SQL

Preparing

Processing

Saving

SchemaInterpolator

开发一个Spark程序

开发常见问题

4. 实际开发的注意事项

实际开发的注意事项

公司平台

1. 版本问题

2. 认证及资源分离问题

3. 项目部署

华为平台

1. 版本

2. 认证及资源分离

3. 部署

阿里云

浪潮

5. 小测试

练手

数据

6. 小测试参考思路

几个解答思路

1. Spark SQL

2. Spark Core + 定义业务类

3. Spark Core + 基本数据结构

Spark开发入门-介绍

spark-dev-tour

`RDD`

`Dataset[T]`&`DataFrame`

获取`SparkContext`&`SparkSession`对象

`SchemaInterpolator`