spark介绍及RDD操作

Spark

   Spark的主要部件

        Spark core:包含spark的主要功能。功能跟RDD有关的API都出自spark core

        Spark SQL：spark 中用于结构化数据处理的软件包。用户可以在spark环境下用SQL语言处理数据

        Spark streaming：spark 中用于处理流数据的部件

        MLlib  ：spark中用来进行机器学习和数据建模的软件包

        GraphX ：spark中用来进行图形计算（如社交媒体关系）的库函数

        ClusterManagers ：spark中用来管理集群或者节点的软件平台，这包括hadoop Yarn，Apache Mesos,和standalone scheduler（spark自带的用于单机系统）

Spark core 应用程序包括以下两部分

     Driver

1.     初始化sparkContext（spark的入口）

2.     Executor部分运行完毕后将SparkContext关闭

     Executor

1.     集合数据集

2.     文件数据集

Spark运行模式

       Standalone模式（spark自带的模式）

      1.     Spark-shell  交互式工具提交spark的job时，Driver在Master节点上运行

      2.     Spark-submit 工具提交job时Driver运行在本地client端上

  Yarn-client模式

  Yarn-cluster模式  当用户向YARN中提交一个应用程序后，YARN将分

       两个阶段运行该应用程序

  Mesos模式 另一种开源的Cluster Manager

Spark 调度模式

     Yarn 模式

     NodeManger

RDD类型

     1.     并行集合（Paralleliced Collections）

             来自于分布式化的数据对象比如python中的list对象，比如用户自己输入的数据

     2.      文件系统数据集

             比如hadoop datasets或文本文件，比如通过SparkContext.textFlie()读取的数据

RDD计算方式

    1.     变换（Transformation）

      如：map、filter的返回值仍然是一个RDD，Transformation操作是Lazy的，也就是说变换只是一些指令集而并不会去马上执行，需要等到有Actions操作的时候才会去真正计算给出结果。Lazy Evalustion

   2.     操作（Actions）

     如count，collect，Action操作会返回结果或把RDD数据输出到各类系统中。Action触发spark启动并找到最优的计算途径。返回值是非并行化的数据集合如python中的list

 

编写处理RDD的代码有两类

        1.     Driver 只有一个（普通的python代码）

        2.     Worker（两类算子）

              a)       变换（transformation）懒执行

              b)       行为（Action）立即执行

 

属于变换：map flatMap groupByKey reduceByKey…

属于行为：count take collect countByValue reduce….

RDD的所有操作方法

RDD元素变换                                      RDD元素操作

   map(func)                                               count()

   flatMap(func)                                          reduce()

   filter(func)                                               countByValue()

      连接变换                                               aggregate((0,0),seqOp,combOp)

         union()

         intersection()

         subtract()                  

         cartesian()

 

RDD元素取值操作                                   RDD Key-Value变换

   take(n)                                                         zip(seq1,seq2)

   top(num)                                                      reduceByKey(func)

   first()                                                            groupByKey()

   collect()                                                        mapValue(func)

   foreach(func)                                                sortByKey()

   taleSample()                                                 combineByKey(4个参数)

                                                                          连接变换

RDD Key-Value 操作                                                 join() 内连接

   countByKey()                                                          rightOuterjoin()右链接

   collectAsMap()                                                        leftOuterjoin()左连接

   lookup(key)                                                             cogroup()全连接

   countByKey()                                                           subtractByKey()减连接

详细解释RDD所有操作

RDD元素变换

         map(func)参数是函数,函数应用于RDD每一个元素，返回值是新的RDD

                       

 

          flatMap(func) 参数是函数，函数应用于RDD每一个元素，将元素数据进行拆分，变成迭代器，返回值是新的RDD

                 

                                连接变换

                                  union()        两个RDD的并集（联合）

                                  intersection()  交集

                                 subtract()      差集

                                 cartesian()     笛卡尔

                          

RDD元素操作

       count() 返回RDD里元素数目

                

      reduce(func)并行汇总所有RDD元素

           lambda中接收两个参数

                

   reduce()参数是一个函数，这个函数有两个参数（首先会分区（默认分区数量与虚拟机的核心数有关，我的是2），然后每个分区得出结果最后汇总），两个参数分别是每次分区后两个分区的结果

执行过程：

        分区：[(1,2),(3,4,5)]

        第一次结果：[3,12]

        最后结果：15

 如果是减法的话那分区的分量就显得更明显了，分区的个数不同，那么每次的值都会不一样,后面可以parallelize([1,2,3,4,5]，3)这样写说明分成了三个分区，这里有个问题，如果我们只有2个分区，但我们给了三个，计算的时候只会先计算前面2个，算好后再来和第三个一起算。

         countByValue() 各RDD元素在RDD中出现次数

                      

        aggregate((0,0),seqOp,combOp) 将前面的数一直累加

                           

         简单理解（spark操作都是分布式计算，所以都会分区，这里不考虑分区去理解）：

             首先理解第一个lambda

              x 程序开始时指代前面的(0,0)初始值，之后是每一次执行后的结果

              y 指代RDD里的每一个元素

              看看执行过程：

                       第一次：0（zoroValue元组的第一个值）+ 1（RDD的第一个元素的值）

                                    0（zoroValue元组的第二个值）+ 1 （固定值，目前我们可以用来表示执行次数）

                                    结果：(1,1) --这个时候 x 的值将是这个

                       第二次：1 + 2（RDD的第二个元素的值）,1+ 1

                                    结果：(3,2)

                       第三次：3+ 3（RDD的第三个元素的值）,2+ 1

                                    结果：(6,3)

                       第四次：6 + 4（RDD的第四个元素的值）,3+1

                                    结果：(10,4)

                       第二个lambda是spark的分区汇总操作

                                  x 指代第一个分区的结果

                                  y 指代第二个分区的结果

      简单描述一下分区：第一个lambda的执行过程并不是上面那样一个区执行的，而是分成两个区去分别执行上述操作，然后通过第二个lambda汇总

RDD元素取值操作

          take(n) 从RDD返回n个元素

          top(num)先从大到小排序，然后从RDD中返回前面的num个数的元素

          first() 从RDD中返回第一个元素

          collect() 从RDD中返回所有的元素（慎用，练习可以用，工作中千万不能用，因为会收集所有的信息，数据量大的会卡死电脑）

                            

           foreach(func)

           taskSample(cithReplacement,num,[seed])

RDD KEY-VALUE变换

        zip(seq1,seq2) 建立KEY-VALUE RDD，在RDD每个配对元素中，第一个被认定为键，第二个认定为值

                   

         reduceByKey(func) 在每一键组内进行汇总变换

                     

         groupByKey() 将值放到每一相同键组内,值是一个迭代器

                     

         mapValues(func) 将每一对RDD键值进行函数func值变换而不改变键

                   

 

         sortByKey() 得到以键排序的RDD

                    

          combineByKey(createCombiner,mergeValue,mergeCombiners,partitioner)

                          

             flatMapValues(func) 用函数产生迭代器并用于RDD每一个键值组对中并产生新的键值对

                 

                               连接变换

                                       join           内连接

                                      rightOuterJoin 右连接 

                                      leftOuterJoin  左连接

                                      cogroup        全连接

                                      subtractByKey  减连接

RDD KEY-VALUE操作

         countByKey() 返回每一键组内的记录数，是个字典

                     

        collectAsMap() 返回一MAP形式的串行化结果

                    

          lookup(key) 返回某键值下的所有值