spark

czh_12

已于 2024-05-13 17:09:40 修改

阅读量514

点赞数 23

文章标签： spark 大数据分布式

于 2024-05-13 14:38:42 首次发布

本文链接：https://blog.csdn.net/czh_12/article/details/138800255

版权

一、SparRDD简介
1.RDD 介绍
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。
RDD算子分为转换（Transformation）算子和行动（ Action）算子，程序运行到转换算子时并不会马上执行转算子，只有碰到行动算子才会真正执行转换算子。

2.RDD 分区
RDD内部的数据集在逻辑上会被划分为多个分区，而在物理上则被分配到多个任务中，以便在分布式计算中进行并行处理。分区的个数决定了计算的并行度，每一个分区内的数据都在一个单独的任务上执行。如果在计算过程中没有指定分区数，那么Spark会采用默认的分区数，默认的分区数为程序运行是分配到的CPU核心数。
3.RDD 创建
创建RDD一般有三种方式：
通过集合创建RDD：使用SparkContext.parallelize方法将集合转成RDD。
通过文件创建RDD：使用SparkContext.textFile方法读取文件内容创建RDD，文件可以是本地文件，也可以是hdfs文件。
通过其他RDD创建RDD,RDD的内容是不可变的，通过RDD算子操作之后会生产新的RDD。

二、

SparkRDD 入门

1、创建 RDD
从集合创建 RDD

2、从外部文件创建 RDD

1.RDD 常用转换算子
1、map算子
map算子：对输入的每一元素进行处理，生成一对一的结果，有多少条数据进入，就有多少数据出来。

2、filter算子
根据给定的函数过滤 RDD 中的元素，并返回一个包含满足条件的元素的新 RDD。

3、flatMap算子
类似于 map，但是对每个输入元素生成多个输出元素（返回一个扁平化的结果）。

4、mapPartitions算子
类似于 map，但是作用于 RDD 的每个分区而不是每个元素，可以减少开销。

5、distinct算子
去除 RDD 中的重复元素，并返回一个包含唯一元素的新 RDD。

6、dsortBy算子
根据给定的比较函数对 RDD 中的元素进行排序。

2、RDD 常用转换算子
1、collect行动算子
将 RDD 中的所有元素收集到驱动程序节点上，并以数组的形式返回。

2、collect行动算子
将 RDD 中的所有元素收集到驱动程序节点上，并以数组的形式返回。

3、count行动算子
返回 RDD 中元素的数量。

4、reduce行动算子
通过一个函数将 RDD 中的元素两两结合，直到将所有元素归约为一个结果。

5、take行动算子

二、SparDataFrame入门

DataFrame是一个二维表结构，那么表格结构就有无法绕开的三个点：

行
列
表结构描述
在MySQL中的一张表：

由许多行组成
数据也被分成多个列
表也有表结构信息（列、列名、列类型、列约束等）
基于这个前提，DataFrame的组成如下:

在结构层面：

StructType对象描述整个DataFrame的表结构
StructField对象描述一个列的信息
在数据层面

Row对象记录一行数据
Column对象记录一列数据并包含列的信息

1、创建SparkDataFrame

从集合创建 DataFrame

2、从外部数据源创建 DataFrame

3、显示 DataFrame 的内容

3、查看 DataFrame 的结构

查询操作

选择列

过滤行

分组聚合

添加和删除列

使用 SQL 查询

在本文中，我们探讨了 Spark 中两个重要的数据抽象：Spark RDD 和 Spark DataFrame。Spark RDD 是最初引入的分布式数据集概念，它提供了对数据的低级别控制和操作。它适用于需要对数据进行精细控制的情况，例如复杂的数据处理和算法实现。

与此相比，Spark DataFrame 是在 Spark SQL 中引入的，它提供了更高级别、更方便的 API，使得数据处理更加直观和简单。它更适用于结构化数据和 SQL 操作，以及大规模数据的数据处理和分析。

