Spark总结

目录

1.介绍spark

优点:

缺点:

Scala的特点

Spark生态系统

2.Spark运行模式及集群

 Spark运行模式

Spark集群

Spark作业流程

3.spark-创建RDD

RDD概念

优点

RDD特性

一、从内部创建RDD

(1).通过并行化集合(Parallelized Collections):

基本语法:

代码示例:

效果:

(2).makeRDD()创建

基本语法:

代码示例:

效果:

二、从外部创建RDD

1.文本文件:textFile

基本语法:

代码实例:

2.Sequence文件:sequenceFile()  

基本语法:

代码实例:

3.对象文件(Object files):

​基本语法:

代码示例:

4.Hive表:sql() 函数

​基本语法:

代码示例:

5.JDBC连接:

​基本语法:

代码示例:

​操作算子:

1.map()方法:

2.sortBy() 方法:

3.collect() 方法:

4.flatMap()方法:

5.take()方法:

转换操作:

1.union()方法:

代码示例:

效果:

2.filter() 方法:

代码示例:

效果:

3.distinst()方法:

代码示例:

效果:

4.intersection() 方法:

代码示例:

效果:

5.subtract() 方法:

代码示例:

效果:

6.cartesian() 方法:

代码示例:

效果:

RDD的连接方法:

1.join()方法:

2.rightOuterJoin():

3.leftOuterJoin():

4.fullOuterJoin():

5.zip() :


1.介绍spark


 导论(基于Hadoop的MapReduce的优缺点)
MapReduce是一个分布式运算程序的编程框架,是用户开发“基于Hadoop的数据分析应用”的核心框架

MapReduce是一种用于处理大规模数据集的编程模型和计算框架。它将数据处理过程分为两个主要阶段:Map阶段和Reduce阶段。在Map阶段,数据被分割为多个小块,并由多个并行运行的Mapper进行处理。在Reduce阶段,Mapper的输出被合并和排序,并由多个并行运行的Reducer进行最终的聚合和计算。MapReduce的优缺点如下:

优点:


    可伸缩性:MapReduce可以处理大规模的数据集,通过将数据分割为多个小块并进行并行处理,可以有效地利用集群的计算资源。它可以在需要处理更大数据集时进行水平扩展,而不需要对现有的代码进行修改。
    容错性:MapReduce具有高度的容错性。当某个节点发生故障时,作业可以自动重新分配给其他可用的节点进行处理,从而保证作业的完成。
    灵活性:MapReduce允许开发人员使用自定义的Mapper和Reducer来处理各种类型的数据和计算任务。它提供了灵活的编程模型,可以根据具体需求进行定制和扩展。
    易于使用:MapReduce提供了高级抽象,隐藏了底层的并行和分布式处理细节。开发人员只需要关注数据的转换和计算逻辑,而不需要关心并发和分布式算法的实现细节。

缺点:


    适用性有限:MapReduce适用于一些需要进行大规模数据处理和分析的场景,但对于一些需要实时计算和交互式查询的场景,MapReduce的延迟较高,不太适合。
    复杂性:尽管MapReduce提供了高级抽象,但对于开发人员来说,编写和调试MapReduce作业仍然是一项复杂的任务。需要熟悉MapReduce的编程模型和框架,并理解分布式计算的概念和原理。
    磁盘IO开销:在MapReduce中,数据需要在Map和Reduce阶段之间进行磁盘IO,这可能会导致性能瓶颈。尽管可以通过合理的数据分区和调优来减少磁盘IO的开销,但仍然需要考虑和处理数据移动和复制的开销。

综上所述,MapReduce是一种适用于大规模数据处理的编程模型和计算框架,具有可伸缩性、容错性、灵活性和易用性等优点。然而,它在实时计算和交互式查询等场景下的适用性有限,同时开发和调试MapReduce作业的复杂性也需要考虑

Scala的特点


① Scala具备强大的并发性,支持函数式编程,可以更好地支持分布式系统。
② Scala语法简洁,能提供优雅的API。
③ Scala兼容Java,运行速度快,且能融合到Hadoop生态圈中。

