文章目录

一.为什么使用Spark
二.Spark简介

1.发展历程
2.Spark优势
3.Spark技术栈
4.Spark环境部署
5.Spark初体验
6.Spark架构设计
7.Spark架构核心组件
8.Spark API

三.核心API:RDD

1.RDD概念
2.RDD与DAG
3.RDD的五大特性
4.RDD编程流程
5.RDD创建
6.RDD分区与RDD的操作
7.RDD转换算子
8.RDD动作算子

一.为什么使用Spark

MapReduce编程模型的局限性

繁杂:只有Map和Reduce两个操作，复杂的逻辑需要大量的样板代码
处理效率低：
1)Map中间结果写磁盘，Reduce写HDFS，多个Map通过HDFS交换数据
2)任务调度与启动开销大
不适合迭代处理、交互式处理和流式处理

Spark是类Hadoop MapReduce的通用并行框架

Job中间输出结果可以保存在内存，不再需要读写HDFS
比MapReduce平均快10倍以上

二.Spark简介

1.发展历程

诞生于加州大学伯克利分校AMP实验室，是一个基于内存的分布式计算框架

2009年诞生于加州大学伯克利分校AMP实验室
2010年正式开源
2013年6月正式成为Apache孵化项目
2014年2月成为Apache顶级项目
2014年5月正式发布Spark 1.0版本
2014年10月Spark打破MapReduce保持的排序记录
2015年发布了1.3、1.4、1.5版本
2016年发布了1.6、2.x版本

2.Spark优势

速度快
1)基于内存数据处理，比MR快100个数量级以上（逻辑回归算法测试）
2)基于硬盘数据处理，比MR快10个数量级以上
易用性
支持Java、Scala、Python、R语言
交互式shell方便开发测试
通用性
一栈式解决方案：批处理、交互式查询、实时流处理、图计算及机器学习
多种运行模式
YARN、Mesos、EC2、Kubernetes、Standalone、Local

3.Spark技术栈

Spark Core:核心组件，分布式计算引擎
Spark SQL:高性能的基于Hadoop的SQL解决方案
Spark Streaming:可以实现高吞吐量、具备容错机制的准实时流处理系统
Spark GraphX:分布式图处理框架
Spark MLlib:构建在Spark上的分布式机器学习库

4.Spark环境部署

选择较新的Spark2.2版本，
下载地址:https://archive.apache.org/dist/spark/spark-2.2.0/spark-2.2.0-bin-hadoop2.7.tgz
解压并配置环境变量:SPARK_HOME
Spark配置文件:$SPARK_HOME/conf/spark-env.sh,$SPARK_HOME/conf/slaves
启动Spark:$SPARK_HOME/sbin/start-all.sh
7077与8080端口

5.Spark初体验

spark-shell：Spark自带的交互式工具
本机:spark-shell --master local[*]
Standalone:spark-shell --master spark://MASTERHOST:7077
YARN:spark-shell --master yarn-client

scala>sc.textFile("hdfs://cluster1/data/hello.txt")
	       .flatMap(x=>x.split("\t"))
	       .map(x=>(x,1)).reduceByKey(_+_).collect

6.Spark架构设计

运行架构

在这里插入图片描述

1)在驱动程序中，通过SparkContext主导应用的执行
2)SparkContext可以连接不同类型的Cluster Manager（Standalone、YARN、Mesos），连接后，获得集群节点上的Executor
3)一个Worker节点默认一个Executor，可通过SPARK_WORKER_INSTANCES调整
4)每个应用获取自己的Executor
5)每个Task处理一个RDD分区

7.Spark架构核心组件

术语	说明
Application	建立在Spark上的用户程序，包括Driver代码和运行在集群各节点Executor中的代码
Driver program	驱动程序。Application中的main函数并创建SparkContext
Cluster Manager	在集群（Standalone、Mesos、YARN）上获取资源的外部服务
Worker Node	集群中任何可以运行Application代码的节点
Executor	某个Application运行在worker节点上的一个进程
Task	被送到某个Executor上的工作单元
Job	包含多个Task组成的并行计算，往往由Spark Action触发生成，一个Application中往往会产生多个Job
Stage	每个Job会被拆分成多组Task，作为一个TaskSet，其名称为Stage

8.Spark API

IDEA创建sparkapi依赖

<properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <encoding>UTF-8</encoding>
        <scala.version>2.11.8</scala.version>
        <spark.version>2.2.0</spark.version>
        <hadoop.version>2.7.1</hadoop.version>
        <scala.compat.version>2.11</scala.compat.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>
    </dependencies>

SparkContext
连接Driver与Spark Cluster（Workers）
Spark的主入口
每个JVM仅能有一个活跃的SparkContext
SparkContext.getOrCreate

import org.apache.spark.{SparkConf, SparkContext}