选择使用哪种数据结构取决于具体的需求和情况。如果你需要对数据进行更复杂的转换和操作，并且对数据的结构不是很了解，那么 Spark DataFrame 可能更适合你。而如果你需要对数据进行更底层的控制，并且更关注性能和灵活性，那么 Spark RDD 可能是更好的选择。

无论你选择使用哪种数据结构，Spark 提供了强大而灵活的工具来处理大规模数据。通过深入了解 Spark RDD 和 Spark DataFrame，你可以更有效地处理和分析数据，并从中获得有价值的见解和洞察。

Spark第二章到第五章全操作代码简解大全
第二章
1.定义与使用常量，变量
(1)常量
(2)变量
2.使用运算符
3.定义与使用数组
4.定义与使用函数
(1)匿名函数
(2)高级函数--函数作为参数
(3)高级函数--函数作为返回值
(4)函数柯里化
5.if判断
6.for循环
7.定义与使用列表
8.定义与使用集合
9.定义与使用映射
10.定义与使用元组
11.使用函数组合器
第三章
1.从内存中读取数据创建RDD
(1)parallelize()
(2)makeRDD()
2.从外部存储系统中读取数据创建RDD
(1)通过HDFS文件创建RDD
(2)通过Linux本地文件创建RDD
3.使用map()方法转换数据
4.使用sortBy()方法进行排序
5.使用collect()方法查询数据
6.使用flatMap()方法转换数据
7.使用take()方法查询某几个值
8.使用union()方法合并多个RDD
9.使用filter()方法进行过滤
10.使用distinct()方法进行去重
11.使用简单的集合操作
(1)intersection()方法
(2)subtract()方法
(3)cartesian()方法
12.创建键值对RDD
13.使用键值对RDD的keys和values方法
14.使用键值对RDD的reduceByKey()方法
15.使用键值对RDD的groupByKey()方法
16.使用join()方法连接两个RDD
(1)join()方法
(2)rightOuterJoin()方法
(3)leftOuterJoin()方法
(4)fullOuterJoin()方法
17.使用zip()方法组合两个RDD
18.使用combineByKey()方法合并相同键的值
19.使用lookup()方法查找指定键的值
第四章
第五章
1.创建DataFrame
2.查看DataFrame数据
（1）printSchema：输出数据模式
（2）show()：查看数据
（3）first()/head()/take()/takeAsList()：获取若干条记录
(4)collect()/collectAsList():获取所有数据
3.查询DataFrame查询操作
(1)where()/filter()方法
(2)select()/selectExpr()/col()/apply()方法
(3)limit()方法
(4)orderBy()/sort()方法
(5)groupBy()方法

第二章
1.定义与使用常量，变量
(1)常量
程序运行过程中值不会发生变化的量
通过val定义

(2)变量
程序运行过程中值可能发生变化的量
通过var定义

2.使用运算符
（1）多行字符串的表示方法

package com.item.action

object Demo3 {
def main(args: Array[String]): Unit = {
var str=
"""
|用我三生烟火，换你一世迷离只缘感君一回顾，使我思君朝与暮。
| 于我虽一眼惊鸿，于你却似指尖清风。
| 我见青山多妩媚，料青山见我应如是。
| 君生我未生，我生君已老。
|""".stripMargin;
print(str);
}

}

（2）算术运算符.

package com.item.action

object Demo5 {
def main(args: Array[String]): Unit = {
var a=5;
var b=8;
var c=2;
var d=9;
println("a+b="+(a+b));
println("a-b="+(a-b));
println("b/c="+(b/c));
println("a%d="+(a%d));
}
}

（3）Scala 注释

package day1
/* 这是一个 Scala 程序
* 这是一行注释
* 这里演示了多行注释
*/
object demo1 {
def main(args: Array[String]) {
// 输出 Hello World
// 这是一个单行注释
println("Hello, world!")
}
}

(4)换行符

package day1

object demo1 {
def main(args: Array[String]) {
val s = "菜鸟教程";
println(s);
println(s);
}
}

