Spark总结

离线分析：

       把一段时间的数据经过收集，整理，分析，会得出一些结论，以供人们做出一些决策。

       spark就是离线分析一个框架。秒级 storm是毫秒级

spark：

由美国加州大学伯克利分校AMP实验室开发的一个快如闪电的并行的集群计算框架

              AMP：Arithmetic算法，Machines机器，People人

              目的：通过算法，机器和人的整合来体现大数据的应用。

       spark的特点？

              1.速度快：

                     在内存中比MR快100X倍，即使在磁盘运行，也快10X倍。

                     DAG有向无环图   基于内存运算

              2.易用性：

                     支持java scala python R四种语言。

                     scala python R 可以通过Shell编程。

                     提供了超过80个算子操作。

              3.通用性：

                     在一个应用程序里可以无缝整合SQL Streaming MLlib GraphX

              4.可以运行在任何地点：

                     运行地点 本地 standalone  yarn ...... 

                     获取数据源 HDFS Hbase Hive......

              Tachyon是基于内存的，方便取数据的数据点，方便spark计算

              本地模式：win

              独立模式：伪分布式

              集群模式：集群模式

              Sparkstreaming：伪实时，批次非常小，让人误认为是实时，Spark Streaming 是个批处理的流式（实时）计算框架。其基本原理是把输入数据以某一时间间隔批量的处理，当批处理间隔缩短到秒级时，便可以用于处理实时数据流。

 

              Sparksql：和hive差不多，Spark SQL是用于结构化数据处理的Spark模块。与基本的Spark RDD API不同，Spark SQL提供的接口提供了更多关于数据结构和正在执行的计算的信息。在内部，Spark SQL使用这些额外的信息来执行额外的优化。

 

伯克利技术栈：

       SparkSQL：通用写sql语句来实现一些数据的分析。

       SparkStreaming：伪实时分析组件

       MLlib：机器学习的算法库

       GraphX：做图形计算的

       SparkR：R语言包

 

SparkCore：是整个spark的核心

 

       数据源：HDFS，HBase，Hive。。。。

       运行平台：

 

spark和MapReduce对比

              运行速度       代码量           硬件设备              安全性

spark             快           少           要求较高              相对不安全

MapReduce   慢           多           廉价机           安全

 

spark环境搭建

windows环境：

       1.解压缩

       2.配置环境变量（jdk的环境变量不要有空格）

       3.cmd下输入 spark-shell

 

       开发工具：

              1.导入spark-->jars里所有的包

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

 

linux环境：

       local 直接解压

              spark-submit --master local[2] --class

       standalone

              在上一步基础上 slaves--》工作节点的主机名 

              spark-env.sh --》SPARK_MASTER_HOST=主节点的主机名

              在sbin目录下启动start-all.sh

              spark-submit --master spark://主机名:7077 --class

       on yarn

              在上一步的基础上 spark-env.sh--》HADOOP_CONF_DIR=hadoop配置文件所在的目录

              spark-submit --master yarn --deploy-mode cluster --class

              spark-submit --master yarn --deploy-mode client --class

 

RDD：  

       弹性的 分布式的 数据集   

       partition分区是一个具体的概念，真实存在，而RDD是一个抽象的概念。

       RDD是spark计算过程中一个瞬时的结果，如果不做持久化，RDD会在内存中消失。

RDD 全称为Resilient Distributed Datasets，中文名称为弹性分布式数据集，是带有容错机制的并行数据结构。Spark 建立在了统一的 RDD 抽象之上，也就是说 RDD 是 Spark 的核心。

partition:分区 一个机器可以存在多个partition，一个partition只能存在于一台机器

partition是一个具体的概念，真实存在，而RDD是一个抽象的概念

RDD是spark运算过程中的一个瞬时结果。

RDD 提供了丰富的 API，让用户可以通过编程的方式操作 RDD，从而更容易的对磁盘以及内存中的数据进行操作。

RDD 提供了一种高度受限的共享内存模型，即 RDD 是只读的数据分区的集合，只能通过在其它 RDD 执行确定的转换操作（如map、join和group by）而创建，然而这些限制使得实现容错的开销很低。

从开发者的角度讲，RDD 就是一个功能强大的集合

 

RDD特性：

多个分区的集合

一个函数可以计算所有切片

可以依赖于其他RDD

可以将RDD中的分区重新分区

本地切片在本地计算

RDD算子：

算子是RDD中定义的函数，可以对RDD中的数据进行转换和操作。

分类：创建算子，缓存算子，转换算子，行动算子

RDD容错机制：

RDD 默认采用任务失败重新计算的容错机制，这种容错机制本身效率并不高，但由于 RDD 为不可变数据集，并且每个 RDD 都会记录各自的 Graph of Operation(运算过程图)，所以当某个子运算产生 RDD 的过程中发生异常，可以根据该子运算的上一级(父级) RDD 重新进行运算，整体运算无需进行重算。

wordcount模型：

第一：textfile：从不同的机器上拿下来block块，每一个块叫partition，所有的 partition叫做RDD，RDD是所有partition的集合

第二：flatmap：形成第二步的RDD

第三：map：形成第三步的RDD

第四：reducebykey：形成第四步RDD

active算子：

transformation算子：

隐式转换

隐式的参数的转换

作为参数隐式转换()()

参数前面加implicit

写一个隐式的val 在object里 import一下这个object

隐式的调用函数

implicit def

 

文件的存储和读取：