val conf=new SparkConf().setMaster("local[2]").setAppName("HelloSpark")
val sc=SparkContext.getOrCreate(conf)

SparkSession
Spark 2.0+应用程序的主入口：包含了SparkContext、SQLContext、HiveContext以及StreamingContext
SparkSession.getOrCreate

import org.apache.spark.sql.SparkSession
val spark = SparkSession.builder
                    .master("local[2]")
                    .appName("appName")
                    .getOrCreate()

三.核心API:RDD

RDD:Spark核心，主要数据抽象
Dataset:从Spark1.6开始引入的新的抽象，特定领域对象中的强类型集合，它可以使用函数或者相关操作并行地进行转换等操作
DataFrame:DataFrame是特殊的Dataset

1.RDD概念

简单的解释

RDD是将数据项拆分为多个分区的集合，存储在集群的工作节点上的内存和磁盘中，并执行正确的操作

复杂的解释

RDD是用于数据转换的接口
RDD指向了存储在HDFS、Cassandra、HBase等、或缓存（内存、内存+磁盘、仅磁盘等），或在故障或缓存收回时重新计算其他RDD分区中的数据

RDD是弹性分布式数据集（Resilient Distributed Datasets）

分布式（ Distributed）
数据的计算并非只局限于单个节点，而是多个节点之间协同计算得到
数据集（ Datasets）
RDD是只读的、分区记录的集合，每个分区分布在集群的不同节点上
RDD并不存储真正的数据，只是对数据和操作的描述
弹性（Resilient）
自动进行存储方式的切换，RDD优先存储内存中，内存不足将自动写入磁盘
基于Linage的高效容错机制，在任何时候都能进行重算，根据数据血统，可以自动从节点失败中恢复分区，各个分片之间的数据互不影响
Stage失败自动重试 / Task失败自动重试
Checkpoint和Persist， checkpoint持久化到文件系统

2.RDD与DAG

两者是Spark提供的核心抽象
DAG（有向无环图）反映了RDD之间的依赖关系

3.RDD的五大特性

1)一系列的分区（分片）信息，每个任务处理一个分区
2)每个分区上都有compute函数，计算该分区中的数据
3)RDD之间有一系列的依赖
4)分区器决定数据（key-value）分配至哪个分区
5)优先位置列表，将计算任务分派到其所在处理数据块的存储位置

4.RDD编程流程

在这里插入图片描述

5.RDD创建

1.使用集合

/*使用集合创建RDD
* 1、Spark默认会根据集群的情况来设置分区的数量，也可以通过parallelize()第二参数来指定
* 2、Spark会为每一个分区运行一个任务进行处理
*/
val rdd=sc.parallelize(List(1,2,3,4,5,6))
rdd.count
rdd.partitions.size
val rdd=sc.parallelize(List(1,2,3,4,5,6),5)
rdd.partitions.size
val rdd=sc.makeRDD(List(1,2,3,4,5,6))

2.加载文件

//通过加载文件产生RDD
val distFile=sc.textFile("file:///home/hadoop/data/hello.txt")
distFile.count
val distHDFSFile=sc.textFile("hdfs://hadoop000:8020/hello.txt")
//加载“file://……”时，以local运行仅需一份本地文件，以Spark集群方式运行，应保证每个节点均有该文件的本地副本


//支持目录、压缩文件以及通配符
sc.textFile("/my/directory")
sc.textFile("/my/directory/*.txt")
sc.textFile("/my/directory/*.gz")
/*
1、Spark默认访问HDFS
2、Spark默认为HDFS文件的每一个数据块创建一个分区，也可以通过textFile()第二个参数指定，但只能比数据块数量多
*/

3.其他方法

/*其他创建RDD的方法
SparkContext.wholeTextFiles()：可以针对一个目录中的大量小文件返回<filename,fileContent>作为PairRDD
普通RDD：org.apache.spark.rdd.RDD[data_type]
PairRDD：org.apache.spark.rdd.RDD[(key_type,value_type)]

Spark 为包含键值对类型的 RDD 提供了一些专有的操作，比如：reduceByKey()、groupByKey()……
也可以通过键值对集合创建PairRDD：
sc.parallelize(List((1,2),(1,3)))


SparkContext.sequenceFile[K,V]()  -->Hadoop SequenceFile的读写支持
SparkContext.hadoopRDD()、newAPIHadoopRDD() -->从Hadoop接口API创建
SparkContext.objectFile()  -->RDD.saveAsObjectFile()的逆操作
*/

6.RDD分区与RDD的操作

分区是RDD被拆分并发送到节点的不同块之一

我们拥有的分区越多，得到的并行性就越强
每个分区都是被分发到不同Worker Node的候选者
每个分区对应一个Task

操作分为lazy与non-lazy两种
Transformation（lazy）：也称转换操作、转换算子
Actions（non-lazy）：立即执行，也称动作操作、动作算子

7.RDD转换算子

