Spark是一种快速、通用、可扩展的大数据分析引擎
Spark的特点
-
Speed：快速高效
-
性能比Hadoop MapReduce快100倍。即便是不将数据cache到内存中，其速度也是MapReduce10 倍以上。
-
Ease of Use：简洁易用
-
Spark支持 Java、Scala、Python和R等编程语言编写应用程序
-
Generality：通用、全栈式数据处理
-
Runs Everywhere：可以运行在各种资源调度框架和读写多种数据源
-
Spark支持的多种部署方案：Standalone是Spark自带的资源调度模式；Spark可以运行在Hadoop的YARN上面；Spark 可以运行在Mesos上（Mesos是一个类似于YARN的资源调度框架）；Spark还可以Kubernetes实现容器化的资源调度
-
丰富的数据源支持。Spark除了可以访问操作系统自身的本地文件系统和HDFS之外，还可以访问 Cassandra、HBase、Hive、Alluxio（Tachyon）以及任何 Hadoop兼容的数据源。这极大地方便了已经 的大数据系统进行顺利迁移到Spark。
面试题：MapReduce和Spark的本质区别：
-
MR只能做离线计算，如果实现复杂计算逻辑，一个MR搞不定，就需要将多个MR按照先后顺序连成一串，一个MR计算完成后会将计算结果写入到HDFS中，下一个MR将上一个MR的输出作为输入，这样就要频繁读写HDFS，网络IO和磁盘IO会成为性能瓶颈。从而导致效率低下。
-
spark既可以做离线计算，又可以做实时计算，提供了抽象的数据集（RDD、Dataset、DataFrame、DStream）
有高度封装的API，算子丰富，并且使用了更先进的DAG有向无环图调度思想，可以对执行计划优化后在执行，并且可以数据可以cache到内存中进行复用，shuffle时，数据可以不排序
MR和Spark在Shuffle时数据都落本地磁盘
-
Spark架构体系
StandAlone模式是spark自带的集群运行模式，不依赖其他的资源调度框架，部署起来简单。
StandAlone模式又分为client模式和cluster模式，本质区别是Driver运行在哪里，如果Driver运行在SparkSubmit进程中就是Client模式，如果Driver运行在集群中就是Cluster模式
-
Spark中重要角色
-
Master ：是一个Java进程，接收Worker的注册信息和心跳、移除异常超时的Worker、接收客户端提交的任务、负责资源调度、命令Worker启动Executor。
-
Worker ：是一个Java进程，负责管理当前节点的资源管理，向Master注册并定期发送心跳，负责启动Executor、并监控Executor的状态。
-
SparkSubmit ：是一个Java进程，负责向Master提交任务。
-
Driver ：是很多类的统称，可以认为SparkContext就是Driver，client模式Driver运行在SparkSubmit进程中，cluster模式单独运行在一个进程中，负责将用户编写的代码转成Tasks，然后调度到Executor中执行，并监控Task的状态和执行进度。
-
Executor ：是一个Java进程，负责执行Driver端生成的Task，将Task放入线程中运行。
-
-
启动Spark Shell程序
-
什么是Spark Shell
-
spark shell是spark中的交互式命令行客户端，可以在spark shell中使用scala编写spark程序，启动后默认已经创建了SparkContext，别名为sc
/opt/apps/spark-3.2.3-bin-hadoop3.2/bin/spark-shell \
--master spark://node-1.51doit.cn:7077 --executor-memory 1g \
--total-executor-cores 3如果Master配置了HA高可用，需要指定两个Master（因为这两个Master任意一个都可能是Active状态）
/bigdata/spark-3.2.3-bin-hadoop3.2/bin/spark-shell \
--master spark://node-1.51doit.cn:7077,node-2.51doit.cn:7077 \
--executor-memory 1g \
--total-executor-cores 3参数说明：
--master 指定masterd地址和端口，协议为spark://，端口是RPC的通信端口
--executor-memory 指定每一个executor的使用的内存大小
--total-executor-cores指定整个application总共使用了cores
-
在shell中编写第一个spark程序
sc.textFile("hdfs://node-1.51doit.cn:9000/words.txt").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_).sortBy(_._2,false).saveAsTextFile("hdfs://node-1.51doit.cn:9000/out")-
Scala编写Spark的WorkCount
-
创建一个Maven项目
-
在pom.xml中添加依赖和插件
<!-- 定义的一些常量 -->
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<encoding>UTF-8</encoding>
<spark.version>3.2.3</spark.version>
<scala.version>2.12.15</scala.version>
</properties>
<dependencies>
<!-- scala的依赖 -->
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>${scala.version}</version>
</dependency>
<!-- spark core 即为spark内核 ，其他高级组件都要依赖spark core -->
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.12</artifactId>
<version>${spark.version}</version>
</dependency>
</dependencies>
<!-- 配置Maven的镜像库 -->
<!-- 依赖下载国内镜像库 -->
<repositories>
<repository>
<id>nexus-aliyun</id>
<name>Nexus aliyun</name>
<layout>default</layout>
<url>http://maven.aliyun.com/nexus/content/groups/public</url>
<snapshots>
<enabled>false</enabled>
<updatePolicy>never</updatePolicy>
</snapshots>
<releases>
<enabled>true</enabled>
<updatePolicy>never</updatePolicy>
</releases>
</repository>
</repositories>
<!-- maven插件下载国内镜像库 -->
<pluginRepositories>
<pluginRepository>
<id>ali-plugin</id>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<snapshots>
<enabled>false</enabled>
<updatePolicy>never</updatePolicy>
</snapshots>
<releases>
<enabled>true</enabled>
<updatePolicy>never</updatePolicy>
</releases>
</pluginRepository>
</pluginRepositories>
<build>
<pluginManagement>
<plugins>
<!-- 编译scala的插件 -->
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<!-- 编译java的插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<executions>
<execution>
<id>scala-compile-first</id>
<phase>process-resources</phase>
<goals>
<goal>add-source</goal>
<goal>compile</goal>
</goals>
</execution>
<execution>
<id>scala-test-compile</id>
<phase>process-test-resources</phase>
<goals>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<executions>
<execution>
<phase>compile</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
</executions>
</plugin>
<!-- 打jar插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.4.3</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>-
编写Spark程序
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
/**
* 1.创建SparkContext
* 2.创建RDD
* 3.调用RDD的Transformation（s）方法
* 4.调用Action
* 5.释放资源
*/
object WordCount {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf().setAppName("WordCount")
//创建SparkContext，使用SparkContext来创建RDD
val sc: SparkContext = new SparkContext(conf)
//spark写Spark程序，就是对抽象的神奇的大集合【RDD】编程，调用它高度封装的API
//使用SparkContext创建RDD
val lines: RDD[String] = sc.textFile(args(0))
//Transformation 开始 //
//切分压平
val words: RDD[String] = lines.flatMap(_.split(" "))
//将单词和一组合放在元组中
val wordAndOne: RDD[(String, Int)] = words.map((_, 1))
//分组聚合，reduceByKey可以先局部聚合再全局聚合
val reduced: RDD[(String, Int)] = wordAndOne.reduceByKey(_+_)
//排序
val sorted: RDD[(String, Int)] = reduced.sortBy(_._2, false)
//Transformation 结束 //
//调用Action将计算结果保存到HDFS中
sorted.saveAsTextFile(args(1))
//释放资源
sc.stop()
}
}-
Java编写Spark的WordCount
-
import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaPairRDD; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.JavaSparkContext; import org.apache.spark.api.java.function.FlatMapFunction; import org.apache.spark.api.java.function.Function2; import org.apache.spark.api.java.function.PairFunction; import scala.Tuple2; import java.util.Arrays; import java.util.Iterator; public class JavaWordCount { public static void main(String[] args) { SparkConf sparkConf = new SparkConf().setAppName("JavaWordCount"); //创建JavaSparkContext JavaSparkContext jsc = new JavaSparkContext(sparkConf); //使用JavaSparkContext创建RDD JavaRDD<String> lines = jsc.textFile(args[0]); //调用Transformation（s） //切分压平 JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() { @Override public Iterator<String> call(String line) throws Exception { return Arrays.asList(line.split(" ")).iterator(); } }); //将单词和一组合在一起 JavaPairRDD<String, Integer> wordAndOne = words.mapToPair( new PairFunction<String, String, Integer>() { @Override public Tuple2<String, Integer> call(String word) throws Exception { return Tuple2.apply(word, 1); } }); //分组聚合 JavaPairRDD<String, Integer> reduced = wordAndOne.reduceByKey( new Function2<Integer, Integer, Integer>() { @Override public Integer call(Integer v1, Integer v2) throws Exception { return v1 + v2; } }); //排序，先调换KV的顺序VK JavaPairRDD<Integer, String> swapped = reduced.mapToPair( new PairFunction<Tuple2<String, Integer>, Integer, String>() { @Override public Tuple2<Integer, String> call(Tuple2<String, Integer> tp) throws Exception { return tp.swap(); } }); //再排序 JavaPairRDD<Integer, String> sorted = swapped.sortByKey(false); //再调换顺序 JavaPairRDD<String, Integer> result = sorted.mapToPair( new PairFunction<Tuple2<Integer, String>, String, Integer>() { @Override public Tuple2<String, Integer> call(Tuple2<Integer, String> tp) throws Exception { return tp.swap(); } }); //触发Action，将数据保存到HDFS result.saveAsTextFile(args[1]); //释放资源 jsc.stop(); } } -
使用Lambda表达式方式
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;
import java.util.Arrays;
public class JavaLambdaWordCount {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("JavaLambdaWordCount");
//创建SparkContext
JavaSparkContext jsc = new JavaSparkContext(conf);
//创建RDD
JavaRDD<String> lines = jsc.textFile(args[0]);
//切分压平
JavaRDD<String> words = lines.flatMap(line -> Arrays.asList(line.split(" ")).iterator());
//将单词和一组合
JavaPairRDD<String, Integer> wordAndOne = words.mapToPair(word -> Tuple2.apply(word, 1));
//分组聚合
JavaPairRDD<String, Integer> reduced = wordAndOne.reduceByKey((a, b) -> a + b);
//调换顺序
JavaPairRDD<Integer, String> swapped = reduced.mapToPair(tp -> tp.swap());
//排序
JavaPairRDD<Integer, String> sorted = swapped.sortByKey(false);
//调换顺序
JavaPairRDD<String, Integer> result = sorted.mapToPair(tp -> tp.swap());
//将数据保存到HDFS
result.saveAsTextFile(args[1]);
//释放资源
jsc.stop();
}
}
