Spark（三）RDD编程

最新推荐文章于 2024-04-02 18:28:19 发布

小雨光

最新推荐文章于 2024-04-02 18:28:19 发布

阅读量722

点赞数 1

分类专栏：大数据文章标签： spark

本文链接：https://blog.csdn.net/weixin_44079636/article/details/119519735

版权

大数据专栏收录该内容

41 篇文章 8 订阅

订阅专栏

一、简介

RDD被表示为对象，通过对象上的方法调用来对RDD进行转换。经过一系列的transformations定义RDD之后，就可以调用actions触发RDD的计算，action可以是向应用程序返回结果(count, collect等)，或者是向存储系统保存数据(saveAsTextFile等)。在Spark中，只有遇到action，才会执行RDD的计算(即延迟计算)，这样在运行时可以通过管道的方式传输多个转换。

二、RDD的创建方式

使用parallelize()从集合创建

 val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))

使用makeRDD()从集合创建,底层是使用parallelize()创建

val rdd1 = sc.makeRDD(Array(1,2,3,4,5,6,7,8))

由外部存储系统的数据集创建【从数据库读取数据创建RDD】

 val rdd1 = sc.makeRDD(Array(1,2,3,4,5,6,7,8))

三、RDD的转换(Transformations)算子

RDD整体上分为Value类型和Key-Value类型

Value类型

1。map(func)

作用：返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
例：

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 10)
//2.将所有元素*2
val rdd2: RDD[Int] = rdd1.map(_*2)
//3.在驱动程序中，以数组的形式返回数据集的所有元素
val arr: Array[Int] = rdd2.collect()
//4.输出数组中的元素
arr.foreach(println)

2。mapPartitions(func)

作用：类似于map，但独立地在RDD的每一个分区上运行
假设有N个元素，有M个分区，那么map的函数的将被调用N次,而mapPartitions被调用M次,一个函数一次处理所有分区。

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 10)
//2.将所有元素*2
val rdd2: RDD[Int] = rdd1.mapPartitions(iter => {
   iter.map(_ * 2)
})
//3.打印结果
rdd2.collect().foreach(println)

map和mapPartition的区别
map()：每次处理一条数据。
mapPartition()：每次处理一个分区的数据

3。mapPartitionsWithIndex(func)

作用：类似于mapPartitions，但func带有一个整数参数表示分区的索引值

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 10)
//2.使每个元素跟所在分区形成一个元组组成一个新的RDD
val rdd2: RDD[(Int, Int)] = rdd1.mapPartitionsWithIndex((index, iter) => {
	iter.map((index, _))
})
//3.打印新的RDD
rdd2.collect().foreach(println)

4。flatMap(func)案例

作用：类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 5)
//2.根据原RDD创建新RDD
val rdd2 = rdd1.flatMap(v => 1 to v)
//3.打印新的RDD
rdd2.collect().foreach(v=>{
    print(v + " ")
})

5。glom

将每一个分区形成一个数组，形成新的RDD类型是RDD[Array[T]]

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 16,4)
//2.根据原RDD创建新RDD
val rdd2: RDD[Array[Int]] = rdd1.glom()
//3.打印
rdd2.collect().foreach(v=>{
    println(v.mkString(","))
})

6。groupBy(func)

分组，按照传入函数的返回值进行分组。将相同的key对应的值放入一个迭代器。

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 10)
//2.根据原RDD创建新RDD
val rdd2: RDD[(Int, Iterable[Int])] = rdd1.groupBy(v=>v%2)
//3.打印
rdd2.collect().foreach(println)

7。filter(func)过滤

返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成。

//1.创建一个RDD
val rdd1: RDD[String] = sc.makeRDD(List("xiaoming","zhangsan","xiaohong","lisi","wangxiao"))
//2.根据原RDD创建新RDD
val rdd2: RDD[String] = rdd1.filter(v=>v.contains("xiao"))
//3.打印
rdd2.collect().foreach(println)

8。distinct去重

作用：对源RDD进行去重后返回一个新的RDD

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(List(1,2,3,3,5,6,7,1,2,3))
//2.根据原有RDD去重，产生新的RDD
val rdd2: RDD[Int] = rdd1.distinct()
//3.打印
rdd2.collect().foreach(println)

