05-SparkRDD原理和编程接口

最新推荐文章于 2023-03-13 10:05:21 发布
最新推荐文章于 2023-03-13 10:05:21 发布
阅读量701 收藏 2
点赞数
分类专栏： spark 文章标签： spark big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39593321/article/details/123566107
版权

1.弹性分布式数据集RDD

1.1.RDD概述

1.1.1.什么是RDD

RDD（Resilient Distributed DataSet）弹性分布式数据集。是spark中最基本的数据抽象，是一个不可变的、可分区的、可并行计算的集合。

Resilient：数据可以选择性的存储在内存中，或者磁盘中

Distributed：分布式存储、分布式计算

DataSet：用于存放数据的数据集合

1.1.2.RDD的属性

  • A list of partitions：分区列表，数据集基本组成单位

    说明：每个分区对应一个计算任务，决定并行计算的粒度。比如：读取hdfs上数据文件产生的RDD分区数，与数据存储block的个数相等

  • A function for computing each split：计算每个分区的函数

    比如：在单词计数任务中的textFile、flatMap、map等函数

  • A list of dependencies on other RDDs：一个RDD会依赖于其他的RDD

    说明：依赖关系

  • Optionally, a Partitioner for key-value RDDs：可选的，一个Partitioner

    说明：只有key/value的RDD才会有Partitioner。当前在spark中提供了两种类型的Partitioner：一个是基于哈希的HashPartitioner；一个是基于范围的RangePartitioner

  • Optionally, a list of preferred locations to compute each split on：可选的，一个列表，存储每个Partition的优先位置

    说明：数据本地性（移动数据不如移动计算划算）

1.1.3.为什么会产生RDD

  • 传统的MapReduce虽然具有自动容错、平衡负载和可拓展性的优点，但是其最大缺点是采用非循环式的数据流模型，使得在迭代计算中要进行大量的磁盘IO操作，RDD正是解决这一缺点的抽象方法。
  • RDD是spark提供的最重要的抽象概念，它是一种具有容错机制的特殊集合，分布在集群的节点上，以函数式编程来操作集合，进行各种并行操作。可以把RDD的结果数据进行缓存，方便进行多次重用，避免重复计算。

1.1.4.RDD在spark中的地位和作用

  • 为什么会有spark：

    因为传统的并行计算模型无法有效的解决迭代计算（iterative）和交互式计算（interactive）。spark的使命便是解决这两个问题（迭代计算和交互式计算），这也是它存在的价值和理由。

  • spark如何解决迭代计算：

    迭代计算的主要实现思想，就是通过RDD，把所有计算的数据保存在分布式的内存中。迭代计算通常情况下都是对同一个数据集做反复的迭代计算。数据在内存中将大大提升IO操作效率。这也是spark的核心：内存计算

  • spark如何实现交互式计算：

    spark是用scala语言实现的，spark和scala能够紧密的集成，spark可以完美的运用scala的解释器，使得其中的scala可以像操作本地集合对象一样轻松操作分布式数据集

  • spark和RDD的关系：

    RDD是一种具有容错性、基于内存计算的抽象方法，RDD是spark Core的底层核心，spark则是这个抽象方法的实现

1.2.创建RDD

#进入spark shell(node03)
cd /export/servers/spark-2.0.2-bin-hadoop2.7/bin
spark-shell --master local[2]

  • 根据scala集合创建

    sc.parallelize(Array(1,2,3,4,5,6))

    在这里插入图片描述

  • 读取外部文件创建

    sc.textFile("/export/servers/testdata/words.txt")

在这里插入图片描述

  • 根据已经存在的RDD，经过算子转换生成新的RDD

    val rdd1=sc.textFile("/export/servers/testdata/words.txt")

rdd1.flatMap(_.split(" "))

1.3.RDD编程API

1.3.1.RDD算子分类

  • Transformation：转换

    根据数据集创建一个新的数据集，计算后返回一个新RDD

  • Action：动作

    对rdd结果计算后，返回一个数值value给驱动程序

1.3.2.Transformation

RDD中的所有转换都是延迟加载的，它们并不会直接计算结果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换操作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行。这种设计让spark更加有效率地运行。

常用的Transformation：

