spark相关知识点

spark相关知识点

1.spark是一站式的数据分析引擎

spark是一个计算组件，只做计算，不能做存储。里面有一个独立的资源管理系统（可以代替yarn，但一般没人用）

sparkRDD：编程的方式做数据分析，取代mapreduce

sparksql：取代hivesql（两者语句相同）

sparkStreaming：取代storm 做实时流

sparkml取代机器学习

2.四大特性

（1）快速：（spark比Hadoop快100倍，实际10倍左右）（因为spark在内存，hadoop在磁盘）

（2）易用：（可以支持多语言进行开发）

（3）通用性：（实时、离线、sql、机器学习）

（4）跨平台：（分配资源、各个地方读数据源）可以运行在：hadoop（yarn）、Apache Mesos、standalone（spark）。数据源多样性：scala集合、mysql、hive、habse、可以从任何能看到的数据系统都能做数据源

计算引擎本质：有向无环图

3.RDD 弹性分布式数据集【spark 数据结构】

弹性：数据既可以在内存也可以在磁盘（需要配置）（spark是尽量基于内存的计算框架）

数据集：数据集的来源有scala集合、hdfs文件、mysql，它们都可以转变成RDD。

sparkRDD组件能从外部加载数据源转换为spark能够识别的数据模型（围绕这个数据模型进行数据分析）

分布式：转换RDD后是分布式存储的，存储单元是partition

默认一个hdfs的block块就是一个RDD分区，所有的分区组合在一起就是一个RDD，就是一个完整的数据集。

补充：sparkRDD编程只能用高阶函数，所以不是面向对象是面向函数编程。

4.sparkRDD的操作

sparkRDD支持两种类型的操作：Transformation类型|Action类型

补充：spark每一个高阶函数都叫做算子

（1）Transformation类型：

输入算子（textFile：读取文本、parallelize：把scala集合变成RDD）

转换算子（map、flatmap、reduceByKey）

缓存算子（cache【内存】、persist【磁盘、内存、序列化或者非序列化、RDD缓存的时候做备份】）

注：transformation类型的算子分为shuffle型(触发stage划分)和非shuffle型。shuffle型算子一般需要让RDD的数据经过网络传输，非shuffle型算子在使用时一般不需要跨网络传输数据，所以尽量使用非shuffle型算子。

（2）Action类型：

一般输出型的算法（打印、持久化磁盘）

foreach()/count()/collect()/reduce()/saveAsHadoopFile()

一般是拉取形成一些集合

一般情况下调用了一个算子，如果返回值类型是RDD一般是transformation算子、如果不是RDD类型，一般为Action算子。

val map = List(1,2,3).map(t=>t+"_1")
  println(map)//scala中会执行，spark中不会执行

只有遇到action类型才会触发程序执行，不然不会执行（懒加载）【stage划分<->task】

spark程序以stage作为最小单元执行.

5.案例实现

案例一：spark版本的wordcount

public static void main(String[] args){
    //1.spark任何一个组件 程序的入口
    SparkConf conf = new SparkConf(); //配置文件信息
    conf.setMaster("local[1]"); //本地执行
    conf.setAppName("wordcount");
    JavaSparkContext jsc = new JavaSparkContext(conf);
    //2.初始化RDD
    JavaRDD<String> linesRDD = jsc.textFile("C:\\Users\\Administrator\\Desktop\\javaclass\\spark\\ww.txt");

    //3.各种数据分析
    JavaRDD<String> flatMapRDD = linesRDD.flatMap(new FlatMapFunction<String, String>() {
        public Iterator<String> call(String line) throws Exception {
            return Arrays.asList(line.split(",")).iterator();
        }
    });
    JavaPairRDD<String, Integer> mapToPairRDD = flatMapRDD.mapToPair(new PairFunction<String, String, Integer>() {
        public Tuple2<String, Integer> call(String word) throws Exception {
            return new Tuple2<String, Integer>(word, 1);
        }
    });
    JavaPairRDD<String, Integer> reduceByKeyRDD = mapToPairRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
        public Integer call(Integer v1, Integer v2) throws Exception {
            System.out.println(v1+" "+v2);
            return v1 + v2;
        }
    });
    //4.结束 打印 持久化MySQLfs/hive/file
    reduceByKeyRDD.foreach(new VoidFunction<Tuple2<String, Integer>>() {
        public void call(Tuple2<String, Integer> tuple) throws Exception {
            System.out.println(tuple._1+" "+tuple._2);
        }
    });
    jsc.stop();
}

