Spark 算子

Spark大数据计算框架

Spark（火花）出现不全是代替Map Reduce，里面有批处理（Spark运行在内存中，Map Reduce运行在硬盘中，根据自身情况选择适应的开发环境（比如：机器的数量，配置，资金等等））

了解Hadoop发展历史：2011年发布1.0版本，2012年发布稳定版，2013年发布2.X版本（里面出现了Yarn，得以重用）

2012年版本中

MR的缺点：

mr基于数据集的计算，所以面向数据

​ 1.基本运算规则从存储介质中获取（采集）数据，然后进行计算，最后将结果存储到介质中，所以主要应用于一次性计算(单节点计算)，不适合数据挖掘和机器学习这样的迭代计算和图形挖掘计算。

​ 2.MR基于文件存储介质操作，所以性能非常慢

​ 3.MR和Hadoop紧密耦合在一起，无法动态替换（违背了ocp原理）

​ 4.RM中，之前的Job任务太重了，导致数据运算太慢。（既要做资源调度任务，又要做资源交互）后来Yarn就把Job职责分开（只做资源交互），AM：负责资源调度任务（AM里面有Driver，Driver与Task关联，RM和NM关联（解耦合了），中间有一个AM（资源，计算：两者之间有AM起到中间连接的作用））最终导致我们的计算框架是可插拔的（也就是Yarn计算，至今还在用RM的原因就是Yarn的存在。）

• M中：NM与Task之间也有一个中间链接Conntainer，Container相当于当前电脑里面的虚拟机，他会占用计算机的一定资源来进行计算，但是他的计算和外面的计算又没有关系，降低了偶合性。
• MR:比较繁杂，只有Map和Reduce两种操作，复杂的逻辑需要大量的样板代码，处理效率低，Map中甲结果写磁盘，Reduce写HDFS，多个Map通过HDFS交换数据

2013年10月发布2.X版本（Yarn）：Yarn作用（就是资源调度框架），所以Yarn主要用于计算，和存储没有太大关系（存储是HDFS执行的）

Yarn架构图

Spark2013年6月发布

定义：Spark是一种基于内存的快速，通用，可扩展的大数据分析引擎

Spark基于Hadoop1.X架构思想，采用自己的方式去改善Hadoop1.X中的问题

交互式shell方便开发测试。

速度快，易用性强（支持java，Scala，Python，R语言，），通用性（客运与机器学），随处运行（Yarn，Mesos，Stand alone（Scala单机模式），Local（与Map Reduce运行很相似））。

Saprk基于内存，并且基于Scala语法开发，所以天生适合迭代式计算（这就是比Map Reduce好的原因）。

Master做资源调度的，Worker和NodeManager相似

资源调度里面的计算：在ApplicationMaster运行，

执行器：是Executor计算的

Saprk存储是在Hadoop中存储的

Saprk和Yarn做计算框架，HDFS做存储框架。

Spark架构设计->运行架构图

中间有ClusterManager作为中间传呼变量。保证两者之间没有耦合性。

Spark内置模块

两个重要角色：Driver（驱动器）可以理解为管理者，Executor（执行器）可以理解为执行者（计算的）

查看Yarn当前运行路径和配置信息：yarn application -list

19/09/29 21:36:32 INFO client.RMProxy: Connecting to ResourceManager at /0.0.0.0:8032
19/09/29 21:36:33 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):0
                Application-Id	    Application-Name	    Application-Type	      User	     Queue	             State        Final-State	       Progress	                       Tracking-URL
[root@bigdata ~]# 

[root@bigdata bin]# ./spark-shell 
19/09/29 21:11:30 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
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://bigdata:4040
Spark context available as 'sc' (master = local[*], app id = local-1569805902675).
Spark session available as 'spark'.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 2.4.3
      /_/
      
      其中：app id = local-1569805902675与Application-Id是一样的。

独立调度器是HDFS自己的支援调度器，Yarn是Hadoop的资源调度，Mesos是Apart另外一个资源调度（国外盛行）

Spark技术栈：

面试Spark版本：1.6或者2.2（主要）版本

自己虚拟机上安装：

运行模式：

Local模式：Local[ * ]模式就直接帮你按照cpu最多cores来设置线程数了。

共享文件夹：

直接搜索–》打开文件资源管理器–》输入ftp://192.168.10.150/–》密码：1–》直接下载下来。

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

在IDEA里面展示Spark程序，先设置xml文件

//书写格式要标准
//从官网下载
<dependency>
	<groupId>org.apache.spark</groupId>
	<artifactId>spark-core_2.11</artifactId>
	<version>2.4.3</version>
</dependency>

SparkSession

• Spark2.0+应用程序

查看Spark程序运行界面的路径是：192.168.56.101：4040

Spark - WordCount实现

sc:表示Spark的上下文对象，本身就可以找到相关路径取读数据。
textFile(传送路径/相对路径):通过一种方法来得到文本文件的内容，这里面是传送路径（把文件传进来）读数据的额方式是一行一行读的。
flatMap(_.split(" ")):表示把文件传出去（可迭代）扁平化压平操作，按照空格分隔符将一行数据映射成一个个单词；

