RDD编程_第五章笔记

TTXS123456789ABC

已于 2022-07-03 16:07:01 修改

阅读量884

点赞数

分类专栏： # Hadoop 文章标签：大数据 scala hadoop

于 2022-06-29 20:23:11 首次发布

本文链接：https://blog.csdn.net/qq_45972323/article/details/125523283

版权

Hadoop 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

RDD编程

1RDD编程基础
2键值对RDD
3数据读写

1RDD编程基础

1.1RDD创建

RDD的创建有两种

1.1.1 从文件系统中加载数据创建RDD

采用textFile()方法来从文件系统中加载数据创建RDD
该方法把文件的URI作为参数，这个URI可以是：
本地文件系统的地址、或者是分布式文件系统HDFS的地址、Amazon S3的地址等
在这里插入图片描述

1.1.2 通过并行集合（数组）创建RDD

调用SparkContext的parallelize方法，在Driver中一个已经存在的集合（数组）上创建
在这里插入图片描述

1.2RDD操作

1.2.1转换操作

对于RDD而言，每一次转换操作都会产生不同的RDD，供给下一个“转换”使用
惰性求值：整个转换过程只是记录了转换的轨迹，并不会发生真正的计算，只有遇到行动操作时，才会发生真正的计算。开始从血缘关系源头开始，进行物理的转换操作。
在这里插入图片描述

filter(func)

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

在这里插入图片描述

map(func)
map(func)操作将每个元素传递到函数func中，并将结果返回为一个新的数据集

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

在这里插入图片描述

flatMap(func)
先map，在flat拍扁

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

在这里插入图片描述

groupByKey()
groupByKey()应用于(K,V)键值对的数据集时，返回一个新的(K, Iterable)形式的数据集

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

在这里插入图片描述

reduceByKey(func)
reduceByKey(func)应用于(K,V)键值对的数据集时，返回一个新的(K, V)形式的数据集，其中的每个值是将每个key传递到函数func中进行聚合后得到的结果

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

在这里插入图片描述

1.2.2行动操作

行动操作是真正触发计算的地方。Spark程序执行到行动操作时，才会执行真正的计算，从文件中加载数据，完成一次又一次转换操作，最终，完成行动操作得到结果。
在这里插入图片描述

1.2.3惰性机制

整个转换过程只是记录了转换的轨迹，并不会发生真正的计算，只有遇到行动操作时，才会触发“从头到尾”的真正的计算。
在这里插入图片描述

1.3持久化

通过持久化（缓存）机制避免这种重复计算的开销
使用persist()方法对一个RDD标记为持久化
出现persist()语句的地方，并不会马上计算生成RDD并把它持久化，而是要等到遇到第一个行动操作触发真正计算以后，才会把计算结果进行持久化
持久化后的RDD将会被保留在计算节点的内存中被后面的行动操作重复使用
可以使用unpersist()方法手动地把持久化的RDD从缓存中移除

persist()的圆括号中包含的是持久化级别参数：
persist(MEMORY_ONLY)：表示将RDD作为反序列化的对象存储于JVM中
如果内存不足，就要按照LRU原则替换缓存中的内容
persist(MEMORY_AND_DISK)表示将RDD作为反序列化的对象存储在JVM中
如果内存不足，超出的分区将会被存放在硬盘上

一般而言，使用cache()方法时，会调用persist(MEMORY_ONLY)

在这里插入图片描述

1.4分区

分区作用：增加并行度，减小通信开销
使得分区的个数尽量等于集群中的CPU核心（core）数目

1.4.1创建RDD时手动指定分区个数

调用textFile()和parallelize()方法的时候手动指定分区个数即可
sc.textFile(path, partitionNum)

1.4.2使用reparititon方法重新设置分区个数

通过转换操作得到新 RDD 时，直接调用 repartition 方法
val rdd = data.repartition(1)

2键值对RDD

2.1键值对RDD的创建

2.1.1从文件中加载

一种主要方式是使用map()函数来实现

val lines = sc.textFile("file:///usr/local/spark/mycode/pairrdd/word.txt")
val pairRDD = lines.flatMap(line => line.split(" ")).map(word => (word,1))
pairRDD.foreach(println)

2.1.2通过并行集合（数组）创建RDD

val list = List("Hadoop","Spark","Hive","Spark")
val rdd = sc.parallelize(list)
val pairRDD = rdd.map(word => (word,1))
pairRDD.foreach(println)

2.2常用的键值对RDD转换操作

2.2.1reduceByKey(func) 求值

reduceByKey(func)的功能是，使用func函数合并具有相同键的值

scala> pairRDD.reduceByKey((a,b)=>a+b).foreach(println)
(Spark,2)
(Hive,1)
(Hadoop,1)