9.coalesce(numPartitions)没有Shuffer,只能减少分区

作用：缩减分区数，用于大数据集过滤后，提高小数据集的执行效率。

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 10,4)
//2.对RDD重新分区
val rdd2: RDD[Int] = rdd1.coalesce(2)
//3.打印
println("分区数："+rdd2.getNumPartitions)

rdd2.collect()

10. repartition(numPartitions)，有shuffer，可以增加也可以减少分区

作用：根据分区数，重新通过网络随机洗牌(shuffle)所有数据。

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 10,4)
//2.重新分区
 val rdd2: RDD[Int] = rdd1.repartition(6)
 //3.打印
println("分区数："+rdd2.getNumPartitions)
rdd2.collect()

11. coalesce和repartition的区别

coalesce重新分区，可以选择是否进行shuffle过程。由参数shuffle: Boolean = false/true决定。
repartition实际上是调用的coalesce，默认是进行shuffle的。
减少分区允许不进行shuffle过程，但是增大分区需要。
所以coalesce可以在不进行shuffle的情况下减少分区，增大分区需要指定第二个参数为true
减少分区的应用场景：例如通过filter之后，有些分区数据量比较少，通过减少分区，防止数据倾斜
增大分区的应用场景：分区内数据量太大，通过增加分区提高并行度

11. sortBy(func,[ascending],[numTasks])

作用：使用func先对数据进行处理，按照处理后的数据比较结果排序，默认为正序。

//1.创建一个RDDval rdd1: RDD[Int] = sc.makeRDD(List(1,12,4,5,2))
//按照自身大小排序val rdd2: RDD[Int] = rdd1.sortBy(v=>v)rdd2.collect().foreach(println)
//按照与3余数的大小排序val rdd3: RDD[Int] = rdd1.sortBy(v=>v%3)rdd3.collect().foreach(println)

12. union(otherDataset)并集

作用：对源RDD和参数RDD求并集后返回一个新的RDD

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 5)
val rdd2: RDD[Int] = sc.makeRDD(4 to 8)
//2.计算两个RDD的并集
val rdd3: RDD[Int] = rdd1.union(rdd2)
//3.打印
rdd3.collect().foreach(println)

13. subtract (otherDataset) 差集

作用：计算差的一种函数，从第一个RDD减去第二个RDD的交集部分

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 5)
val rdd2: RDD[Int] = sc.makeRDD(4 to 8)
//2.计算两个RDD的差集
val rdd3: RDD[Int] = rdd1.subtract(rdd2)
//3.打印
rdd3.collect().foreach(println)
//结果：1 2 3

14. intersection(otherDataset)交集

作用：对源RDD和参数RDD求交集后返回一个新的RDD

//1.创建一个RDD
val rdd1: RDD[Int] = sc.makeRDD(1 to 5)
val rdd2: RDD[Int] = sc.makeRDD(4 to 8)
//2.计算两个RDD的交集
val rdd3: RDD[Int] = rdd1.intersection(rdd2)
//3.打印
rdd3.collect().foreach(println)
//结果：4 5

Key-Value类型

1. groupByKey

作用：groupByKey也是对每个key进行操作，但只生成一个sequence。

//1.创建一个RDD
val rdd1: RDD[String] = sc.makeRDD(List("one", "two", "two", "three", "three", "three"))
//2.相同key对应值的相加结果
val rdd2: RDD[(String, Int)] = rdd1.map((_,1)).groupByKey().map(v=>(v._1,v._2.size))
//3.打印
rdd2.collect().foreach(println)
结果(three,3)  (two,2)  (one,1)

2. reduceByKey(func, [numTasks])

在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，reduce任务的个数可以通过第二个可选的参数来设置。

//1.创建一个RDD
val rdd1: RDD[(String,Int)] = sc.makeRDD(List(("female",1),("male",5),("female",5),("male",2)))
//2.相同key对应值的相加结果
val rdd2: RDD[(String, Int)] = rdd1.reduceByKey(_+_)
//3.打印
rdd2.collect().foreach(println)

结果：(male,7)  (female,6)

3.reduceByKey和groupByKey的区别

reduceByKey：按照key进行聚合，在shuffle之前有combine（预聚合）操作，返回结果是RDD[k,v]
groupByKey：按照key进行分组，直接进行shuffle。
开发指导：reduceByKey比groupByKey，建议使用。但是需要注意是否会影响业务逻辑。