map((_,1))：返回值【map(x=>{(x,1)})简写成：map((_,1))】：对每一个元素操作，将单词映射为元组。
reduceByKey(_+_):相同的 Key 进行聚合，reduce聚合的时候是两两相加的，第一个参数作为第一个参数，第一个参数作为第二个参数(最后得到的而结果就是元组)。
collect:收集展现在控制台上（Driver）
scala> sc.textFile("/root/a.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect
res5: Array[(String, Int)] = Array((mm,1), (hello,4), (cmmagk,1), (world,1), (lice,1), (makkk,1), (kb02,2))
scala> 

在IDEA中实现Spark步骤：

创建方法一个maven工程，不走前期博客可见（类似）

//使用 SparkSession之前需要导包
<dependency> 
	<groupId>org.apache.spark</groupId>  
	<artifactId>spark-sql_2.11</artifactId> 
	<version>2.4.3</version>
</dependency>

//运行代码

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

object WordCount {
  def main(args: Array[String]): Unit = {
    //使用开发工具完成Spark WordCount的开发

    //LocaL模式
    //创建SparkConf对象
    //设定Spark设计框架的运行（部署）环境
    //App id
    val config:SparkConf = new SparkConf().setMaster("local[*]").setAppName("wordCount")

    //创建一个Spark上下文对象sc
    val sc = new SparkContext(config)

    //读取文件,将文件内容一行一行的读取出来,这里的String是一行的意思
    val lines:RDD[String] = sc.textFile("d:/a.txt")

    //将一行一行的数据分解一个一个的单词，这里的String是一个一个的意思
    val words:RDD[String] = lines.flatMap(_.split(" "))

    //为了统计方便，将单词数据进行结构数据转换
    val wordToOne:RDD[(String,Int)] = words.map((_,1))

    //对转换结构后的数据进行分组聚合
    val wordToSum:RDD[(String,Int)] = wordToOne.reduceByKey(_+_)

    //将统计结果采集后打印到控制台
    val result:Array[(String,Int)] = wordToSum.collect()

    //println(result)
    result.foreach(println)
  }
}

运行结果：

Spark Yarn部署流程：

Java IO回顾：

Java IO中体现装饰者设计模式，表示一种功能的扩展（比如：以前没有这个功能，但是现在我可以包装一下，修饰一下就有这个功能了）。

输入I，输出O

字节（rar,zip,dat,png,jpeg）,字符（txt）字符流里面可以一行一行的读数据（BuffereReader（入），BuffereWriter（出））

//文件输入流

Input Stream in = new FileInputStream(“xxxxxxxx”)

//缓冲流,解决前面文件传输效率的问题

InputStream bufferIn = new BufferedInputStream( new FileInputStream(“xxxxxxx”))

//文件输入流

Input Stream in = File Input Stream（“xxxxxx”）

//使用字符流读取一行数据

Reader reader = new BuffereReader（new FileInputStream( in," UTF-8 " )）

RDD编程 - - - 编程模型

Spark中，RDD被标示为对象，通过对象的方法调用来的RDD进行转换。金国一系列的transformations定义RDD之后，就可以调用actions触发RDD的计算，action可以是向应用程序返回结果（count,collect等），或者时向存储系统保存数据（saveAsTextFile等），在Spark中只有遇到action，才会执行RDD的计算（即延迟计算），这样在运行时可以通过管道的方式传输多个转换。

mSpark RDD 概念

• RDD是将数据项拆分为多个分区的集合，存储在集群的工作节点上的内存中，并执行正确的的操作
• RDD是用于数据转换的接口
• RDD指向了存储在HDFS，Cassandra，HBase等，或缓存（内存，内存+磁盘，仅磁盘等），或在故障或缓存回收时重新计算其他RDD分区中的数据。
• RDD是弹性分布式数据集（Resilient Distributed Datasets）
  • RDD是只读的，分区记录的集合，每个分区
  • RDD

RDD的特性：

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

创建RDD的方式，两种

val rdd=sc.parallelize(List(1,2,3,4,5,6))
rdd.count
//下面两个都是从内存创建，底层实现时一样的。
rdd.partitions.size
//一般正常使用 .makeRDD
val rdd = sc.makeRDD(List(1,2,3,4,5,6))

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

RDD概述

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

RDD:体现了装饰者设计模式，是将数据处理逻辑进行封装。

并行与并发的区别：

并发：线程并发（一个CPU的内核有多个线程来抢栈资源，这时只有一个线程资源能抢占上，其他的都抢占不上，应为线程堵塞了，最后线程释放之后其他的线程才有机会），这个时间会非常快。

并行：多个CPU迎接多个线程资源，不用抢占，可以同时执行多个任务。

RDD特点：

RDD表示只读的分区数据集，对RDD进行改动，只能通过RDD的上转换操作，有一个个RDD得到一个新的RDD，新的RDD包含了从其他RDD衍生所必须的信息。RDD之间存在依赖，RDD的执行按照血缘关系延时计算的。如果血缘关系较长，可以