Spark API 总结

最新推荐文章于 2022-09-24 23:03:01 发布
最新推荐文章于 2022-09-24 23:03:01 发布
阅读量735 收藏 4
点赞数
分类专栏： 个人日记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cincinnati_De/article/details/109073451
版权

RDD 核心术语

名称含义
ApplicationSpark的应用程序，包含一个Driver program和若干个Executor
Driver Program运行Application的main()函数并创建SparkContext
SaprkContextSpark应用程序的入口，负责调度work的原酸资源，协调WorkerNode上的Executor
Executor是Application运行在Work Node 上的一个进程，该进程负责运行Task，并且负责将数据存在内存或者磁盘上，每个Application都会申请各自的Executor处理任务
Cluster Manger在集群上获取资源的外部服务(eg: Standalone、Mesos，Yarn)
Work Node在集群中任何可以运行Application代码的节点，运行一个或者多个Executor进程
Task运行在Executor上的工作单元
JobSparkContext提交具体的Action一系列操作
Stage每个Job会被拆分为很多组任务(Task)，每组任务被称为Stage，也成为 TaskSet
RDDSpark核心模块和类
DAG Scheduler根据Job构建基于Stage的DAG，并提交Stage给TaskScheduler
Task Scherduler将Taskset提交给Worker node，集群运行并返回结果
Transformations/ActionsSpark API的两种类型之一，Transformations返回值还是一个RDD，Actions返回值不是一个RDD，而是一个Scala集合，所有的Transformations都是采用的Lazy策略，如果只是将Transformation提交时不会执行计算的，计算只会在Action提交时才会被触发。

RDD 分区

RDD 对象实质上是一个元数据结构，存储着Block、Node等映射关系，以及其他元数据信息。一个RDD就是一组分区(Partition)，RDD的每个分区Partition对应一个Block，Block可以存储在内存，当内存不够时可以存储到磁盘上。
RDD 的数据源也可以存储在HDFS上，数据按照HDFS分部策略进行分区，HDFS中的一个Block对应SparkRDD的一个Partition。

RDD 依赖

分为 “宽依赖” (Narrow) 和 “窄依赖” (Wide)
在这里插入图片描述

RDD 核心概念

在这里插入图片描述

RDD 中可看到Task和Partition一对一对应

计算向数据移动的体现
在这里插入图片描述

STAGE DAG

在这里插入图片描述

SPARK 调度

在这里插入图片描述

SPARK API

Transformations: SparkAPI的两种类型之一，Transformations返回值还是一个RDD
Actions: Actions返回值不是一个RDD，而是一个Scala集合
所有Transformations都是采用Lazy策略，如果只是将Transformation提交是不会执行计算的，计算只会在Action提交时才会被触发

Transformations 算子

算子名称 map(func)
功能：将RDD 中的数据映射成另一个RDD中的元素。输入三行、输出三行。

算子名称 filter(func)
功能：对RDD中的数据进行过滤。

// An highlighted block
package ypl.com

import org.apache.log4j.{Level, Logger}
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}


object MapFilter {

  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.ERROR)
    val sparkconf: SparkConf = new SparkConf().setAppName("spark api").setMaster("local")
    val sparkcontext: SparkContext = new SparkContext(sparkconf)

    val data: Array[Int] = Array(1, 2, 3, 4, 5)
    val inputRdd: RDD[Int] = sparkcontext.parallelize(data)
    
    inputRdd.map(x=>{
      x*2
    }).filter(_>5)
      .foreach(println(_))
    
    // inputRdd.collect().foreach(println(_))
    
  }
}
#######################结果:#######################
6
8
10
####################################################

算子名称 flatMap(func)
功能：对RDD中的数据进行映射后，并将数据进行打散。输入三行，三列。输出九行。

// An highlighted block
inputRdd2.flatMap(
 x=>{
   x.map(y=>{
     y*2
   })
 }
).foreach(println(_))
#################### 结果 ###################
2
4
6
8
  • FlatMap 与 map 之间的区别
    在这里插入图片描述

