Spark基本概念，RDD算子创建与使用

一.为什么使用Spark

分布式计算框架（处理效率）

1.MapReduce编程模型的局限性

缺点：代码复杂，处理效率低

• 繁杂
  只有Map和Reduce两个操作，复杂的逻辑需要大量的样板代码

• 处理效率低：
  Map中间结果写磁盘，Reduce写HDFS，多个Map通过HDFS交换数据
  任务调度与启动开销大

• 不适合迭代处理、交互式处理和流式处理

  Spark是类Hadoop MapReduce的通用并行框架
  Job中间输出结果可以保存在内存，不再需要读写HDFS
  比MapReduce平均快10倍以上

2.Spark简介

诞生于加州大学伯克利分校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版本

3.Spark优势

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

4.Spark技术栈

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

5.Spark-shell：spark自带的交互式工具

• 本机（没有master和worker进程）
  spark-shell --master local[*]
• Standalone（会有master和worker进程）
  spark-shell --master spark://MASTERHOST:7077
• YARN
  spark-shell --master yarn-client

6.Spark架构设计

sc是SparkContext的一个对象

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

job下可有很多task，每一个task运行在executor里面，处理一个RDD分区

drive端取决于client和cluster

executor运行在 Worker node端，driver可能运行Master 节点上

Worker node Executor（执行代码）

Master node Driver（把运行程序通过cluster manager分发给executor端）

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

job—stage—task（根据分区）

二.Spark API

创建maven工程：

​ （1）新建一个maven工程

​ （2）下载依赖包

scala-library
spark-core
spark-sql

   <dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>2.11.8</version>
    </dependency>

    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>2.1.1</version>
    </dependency>

  <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>2.1.1</version>
    </dependency>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.21</version>
    </dependency>

（3）在main文件夹下创建scala目录文件夹并设置成资源文件夹（右键—new—directory—scala—mark directory as —source root）

（4）添加Scala SDK(File—Project Structure —libraries—+—Scala SDK—ok—ok—ok)

（5）（避免在控制台中打印log）在工程目录下创建一个资源文件夹（resource），找到log4j-defaults.properties（External Libraries—Maven:org.apache.spark:spark-core_2.11:2.1.1—spark-core_2.11-2.1.1.jar—org—apache.spark—log4j-defaults.properties），复制log4j-defaults.properties文件到resource文件下，并改名为log4j.properties；并将log4j.properties中第19行log4j.rootCategory=INFO, console改成log4j.rootCategory=ERROR, console

（6）使用idea实现wordcount功能（先将文件上传到hdfs上）

​ 1.SparkContext

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

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

object SparkContextDemo extends App {
   
        //创建一个sparkcontext对象
        val conf: SparkConf = new SparkConf().setMaster("local[2]").setAppName("sparkTest")
        val sc: SparkContext = SparkContext.getOrCreate(conf)
    //实现wordcount的代码
  sc.textFile("hdfs://192.168.36.100:9000/data/a.txt").flatMap(x=>x.split(" ")).map((_,1)).reduceByKey(_+_).collect.foreach(println)
    //关闭资源
    sc.stop()
}

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

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

object SparkContextDemo extends App {
   
  //创建一个sparkcontext对象
   val spark: SparkSession = SparkSession.builder().master("local[2]")
    .appName("sparkSessionTest")
    .getOrCreate()
  private val sc: SparkContext = spark.sparkContext
  sc.textFile("hdfs://192.168.36.100:9000/data/a.txt").flatMap(x=>x.split(" ")).map((_,1)).reduceByKey(_+_).collect.foreach(println)
}
//输出
(are,1)
(hive,1)
(love,4)
(python,1)
(mapreduce,1)
(,2)
(basic,1)
(mysql,1)
(very,1)
(important,1)
(ever,1)
(linux,1)
(java,1)
(yarn,1)
(them,1)
(forget,1)
(you,2)
(forever,1)
(hadoop,2)
(if,1)
(lovr,1)
(i,6)
(to,2)
(wish,7)
(won't,1)
(things,1)
(but,1)
(and,2)
(hdfs,1)
(these,1)
(the,3)
(hbase,1)

三.Spark RDD

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

1.Spark RDD概念

简单的解释
RDD是将数据项拆分为多个分区的集合，存储在集群的工作节点上的内存中，并执行正确的操作
复杂的解释
RDD是用于数据转换的接口
RDD指向了存储在HDFS、Cassandra、HBase等、或缓存（内存、内存+磁盘、仅磁盘等），或在故障或缓存收回时重新计算其他RDD分区中的数据

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

• 分布式数据集（Distributed）

​ 数据的计算

• 数据集（ Datasets）

  RDD是只读的、分区记录的集合，每个分区分布在集群的不同节点上
  RDD并不存储真正的数据，只是对数据和操作的描述

• 弹性（Resilient）
  自动进行存储方式的切换，RDD默认存放在内存中，当内存不足，Spark自动将RDD写入磁盘

  基于Lineage的高效容错机制，在任何时候都能进行重算，根据数据血统，以自动从节点失败中恢复分区，各个分区之间的数据互不影响

  Stage失败自动重试/Task失败自动重试

  Check point和Persist，checkpoint持久化到文件系统

• 容错性
  根据数据血统，可以自动从节点失败中恢复分区

rdd是集合，指向数据

2.RDD的五大特性

（1）A list of partitions

一个分区列表，RDD中的数据都存在一个分区列表里面，每个任务处理一个分区

（2）A function for computing each split

每个分区上都有compute函数，计算该分区中的数据，相当于对RDD的每个split或partition做计算

（3）A list of dependencies on other RDDs

RDD之间有依赖关系，RDD的容错机制就是根据这个特性而来

（4）Optionally,a Partitioner for key-value RDDs(e.g. to say that the RDD is hash-partitoned)

可选的，针对于kv类型的RDD才具有这个特性，作用是决定了数据的来源以及数据处理后的去向

（5）Optionally,a list of preferred locations to compute each split on(e.g. block locations for an HDFS file)

可选项，数据本地性，数据位置最优；将计算任务分派到其所在处理数据块的存储位置

3.RDD与DAG

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

4.RDD编程流程

RDD创建—RDD转换—RDD持久化—RDD执行

四.RDD创建

1.使用集合创建RDD

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

object rddCreate extends  App {
   
      //创建SparkContext对象
     private val conf: SparkConf = new SparkConf().setAppName("rddCreate").setMaster("local[*]")
     private val sc = new SparkContext(conf)
     //1.用集合创建RDD
      //*使用parallelize创建RDD
     val rdd1=sc.parallelize(List(1,2,3,4,5,6))
          //计算集合
          println(rdd1.count)
         println(rdd1.partitions.size)
         //设置分区数
       val  rdd2=sc.parallelize(List(1,2,3,4,5,6),5)
       println(rdd2.partitions.size)
       //*使用makeRDD创建RDD
       private val rdd3: RDD[Int] = sc.makeRDD(List(1,2,3,4,5))
       println(rdd3.partitions.size)
}
//输出
6 
12//默认分区数是电脑可用线程数
5
12

注：

• Spark默认会根据集群的情况来设置分区的数量，也可以通过parallelize()第二参数来指定
• Spark会为每一个分区运行一个任务进行处理

2.通过加载文件产生RDD

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

object rddCreate extends App {
   

  //创建SparkContext对象
  private val conf: SparkConf = new SparkConf()