3.定义与使用数组
方式1：var gsj: Array[String] = new ArrayString
方式2：var gsj:Array[String] = Array(元素1,元素2,…)
var gsj:Array[String] = Array(“baidu”,“google”,“bing”)
gsj.length
gsj.head
gsj.tail
gsj.isEmpty
gsj.contains(“baidu”)
定义数组gsj
查看长度
查看第一个元素
查看除第一个元素外其他元素
查看是否为空
查看是否包含元素"baidu"

4.定义与使用函数
def gsj(a:Int,b:Int):Int={a+b)
gsj(2,3)
定义两个整数相加的函数
调用函数计算2+3

(1)匿名函数
定义函数时不给出函数名的函数

val gsj=(x:Int,y:Int)=>x+y
gsj(1,2)
定义两个整数相加的匿名函数
调用函数计算1+2

(2)高级函数–函数作为参数
def gsj(f:(Int,Int)=>Int,a:Int,b:Int)=f(a,b)
gsj((a:Int,b:Int)=>a+b,1,2)

(3)高级函数–函数作为返回值
def gsj(length:Double)=(height:Double)=>(length+height)*2
val func=gsj(4)
println(func(5))

(4)函数柯里化
def gsj(a:Int)(b:Int):Int=a+b
gsj(1)(2)

5.if判断
if(布尔表达式){若布尔表达式为true,则执行该语句块}

6.for循环
for(变量<- 集合) {循环语句}

7.定义与使用列表
列表是不可变的
val gsj:List[数据类型]=List(元素1,元素2,…)
gsj.head
gsj.init
gsj.last
gsj.tail
gsj.take(2)
定义集合
获取列表第一个元素
返回所有元素除了最后一个
获取列表的最后一个元素
返回所有元素除了第一个
获取列表前n个元素
val gsj1:List[Int]=List(1,2,3)
val gsj2:List[Int]=List(4,5,6)
gsj1:::gsj2
gsj1.:::(gsj2)
List.concat(gsj1,gsj2)
合并两个列表
val gsj:List[Int]=List(1,2,3)
gsj.contains(3)
判断列表中是否包含某个元素

8.定义与使用集合
集合是没有重复对象的，所有元素都是唯一的

val gsj:Set[Int]=Set(1,2,3,4,5)
gsj.head
gsj.init
gsj.last
gsj.tail
gsj.take(2)
定义集合
获取集合第一个元素
返回所有元素除了最后一个
获取集合的最后一个元素
返回所有元素除了第一个
获取集合前n个元素

9.定义与使用映射
映射是一种可迭代的键值对结构
val gsj:Map[String,Int]=Map(“John”->21,“Betty”->20,“Mike”->22)
gsj.head
gsj.init
gsj.last
gsj.tail
gsj.take(n)
gsj.isEmpty
gsj.keys
gsj.values
定义映射
获取映射第一个元素
返回所有元素除了最后一个
获取映射的最后一个元素
返回所有元素除了第一个
获取映射前n个元素
判断映射的数据是否为空
获取所有的键
获取所有的值

10.定义与使用元组
元组可以包含不同类型的元素
Scala支持的元组最大长度为22
val gsj=(1,3.14,“a”)
val gsj=new Tuple3(1,3.14,“a”)
gsj._1
gsj._3
定义元组的第一种方法
定义元组的第二种方法
访问元组第一个元素
访问元组第三个元素

11.使用函数组合器
(1)map()方法
(2)foreaach()方法
(3)filter()方法
(4)flatten()方法
(5)flatMap()方法
(6)groupBy()方法

第三章
1.从内存中读取数据创建RDD
(1)parallelize()
val gsj = Array(1,2,3,4,5)
val gsjrdd=sc.parallelize(gsj)
gsjrdd.partitions.size
val gsjrdd=sc.parallelize(gsj,4)
gsjrdd.partitions.size
定义一个数组
创建RDD
查看RDD默认分区个数
设置分区个数为4后创建RDD
再次查看RDD分区个数