算子名称 mapPartitions(func)
功能：和 map 算子相似。应用场景像是建立数据库连接，面向partition。或者对所在分区集合进行操作。

 val data: Array[Int] = Array(1, 2, 3, 4, 5)
 val inputRdd: RDD[Int] = sparkContext.parallelize(data)

 inputRdd.mapPartitions(x=>{
   //database connection
   x.map(
     // database Insert
     y=>{
       y * 2
     }
   )
 }).foreach(println(_))
}

算子名称 mapPartitionsWithIndex(func)
功能：和 mapPartitions 并返回数据所在的索引位置。

inputRdd.mapPartitionsWithIndex((idx,iter)=>{
  iter.map(x=>{
    (idx,x)
  })
}).foreach(println(_))

算子名称 sample(withReplacement，fraction，seed)
功能：对RDD进行随机抽样。 第一个参数 true 表示是否拿重复的。

val data: Array[Int] = Array(1, 2, 3, 4, 5,200,600,100,300,700,22,66,33)
val inputRdd: RDD[Int] = sparkContext.parallelize(data,4)
inputRdd.sample(true,0.5).foreach(println(_))


2
3
4
200
100
66

算子名称 union(otherDataset)
功能：对RDD进行拼接。

val data: Array[Int] = Array(1, 2, 3, 4, 5)
val inputRdd: RDD[Int] = sparkcontext.parallelize(data)
val rdd1 = inputRdd.map((_,1))
val rdd2= inputRdd.map(_*2).map((_,1))
// union
val rdd_union = rdd1.union(rdd2)
rdd_union.foreach(println(_))
#################### 结果 ###################
(1,1)
(2,1)
(3,1)
(4,1)
(5,1)
(2,1)
(4,1)
(6,1)
(8,1)
(10,1)

算子名称 intersection(otherDataset)
功能：获取两个RDD 的交集

rdd1.intersection(rdd2).foreach(println(_))
######### intersection #############
(4,1)
(2,1)

算子名称 distinct(numTasks)
功能：返回一个对源 dataset 进行去重的 新dataset

// An highlighted block
var foo = 'bar';

算子名称 groupBy(传入key)
功能：对key进行聚合，value是 k,v

val data = Array(Tuple2(1,2),Tuple2(1,3),Tuple2(1,4),Tuple2(2,2),Tuple2(2,1),Tuple2(3,2),Tuple2(3,5))
val inputRdd  = sparkContext.parallelize(data)
inputRdd.groupBy(_._1).foreach(println(_))
############# 按照key分组，value 是 kv ############# 
(1,CompactBuffer((1,2), (1,3), (1,4)))
(3,CompactBuffer((3,2), (3,5)))
(2,CompactBuffer((2,2), (2,1)))

算子名称 groupByKey([numTasks])
功能：按照key进行分组，有大量的shuffle操作。

val data = Array(Tuple2(1,2),Tuple2(1,3),Tuple2(1,4),Tuple2(2,2),Tuple2(2,1),Tuple2(3,2),Tuple2(3,5))
val inputRdd  = sparkContext.parallelize(data)
inputRdd.groupByKey().foreach(println(_))
############# 按照key分组，value 是 v ############# 
(1,CompactBuffer(2, 3, 4))
(3,CompactBuffer(2, 5))
(2,CompactBuffer(2, 1))

inputRdd.groupByKey().map(x=>{
  val key = x._1
  var sum = 0
  x._2.map(y =>{
    sum+= y
  })
  (key,sum)
}).foreach(println(_))

算子名称 reduceByKey(func,[numTasks])
功能：将value 进行聚合或者相加，相比 groupbykey，会提前进行combiner操作。

// An highlighted block
val data = Array(Tuple2(1,2),Tuple2(1,3),Tuple2(1,4),Tuple2(2,2),Tuple2(2,1),Tuple2(3,2),Tuple2(3,5))
val inputRdd  = sparkContext.parallelize(data)
inputRdd.reduceByKey(_+_).foreach(println(_))
(1,9)
(3,7)
(2,3)

二者不一样是按照Map reduce的理解来看，reducebykey有提前 combiner的操作。

在这里插入图片描述

算子名称 aggregareByKey([numTasks])
功能：返回一个对源 dataset 进行去重的 新dataset

// An highlighted block
var foo = 'bar';

算子名称 sortByKey([numTasks])
功能：返回一个对源 dataset 进行去重的 新dataset

// An highlighted block
var foo = 'bar';