4.aggregateByKey

参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)

作用：在kv对的RDD中，，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。

参数描述：

（1）zeroValue：给每一个分区中的每一个key一个初始值；

（2）seqOp：函数用于在每一个分区中用初始值逐步迭代value；

（3）combOp：函数用于合并每个分区中的结果。

//1.创建一个RDD
val rdd1: RDD[(String,Int)] = sc.makeRDD(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
//2.取出每个分区相同key对应值的最大值
val rdd2: RDD[(String, Int)] = rdd1.aggregateByKey(0)((v1,v2)=> if(v1 > v2) v1 else v2 ,_+_)
//3.打印
rdd2.collect().foreach(println)
    
结果：(b,3)  (a,3)  (c,12)

5.sortByKey([ascending],[numTasks])

作用：在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD

//1.创建一个RDD
val rdd1: RDD[(Int,String)] = sc.makeRDD(List((3,"aa"),(6,"cc"),(2,"bb"),(1,"dd")))
//2.按照key的正序
rdd1.sortByKey(true).collect().foreach(print)   //(1,dd)(2,bb)(3,aa)(6,cc)
//3.按照key的降序
rdd1.sortByKey(false).collect().foreach(print)  //(6,cc)(3,aa)(2,bb)(1,dd)

5.mapValues

针对于(K,V)形式的类型只对V进行操作

//1.创建一个RDD
val rdd1: RDD[(Int,String)] = sc.makeRDD(List((1,"a"),(1,"d"),(2,"b"),(3,"c")))

//val rdd1: RDD[(Int,String)] = sc.makeRDD(List((1,"a"),(1,"d"),(2,"b"),(3,"c")))
//rdd1.map( v => (v._1,v._2 + "_x")  )   key不变，只对value操作.  和下边的用法相同
//2.给value增加一个_x
val rdd2: RDD[(Int, String)] = rdd1.mapValues(v=>v+"_x")
//3.打印
rdd2.collect().foreach(print)

结果 (1,a_x)(1,d_x)(2,b_x)(3,c_x)

6.join(otherDataset,[numTasks])

作用：在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD

//1.创建一个RDD
val rdd1: RDD[(Int,String)] = sc.makeRDD(List((1,"a"),(2,"b"),(3,"c")))
val rdd2: RDD[(Int,Int)] = sc.makeRDD(List((1,4),(2,5),(3,6)))
//2.join操作
val rdd3: RDD[(Int, (String, Int))] = rdd1.join(rdd2)
//3.打印
rdd3.collect().foreach(println)

结果：(1,(a,4))
	(2,(b,5))
	(3,(c,6))

四、RDD的行动(Action)算子

1.reduce(func)

作用：通过func函数聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据。

val rdd1 = sc.makeRDD(1 to 10)
println(rdd1.reduce(_ + _))     //输出 55

val rdd2 = sc.makeRDD(Array(("a",1),("a",3),("c",3),("d",5)))
println(rdd2.reduce((v1, v2) => (v1._1 + v2._1, v1._2 + v2._2)))  //输出 (aacd,12)

2.collect()

作用：在驱动_个RDD，并将RDD内容收集到Driver端打印

3.count()

作用：返回RDD中元素的个数

val rdd1 = sc.makeRDD(1 to 10)
println(rdd1.count())			//输出 10

4.first()

作用：返回RDD中的第一个元素

val rdd1 = sc.makeRDD(1 to 10)
println(rdd1.first())

5.take(n)

作用：返回一个由RDD的前n个元素组成的数组

val rdd1 = sc.makeRDD(1 to 10)
println(rdd1.take(5).mkString(","))   	 //输出：1,2,3,4,5

6.takeOrdered(n)

作用：返回该RDD排序后的前n个元素组成的数组

val rdd = sc.parallelize(Array(2,5,4,6,8,3))
println(rdd.takeOrdered(3).mkString(","))	 //输出：2,3,4

7.aggregate

参数：(zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)
作用：aggregate函数将每个分区里面的元素通过seqOp和初始值进行聚合，然后用combine函数将每个分区的结果和初始值(zeroValue)进行combine操作。这个函数最终返回的类型不需要和RDD中元素类型一致。

8.fold(num)(func)

作用：折叠操作，aggregate的简化操作，seqop和combop一样。

9.saveAsTextFile(path)

作用：将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本

10.saveAsSequenceFile(path)

作用：将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。

11.saveAsObjectFile(path)

作用：用于将RDD中的元素序列化成对象，存储到文件中。

12.countByKey()

作用：针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。

val rdd = sc.parallelize(List((1,3),(1,2),(1,4),(2,3),(3,6),(3,8)))
val map: collection.Map[Int, Long] = rdd.countByKey()
println(map)

输出：Map(1 -> 3, 2 -> 1, 3 -> 2)

13.foreach(func)

作用：在数据集的每一个元素上，运行函数func进行更新。

五、Spark对外部数据库的写入

MySQL数据库

添加依赖

<dependency>
    <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
</dependency>

将spark计算的数据写入mysql

val data = sc.parallelize(List("zhangsan", "lisi","wangwu"),2)
data.foreachPartition(iter=>{
   val conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1","root", 	"123456")
        iter.foreach(data=>{
          val ps = conn.prepareStatement("insert into spark_user(name) values (?)")
          ps.setString(1, data)
          ps.executeUpdate()
        })
        conn.close()   
})

六、广播变量

在spark程序中，当一个传递给Spark操作(例如map和reduce)的函数在远程节点上面运行时，Spark操作实际上操作的是这个函数所用变量的一个独立副本。这些变量会被复制到每台机器上，并且这些变量在远程机器上的所有更新都不会传递回驱动程序。通常跨任务的读写变量是低效的，但是，Spark还是为两种常见的使用模式提供了两种有限的共享变量：广播变量（broadcast variable）和累加器（accumulator）

广播变量的意义

如果我们要在分布式计算里面分发大对象，例如：字典，集合，黑白名单等，这个都会由Driver端进行分发，一般来讲，如果这个变量不是广播变量，那么每个task就会分发一份，这在task数目十分多的情况下Driver的带宽会成为系统的瓶颈，而且会大量消耗task服务器上的资源，如果将这个变量声明为广播变量，那么只是每个executor拥有一份，这个executor启动的task会共享这个变量，节省了通信的成本和服务器的资源。

广播变量图解

在这里插入图片描述

定义一个广播变量

val a = 3
val broadcast = sc.broadcast(a)

还原一个广播变量

val c = broadcast.value

广播变量使用

val conf = new SparkConf()
conf.setMaster("local").setAppName("brocast")
val sc = new SparkContext(conf)
val list = List("hello hadoop")
val broadCast = sc.broadcast(list)
val lineRDD = sc.textFile("./words.txt")
lineRDD.filter { x => broadCast.value.contains(x) }.foreach { println}
sc.stop()

注意事项

变量一旦被定义为一个广播变量，那么这个变量只能读，不能修改
1、能不能将一个RDD使用广播变量广播出去？

   不能，因为RDD是不存储数据的。可以将RDD的结果广播出去。

2、广播变量只能在Driver端定义，不能在Executor端定义。

3、在Driver端可以修改广播变量的值，在Executor端无法修改广播变量的值。

4、如果executor端用到了Driver的变量，如果不使用广播变量在Executor有多少task就有多少Driver端的变量副本。

5、如果Executor端用到了Driver的变量，如果使用广播变量在每个Executor中只有一份Driver端的变量副本。

七、累加器

累加器的意义

在spark应用程序中，我们经常会有这样的需求，如异常监控，调试，记录符合某特性的数据的数目，这种需求都需要用到计数器，如果一个变量不被声明为一个累加器，那么它将在被改变时不会再driver端进行全局汇总，即在分布式运行时每个task运行的只是原始变量的一个副本，并不能改变原始变量的值，但是当这个变量被声明为累加器后，该变量就会有分布式计数的功能。

图解累加器

在这里插入图片描述

使用：

val a = sc.accumulator(0)
val b = a.value
val conf = new SparkConf()
conf.setMaster("local").setAppName("accumulator")
val sc = new SparkContext(conf)
val accumulator = sc.accumulator(0)
sc.textFile("./words.txt").foreach { x =>{accumulator.add(1)}}
println(accumulator.value)
sc.stop()