(2)makeRDD()
val seq = Seq((1,Seq(“iteblog.com”,“sparkhost1.com”)),
((3,Seq(“iteblog.com”,“sparkhost2.com”)),
((2,Seq(“iteblog.com”,“sparkhost3.com”)))
val gsj = sc.makeRDD(seq)
gsj.collect
gsj.partitioner
gsj.partitions.size
gsj.preferredLocations(gsj.partitions(0))
gsj.preferredLocations(gsj.partitions(1))
gsj.preferredLocations(gsj.partitions(2))
定义一个序列seq
创建RDD
查看RDD的值
查看分区个数
根据位置信息查看每一个分区的值

2.从外部存储系统中读取数据创建RDD
(1)通过HDFS文件创建RDD
val gsj = sc.textFile(“/user/root/test.txt”)

(2)通过Linux本地文件创建RDD
val gsj = sc.textFile(“file:///opt/text.txt”)

3.使用map()方法转换数据
val gsj = sc.parallelize(List(1,3,45,3,76))
val sq_gsj=gsj.map(x => x*x)
求平方值

4.使用sortBy()方法进行排序
val gsj =sc.parallelize(List((1,3),(45,3),(7,6))
val sort_gsj = data.sortBy(x => x._2,false,1)

5.使用collect()方法查询数据
sq_gsj.collect
sort_gsj.collect

6.使用flatMap()方法转换数据
val gsj =sc.parallelize(List(“How are you”,“I am fine”,“What about you”))
gsj.collect
gsj.map(x => x.split(" “)).collect
gsj.flatMap(x => s.split(” ")).collect

7.使用take()方法查询某几个值
val gsj = sc.parallelize(1 to 10)
gsj.take(5)

8.使用union()方法合并多个RDD
val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,2),(‘c’,3)))
val gsj2 = sc.parallelize(List((‘a’,1),(‘d’,4),(‘e’,5)))
gsj1.union(gsj2).collect

9.使用filter()方法进行过滤
val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,2),(‘c’,3)))
gsj1.filter(_._2 >1).collect
gsj1.filter(x => x._2 >1).collect

10.使用distinct()方法进行去重
val gsj = sc.makeRDD(List(‘a’,1),(‘a’,1),(‘b’,1),(‘c’,1)))
gsj.distinct().collect

11.使用简单的集合操作
(1)intersection()方法
求出两个RDD的共同元素(求交集)
val gsj1 = sc.parallelize(List((‘a’,1),(‘a’,1),(‘b’,1),(‘c’,1)))
val gsj2 = sc.parallelize(List((‘a’,1),(‘b’,1),(‘d’,1)))
gsj1.intersection(gsj2).collect

(2)subtract()方法
求补集
val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,1),(‘c’,1)))
val gsj2 = sc.parallelize(List((‘d’,1),(‘e’,1),(‘c’,1)))
gsj1.subtract(gsj2).collect
gsj2.subtract(gsj1).collect

(3)cartesian()方法
求笛卡儿积
val gsj1 = sc.makeRDD(List(1,3,5,3))
val gsj2 = sc.makeRDD(List(2,4,5,1))
gsj1.cartesian(gsj2).collect

12.创建键值对RDD
val gsj =sc.parallelize(List(“this is a test”,“how are you”,“I am fine”,“can you tell me”))
val gsjs = gsj.map(x => (x.split(" ")(0),x))
gsjs.collect

13.使用键值对RDD的keys和values方法
val key = gsjs.keys
key.collect
val value = gsjs.values
value.collect

14.使用键值对RDD的reduceByKey()方法
val gsj = sc.parallelize(List((‘a’,1),(‘a’,2),(‘b’,1),(‘c’,1),(‘c’,1)))
val re_gsj = gsj.reduceByKey((a,b) => a+b)
re_gsj.collect

15.使用键值对RDD的groupByKey()方法
val g_gsj = gsj,groupByKey()
g_gsj.collect
g_gsj.map(x => (x._1,x._2.size)).collect