序号 转换 含义
1 map(func) 返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
2 filter(func) 返回一个新的RDD，该RDD由经过func函数计算，后返回值为true的输入元素组成
3 flatMap(func) 类似于map，每一个输入元素可以被映射为0或多个输出元素（func返回一个序列，而不是单一元素）
4 mapPartitions(func) 类似于map，独立地在RDD的每一个分片上运行，在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
5 mapPartitionsWithIndex(func) 类似于mapPartitions，func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是 (Int, Interator[T]) => Iterator[U]
6 union(othersDataSet) 对源RDD和参数RDD求并集后返回一个新的RDD
7 intersection(otherDataSet) 对源RDD和参数RDD求交集后返回一个新的RDD
8 distinct([numTasks]) 对源RDD进行去重后返回一个新的RDD
9 groupByKey([numTasks]) 在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
10 reduceByKey(func,[numTasks]) 在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
11 sortByKey([ascending],[numTasks]) 在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
12 sortBy(func,[ascending],[numTasks]) 与sortByKey类似，但是更灵活
13 join(otherDataSet,[numTasks]) 在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
14 cogroup(otherDataSet,[numTasks]) 在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
15 coalesce(numPartitions) 减少 RDD 的分区数到指定值
16 repartition(numPartitions) 重新给 RDD 分区
17 repartitionAndSort\ 重新给 RDD 分区，并且每个分区内以记录的 key 排序
18 WithinPartitions(partitioner)

1.3.3.Action

序号 动作 含义
1 reduce(func) reduce将RDD中元素前两个传给输入函数，产生一个新的return值，新产生的return值与RDD中下一个元素（第三个元素）组成两个元素，再被传给输入函数，直到最后只有一个值为止
2 collect() 在驱动程序中，以数组的形式返回数据集的所有元素生
3 count() 返回RDD的元素个数
4 first() 返回RDD的第一个元素（类似于take(1)）
5 take(n) 返回一个由数据集的前n个元素组成的数组
6 takeOrdered(n,[ordering]) 返回自然顺序或者自定义顺序的前 n 个元素
7 saveAsTextFile(path) 将数据集的元素以textfile的形式保存到hdfs文件系统或者其他支持的文件系统，对于每个元素，spark将会调用toString方法，将它装换为文件中的文本
8 saveAsSequenceFile(path) 将数据集中的元素以hadoop sequencefile的格式保存到指定的目录下，可以使hdfs或者其他hadoop支持的文件系统
9 saveAsObjectFile(path) 将数据集的元素，以 Java 序列化的方式保存到指定的目录下
10 countByKey() 针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数
11 foreach(func) 在数据集的每一个元素上，运行函数func
12 foreachPartition(func) 在数据集的每一个分区上，运行函数func

1.4.RDD常用算子操作

启动spark-shell：

#进入spark shell(node03)
cd /export/servers/spark-2.0.2-bin-hadoop2.7/bin
spark-shell --master spark://node01:7077

1.4.1.map、filter

# 通过并行化生成rdd
val rdd1=sc.parallelize(List(5, 6, 4, 7, 3, 8, 2, 9, 1, 10))
#对rdd1里的每一个元素乘2然后排序
 val rdd2=rdd1.map(_*2).sortBy(x=>x,true)
# 过滤出大于等于5的元素
 val rdd3=rdd2.filter(_>=5)
# 将元素以数组的方式在客户端显示
 rdd3.collect

在这里插入图片描述

1.4.2.flatMap

# 通过并行化生成rdd
val rdd1 = sc.parallelize(Array("a b c", "d e f", "h i j"))
# 将rdd1里面的每一个元素先切分再压平
val rdd2=rdd1.flatMap(_.split(" "))
#将元素以数组的方式在客户端显示
rdd2.collect

在这里插入图片描述

1.4.3.union、intersection

#并行化生成两个rdd
val rdd1 = sc.parallelize(List(5, 6, 4, 3))
val rdd2 = sc.parallelize(List(1, 2, 3, 4))
# 求并集
val unionRdd=rdd1.union(rdd2)
# 求交集
val intersectRdd=rdd1.intersection(rdd2)
# 并集去重
val distinctRdd=unionRdd.distinct
# 在客户端显示结果集
unionRdd.collect
intersectRdd.collect
distinctRdd.collect