Spark生态系统


在实际应用中,大数据处理主要包括一下3个类型:
       ① 复杂的批量数据处理:时间跨度通常在数十分钟到数小时之间。
       ② 基于历史数据的交互式查询:时间跨度通常在数十秒到数分钟之间。
       ③ 基于实时数据流的数据处理:时间跨度通常在数百毫秒到数秒之间。

当同时存在以上三种场景时,就需要同时部署三种不同的软件

2.Spark运行模式及集群

 Spark运行模式

Spark集群

Spark作业流程

3.spark-创建RDD

RDD概念

1.一个RDD就是一个分布式对象集合,本质上是一个只读的分区记录集合,不同节点上进行并行计算

2.RDD提供了一种高度受限的共享内存模型,RDD是只读的记录分区集合,不能直接修改,只能通过在转换的过程中改

优点


惰性调用,管道化,避免同步等待,不需要保存中间结果,每次操变得简单

RDD特性


1.高效的容错性

现有容错机制:数据复制或者记录日志RDD具有天生的容错性:血缘关系,重新计算丢失分区,无需回滚系统,重算过程在不同节点之间并行,只记录粗粒度的操作

2.中间结果持久化到内存,数据在内存中的多个RDD操作直接按进行传递,避免了不必要的读写磁盘开销

3.存放的数据可以是JAVA对象,避免了不必要的对象序列化和反序列化

一、从内部创建RDD

(1).通过并行化集合(Parallelized Collections):

可以使用SparkContextparallelize方法将一个已有的集合转换为RDD

基本语法:
parallelize(collection, numSlices=None)
代码示例:
import org.apache.spark.{SparkConf, SparkContext}
 
val conf = new SparkConf().setAppName("ParallelizeExample").setMaster("local")
val sc = new SparkContext(conf)
 
val data = Array(1, 2, 3, 4, 5)
val rdd = sc.parallelize(data)
 
rdd.foreach(println)
 
sc.stop()
效果:

(2).makeRDD()创建

版本的 Spark 中,通常使用 parallelize() 方法来创建 RDD,这个方法与 makeRDD() 类似,都是用来从集合创建 RDD。

基本语法:
parallelize(collection, numSlices=None)
代码示例:
from pyspark import SparkContext
 
# 创建 SparkContext 对象
sc = SparkContext("local", "parallelize Example")
 
# 创建一个列表
data = [1, 2, 3, 4, 5]
 
# 使用 parallelize() 方法创建 RDD
rdd = sc.parallelize(data)
 
# 打印 RDD 中的元素
for element in rdd.collect():
    print(element)
效果:

二、从外部创建RDD


1.文本文件:textFile


textFile() 方法是 Apache Spark 中用于从文件系统中读取文本文件的函数

基本语法:
textFile(path, minPartitions=None, use_unicode=True)
代码实例:
from pyspark import SparkContext
 
# 创建 SparkContext 对象
sc = SparkContext("local", "textFile Example")
 
# 读取文本文件
lines = sc.textFile("path/to/file.txt")
 
# 打印每一行
for line in lines.collect():
    print(line)

2.Sequence文件:sequenceFile()  

sequenceFile()  方法用于在 Apache Spark 中读取 Hadoop SequenceFile 格式的文件,并将其作为 RDD 返回。SequenceFile 是 Hadoop 中一种常用的二进制文件格式,通常用于存储键-值对数据。

基本语法:
sequenceFile(path, keyClass=None, valueClass=None, keyConverter=None, valueConverter=None, minSplits=None, batchSize=0)
代码实例:
from pyspark import SparkContext
 
# 创建 SparkContext 对象
sc = SparkContext("local", "sequenceFile Example")
 
# 读取 SequenceFile 文件并创建 RDD
data = sc.sequenceFile("hdfs://path/to/sequence_file")
 
# 打印 RDD 中的元素
for key, value in data.collect():
    print(key, value)