算子名称 join([numTasks])
功能：返回一个 rdd 按照 map的key 聚合，value进行追加

val data: Array[Int] = Array(1, 2, 3, 4, 5)
val inputRdd: RDD[Int] = sparkcontext.parallelize(data)
val rdd1 = inputRdd.map((_,1))
val rdd2= inputRdd.map(_*2).map((_,1))
########## rdd1 ############
(1,1)
(2,1)
(3,1)
(4,1)
(5,1)
######### rdd2 #############
(2,1)
(4,1)
(6,1)
(8,1)
(10,1)
######### join #############
(4,(1,1))
(2,(1,1))

Process finished with exit code 0

算子名称 cogroup([numTasks])
功能 类似 full join

val data: Array[Int] = Array(1, 2, 3, 4, 5)
val inputRdd: RDD[Int] = sparkcontext.parallelize(data)
val rdd1 = inputRdd.map((_,1))
val rdd2= inputRdd.map(_*2).map((_,1))
rdd1.cogroup(rdd2).foreach(println(_))

######### cogroup #############
(4,(CompactBuffer(1),CompactBuffer(1)))
(1,(CompactBuffer(1),CompactBuffer()))
(6,(CompactBuffer(),CompactBuffer(1)))
(3,(CompactBuffer(1),CompactBuffer()))
(8,(CompactBuffer(),CompactBuffer(1)))
(10,(CompactBuffer(),CompactBuffer(1)))
(5,(CompactBuffer(1),CompactBuffer()))
(2,(CompactBuffer(1),CompactBuffer(1)))

Process finished with exit code 0

算子名称 cartesian([otherDataset])
功能：返回一个笛卡尔积

rdd1.cartesian(rdd2).foreach(println(_))
((1,1),(2,1))
((1,1),(4,1))
((1,1),(6,1))
((1,1),(8,1))
((1,1),(10,1))
((2,1),(2,1))
((2,1),(4,1))
((2,1),(6,1))
((2,1),(8,1))
((2,1),(10,1))
((3,1),(2,1))
((3,1),(4,1))
((3,1),(6,1))
((3,1),(8,1))
((3,1),(10,1))
((4,1),(2,1))
((4,1),(4,1))
((4,1),(6,1))
((4,1),(8,1))
((4,1),(10,1))
((5,1),(2,1))
((5,1),(4,1))
((5,1),(6,1))
((5,1),(8,1))
((5,1),(10,1))

Process finished with exit code 0

算子名称 pipe([command,[envVars]])
功能：传入 linux shell

inputRdd.pipe("head -1 ")

算子名称 coalesce(numPartitions)
功能：指定rdd 有几个分区，并且可以选择是否进行 shuffle操作。
数据分布不均，优化的选择。

inputRdd.coalesce(2,false).mapPartitionsWithIndex((idx,iter)=>{
  iter.map(x=>{
    (idx,x)
  })
}).foreach(println(_))
}

#############输出结果################
(0,2)
(0,3)
(0,4)
(0,5)
(0,200)
(1,600)
(1,100)
(1,300)
(1,700)
(1,22)
(1,66)
(1,33)
                                                                                
Process finished with exit code 0

算子名称 repatition(numPartitions)
功能：对RDD 进行重新分区，底层是 coalesce 算子，默认shuffle
数据分布不均，优化的选择。

inputRdd.repartition(5).mapPartitionsWithIndex((idx,iter)=>{
  iter.map(x=>{
    (idx,x)
  })
})//.foreach(println(_))

ACTIONS 算子

算子名称 reduce(func)
功能：对RDD 进行聚合

// An highlighted block
var foo = 'bar';

算子名称 collect()
功能： 数据会收集到 driver。

val data: Array[Int] = Array(1, 2, 3, 4, 5,200,600,100,300,700,22,66,33)
val inputRdd: RDD[Int] = sparkContext.parallelize(data,4)
inputRdd.collect()

算子名称 count()
功能：返回 dataset 的对象的数量

// An highlighted block
var foo = 'bar';

算子名称 first()
功能：返回 第一个

inputRdd.first(10)

算子名称 take()
功能：返回 前 n 个

inputRdd.take(10)

算子名称 takeSample(withReplacement,num,[seed])
功能：随机返回几个

