day10-spark学习前奏(Spark基本介绍、特点、spark安装，java及scala实现基于Spark的wordcount)

前言

day09，我们学习了scala的泛型、上界与下界、隐式转换。今天开始进入spark的学习，今天主要介绍Spark是什么及其特点、Spark架构、Spark的安装、演示使用scala和java实现的基于spark进行wordcount程序的示例。

spark是什么

Apache Spark是用于大规模数据处理的分析引擎。Spark于2009诞生于伯克利大学，2010年开源，2013年6月成为Apache的孵化项目，2014年2月正式成为apache的顶级项目。spark主要由以下几部分组成：

1. Spark Core：spark中最核心，最重要的部分。Spark Streaming。
2. Spark SQL：基于Spark Core，类似Hive，一般用于离线数据处理。
3. Spark Streaming：基于Spark Core，做实时计算。
4. Spark MLlib：数据分析、建模。
5. Spark Graphx：图计算。

Spark特点

速度快：Spark的最大特点是速度快，官方的说法是比hadoop快100倍，如下是官方原文截图：

这是个对比是不公平的，因为spark官方做对比的是在逻辑回归情景下，这是拿自己的长处去与hadoop的短处作比较。当然，Spark的运算整体比Hadoop快3~5倍是没问题的。
容易使用：Spark支持Java, Scala, Python, R等语言的API，同时还支持SQL。
功能齐全:Saprk提供Spark Streaming、Spark SQL、Spark MLlib、Spark Graphx等一组组件，支持离线数据处理、实时数据处理、机器学习库、图计算等。
兼容性：Spark可以运行在Hadoop、Apache Mesos、Kubernetes或云上，可以访问不同时的数据源。

Spark架构

如下是官方提供的Spark架构图。

Spark由Mapster、Worker节点组成，它们的功能如下 ：
主节点master的功能：

1. 管理集群
2. 任务分配
3. 接收客户端的请求

从节点worker的功能：

1. 管理本节点的资源，如CPU、内存等。
2. 执行任务的是Executor，所以worker上面会有多个Executor。

Spark的安装

Spark的的安装方式主要分伪分布式、完全分布式两种。

伪分布式

到官网下载安装包，然后解压到安装目录下，这时安装到/opt/module/spark-2.1.0-bin-hadoop2.7目录下。
Spark需要修改的配置文件有两个：
conf/spark-env.sh，修改后的完整配置如下：

export JAVA_HOME=/opt/module/jdk1.8.0_121/  #根据自己机器的jdk安装目录
export SPARK_MASTER_HOST=bigdata121   #Master节点的主机名
export SPARK_MASTER_PORT=7077  #Master的端口

conf/slaves，这个文件配置的是Worker节点的主机名，这里的内容如下：

bigdata121

启动

/opt/module/spark-2.1.0-bin-hadoop2.7/sbin/start-all.sh

启动后，使用jps可以看到Worker及Master进程。

[root@bigdata121 ~]# jps
1159 Worker
1214 Jps
1071 Master
[root@bigdata121 ~]# 

并且在浏览器中访问8080端口，可以打开如下的Spark的web界面。

完全分布式

完全分布式的安装与伪分布式基本一样，唯一不同的是conf/slaves这个配置文件不一样，完全分布式的Worker节点有多个，所以conf/slaves配置文件中会有多行，每行对应一台Worker节点的主机名。

基于Spark的worldcount代码实例

scala实现

基于Spark进行wordcount的scala实现worldcount，其核心代码也就一行，非常的简便。

package day20191227
import org.apache.spark.{SparkConf, SparkContext}
/**
  * scala的workcount
  * @author jinrui
  * @date 2019/12/28 13:28
  * @version 1.0
  */
object WordCountScala extends App {
  /**
    * 获取spark环境
    * setAppName定义应用程序的名字
    * setMaster指定任务运行的模式，
    */
  val conf = new SparkConf().setAppName("WordCount").setMaster("local")
  val sc = new SparkContext(conf)
  //读取数据,通过sc读取数据
  val line = sc.textFile("C:\\javacore\\14_bigdata\\workcount.txt")
  //word count
  val result = line.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)
 //打印
  result.foreach(println)

}

java实现

基于Spark进行wordcount的java代码实现要比scala的实现复杂一些，因为java中没有高阶函数的概念，要调用Spark的API就需要实现其接口。

package day20191227;
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 org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;
import java.util.Arrays;
import java.util.Iterator;

/**
 * java版本的word count
 * @author jinrui
 * @version 1.0
 * @date 2019/12/28 13:51
 */
public class WordCountJava {
    public static void main(String[] args) {
        //获取spark的环境
        SparkConf conf = new SparkConf().setAppName("JAVA").setMaster("local");
        JavaSparkContext jsc = new JavaSparkContext(conf);
        //读取数据
        JavaRDD<String> javardd = jsc.textFile("C:\\javacore\\14_bigdata\\workcount.txt");

        /**
         * 数据的切分,
         * flatMap在scala中是传递一个匿名函数，形成高阶函数，java中是没有高阶函数的
         * java中是基于接口，我们要实现spark的接口,形成一个匿名类
         */
        JavaRDD word = javardd.flatMap(new FlatMapFunction<String,String>(){
            //String s代表的就是读取的一行数据
            @Override
            public Iterator<String> call(String s){
                String[] s1 = s.split(" ");
                return Arrays.asList(s1).iterator();
            }
        });
        //数据拼接
        JavaPairRDD<String,Integer> javaPairRDD = word.mapToPair(new PairFunction<String,String,Integer>() {
            @Override
            public Tuple2<String,Integer> call(String s) throws Exception {
                return new Tuple2<>(s,1);
            }
        });
        //合并
        JavaPairRDD<String,Integer> result = javaPairRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) throws Exception {
                return integer + integer2;
            }
        });

        //打印
        result.foreach(new VoidFunction<Tuple2<String, Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> stringIntegerTuple2) throws Exception {
                System.out.println(stringIntegerTuple2);
            }
        });
    }
}