2.2.2groupByKey() 分组

groupByKey()的功能是，对具有相同键的值进行分组

对四个键值对("spark",1)、("spark",2)、("hadoop",3)和("hadoop",5)，采用groupByKey()后得到的结果是：("spark",(1,2))和("hadoop",(3,5))

两者区别求值

val words = Array("one", "two", "two", "three", "three", "three")  
val wordPairsRDD = sc.parallelize(words).map(word => (word, 1))  
val wordCountsWithReduce = wordPairsRDD.reduceByKey(_ + _)  
val wordCountsWithGroup = wordPairsRDD.groupByKey().map(t => (t._1, t._2.sum))

2.2.3keys和values

keys只会把Pair RDD中的key返回形成一个新的RDD

scala> pairRDD.keys
scala> pairRDD.keys.foreach(println)
Hadoop
Spark
Hive
Spark

values只会把Pair RDD中的value返回形成一个新的RDD。

scala> pairRDD.values
scala> pairRDD.values.foreach(println)
1
1
1
1

2.2.4sortByKey()和sortBy()

sortByKey()的功能是返回一个根据键排序的RDD
sortBy()应该是返回一个根据值排序的RDD
false：应该是降序排序
true：应该是升序排序

scala> val d1 = sc.parallelize(Array((“c",8),(“b“,25),(“c“,17),(“a“,42),(“b“,4),(“d“,9),(“e“,17),(“c“,2),(“f“,29),(“g“,21),(“b“,9)))
scala> d1.reduceByKey(_+_).sortByKey(false).collect
res2: Array[(String, Int)] = Array((g,21),(f,29),(e,17),(d,9),(c,27),(b,38),(a,42))

scala> val d2 = sc.parallelize(Array((“c",8),(“b“,25),(“c“,17),(“a“,42),(“b“,4),(“d“,9),(“e“,17),(“c“,2),(“f“,29),(“g“,21),(“b“,9)))
scala> d2.reduceByKey(_+_).sortBy(_._2,false).collect
res4: Array[(String, Int)] = Array((a,42),(b,38),(f,29),(c,27),(g,21),(e,17),(d,9))

2.2.6mapValues(func)

对键值对RDD中的每个value都应用一个函数，但是，key不会发生变化

scala> pairRDD.mapValues(x => x+1)
scala> pairRDD.mapValues(x => x+1).foreach(println)
(Hadoop,2)
(Spark,2)
(Hive,2)
(Spark,2)

2.2.7join

join就表示内连接。
对于内连接，对于给定的(K,V1)和(K,V2)只有它两都存在相同的key才会被输出，最终得到一个数据集类型为(K,(V1,V2))。

scala> val pairRDD1 = sc.parallelize(Array(("spark",1),("spark",2),("hadoop",3),("hadoop",5)))
scala> val pairRDD2 = sc.parallelize(Array(("spark","fast")))
scala> pairRDD1.join(pairRDD2)
scala> pairRDD1.join(pairRDD2).foreach(println)
(spark,(1,fast))
(spark,(2,fast))

2.2.8combineByKey 比较难

一些高阶键值对函数底层都是用它实现的，诸如 groupByKey,reduceByKey
链接: combineByKey

3数据读写

3.1文件数据读写

3.1.1本地文件系统的数据读写

因为Spark采用了惰性机制，在执行转换操作的时候，即使输入了错误的语句，spark-shell也不会马上报错，比如读错文件

scala> val  textFile = sc.textFile("file:///usr/local/spark/mycode/wordcount/word.txt")

scala> textFile.saveAsTextFile("file:///usr/local/spark/mycode/wordcount/writeback")

3.1.2分布式文件系统HDFS的数据读写

scala> val  textFile = sc.textFile("hdfs://localhost:9000/user/hadoop/word.txt")
scala> textFile.saveAsTextFile("writeback")

3.1.3JSON文件的数据读写

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式
JSON.parseFull(jsonString:String)函数，以一个JSON字符串作为输入并进行解析，如果解析成功则返回一个Some(map: Map[String, Any])，如果解析失败则返回None

scala> val  jsonStr = sc.textFile("file:///usr/local/spark/examples/src/main/resources/people.json")
scala> jsonStr.foreach(println)

3.2读写HBase数据

3.2.1HBase简介

在这里插入图片描述

HBase中需要根据行键、列族、列限定符和时间戳来确定一个单元格，因此，可以视为一个“四维坐标”
[行键, 列族, 列限定符, 时间戳]

3.2.2创建一个HBase表

//检查是否已经被命名，有的话删除
disable 'student'
drop 'student'

//创建一个HBase表
create 'student','info'
put 'student','1','info:name','xsg'
put 'student','1','info:gender','F'
put 'student','1','info:age','22'