在这里插入图片描述

1.4.4.join、groupByKey

# 并行化生成两个rdd
val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))
# 联合操作求join
val rdd3=rdd1.join(rdd2)
rdd3.collect
# 求并集
val rdd4=rdd1.union(rdd2)
rdd4.collect
# 按key进行分组
val rdd5=rdd4.groupByKey
rdd5.collect

在这里插入图片描述

1.4.5.cogroup

# 并行化生成两个rdd
val rdd1 = sc.parallelize(List(("tom", 1), ("tom", 2), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("jim", 2)))
# cogroup操作
val rdd3=rdd1.cogroup(rdd2)
# 在客户端显示结果集
rdd3.collect

在这里插入图片描述

1.4.6.reduce

# 并行化生成一个rdd
val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5))
# reduce操作
val rdd2=rdd1.reduce(_+_)

在这里插入图片描述

1.4.7.reduceByKey、sortByKey

# 并行化生成两个rdd
val rdd1 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2),  ("shuke", 1)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 3), ("shuke", 2), ("kitty", 5)))
# 求并集union
val rdd3=rdd1.union(rdd2)
rdd3.collect
# 按key进行聚合
val rdd4=rdd3.reduceByKey(_+_)
rdd4.collect
#按value的降序排序
val rdd5=rdd4.map(t=>(t._2,t._1)).sortByKey(false).map(t=>(t._2,t._1))
rdd5.collect

在这里插入图片描述

1.4.8.repartition、coalesce

# 并行化生成一个rdd（指定三个分区）
val rdd1 = sc.parallelize(1 to 10,3)
rdd1.getNumPartitions
# 利用repartition改变rdd1分区数
  ## 减少分区
  rdd1.repartition(2).partitions.size
  ## 增加分区
  rdd1.repartition(4).partitions.size
#利用coalesce改变rdd1分区数（只能减少分区）
  ##减少分区
  rdd1.coalesce(2).partitions.size

在这里插入图片描述

1.5.RDD编程实战

1.5.1.通过spark实现点击流日志分析案例

1.5.1.1.点击流介绍

点击流数据是由网站日志中整理得到的，它可以比网站日志本身包含更多的信息 。更注重用户浏览网站的整个流程，网站日志中记录的用户点击就像是图上的“点”，而点击流更像是将这些“点”串起来形成的“线” 。可以把“点”认为是网站的Page（单个操作），而“线”则是访问网站的Session （一次会话完整操作）。

点（Page）的信息：URL、点击时间（Hit Time）、页面停留时间（Time on Page）、位于Session的第几步（Step），Sessionid（在关系数据库中可以用于跟Session表的外键关联）……

**线（Session）的信息：**Sessionid（唯一标识符）、访问来源（Referrers）、进入页面（Entrance）、离开页面（Exit）、开始时间（Begin Time）、结束时间（End Time）、访问时长（Time on Site）、访问页面数（Depth of Visit）、访问用户（Cookie）……

1.5.1.2.案例日志格式介绍

在这里插入图片描述

日志组成：

ip地址 用户Id cookieId 访问时间 请求方式 请求协议 响应状态码 流量 请求的url 客户端信息

1.5.1.3.创建项目

在这里插入图片描述