// An highlighted block
var foo = 'bar';

算子名称 takeOrdered(n,[ordering])
功能：排序过后取值

// An highlighted block
var foo = 'bar';

算子名称 saveAsTextFile(n,[ordering])
功能：存储到文件

// An highlighted block
var foo = 'bar';

算子名称 saveAsSequenceFile(n,[ordering])
功能：存储到序列化文件

// An highlighted block
var foo = 'bar';

算子名称 saveAsObjectFile(n,[ordering])
功能：存储成对象文件

// An highlighted block
var foo = 'bar';

算子名称 countByKey()
功能：按照key进行聚合并统计数量

// An highlighted block
var foo = 'bar';

算子名称 foreach(func)
功能：把每个数据遍历一遍

// An highlighted block
var foo = 'bar';

IO 读取hdfs 文件

Logger.getLogger("org").setLevel(Level.ERROR)
val sparkconf: SparkConf = new SparkConf().setAppName("spark api").setMaster("local")
val sparkContext: SparkContext = new SparkContext(sparkconf)

val inputRDD: RDD[String] = sparkContext.textFile("/Users/michale/Desktop/tmp/Spark-API/src/main/resources/*")

inputRDD.foreach(println(_))

路径可以是文件，也可以是目录。

SPARK 创建

// An highlighted block
val conf = new SparkConf().setAppName(appName).setMaster(master)
new SparkContext(conf)
Cincinnati_De
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark API
TT15751097576的博客
11-18 359
Spark API主要有两个抽象部件组成：Spark Context和RDD，应用程序通过这两个部件和Spark进行交互，连接到Spark集群并使用相关资源。 1.Spark Context 是定义在Spark库中的一个类，作为Spark库的入口，包含应用程序 main( ) 方法的Driver program通过Spark Context对象访问Spark，因为Spark Context对象表示...
Spark 核心API
最新发布
bluedraam_pp的博客
03-08 1182
这两个函数是 PairRDDFunctions 的匿名类中的函数，从 PairRDDFunctions 的名称中可以知道，PairRDDFunctions 是真的键值对的，也就是说 RDD 中的数据是键值对的时候，我们可以调 PairRDDFunctions 的函数，scala 这个功能好像类的被动技能。action 算子是真正出发计算的算子，在 action 算子之前， 所有的算子就像流水线上的一个工序，按照我们想要的结果设置好了加工模具，action 才能够决一个 job 的开始。就看一下它的入参吧。
spark-RDD API(scala)
weixin_47734224的博客
09-24 943
RDD API(scala)操作
spark_API文档
11-13
为了方便学习，wget了spark的api，有需要的可下载参考。
Spark的API
07-15
Spark的API文档，不是特别好使，下回再优化
Spark学习总结-入门
11-06
Spark是一个高效的分布式计算系统，发源...Spark立足于内存计算，相比Hadoop MapReduce，Spark在性能上要高100倍，而且Spark提供了比Hadoop更上层的API，同样的算法在Spark中实现往往只有Hadoop的1/10或者1/100的长度。
Spark生产优化总结
04-27
Spark 生产优化总结 Spark 生产优化是企业中 Spark 作业的调优的总结，涉及 Spark 任务的详细解释、调度、资源分配等多方面的内容。本文将从三个方向考虑 Spark 生产优化：磁盘存储、CPU cores 和内存。 磁盘存储...
springboot与spark整合开发, 练习spark api
06-29
总结来说，Spring Boot与Spark的整合主要涉及以下几个步骤：引入Spark依赖、配置Spark实例、创建服务类实现Spark API操作、设计控制器提供REST接口。这样的结合使得开发人员可以方便地在微服务架构中利用Spark的强大...
Spark2.0.2API java
01-03
总结，Spark 2.0.2 API for Java 提供了强大且易用的工具，让Java开发者能够高效地处理大规模数据。通过理解和熟练运用上述概念和组件，开发者可以构建出高性能、高容错性的大数据应用。在实践中，不断探索和优化...
Spark 1.0.2 API (Scala)
09-11
总结，Spark 1.0.2的Scala API提供了丰富的工具，用于构建高效的大数据处理应用。理解并熟练运用这些API，能够帮助开发者充分利用Spark的强大功能，处理大规模数据，实现快速计算。通过掌握RDD、DataFrame、Spark ...
浅谈Spark RDD API中的Map和Reduce
01-10
RDD是什么？ RDD是Spark中的抽象数据结构类型，任何数据在Spark中都被表示为RDD。从编程的角度来看，RDD可以简单看成是一个数组。和普通数组的区别是，RDD中的数据是分区存储的，这样不同分区的数据就可以分布在不同的机器上，同时可以被并行处理。因此，Spark应用程序所做的无非是把需要处理的数据转换为RDD，然后对RDD进行一系列的变换和操作从而得到结果。本文为第一部分，将介绍Spark RDD中与Map和Reduce相关的API中。 如何创建RDD？ RDD可以从普通数组创建出来，也可以从文件系统或者HDFS中的文件创建出来。 举例：从普通数组创建RDD，里面包含了1到9
spark shell学习笔记
weixin_33727510的博客
07-30 431
http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html
Spark基础全解析
vinfly_li的博客
02-28 2万+
SPARK全解析 标签（空格分隔）： Spark SPARK全解析 Spark是什么？ Spark 源码编译 Spark本地模式安装配置及Spark Shell基本使用 Spark集群 Spark Application开发、运行及监控（IDEA） Spark 日志监控（HistoryServer）配置 Spark RDD Spark共享变量 Spark 内核 Spark 依赖 Spa...
Opencv标注开源工具CVAT介绍和使用心得
sparkapi的博客
08-26 9694
介绍一下背景，公司为100人左右TO B端AI企业，致力于用AI技术如人脸识别，NLP等技术赋能传统企业。公司算法大概10+，算法需要训练数据但是公司又没有精力自己开发一套标注系统，所以抱着试试看的态度找到了OPENCV开源的标注系统CVAT CVAT的github地址如下： https://github.com/opencv/cvat 下面介绍一下这个工具 1）有基本的成员管理系统如创建...
Spark RDD API 参考示例（三）
xumuteqiu的博客
06-08 1600
Spark RDD API 参考示例详解，Spark RDD 快速入门 Spark 详解
Spark JAVA RDD API 最全合集整理，持续更新中~
热门推荐
泰格数据
06-29 2万+
SPARK的核心就是RDD，对SPARK的使用入门也就是对RDD的使用， 对于JAVA的开发者，Spark的RDD对JAVA的API我表示很不能上手， 单单看文档根本是没有办法理解每个API的作用的，所以每个SPARK的新手，最好按部就班直接学习scale, 那才是一个高手的必经之路，但是由于项目急需使用，没有闲工夫去学习一门语言，只能从JAVA入门的同学， 福利来了
spark java api 环境_spark 快速入门 java API
weixin_29699041的博客
02-27 285
Spark的核心就是RDD，对SPARK的使用入门也就是对RDD的使用，包括action和transformation对于Java的开发者，单单看文档根本是没有办法理解每个API的作用的，所以每个SPARK的新手，最好按部就班直接学习scale,那才是一个高手的必经之路，但是由于项目急需使用，没有闲工夫去学习一门语言，只能从JAVA入门的同学，福利来了。。。。对API的解释：1.1transfo...
spark 2.2.0源码解读(二) spark context源码解读
qq_16234927的博客
10-09 522
spark context源码解读 spark context是spark的上下文环境，也是spark程序的入口，在spark2.0中sparkcontext融入到sparksession中，直接可以用sparksession.sparkContext去调用它。 spark程序是运行在jvm上的，一个jvm只能有一个活跃的sparkcontext，所以在你代码末尾加上一个sparkcontext....
spark API的操作
LEOZHYD的博客
08-04 286
object WordCount { def main(args: Array[String]): Unit = { //创建一个SparkContext,用来闯将最原始的RDD //创建一个SparkConf().setAppName(),加载SparkConf文件,并为其取名字"WordCount" val conf = new SparkConf().setAppName("WordCount") //创建SparkContext,他可以跟集群建立连接申请资源,里.
sparksql 和sparkapi
08-11
总结而言，Spark SQL是通过SQL语句和DataFrame API来处理结构化数据的模块，而Spark API是Spark框架中的核心API，用于编写分布式数据处理逻辑。它们可以互相配合使用，根据具体的需求选择合适的接口来操作数据。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值