sc.wholeTextFiles() 显示文件路径 逗号前面是文件名的路径 后面是文件中的所有东西

 

持久化策略：3个

cache：相当于调用无参数的persist的方法

rdd.cache()

persist：rdd.persist() 有storageLevel选项

无参数的时候，调用的是默认的MEMORY_ONLY持久化策略

MEMORY_ONLY和MEMORY_ONLY_SER

前一个是以对象的形式存储，后一个以序列化的形式存储。

MEMORY_ONLY和MEMORY_AND_DISK

前一个先可内存存储，如果内存存不下，就不存了。直接从HDFS上读取数据重新算。

后一个先可内存存储，如果内存存不下，把剩下的存入到磁盘当中。

为什么选择MEMORY_ONLY为默认级别：

按照spark的特性，即使从HDFS上取数据重新计算也比多一次IO读写要快。

checkpoint：

检查点 一定要在collect之前操作 强烈建议在checkpoint之前做一次持久化

sc.setCheckPointDir() 设置检查点的目录

先persist 后checkpoint，否则需要重新计算一次。

适用条件：前面的计算及其复杂。创建checkpoint之后，所有的父级RDD依赖关系全部被移除，

本身成为顶级父RDD。

查看存储级别：

localhost:4040 Thead.sleep()

rdd.getStorageLevel.discribtion

持久化策略归纳：

1.默认使用的是MEMORY_ONLY，最好的。

2.如果内存有些不够用，使用MEMORY_ONLY_SER

3.如果想要做一些容错，使用_2

4.如果当前rdd计算比较复杂，可以使用MEMORY_AND_DISK

 

spark快速大数据分析

图解spark

 

任务的切割 运行原理 简单看一下源码

任务切割

宽依赖：每个父rdd的分区指定到子rdd里的多个分区

窄依赖：每个父rdd的分区指定到子rdd里的唯一分区

由算子确定宽窄依赖 如果有shuffle就是宽依赖

任务切割：

由算子确定DAG，通过action提交job

job=》根据宽依赖划分stages=》taskSets=》task（spark计算中的最小计算单元，由partition数量决定）

几个基本概念：

application:一个应用程序

Driver：驱动程序。job提交之后的第一个程序

clusterManager：资源管理器。

WorkerNode：工作节点。执行程序的机器。

Excutor：进程，任务集

线程：task

job

stage

taskSet

 

Spark运行结构图：

•首先在SparkContext初始化的时候会创建DAGScheduler,这个DAGScheduelr每个应用只有一个。然后DAGScheduler创建的时候，会初始化一个事件捕获对象，并且开启监听。之后我们的任务都会发给这个事件监听器，它会按照任务的类型创建不同的任务。

•再从客户端程序方面说，当我们调用action操作的时候，就会触发runjob，它内部其实就是向前面的那个事件监听器提交一个任务。

•最后事件监听器调用DAGScheduler的handleJobSubmitted真正的处理

•处理的时候，会先创建一个resultStage，每个job只有一个resultstage，其余的都是shufflestage.然后根据rdd的依赖关系，按照广度优先的思想遍历rdd，遇到shufflerdd就创建一个新的stage。

•形成DAG图后，遍历等待执行的stage列表，如果这个stage所依赖的父stage执行完了，它就可以执行了；否则还需要继续等待。

•最终stage会以taskset的形式，提交给TaskScheduler，然后最后提交给excutor。

 

 

 

Spark任务接收 提交执行

执行程序：

job提交之后

Driver驱动SparkContext

rdd绘制出DAG =》通过DAG Schedule 划分出stages =》通过Task Schedule 划分出TaskSet =》 提交和分配任务

向clusterManager注册并申请节点的资源=》所有节点向cluster反馈节点信息

=》clusterManager获取到节点信息之后，反馈给sparkContext

sparkContext向申请到的节点资源分配任务。

workNode获取到任务之后，启动一个Excutor进程，以线程的形式执行最小计算单元task

 

广播变量，累加器：

Broadcast：广播变量 保证不同节点的值都是同步可读的

sc.broadcast(v)

Accumulators:累加器 只通过关联和交换操作添加的变量 用于计数

sc.longAccumulator(name)

通过add方法添加值 只能加不能读 只有driver可以通过value读

sc.doubleAccumulator(name)

 

SparkSQL：

sparkSql：

处理结构化数据的一个spark的组件。

特点：

1.综合的

可以使用sql语句，DataSet API

2.统一的数据处理

是用同一种方式处理各种数据源。

3.hive集成

4.标准的连接

JDBC / ODBC

DataSet和DataFrame

1.创建sparkSession

import org.apache.spark.sql.SparkSession

val spark =SparkSession.builder().master("local[3]").appName("app").getOrCreate

2.读json文件

val ds = spark.read.json("path") //ds是一个dataset

ds.show() //表的形式展现

3.dataSet API

ds.printSchema() //输出表头信息

ds.select($"name").show

ds.select($"name",$"age"+1)

ds.filter($"age" > 21)

ds.groupBy("age").count().show

4.ds.createOrReplaceTempView("people") //建表

. ds.createTempView("people")

val peopleDS = spark.sql("select * from people")

peopleDS.show

5.ds.createGlobalTempView("people")

val peopleDS = spark.newSession().sql("select * from global_tmp.people")

6.case class People(name:String,age:Int) //case类自动生成一些方法 作用在伴生对象 其中有apply方法

import spark.implicits._