16.使用join()方法连接两个RDD
(1)join()方法
val gsj1 = sc.parallelize(List((‘a’,1),(‘b’,2),(‘c’,3)))
val gsj2 = sc.parallelize(List((‘a’,1),(‘d’,4),(‘e’,5)))
val j_gsj = gsj1.join(gsj2)
j_gsj.collect

(2)rightOuterJoin()方法
右外连接
val right_gsj = gsj1.rightOuterJoin(gsj2)
right_gsj.collect

(3)leftOuterJoin()方法
左外连接
val left_gsj = gsj1.leftOuterJoin(gsj2)
left_gsj.collect

(4)fullOuterJoin()方法
全外连接
val full_gsj = gsj1.fullOuterJoin(gsj2)
full_gsj.collect

17.使用zip()方法组合两个RDD
val gsj1 = sc.makeRDD(1 to 5 ,2)
val gsj2 = sc.makeRDD(seq(“A”,“B”,“C”,“D”,“E”),2)
gsj1.zip(gsj2).collect
gsj2.zip(gsj1).collect

18.使用combineByKey()方法合并相同键的值
combineByKey(createCombiner,mergeValue,mergeCombiners,numPartitions=None)

19.使用lookup()方法查找指定键的值
gsj.lookup(“panda”)
通过lookup()方法查询gsj中键为panda的所有对应值

第四章
第四章代码也看？看下一章了！

第五章
1.创建DataFrame
1.1、利用结构化数据文件parquet文件创建DataFrame

scala> val df=spark.sqlContext.read.load("file:/usr/local/spark-2.2.2-bin-hadoop2.6/examples/src/main/resources/users.parquet")
scala> df.show
+------+--------------+----------------+
| name|favorite_color|favorite_numbers|
+------+--------------+----------------+
|Alyssa| null| [3, 9, 15, 20]|
| Ben| red| []|
+------+--------------+----------------+

2.2、spark读取json文件为dataframe，有两种方法，都一样

scala> val df1=spark.sqlContext.read.format("json").load("file:/usr/local/spark-2.2.2-bin-hadoop2.6/examples/src/main/resources/people.json")

scala> val df2=spark.sqlContext.read.json("file:/usr/local/spark-2.2.2-bin-hadoop2.6/examples/src/main/resources/people.json")
df2: org.apache.spark.sql.DataFrame = [age: bigint, name: string]

scala> df2.show
+----+-------+
| age| name|
+----+-------+
|null|Michael|
| 30| Andy|
| 19| Justin|
+----+-------+

2、外部数据库创建DataFrame

连接 mysql，利用mysql的表创建dataframe，记得mysql要开远程连接权限

val jdf = spark.sqlContext.read.format("jdbc").options(Map("url"->"jdbc:mysql://master:3306/test","user"->"root","password"->"123456","dbtable"->"aaa")).load()
3、RDD创建DataFrame

scala> val data=sc.textFile("file:/usr/local/spark-2.2.2-bin-hadoop2.6/examples/src/main/resources/people.txt")
data: org.apache.spark.rdd.RDD[String] = file:/usr/local/spark-2.2.2-bin-hadoop2.6/examples/src/main/resources/people.txt MapPartitionsRDD[13] at textFile at <console>:24

scala> val data1=data.map{x=>val line=x.split(", ");(line(0),line(1).toInt)}
data1: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[14] at map at <console>:26

scala> val person=data1.toDF()
person: org.apache.spark.sql.DataFrame = [_1: string, _2: int]

scala> person.show
+-------+---+
| _1| _2|
+-------+---+
|Michael| 29|
| Andy| 30|
| Justin| 19|
+-------+---+

2.查看DataFrame数据
（1）printSchema：输出数据模式

2）show()：查看数据
gsjDF.show()：显示前20条记录
gsjDF.show(false)：显示所有字符

（3）first()/head()/take()/takeAsList()：获取若干条记录

frist():获取第一条记录

head(n):获取前n条记录
take(n):获取前n条记录
takeAsList(n):获取前n条记录,并以列表的形式展现