案例二：jdk1.8版本的wordcount

public static void main(String[] args){

    SparkConf conf = new SparkConf();
    conf.setMaster("local[1]");
    conf.setAppName("wordcount");
    JavaSparkContext jsc = new JavaSparkContext(conf);
    JavaRDD<String> linesRDD = jsc.textFile("C:\\Users\\Administrator\\Desktop\\javaclass\\spark\\ww.txt");

    //数据分析
    JavaRDD<String> flatMapRDD = linesRDD.flatMap(line -> Arrays.asList(line.split(",")).iterator());
    /**
     * 函数式编程  实现函数：输入-->输出
     *  输入：上一个RDD javaRDD["i","jump"]
     *  输出
     *
     *  def mapToPair[K2, V2](f: PairFunction[T, K2, V2]): JavaPairRDD[K2, V2] = {
     *     def cm: ClassTag[(K2, V2)] = implicitly[ClassTag[(K2, V2)]]
     *     new JavaPairRDD(rdd.map[(K2, V2)](f)(cm))(fakeClassTag[K2], fakeClassTag[V2])
     *   }
     *   @FunctionalInterface
     * public interface PairFunction<T, K, V> extends Serializable {
     *   Tuple2<K, V> call(T t) throws Exception;
     * }
     */
    JavaPairRDD<String, Integer> mapToPairRDD = flatMapRDD.mapToPair(word -> new Tuple2<String, Integer>(word, 1));
    /**
     * @FunctionalInterface
     * public interface Function2<T1, T2, R> extends Serializable {
     *   R call(T1 v1, T2 v2) throws Exception;
     * }
     */
    JavaPairRDD<String, Integer> reduceByKeyRDD = mapToPairRDD.reduceByKey((v1, v2) -> v1 + v2);
    reduceByKeyRDD.foreach(t-> System.out.println(t._1+" "+t._2));

    jsc.stop();
}

案例三：scala版本

def main(args: Array[String]): Unit = {

  val conf: SparkConf = new SparkConf()
    .setMaster("local")
    .setAppName("scala_wordcount")
  val sc: SparkContext = new SparkContext(conf)
  //scala 列表
  val list = List(
    "i,jump",
    "you,jump"
  )
  val listRDD: RDD[String] = sc.parallelize(list)//集合变为RDD
  /**
   * 接下来可以使用各种spark高阶算子做数据分析了
   */
  listRDD.flatMap(t=>t.split(","))
    .map(word=>(word,1))
    .reduceByKey((num1,num2)=>num1+num2)
    .foreach(println)
  //简化代码    
  //listRDD.flatMap(_.split(",")).map((_,1)).reduceByKey(_+_).foreach(println)
  sc.stop()
}

6.宽依赖和窄依赖

宽依赖：RDD中partition中的数据，如果依赖父RDD多个分区（跨节点）【bykey】，叫宽依赖

窄依赖：RDD中partition中的数据，如果只依赖父RDD的一个分区、常量级的分区，就叫窄依赖。

常量级的分区一般出现在分区的合并（一般不跨节点）

sc.textfile.flatmap.map.reduceByKey.foreach():血缘关系链

从血缘关系链中可以看出stage划分

注意：

var rdd1 = sc.textfile.flatmap
var rdd2 = rdd1.map
//rdd1只会被消费一次
var rdd3 = rdd1.map
//会从sc.textfile.flatmap开始再执行一遍而不是从rdd1开始，除非做了持久化

.map.reduceByKey.foreach():血缘关系链

从血缘关系链中可以看出stage划分

注意：

var rdd1 = sc.textfile.flatmap
var rdd2 = rdd1.map
//rdd1只会被消费一次
var rdd3 = rdd1.map
//会从sc.textfile.flatmap开始再执行一遍而不是从rdd1开始，除非做了持久化