一、Spark入门

1、官网（http://spark.apache.org/docs/2.2.2/）

2、Spark产生的背景

MapReduce局限性：
1）繁杂

只有map/reduce两个算子

mapjoin只有map，没有reduce

测试麻烦

2）效率低

进程级别：MapTask ReduceTask

IO：chain 网络+磁盘

排序：面试题：key类型是实现什么接口？

Memory：有些的内存操作

3）不适合迭代处理

4）只能离线计算，不适合实时流式处理

5）速度慢

3、很多框架各自为政

二、Spark(http://spark.apache.org)

Apache Spark is a fast and general-purpose cluster computing system. It provides high-level APIs in Java, Scala, Python and R, and an optimized engine that supports general execution graphs.

特点：

1、Speed，计算速度快

Run workloads 100x faster.

基于memory，线程，排序可以配置，DAG（有向无环图，pipeline）

2、Ease of Use

high-level operators：join、group by...

interactively from scala、python、R的shell脚本，可以直接测试

3、Generality

SQL、streaming、complex

4、Runs Everywhere

Spark runs on Hadoop, Apache Mesos, Kubernetes, standalone, or in the cloud.

Access data in HDFS, Alluxio, Apache Cassandra, Apache HBase, Apache Hive, and hundreds of other data sources.

存取

总结：

fast + genernal engine

write code：java/scala/python/r

run：memory/DAG/thread model...

三、Spark版本介绍

Apache Spark 2.2.0

2：主要版本，一些API的变化

2：小版本，添加一些API/features

0：修复bug，最好选择非0的版本

四、如何学习Spark

1、社区Community

官网

Mailing Lists(http://spark.apache.org/community.html#mailing-lists)

meetup/峰会

github源码的例子(https://github.com/apache/spark)

源码

user-list（google）

五、搭建Spark环境

1、下载

wget https://archive.apache.org/dist/spark/spark-2.2.0/spark-2.2.0.tgz

2、解压

tar -xzvf spark-2.2.0.tgz -C /opt/app/

3、编译

1）条件

Maven 3.3.9 or newer and

Java 8+.

scala

hadoop 2.6.0

另外：git也安装一下

yum -y install git

2）Setting up Maven’s Memory Usage

系统环境变量添加

export MAVEN_OPTS="-Xmx2g -XX:ReservedCodeCacheSize=512m"

3）编译方式1：build/mvn

./build/mvn -DskipTests clean package

mvn -DskipTests clean package（跳过测试打包）

4）编译方式2：Building a Runnable Distribution（大部分选择这个）

./dev/make-distribution.sh --name custom-spark --pip --r --tgz -Psparkr -Phadoop-2.7 -Phive -Phive-thriftserver -Pmesos -Pyarn

5）指定Hadoop和Yarn版本

Specifying the Hadoop Version and Enabling YARN

默认是pom.xml里的2.6.0

# Apache Hadoop 2.6.X
./build/mvn -Pyarn -DskipTests clean package

# Apache Hadoop 2.7.X and later
./build/mvn -Pyarn -Phadoop-2.7 -Dhadoop.version=2.7.3 -DskipTests clean package

5）uilding With Hive and JDBC Support

# With Hive 1.2.1 support
./build/mvn -Pyarn -Phive -Phive-thriftserver -DskipTests clean package

6）Building for Scala 2.10

./dev/change-scala-version.sh 2.10
./build/mvn -Pyarn -Dscala-2.10 -DskipTests clean package

默认是2.11.8，如果需要2.10就按上述步骤处理

总结：

1）./build/mvn -Pyarn -Phive -Phive-thriftserver -Phadoop-2.6 -Dhadoop.version=2.6.0-cdh5.7.0 -DskipTests clean package

2）./dev/make-distribution.sh --name 2.6.0-cdh5.7.0 --tgz -Phadoop-2.6 -Dhadoop.version=2.6.0-cdh5.7.0 -Phive -Phive-thriftserver -Pyarn

./dev/make-distribution.sh --name CDH版本号 --tgz -Phadoop-2.6 -Dhadoop.version=2.6.0-cdh5.7.0 -Phive -Phive-thriftserver -Pyarn

4、加快编译

1）打开 make-distribution.sh

2）注释掉这四个属性

3）输入

VERSION=2.2.0

SCALA_VERSION=2.11

SPARK_HADOOP_VERSION=2.6.0-cdh5.7.0

SPARK_HIVE=1

4）编译

出现下载失败，报这个错误 Could not resolve dependencies for project org.apache.spark:spark-launcher_2.11:jar:2.3.1: Could not find artifact org.apache.hadoop:hadoop-client:jar:2.6.0-cdh5.7.0 in central (https://repo.maven.apache.org/maven2)

这是因为我们是apache的版本，所以对应的库是apache的，所以我们要添加cdh的依赖

vi pom.xml

添加：

<id>cloudera</id>

<name>cloudera Repository</name>

<url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>

</repository>

5）编译成功

./dev/make-distribution.sh --name 2.6.0-cdh5.7.0 --tgz -Phadoop-2.6 -Dhadoop.version=2.6.0-cdh5.7.0 -Phive -Phive-thriftserver -Pyarn

6）解压

7）Spark安装包目录结构说明

bin：存放客户端相关的脚本

conf：配置文件

data：存放测试数据

example：Spark自带的测试用例——一定要重点查看

jars：存放Spark相应的jar包

sbin：存放服务端相关的脚本：启停集群...

yarn：存放yarn相关的jar

8）编译子模块

Building submodules individually

./build/mvn -pl :spark-streaming_2.11 clean install

六、RDD

让开发者大大降低开发分布式应用程序的门槛和提高执行效率

RDD源码：https://github.com/apache/spark/blob/master/core/src/main/scala/org/apache/spark/rdd/RDD.scala

1、如何学源码

1）idea—debug

2）找入口，看注释

A Resilient Distributed Dataset (RDD) 弹性、分布式、数据集：不依赖别的RDD，可以不同节点，类似block

RDDA=>RDDB=>RDDC,如果RDDC出问题了，只需修复RDDB即可，不需动A的数据，因此弹性。

the basic abstraction in Spark 基本抽象

basic operations available 操作、不可变：val，RDD产生后不可变。

partitioned collection of elements 基础分区采集，block/InputSplit

that can be operated on in parallel 可以平行操作

总结：

RDDA：（1，2，3，4，5，6，7，8，9） +1

hadoop001：Partition1 （1，2，3） +1

hadoop002：Partition2 （4，5，6） +1

hadoop003：Partition3 （7，8，9） +1

1、RDD的定义

abstract class RDD[T: ClassTag](

@transient private var _sc: SparkContext,

@transient private var deps: Seq[Dependency[_]]

) extends Serializable with Logging {

1）抽象类：RDD必然是由子类实现的，我们使用的时候直接使用其子类即可

2）Serializable：序列化

3）Logging：记录日志

4）T：泛型，里面可以支持各种数据类型，说明RDD存储的数据类型是不确定的。

5）SparkContext

6）@transient

2、RDD的五大特性

* - A list of partitions ：类似一个大数据集分很多block去计算

* - A function for computing each split ：对RDD计算，相当于对RDD的分区计算

* - A list of dependencies on other RDDs ：每一个RDD之间有依赖关系。加载出RDDA=>RDDB=>RDDC

* - Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)

哈希分区用于把表平均分配到各个分区中，做到负载均衡和克服表2亿行数据的限制。

* - Optionally, a list of preferred locations to compute each split on (e.g. block locations for

* an HDFS file)首选放在HDFS文件上

3、RDD五大特点和RDD源码中的对应关系

def compute(split: Partition, context: TaskContext): Iterator[T]，RDD是对分区做计算，必然传参有分区，对应特点1

protected def getPartitions: Array[Partition]，RDD是由分区组成，所以RDD的类型是数组。对应特点1

protected def getDependencies: Seq[Dependency[_]] = deps，对应特点3

protected def getPreferredLocations(split: Partition): Seq[String] = Nil，RDD要先获取首选位置，所以传参是分区，结果是依赖关系，因此是seq类型（String），对应特点5

@transient val partitioner: Option[Partitioner] = None，对应特点4，/** Optionally overridden by subclasses to specify how they are partitioned. */

4、查看JDBCRDD有无上述方法

（1）分区

（2）JDBC编程

（3）图解RDD

1）RDD是什么

RDD：Spark的核心概念是RDD (resilientdistributed dataset)，指的是一个只读的，可分区的分布式数据集，这个数据集的全部或部分可以缓存在内存中，在多次计算间重用。

分区是RDD内部并行计算的一个计算单元，RDD的数据集在逻辑上被划分为多个分片，每一个分片称为分区，分区的格式决定了并行计算的粒度，而每个分区的数值计算都是在一个任务中进行的，因此任务的个数，也是由RDD(准确来说是作业最后一个RDD)的分区数决定。

RDD分区的一个分区原则：尽可能是得分区的个数等于集群核心数目

Spark中的RDD就是一个不可变的分布式对象集合。每个RDD都被分为多个分区，这些分区运行在集群的不同节点上。创建RDD的方法有两种：一种是读取一个外部数据集；一种是在群东程序里分发驱动器程序中的对象集合，不如刚才的示例，读取文本文件作为一个字符串的RDD的示例。

创建出来后，RDD支持两种类型的操作:转化操作和行动操作

转化操作会由一个RDD生成一个新的RDD。

行动操作会对RDD计算出一个结果，并把结果返回到驱动器程序中，或把结果存储到外部存储系统（比如HDFS）中。

RDD计算方式

来源： https://www.cnblogs.com/wzj4858/p/8204395.html

七、SparkContext

类似Context：

ServletContext

StrutsContext

JbpmContext

SpringContext ==> SpringBoot

1、初始化Spark

The first thing a Spark program must do is to create a SparkContext object, which tells Spark how to access a cluster.

cluster：

Local

standalone

yarn

mesos

2、创建SparkContext要先创建SparkConf对象（key:value）

（1）To create a SparkContext you first need to build a SparkConf object that contains information about your application.

SparkConf：

val conf = new SparkConf().setAppName(appName).setMaster(master)

new SparkContext(conf)

（2）重点：

In practice, when running on a cluster, you will not want to hardcode master in the program, but rather launch the application with spark-submit and receive it there. However, for local testing and unit tests, you can pass “local” to run Spark in-process.

1）尽可能使用local模式测试

2）生产上不要通过硬编码，要通过spark-submit提交，这样同一段代码就可以既跑在mesos，也可以跑在yarn上，不用修改代码。