3.对象文件(Object files):

 objectFile() 方法用于在 Apache Spark 中读取以序列化形式保存的对象文件,并将其作为 RDD 返回。这种文件格式通常用于将对象序列化为字节流,并存储在文件中,以便在后续操作中进行读取和处理。


​基本语法:
objectFile(path, minPartitions=None, batchSize=0)
代码示例:
from pyspark import SparkContext
 
# 创建 SparkContext 对象
sc = SparkContext("local", "objectFile Example")
 
# 读取对象文件并创建 RDD
data = sc.objectFile("hdfs://path/to/object_file")
 
# 打印 RDD 中的元素
for obj in data.collect():
    print(obj)

4.Hive表:sql() 函数


在Spark中配置了Hive支持,你可以使用 sql() 函数执行Hive查询并将结果作为RDD返回。sql() 方法是 SparkSession 类的一个成员方法,用于执行 SQL 查询并返回结果作为 DataFrame。sql() 方法可以让你直接在 Spark 中执行 SQL 查询,而不需要编写基于 RDD 的代码。

​基本语法:
DataFrame = sql(sqlQuery)
代码示例:
from pyspark.sql import SparkSession
 
# 创建 SparkSession 对象
spark = SparkSession.builder \
    .appName("SQL Example") \
    .getOrCreate()
 
# 创建 DataFrame
df = spark.createDataFrame([(1, 'Alice'), (2, 'Bob'), (3, 'Charlie')], ["id", "name"])
 
# 注册临时表
df.createOrReplaceTempView("people")
 
# 执行 SQL 查询
result = spark.sql("SELECT * FROM people")
 
# 显示结果
result.show()

5.JDBC连接:


使用 jdbc() 函数来连接关系型数据库,并通过执行SQL查询来创建RDD。

​基本语法:

jdbcDF = spark.read \
    .jdbc(url="jdbc:postgresql:dbserver", table="schema.tablename",
          properties={"user": "username", "password": "password"})

代码示例:
from pyspark.sql import SparkSession
spark = SparkSession.builder \
    .appName("JDBC Example") \
    .config("spark.driver.extraClassPath", "path/tobc-driver.jar") \
    .getOrCreate()
 
 jdbcDF = spark.read \
    .format("jdbc") \
    .option("url", "jdbc:postgresql://database_server:port/database_name") \
    .option("dbtable", "table_name") \
    .option("user", "username") \
    .option("password", "password") \
    .load()
jdbcDF.show()
spark.stop()

​操作算子:

Scala集合提供了丰富的计算算子,用于实现集合/数组的计算,这些计算子一般针对于List、Array、Set、Map、Range、Vector、Iterator等都可以适用

1.map()方法:

map() 方法用于对集合(如列表、数组、映射等)中的每个元素应用一个函数,并返回结果的新集合。

def map[B](f: (A) ⇒ B): List[B]
2.sortBy() 方法:

sortBy() 方法用于根据指定的标准对集合中的元素进行排序,并返回排序后的新集合。
​基本语法:

def sortBy[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): List[A]
3.collect() 方法:

用于对集合中的元素进行筛选和转换,并返回符合条件的新集合。

def collect[B](pf: PartialFunction[A, B]): List[B]
4.flatMap()方法:

flatMap() 方法是集合类(如列表、数组等)的常见操作之一,它结合了 map() 和 flatten() 两个操作,常用于在集合的元素上应用一个函数,并将结果展平成一个新的集合。

def flatMap[B](f: (A) => IterableOnce[B]): IterableOnce[B]
5.take()方法:

take() 方法用于从集合中获取指定数量的元素,返回一个新的集合。

def take(n: Int): Repr

转换操作:

1.union()方法:

union() 方法用于将两个集合合并成一个新的集合,去除重复的元素。它是集合类的方法之一,适用于 Set 和 Seq 类型的集合。

代码示例:
 
val set1 = Set(1, 2, 3)
val set2 = Set(3, 4, 5)
 
val result = set1.union(set2)
// result: Set[Int] = Set(1, 2, 3, 4, 5)
效果:

2.filter() 方法:

代码示例:

val list = List(1, 2, 3, 4, 5)
 