collect():获取所有数据,返回一个数组
collectAsList():获取所有数据,返回一个列表

3.查询DataFrame查询操作
(1)where()/filter()方法
条件查询

(2)select()/selectExpr()/col()/apply()方法

select():获取指定字段值
selectExpr():对指定字段进行特殊处理

col():获取指定字段值
apply():获取指定字段值

(3)limit()方法

limit():获取指定DataFrame数据的前n条记录

(4)orderBy()/sort()方法
orderBy():根据指定字段对数据进行排序，默认为升序排序
val gsjorderby = gsjDF.orderBy(desc(“id”))
val gsjorderby = gsjDF.orderBy($“id”.desc)
val gsjorderby = gsjDF.orderBy(-user(“id”))
gsjorderby.show()

sort():根据指定字段对数据进行排序
val gsjsort = gsjDF.sort(asc(“id”))
val gsjsort = gsjDF.sort($“id”.asc)
val gsjsort = gsjDF.sort(user(“id”))
gsjsort.show()

(5)groupBy()方法
groupBy():根据指定字段对数据进行分组操作
val gsjgroupby = gsjDF.groupBy(“age”)
val gsjgroupby = gsjDF.groupBy(user(“age”))
val gsjgroupbycount = gsjDF.groupBy(“age”).count
gsjgroupbycount.show()

一.了解spark框架

1.客户端：用户提交作业的客户端。

2. Driver：主运用程序，该进程运行应用的 main() 方法并且创建 SparkContext。

3.SparkContext：应用上下文，控制整个生命周期。

4.Cluster manager：集群资源管理器（例如，Standlone Manager，Mesos，YARN）。

5.Spark Worker：集群中任何可以运行应用程序的节点，运行一个或多个Executor进程。

6.Executor：位于工作节点上的应用进程，负责执行计算任务并且将输出数据保存到内存或者磁盘中。

7.Task：被发送到 Executor 中的工作单元。

二.了解Spark作业运行流程

Spark有3种运行模式，即Standalone，YARN和Mesos。

1.Standalone模式

客户端提交作业给Master，Master让一个Worker启动Driver，即SchedulerBackend。Worker创建一个DriverRunner线程，DriverRunner启动SchedulerBackend进程。另外，Master还会让其余Worker启动Executor，即ExecutorBackend。Worker创建一个ExecutorRunner线程，ExecutorRunner会启动ExecutorBackend进程。ExecutorBackend启动后会向Driver的SchedulerBackend注册。SchedulerBackend进程中包含DAGScheduler，它会根据用户程序生成执行计划，并调度执行。对于每个Stage的Task，都会被存放到TaskScheduler中，ExecutorBackend向SchedulerBackend汇报时把TaskScheduler中的Task调度到ExecutorBackend执行。所有Stage都完成后作业结束。

程序执行过程中，由Worker节点向Master发送心跳，随时汇报Worker的健康状况。

2.YARN模式

1.YARN集群模式的作业运行流程

基于YARN的Spark作业首先由客户端生成作业信息，提交给ResourceManager，ResourceManager在某一NodeManager汇报时把AppMaster分配给NodeManager，NodeManager启动SparkAppMaster，SparkAppMaster启动后初始化作业，然后向ResourceManager申请资源，申请到相应资源后SparkAppMaster通过RPC让NodeManager启动相应的SparkExecutor，SparkExecutor向NodeManager上的SparkAppMaster汇报并完成相应的任务。

2.YARN客户端模式的作业运行流程

基于YARN的Spark作业首先由客户端生成作业信息，提交给ResourceManager，ResourceManager在某一NodeManager汇报时把AppMaster分配给NodeManager，NodeManager启动SparkAppMaster，SparkAppMaster启动后初始化作业，然后向ResourceManager申请资源，申请到相应资源后SparkAppMaster通过RPC让NodeManager启动相应的SparkExecutor，SparkExecutor向本地启动的SparkAppMaster汇报并完成相应的任务。

三.了解Spark核心数据集RDD