Spark core详解系列一

学习spark重在详读官网！

spark官网地址：http://spark.apache.org

spark特点：

1. Speed
   1）基于内存计算。
   2）支持pipeline，不会像mr每次都要数据落地。
   3）spark作业以线程形式，而mr的map和reduce任务都是进程级别的。
2. Ease of use
   支持多种语言开发Java、Scala、Python、R和SQL，但是主流是scala。
3. generality （统一的、一站式)
   SQL、Streaming、MLlib、GraphX。
4. Runs Everywhere
   如：hadoop、mesos、kubernetes、standalone、cloud

部署环境：

1. spark版本尽量选择最新稳定版本，但是生产环境一般不做版本升级，可以打补丁。
   x.y.z
   x: 大版本 1、2
   y: 小版本 2.4.3
   z： 针对小版本的bug进行了修复
2. 下载spark的最新的 Source Code 后，自己编译。（生产环境或多或少会对原生spark变动许多，必须学会自己编译。）
   
   编译步骤参考官网：http://spark.apache.org/docs/latest/building-spark.html
   编译之前，注意maven版本和java版本，由于需要指定hadoop版本是2.6.0-cdh5.15.1，所以，需要在源码包的pom.xml文件中加入cdh的下载地址，aliyun无法下载cdh。
   注意：原生的maven仓库地址必须写在顶部。（pom.xml注解中有注释。）
   
   编译命令：

./dev/make-distribution.sh --name 2.6.0-cdh5.15.1 --pip --r --tgz -Psparkr -Phadoop-2.6 -Dhadoop.version=2.6.0-cdh5.15.1  -Phive -Phive-thriftserver -Pyarn –Pkubernetes

3. 构建项目的pom依赖
   
   注意：hadoop版本可以是cdh的，也可以是apache的，因为项目打包时，这些都不会打进去。若需要额外的jar，可通过 - -jars 手动加入。

初识RDD

地址：http://spark.apache.org/docs/latest/rdd-programming-guide.html

1. rdd特性
   源码描述：

* A Resilient Distributed Dataset (RDD), the basic abstraction in Spark. Represents an immutable, 
* partitioned collection of elements that can be operated on in parallel. This class contains the basic operations available on all RDDs, 
* such as `map`, `filter`, and `persist`. In addition,
[[org.apache.spark.rdd.PairRDDFunctions]] contains operations available only on RDDs of key-value pairs, such as `groupByKey` and `join`;
[[org.apache.spark.rdd.DoubleRDDFunctions]] contains operations available only on RDDs of Doubles; and
[[org.apache.spark.rdd.SequenceFileRDDFunctions]] contains operations available on RDDs that can be saved as SequenceFiles.
All operations are automatically available on any RDD of the right type (e.g. RDD[(Int, Int)]) through implicit.
Internally, each RDD is characterized by five main properties:
*  - A list of partitions
*  - A function for computing each split
*  - A list of dependencies on other RDDs
*  - Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
*  - Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)
1）the basic abstraction in Spark 
2）Represents an immutable
3）partitioned collection of elements that can be operated on in parallel.
4）PairRDDFunctions：<k,v>类型的rdd，如：groupByKey、join。

五大特性：
1）一个RDD包含一系列的partition
2）针对RDD做操作其实就是针对RDD底层的partition进行操作
3）rdd之间的依赖
4）partitioner
5）locations

2. RDD创建方式
   1）parallelize 适用于测试
   2）External Datasets 生产
   3）通过已有RDD转换过来的 生产

3. RDD算子类型
   transformation（lazy）：它不会立即执行。
   action（eager）：只有遇到action才会提交作业开始执行。

RDD的Transformations算子

1. map：处理每一条数据
   如：rdd.map(_*2)

2. mapPartitions：对每个分区进行处理
   如：rdd.mapPartitions(partition => partition.map(_*2))

3. mapPartitionsWithIndex：RDD[K,V]型的rdd，k为每个分区的索引号，从0 开始。
   如：rdd.mapPartitionsWithIndex((index, partition) =>{
   partition.map(x => s"分区编号是$index,元素是$x")
   })