val evenNumbers = list.filter(_ % 2 == 0)
// evenNumbers: List[Int] = List(2, 4)
效果:


用于从集合中筛选出满足特定条件的元素,然后返回一个包含满足条件的元素的新集合。

3.distinst()方法:


distinct() 方法用于从集合中移除重复的元素,并返回一个包含唯一元素的新集合。这个方法适用于 Seq、Set 和 Map 类型的集合。

代码示例:
 

val list = List(1, 2, 2, 3, 3, 4, 5, 5)
 
val uniqueList = list.distinct
// uniqueList: List[Int] = List(1, 2, 3, 4, 5)

效果:

4.intersection() 方法:

用于获取两个RDD(弹性分布式数据集)之间的交集。


代码示例:
import org.apache.spark.{SparkConf, SparkContext}
 
object RDDIntersectionExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("RDDIntersectionExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建两个RDD
    val rdd1 = sc.parallelize(Seq(1, 2, 3, 4, 5))
    val rdd2 = sc.parallelize(Seq(4, 5, 6, 7, 8))
 
    // 计算两个RDD的交集
    val intersectionRDD = rdd1.intersection(rdd2)
 
    // 打印结果
    intersectionRDD.collect().foreach(println)
 
    sc.stop()
  }
}
效果:

5.subtract() 方法:

用于从一个 RDD 中移除另一个 RDD 中包含的元素,得到两个 RDD 的差集。

代码示例:
import org.apache.spark.{SparkConf, SparkContext}
 
object RDDSubtractExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("RDDSubtractExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建两个RDD
    val rdd1 = sc.parallelize(Seq(1, 2, 3, 4, 5))
    val rdd2 = sc.parallelize(Seq(4, 5, 6, 7, 8))
 
    // 计算两个RDD的差集
    val subtractRDD = rdd1.subtract(rdd2)
 
    // 打印结果
    subtractRDD.collect().foreach(println)
 
    sc.stop()
  }
}
效果:

6.cartesian() 方法:

用于计算两个 RDD 的笛卡尔积(Cartesian product)。笛卡尔积是两个集合之间的所有可能的组合,其中一个元素来自第一个集合,另一个元素来自第二个集合。

代码示例:
import org.apache.spark.{SparkConf, SparkContext}
 
object RDDCartesianExample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("RDDCartesianExample").setMaster("local[*]")
    val sc = new SparkContext(conf)
 
    // 创建两个RDD
    val rdd1 = sc.parallelize(Seq("A", "B", "C"))
    val rdd2 = sc.parallelize(Seq(1, 2, 3))
 
    // 计算两个RDD的笛卡尔积
    val cartesianRDD = rdd1.cartesian(rdd2)
 
    // 打印结果
    cartesianRDD.collect().foreach(println)
 
    sc.stop()
  }
}
效果:

RDD的连接方法:

1.join()方法:

用于将两个 RDD 按照键进行连接操作。它接收另一个键值对 RDD 作为参数,并返回一个新的 RDD,其中的元素是两个原始 RDD 中具有相同键的元素的笛卡尔积。

2.rightOuterJoin():

右外连接是一种数据库连接操作,它返回两个数据集中所有右表(第二个数据集)的记录,以及左表(第一个数据集)中与右表匹配的记录。如果左表中没有匹配的记录,则会为其添加 null 值。

3.leftOuterJoin():

左外连接是一种数据库连接操作,它返回两个数据集中所有左表(第一个数据集)的记录,以及右表(第二个数据集)中与左表匹配的记录。如果右表中没有匹配的记录,则会为其添加 null 值。

4.fullOuterJoin():

全外连接是一种数据库连接操作,它返回两个数据集中所有记录的并集,并将匹配的记录组合在一起。如果两个数据集中都没有匹配的记录,则会为其添加 null 值。

5.zip() :

用于将两个 RDD 中的元素一一配对的方法之一。它将两个 RDD 中的元素按顺序一一配对,形成新的 RDD,其中每个元素是一个由两个 RDD 中对应位置的元素组成的元组。

  • 14
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值