1.5.1.3.导入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>project_djl</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>jar</packaging>

    <properties>
        <scala.version>2.11.8</scala.version>
        <hadoop.version>2.7.4</hadoop.version>
        <spark.version>2.0.2</spark.version>
        <mysql.version>5.1.38</mysql.version>


    </properties>

    <dependencies>
        <!--scala依赖-->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>
        <!--spark依赖-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!--hadoop依赖-->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>
        <!--依赖mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
    </dependencies>

    <!--配置插件-->
    <build>
        <plugins>
            <!--scala编译插件-->
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
最低0.47元/天 解锁文章
被数据处理的蜗牛
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark大数据处理学习笔记（3.1）掌握RDD的创建
Python_XTyyds的博客
06-14 1544
注意：访问本地文件，必须加file://前缀，否则系统会认为是访问hdfs://master:9000/home/test.txt，从而会报错。执行命令：val rdd = sc.textFile(“hdfs://master:9000/park/test.txt”)执行命令：val rdd = sc.textFile(“hdfs://master:9000/park/test.txt”)执行命令：val rdd = sc.textFile(“file:///home/test.txt”)
【Spark】RDD的设计和运行原理
兰陵鸡王的博客
03-20 2427
Spark的核心是建立在统一的抽象RDD之上，使得Spark的各个组件可以无缝进行集成，在同一个应用程序中完成大数据计算任务。 RDD设计背景 在实际应用中，存在许多迭代式算法（比如机器学习、图算法等）和交互式数据挖掘工具，这些应用场景的共同之处是，不同计算阶段之间会重用中间结果，即一个阶段的输出结果会作为下一个阶段的输入。 但是，目前的MapReduce框架都是把中间结果写入到HDFS中，带来了...
Spark RDD编程 文件数据读写
晓晓的天空
03-13 3582
Spark RDD编程 文件数据读写
Spark入门——1：RDD及编程接口
大白菜的奋斗专栏
05-10 2044
RDD是Spark的核心，也是整个Spark的架构基础。spark与mapreduce相比，前者提供了更加丰富的编程接口给程序猿们。所以下面主要说明RDD的基本概念，以及其重要接口。       RDD包含4大操作：                1，创建操作：RDD的创建有两个途径。一个是来之外部存储系统（例如：HDFS，S3）或者内部集合，另外一个是来自其他RDD的转换操作（例如m
RDD运行原理
abcdrachel的博客
04-23 1802
RDD产生的原因 在之前的机器学习里以及交互式挖掘等经常会涉及很多迭代式计算，这些迭代计算会涉及到一个中间结果计算的重用问题，MapReduce是把中间结果写入到磁盘里面，下次要使用的时候再从磁盘里读取中间结果，这样就会带来大量化的磁盘读写开销以及序列化与反序列化的开销。这里说的序列化是指将内存中的java对象进行转换为存储或传输的格式，比如说可以将java对象序列化为二进制对象...
RDD编程初级实践 .docx
11-21
总的来说，这份实验报告详细介绍了如何运用RDD编程解决实际问题，涵盖了从基础的RDD操作到复杂的数据处理任务，是学习Spark和RDD编程的良好实践。通过这样的实践，学习者可以深入理解Spark的工作原理，掌握分布式...
The-Spark-Foundation
03-21
Spark提供了多种编程接口，包括Scala、Java、Python和R，使得不同背景的开发者都能轻松上手。Jupyter Notebook是Spark学习中的常用工具，它允许我们在交互式环境中编写代码、展示结果，并且可以方便地结合Markdown...
mips-spark-optimization：Mips Spark优化
02-15
在MIPS SPARK环境下，Python可以通过PySpark接口进行编程，实现数据处理和分析任务。 1. PySpark API：Python通过PySpark提供了与Scala和Java等语言类似的API，简化了Spark应用的开发。理解并熟练运用这些API，能够...
《Spark 编程基础》 教材讲义 厦门大学 林子雨
04-03
第3章《Spark的设计与运行原理》深入探讨了Spark的架构和核心组件，如RDD（弹性分布式数据集）和DAG（有向无环图）。这部分内容将帮助读者理解Spark如何处理数据并实现快速计算。 第4章《Spark环境搭建和使用方法》...
spark-branch-2.3.zip
06-02
`spark-branch-2.3.zip`是一个包含了Spark 2.3源码的压缩包，用户在下载后，可以直接在IDEA中解压并打开，然后等待Maven自动下载依赖，以便于进一步理解和学习Spark的内部工作原理。 Spark的核心设计原则是基于DAG...
第二章 Spark RDD以及编程接口
01-07
第二章 Spark RDD以及编程接口 目录 Spark程序”Hello World” Spark RDD 创建操作 转换操作 控制操作 行动操作 注：学习《Spark大数据处理技术》笔记 1. Spark程序”Hello World” 1. 概述 计算存储在HDFS的Log文件中出现字符串”Hello World”的行数 2. 代码实现 3. 行解 第一行 对于所有的Spark程序而言，要进行任何操作，首先要创建一个Spark上下文，在创建上下文的过程中，程序会向集群申请资源以及构建相应的运行环境 需要传入四个变量 1. Spark程序运行的集群地址，如”spark://localho
Spark总结
cjl的博客
05-10 369
Spark总结Spark的内置模块Spark的特点 和 hadoop的区别Spark的重要角色RDD持久化原理checkpoint检查点机制checkpoint和持久化机制的区别RDD机制理解吗Spark streaming以及基本工作原理Spark工作机制宽依赖和窄依赖Spark主备切换机制原理Spark数据倾斜的产生和解决方法Spark Sql 和 DataFrameRDD中reduceBykey与groupByKey哪个性能好 Spark的内置模块 Spark Core：Spark Core包含
Spark RDD（三）
RivenDong
07-07 708
文章目录1. 前言2. 数据源3. 调度器4. RDD 编程接口4.1 数据源自于集合的接口4.2 数据源自于RDD的接口4.3 数据源自于DataFrame的接口5. RDD操作5.1 Spark基于命令行的操作5.2 Spark基于应用作业的操作5.3 Spark操作的基础命令与开发工具介绍5.4 Spark基于YARN的调度模式5.5 Spark基于Scala语言的本地应用开发5.6 Spa...
Spark快速入门系列（二）RDD 入门
weixin_45417821的博客
08-24 246
文章目录RDD入门RDD 是什么定义特点RDD 的分区创建 RDDRDD 算子 RDD入门 目标 上面通过一个 WordCount 案例, 演示了 Spark 大致的编程模型和运行方式, 接下来针对 Spark 的编程模型做更详细的扩展 理解 WordCount 的代码 从执行角度上理解, 数据之间如何流转 从原理角度理解, 各个算子之间如何配合 粗略理解 Spark 中的编程模型 RDD 理解 Spark 中 RDD 的各个算子 object WordCounts { def main(args:
10.Spark之RDD及编程接口
weixin_34358092的博客
01-28 186
2019独角兽企业重金招聘Python工程师标准>>> ...
RDD的执行流程（简略）
机械工程跑路哥
06-23 1534
从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。流程概括： ①准备资源 ②创建Driver和Executor节点 ②然后将应用程序的数据处理逻辑分解成一个一个的计算任务task。 ③然后将任务task发到已经分配资源的计算节点executor上, 按照指定的计算模型进行数据计算。最后得到计 Driver和Executor都是运行在NodeManager上面的 ！ ResourceManager是用于管理的，所以真正运行任务
Spark核心RDD详解（设计与运行原理，分区，创建，转换，行动与持久化）
个人学习笔记库，一篇一篇记录成长的足迹
01-30 3424
弹性分布式数据集， 是分布式内存的一个抽象概念，RDD提供了一种高度受限的共享内存模型，即RDD是只读的记录分区的集合，只能通过在其他RDD执行确定的转换操作（如map、join和group by）而创建，然而这些限制使得实现容错的开销很低。对开发者而言，RDD可以看作是Spark的一个对象，它本身运行于内存中，如读文件是一个RDD，对文件计算是一个RDD，结果集也是一个RDD ，不同的分片、 数据之间的依赖 、key-value类型的map数据都可以看做RDD。
Spark——标准Java函数接口
Mr.Write的博客
01-31 1036
作者：翁松秀 Spark——标准Java函数接口 在Java中，函数需要作为实现了Spark的org.apache.spark.api.java.function包中的任一函数接口的对象来传递。 Function&lt;T,R&gt; 实现方法：R Call(T) 用途：接收一个输入值并返回一个输出值，用于类似map()和filter()等操作中。 Function2&lt;T1,T2,R&gt...
Spark[1]：基本概念与python接口使用
miya的博客
01-08 1070
一、目标list 创建SparkContext与SparkSession 创建RDD Dataframes 和 SparkSQL的使用 预备工作 import findspark findspark.init() # PySpark is the Spark API for Python. In this lab, we use PySpark to initialize the spark context. from pyspark import SparkContext, SparkConf fr
小白学习spark05-spark sql
最新发布
03-16
1. Spark SQL的基本概念和原理：Spark SQL是Spark的一个模块，它提供了一种基于结构化数据的编程接口，可以通过SQL语句或DataFrame API来操作数据。Spark SQL支持多种数据源，包括Hive、JSON、Parquet等。 2. Spark...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值