4. mapValues：是针对RDD[K,V]的V做处理。
   如：sc.parallelize(List((“ruoze”,30),(“J哥”,18))).mapValues(_ + 1)

5. flatmap：map + flatten
   如：sc.parallelize(List(List(1,2),List(3,4))).flatMap(x=>x.map(_*2))

6. glom：返回每个分区的详细信息。
   如：sc.parallelize(1 to 30).glom()

7. sample：返回抽样数据。
   如：sc.parallelize(1 to 30).sample(true, 0.4, 2) //true表示放回抽样。

8. filter： 留下满足条件的结果。
   如：sc.parallelize(1 to 30).filter(_ > 20)

9. union：合并两个rdd，不去重。
   如：rdd1.union(rdd2)

10. intersection：两个rdd的交集
    如：rdd1. intersection (rdd2)

11. subtract：两个rdd的差集
    如：rdd1. subtract (rdd2) // 出现在rdd1没有出现在rdd2。

12. distinct：去重
    如：rdd.distinct(4).mapPartitionsWithIndex((index,partition)=>{
    partition.map(x => s"分区是$index,元素是$x")
    }) //可以重新指定分区数，元素%partitions
    分区是0,元素是4, 4%4=0
    分区是0,元素是8, 8%4=0
    分区是1,元素是5, 5%4=1
    分区是2,元素是6, 6%4=2
    分区是3,元素是3, 3%4=3
    分区是3,元素是7,7%4=3
    思考：如何不用distinct实现去重？
    val b = sc.parallelize(List(3,4,5,6,7,8,8))
    b.map(x => (x,null)).reduceByKey((x,y) => x).map(_._1)
    //distinct底层就是这样做的！即distinct底层调用的是reduceByKey。

13. groupKeyKey：作用于RDD[K,V]
    如：sc.parallelize(List((“a”,1),(“b”,2),(“c”,3),(“a”,99))).groupByKey().mapvalues(x=>x.sum)

14. reduceByKey：作用于RDD[K,V]，根据相同key，对value做操作
    如：sc.parallelize(List((“a”,1),(“b”,2),(“c”,3),(“a”,99))).reduceByKey(+)

15. groupBy：自定义分组，分组条件就是自定义传进去的
    如：sc.parallelize(List(“a”,“a”,“a”,“b”,“b”,“c”)).groupBy(x=>x).mapValues(x=>x.size)

16. sortBy：自定义排序，底层调用的也是sortByKey。
    如：sc.parallelize(List((“张三”,30),(“李四”,18),(“星星”,60))).sortBy(_.2,false) //按第二个字段降序排。sortBy(.2,false)等价于sortBy(-._2)

17. sortByKey：按key排序
    如：sc.parallelize(List((“张三”,30),(“李四”,18),(“星星”,60))).map(x=>(x._2,x._1)).sortByKey ().map(x=>(x._2,x._1))

18. join：作用于RDD[K,V]，默认内连接, 底层就是使用了cogroup
    如：val a = sc.parallelize(List((“张三”,“北京”),(“李四”,“上海”),(“老师”,“杭州”)))
    val c = sc.parallelize(List((“张三”,“30”),(“李四”,“18”),(“星星”,“60”)))
    val value: RDD[(String, (String, String))] =a.join©
    val value1: RDD[(String, (String, Option[String]))] = a.leftOuterJoin©
    val value2: RDD[(String, (Option[String], String))] = a.rightOuterJoin©
    val value3: RDD[(String, (Option[String], Option[String]))] = a.fullOuterJoin©
    val value4: RDD[(String, (Iterable[String], Iterable[String]))] = a.cogroup©

注意：比较join和cogroup区别，join底层就是使用了cogroup。

• fullOuterJoin返回值类型 RDD[(K, (Option[V], Option[W]))]
• cogroup返回值类型 RDD[(K, (Iterable[V], Iterable[W]))]

附：官网贴图