Spark基础

一Spark的定义：

专为大规模数据处理而设计的快速通用的计算引擎，并形成一个高速 发展应用广泛的生态系统。

二 spark 的特点

速度快

易用性： 80多个高级运算符，

跨语言：使用Java，Scala，Python，R和SQL快速编写应用程序

通用性：Spark 提供了大量的库，包括 SQL、DataFrames、MLib、GraphX、 Spark

开发者可以在同一个应用程序中无缝组合使用这些库。

三spark 架构设计

四、 十五个核心概念

1 RDD 弹性分布式数据集，是对数据集在spark存储和计算过程中的一种抽象。横向上可切分行计算，纵向上可进行内外存切换使用

2 Partition 分区 划分的依据有很多

3 算子 广义上：对任何函数进行某一项操作都可以认为是一个算子。 通俗来说，算子即为映射、关系、变换.  MapReduce 算子，主要分为两个，即为 Map 和 Reduce 两个主要操作的 算子，导致灵活可用性比较差。Spark 算子，分为两大类，即为 Transformation 和 Action 类，合计有 80 多个

4 、Transformation 类算子  : 操作是延迟计算的

5 Action类算子： 会触发Spark 提交作业（Job） 并将数据输出Spark 系统

6 窄依赖：一个父的分区只能到一个子的分区 代表： map, filter

7宽依赖： 一个父的分区被多个子分区 使用

8  Application  指的是用户编写的 Spark 应用程序，包含了一个 Driver 功能的代码和分布在集群中多个节点上运行的 Executor 代码

9 Driver  运行 main 函数并且创建 SparkContext 的程序

10 Cluster Manage   集群的资源管理器，在集群上获取资源的服务

11    WorkerNode  集群中任何一个可以运行 spark 应用代码的节点。

12  Executor    即为 spark 概念的资源容器，类比于 yarn 的 container 容 器，真正承载 Task 的运行与管理，以多线程的方式运行 Task，更加高 效快速。

13 Task          Task 分为两类，即为 ShuffleMapTask 和 ResultTask。  ShuffleMapTask 由 transformation操作组成。        ResultTask 由 action操作组成

14 Job （作业） Spark RDD 里的每个 action 的计算会生成一个 job。

15  Stage（阶段）  Stage 是 Job 的组成部分，每个 Job 可以包含 1 个或者多个 Stage。每个 Job 会被拆分很多组 Task，每组任务被称为 Stage，也可称 TaskSet，一个作业可以被分为一个或多个阶段

五 、spark 运行模式 

 2.2用户交互方式

        1、spark-shell:spark 命令行方式来操作 spark 作业。 o 多用于简单的学习、测试、简易作业操作。 2、spark-submit:通过程序脚本，提交相关的代码、依赖等来操作 spark 作业。 o 最多见的提交任务的交互方式，简单易用、参数齐全。 3、spark-sql:通过 sql 的方式操作 spark 作业。 o sql 相关的学习、测试、生产环境研发均可以使用该直接操作交互方 式。 4、spark-class:最低层的调用方式，其它调用方式多是最终转化到该方式中去提交。 o 直接使用较少 5、sparkR,sparkPython:通过其它非 java、非 scala 语言直接操作 spark 作业的方式。 o R、python 语言使用者的交互方式。

Java 实现spark wordcount 示例

  1 配置  winutils.exe

2配置依赖

 eclipse-jee 版
 spark-2.3.2
 jdk1.8.x（自 spark2.2.0 起，jdk1.7 将不再支持）
 log4j
o pom 配置模板
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http:/
/maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>study</groupId>
<artifactId>spark_study</artifactId>
<version>0.1</version>
<properties>
<project.build.sourceEncoding>UTF8</project.build.sourceEncoding>
</properties>
<!-- 首先配置仓库的服务器位置,首选阿里云，也可以配置镜像方式，效果雷
同 -->
<repositories>
<repository>
<id>nexus-aliyun</id>
<name>Nexus aliyun</name>
<url>http://maven.aliyun.com/nexus/content/groups/publ
ic</url>
</repository>
</repositories>
<dependencies>
<dependency><groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.3.2</version>
<scope>provided</scope>
</dependency>
<!-- log4j 依赖添加 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>spark_study</finalName>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<descriptorRefs>
<descriptorRef>jar-withdependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>assembly</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Java代码

 public static void main(String[] args) {
        //1 创建SparkConf
        SparkConf conf = new SparkConf();
        //设置app name
        conf.setAppName("JavaWordCount");


        //2 创建spark context
        JavaSparkContext jsc = new JavaSparkContext(conf);
        //3 读取文件构建line rdd （数据集合，每一行的数据）
        String localFilePath= "D:\\ideaWork\\spark_wordcount_01\\data\\input.txt";

        JavaRDD<String> fileRDD= jsc.textFile(localFilePath);

        //4 line rdd ->word rdd
        JavaRDD<String> wordRDD = fileRDD.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterator<String> call(String word) throws Exception {
                return Arrays.asList(word.split("\\s+")).iterator();
            }
        });

        //5 word rdd ->(word,1)
        JavaPairRDD<String,Integer> kvPairRDD = wordRDD.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String word1) throws Exception {
                return new Tuple2<String,Integer>(word1,1);
            }
        });

        //6 (word ,1) ->(word,freq)
        JavaPairRDD<String,Integer> wcPairRDD = kvPairRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer f1, Integer f2) throws Exception {
                 return f1 +f2;
             }
         });
        //7执行action算子落地成结果
        List<Tuple2<String,Integer>>  pairList = wcPairRDD.collect();
        for (Tuple2<String,Integer> tuple2: pairList){
            System.out.println(tuple2);
        }
        //8关闭 spark context
        jsc.stop();
    }

代码 运行 三种方式      

     a）本地方式 -local - 开发环境        直接在主类中， run as  application即可

      b）linux 本地方式   -local -生产环境

                         开发环境打包：跟之前的 maven 打包完全一致
                                 编写 Shell 运行脚本

     c） 集群方式

        yarn-client