对于转换操作，RDD的所有转换都不会直接计算结果

仅记录作用于RDD上的操作
当遇到动作算子（Action）时才会进行真正计算

RDD常用的转换算子-map算子
对RDD中的每个元素都执行一个指定的函数来产生一个新的RDD
任何原RDD中的元素在新RDD中都有且只有一个元素与之对应
输入分区与输出分区一一对应

//将原RDD中每个元素都乘以2来产生一个新的RDD
val a=sc.parallelize(1 to 9)
val b=a.map(x=>x*2)
a.collect
b.collect

//map把普通RDD变成PairRDD
val a=sc.parallelize(List("dog","tiger","lion","cat","panther"))
val b=a.map(x=>(x,1))
b.collect

RDD常用的转换算子-filter算子

对元素进行过滤，对每个元素应用指定函数，返回值为true的元素保留在新的RDD中

val a=sc.parallelize(1 to 10)
a.filter(_%2==0).collect      
a.filter(_<4).collect	
//map&filter
val rdd=sc.parallelize(List(1 to 6))
val mapRdd=rdd.map(_*2)
mapRdd.collect
val filterRdd=mapRdd.filter(_>5)
filterRdd.collect

RDD常用的转换算子-mapValues算子

原RDD中的Key保持不变，与新的Value一起组成新的RDD中的元素，仅适用于PairRDD

val a=sc.parallelize(List("dog","tiger","lion","cat","panther","eagle"))
val b=a.map(x=>(x.length,x))
b.mapValues("x"+_+"x").collect
//输出结果：
//Array((3,xdogx), (5,xtigerx), (4,xlionx), (3,xcatx), (7,xpantherx), (5,xeaglex))

更多常用转换算子

distinct
reduceByKey
groupByKey
sortByKey
union
join

val dis = sc.parallelize(List(1,2,3,4,5,6,7,8,9,9,2,6))
dis.distinct.collect
dis.distinct(2).partitions.length

val a = sc.parallelize(List("dog", "salmon", "pig"), 3)
val f = a.map(x=>(x.length,x))
f.reduceByKey((a,b)=>(a+b)).collect
f.reduceByKey(_+_).collect
f.groupByKey.collect

val a = sc.parallelize(List("dog", "salmon", "pig"), 3)
val f = a.map(x=>(x.length,x))
f.sortByKey().collect
f.sortByKey(false).collect

val u1 = sc.parallelize(1 to 3)
val u2 = sc.parallelize(3 to 4)
u1.union(u2).collect
(u1 ++ u2).collect
u1.intersection(u2).collect

val j1 = sc.parallelize(List("abe", "abby", "apple"))
                                                                           .map(a => (a, 1))
val j2 = sc.parallelize(List("apple", "beatty", "beatrice")).map(a => (a, 1))
j1.join(j2).collect
j1.leftOuterJoin(j2).collect
j1.rightOuterJoin(j2).collect

8.RDD动作算子

本质上动作算子通过SparkContext执行提交作业操作，触发RDD DAG（有向无环图）的执行
所有的动作算子都是急迫型（non-lazy），RDD遇到Action就会立即计算

RDD常用动作算子

count

返回的是数据集中的元素的个数

val rdd=sc.parallelize(List(1,2,3,4,5,6))
rdd.count

collect

以Array返回RDD的所有元素。一般在过滤或者处理足够小的结果的时候使用
应注意到，前面所有转换操作都结合了collect动作算子进行计算输出

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

take: 返回前n个元素

val rdd=sc.parallelize(List(1,2,3,4,5,6))
rdd.take(3)

first:返回RDD第一个元素

val rdd=sc.parallelize(List(1,2,3,4,5,6))
rdd.first

reduce：根据指定函数，对RDD中的元素进行两两计算，返回计算结果

val a=sc.parallelize(1 to 100)
a.reduce((x,y)=>x+y)
a.reduce(_+_)		//与上面等价
val b=sc.parallelize(Array(("A",0), ("A",2), ("B",1), ("B",2), ("C",1)))
b.reduce((x,y)=>{(x._1+y._1,x._2+y._2)})		//(AABBC,6)

foreach：对RDD中的每个元素都使用指定函数，无返回值

val rdd=sc.parallelize(1 to 100)
rdd.foreach(println)

lookup：用于PairRDD,返回K对应的所有V值

val rdd=sc.parallelize(List(('a',1), ('a',2), ('b',3), ('c',4)))
rdd.lookup('a')		//输出WrappedArray(1, 2)

最值：返回最大值、最小值

val y=sc.parallelize(10 to 30)
y.max	//求最大值
y.min	//求最小值

saveAsTextFile：保存RDD数据至文件系统

val rdd=sc.parallelize(1 to 10,2)
rdd.saveAsTextFile("hdfs://hadoop000:8020/data/rddsave/")

Apache Spark基础及架构