阅读量:1
文章目录
IDEA 配置Spark环境
增加scala插件
创建Maven项目，配置pom.xml
<dependencies> <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-core_2.12</artifactId> <version>3.0.0</version> </dependency> </dependencies> 配置log4j.properties
在resources包下创建log4j.properties文件
增加以下代码：
log4j.rootCategory=ERROR, console log4j.appender.console=org.apache.log4j.ConsoleAppender log4j.appender.console.target=System.err log4j.appender.console.layout=org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n # Set the default spark-shell log level to ERROR. When running the spark-shell, the # log level for this class is used to overwrite the root logger's log level, so that # the user can have different defaults for the shell and regular Spark apps. log4j.logger.org.apache.spark.repl.Main=ERROR # Settings to quiet third party logs that are too verbose log4j.logger.org.spark_project.jetty=ERROR log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=ERROR log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=ERROR log4j.logger.org.apache.parquet=ERROR log4j.logger.parquet=ERROR # SPARK-9183: Settings to avoid annoying messages when looking up nonexistentUDFs in SparkSQL with Hive support log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=FATAL log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR Spark 三大数据结构
- RDD : 弹性分布式数据集
- 累加器：分布式共享只写变量
- 广播变量：分布式共享只读变量
RDD
RDD概念
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是 Spark 中最基本的数据处理模型。代码中是一个抽象类，它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。
- 弹性
- 存储的弹性：内存与磁盘的自动切换；
- 容错的弹性：数据丢失可以自动恢复；
- 计算的弹性：计算出错重试机制；
- 分片的弹性：可根据需要重新分片。
- 分布式：数据存储在大数据集群不同节点上
- 数据集：RDD封装了计算逻辑，并不保存数据
- 数据抽象：RDD是一个抽象类，需要子类具体实现
- 不可变：RDD封装了计算逻辑，是不可以改变的，想要改变，只能产生新的RDD，在新的RDD里面封装计算逻辑
- 可分区、并行计算
核心属性
- 分区列表
RDD数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要属性 - 分区计算函数
Spark 在计算时，是使用分区函数对每一个分区进行计算 - RDD之间的依赖关系
RDD是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个RDD建
立依赖关系 - 分区器（可选）
当数据为KV类型数据时，可以通过设定分区器自定义数据的分区 - 首选位置（可选）
计算数据时，可以根据计算节点的状态选择不同的节点位置进行计算
执行原理
从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合。
Spark 框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的
计算任务。然后将任务发到已经分配资源的计算节点上, 按照指定的计算模型进行数据计算。最后得到计算结果。
RDD是Spark框架中用于数据处理的核心模型，接下来我们看看，在Yarn环境中，RDD的工作原理:
- 启动Yarn集群环境
- Spark 通过申请资源创建调度节点和计算节点
- Spark 框架根据需求将计算逻辑根据分区划分成不同的任务
- 调度节点将任务根据计算节点状态发送到对应的计算节点进行计算
基础编程
RDD创建
- 从集合（内存）中创建RDD
从集合中创建RDD，Spark主要提供了两个方法：parallelize和makeRDD
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val rdd1 = sparkContext.parallelize( List(1,2,3,4) ) val rdd2 = sparkContext.makeRDD( List(1,2,3,4) ) rdd1.collect().foreach(println) rdd2.collect().foreach(println) sparkContext.stop() 从底层代码实现来讲，makeRDD方法其实就是parallelize方法
def makeRDD[T: ClassTag]( seq: Seq[T], numSlices: Int = defaultParallelism): RDD[T] = withScope { parallelize(seq, numSlices) } - 从外部存储（文件）创建RDD
由外部存储系统的数据集创建RDD包括：本地的文件系统，所有Hadoop支持的数据集，比如HDFS、HBase等。
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val fileRDD: RDD[String] = sparkContext.textFile("input") fileRDD.collect().foreach(println) sparkContext.stop() - 从其他RDD创建
主要是通过一个RDD运算完后，再产生新的RDD。详情请参考后续章节 - 直接创建RDD（new）
使用new的方式直接构造RDD，一般由Spark框架自身使用。
RDD 并行度与分区
默认情况下，Spark可以将一个作业切分多个任务后，发送给Executor节点并行计算，而能够并行计算的任务数量我们称之为并行度。这个数量可以在构建RDD时指定。记住，这里的并行执行的任务数量，并不是指的切分任务的数量。
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("spark") val sparkContext = new SparkContext(sparkConf) val dataRDD: RDD[Int] = sparkContext.makeRDD( List(1,2,3,4), 4) val fileRDD: RDD[String] = sparkContext.textFile( "input", 2) fileRDD.collect().foreach(println) sparkContext.stop() 读取内存数据时，数据可以按照并行度的设定进行数据的分区操作，数据分区规则的
Spark 核心源码如下：
def positions(length: Long, numSlices: Int): Iterator[(Int, Int)] = { (0 until numSlices).iterator.map { i => val start = ((i * length) / numSlices).toInt val end = (((i + 1) * length) / numSlices).toInt (start, end) } } 读取文件数据时，数据是按照Hadoop文件读取的规则进行切片分区，而切片规则和数据读取的规则有些差异，具体Spark核心源码如下
public InputSplit[] getSplits(JobConf job, int numSplits) throws IOException { long totalSize = 0; // compute total size for (FileStatus file: files) { // check we have valid files if (file.isDirectory()) { throw new IOException("Not a file: "+ file.getPath()); } totalSize += file.getLen(); } long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits); long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input. FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize); ... for (FileStatus file: files) { ... if (isSplitable(fs, path)) { long blockSize = file.getBlockSize(); long splitSize = computeSplitSize(goalSize, minSize, blockSize); ... } protected long computeSplitSize(long goalSize, long minSize, long blockSize) { return Math.max(minSize, Math.min(goalSize, blockSize)); } RDD转换算子
RDD根据数据处理方式的不同将算子整体上分为Value类型、双Value类型和Key-Value类型
Value类型
- map
1）函数签名
def map[U: ClassTag](f: T => U): RDD[U] 2）函数说明
val dataRDD: RDD[Int] = sparkContext.makeRDD(List(1,2,3,4)) val dataRDD1: RDD[Int] = dataRDD.map( num => { num * 2 } ) val dataRDD2: RDD[String] = dataRDD1.map( num => { "" + num } ) - mapPartitions
1）函数签名
def mapPartitions[U: ClassTag]( f: Iterator[T] => Iterator[U], preservesPartitioning: Boolean = false): RDD[U] 2）函数说明
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // TODO 算子 - mapPartitions val rdd = sc.makeRDD(List(1, 2, 3, 4), 2) val mapRdd : RDD[Int] = rdd.mapPartitionsWithIndex( (index, iter) => { if(index == 1) { iter } else { Nil.iterator } } ) mapRdd.collect().foreach(println) sc.stop() } map和mapPartitions的区别？
- 数据处理角度
Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而mapPartitions算子是以分区为单位进行批处理操作。 - 功能的角度
Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据 - 性能的角度
Map 算子因为类似于串行操作，所以性能比较低，而是mapPartitions算子类似于批处理，所以性能较高。但是mapPartitions算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用map操作。
- 数据处理角度
mapPartitionsWithIndex
1）函数签名
def mapPartitionsWithIndex[U: ClassTag]( f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false): RDD[U] 2）函数说明
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。
val dataRDD1 = dataRDD.mapPartitionsWithIndex( (index, datas) => { datas.map(index, _) } ) - flatMap
1）函数签名
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U] 2）函数说明
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
val dataRDD = sparkContext.makeRDD(List( List(1,2),List(3,4) ),1) val dataRDD1 = dataRDD.flatMap( list => list ) - glom
1）函数签名
def glom(): RDD[Array[T]] 2）函数说明
将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // TODO 算子 - map val rdd = sc.makeRDD(List(1, 2, 3, 4), 2) val glomRDD = rdd.glom() glomRDD.collect().foreach(data => println(data.mkString(","))) sc.stop() } - groupBy
1）函数签名
def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])] 2）函数说明
将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中
一个组的数据在一个分区中，但是并不是说一个分区中只有一个组
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // TODO 算子 -- groupBy val rdd = sc.makeRDD(List("Hello", "Spark", "Scala", "Hadoop"), 2) // 分组和分区没有必然的关系 val groupRDD = rdd.groupBy(_.charAt(0)) groupRDD.collect().foreach(println) sc.stop() } - filter
1）函数签名
def filter(f: T => Boolean): RDD[T] 2）函数说明
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。 当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。
// 过滤偶数 def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // TODO 算子 -- filter val rdd = sc.makeRDD(List(1, 2, 3, 4)) val filterRDD = rdd.filter(num => num % 2 != 0) filterRDD.collect().foreach(println) sc.stop() } - sample
1）函数签名
def sample( withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T] 2）函数说明
根据指定的规则从数据集中抽取数据
val dataRDD = sparkContext.makeRDD(List( 1,2,3,4 ),1) // 抽取数据不放回（伯努利算法） // 伯努利算法：又叫0、1分布。例如扔硬币，要么正面，要么反面。 // 具体实现：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于不 要 // 第一个参数：抽取的数据是否放回，false：不放回 // 第二个参数：抽取的几率，范围在[0,1]之间,0：全不取；1：全取； // 第三个参数：随机数种子 val dataRDD1 = dataRDD.sample(false, 0.5) // 抽取数据放回（泊松算法） // 第一个参数：抽取的数据是否放回，true：放回；false：不放回 // 第二个参数：重复数据的几率，范围大于等于0.表示每一个元素被期望抽取到的次数 // 第三个参数：随机数种子 val dataRDD2 = dataRDD.sample(true, 2) - distinct
1）函数签名
def distinct()(implicit ord: Ordering[T] = null): RDD[T] def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] 2）函数说明
将数据集中重复的数据去重
val dataRDD = sparkContext.makeRDD(List( 1,2,3,4,1,2 ),1) val dataRDD1 = dataRDD.distinct() val dataRDD2 = dataRDD.distinct(2) - coalesce
1）函数签名
def coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null) : RDD[T] 2）函数说明
根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率
当spark 程序中，存在过多的小任务的时候，可以通过coalesce方法，收缩合并分区，减少分区的个数，减小任务调度成本
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // TODO 算子 - coalesce val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 3) // coalesce 方法默认情况下不会将分区的数据打乱重新组合 // 这种情况下的缩减分区可能会导致 数据不均衡, 出现数据倾斜 // 如果想要数据均衡, 可以进行shuffle val newRDD = rdd.coalesce(2, true) newRDD.saveAsTextFile("output") sc.stop() } - repartition
1）函数签名
def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] 2）函数说明
该操作内部其实执行的是coalesce操作，参数shuffle的默认值为true。无论是将分区数多的RDD转换为分区数少的RDD，还是将分区数少的RDD转换为分区数多的RDD，repartition操作都可以完成，因为无论如何都会经shuffle过程。
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // TODO 算子 - repartition -- 扩大分区 val rdd = sc.makeRDD(List(1, 2, 3, 4, 5, 6), 2) // repartition可以进行扩大分区 默认执行shuffle val newRDD = rdd.repartition(3) newRDD.saveAsTextFile("output") sc.stop() } - sortBy
1）函数签名
def sortBy[K]( f: (T) => K, ascending: Boolean = true, numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T] 2）函数说明
该操作用于排序数据。在排序之前，可以将数据通过f函数进行处理，之后按照f函数处理的结果进行排序，默认为升序排列。排序后新产生的RDD的分区数与原RDD的分区数一致。中间存在shuffle的过程
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // TODO 算子 -- sortBy --排序 val rdd = sc.makeRDD(List(1, 3, 5, 2, 6, 4), 1) // sortBy方法可以根据指定的规则对数据源中的数据进行排序, 默认为升序, 第二个参数可以指定 改为false即为降序 // sortBy默认情况下, 不会改变分区, 但是中间存在shuffle操作 val sortRDD = rdd.sortBy(num => num, false) sortRDD.saveAsTextFile("output") sc.stop() } 双Value类型
- intersection
1）函数签名
def intersection(other: RDD[T]): RDD[T] 2）函数说明
对源RDD和参数RDD求交集后返回一个新的RDD
- union
1）函数签名
def union(other: RDD[T]): RDD[T] 2）函数说明
对源RDD和参数RDD求并集后返回一个新的RDD
- subtract
1）函数签名
def subtract(other: RDD[T]): RDD[T] 2）函数说明
以一个RDD元素为主，去除两个RDD中重复元素，将其他元素保留下来。求差集
- zip
1）函数签名
def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)] 2）函数说明
将两个RDD中的元素，以键值对的形式进行合并。其中，键值对中的Key为第1个RDD
中的元素，Value为第2个RDD中的相同位置的元素。
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- 双 Value类型 val rdd1 = sc.makeRDD(List(1, 2, 3, 4)) val rdd2 = sc.makeRDD(List(3, 4, 5, 6)) // 交集 val rdd3 = rdd1.intersection(rdd2) println(rdd3.collect().mkString(",")) // 并集 val rdd4 = rdd1.union(rdd2) println(rdd4.collect().mkString(",")) // 差集 val rdd5 = rdd1.subtract(rdd2) println(rdd5.collect().mkString(",")) // 拉链 val rdd6 = rdd1.zip(rdd2) println(rdd6.collect().mkString(",")) sc.stop() } Key - Value类型
- partitionBy
1）函数签名
def partitionBy(partitioner: Partitioner): RDD[(K, V)] 2）函数说明
将数据按照指定Partitioner重新进行分区。Spark默认的分区器是HashPartitioner
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- key-Value类型 val rdd = sc.makeRDD(List(1, 2, 3, 4),2) val mapRDD = rdd.map((_,1)) // RDD => PairRDDFunctions // 隐式转换 (二次编译) // partitionBy() 根据指定的分区规则对数据进行重分区 mapRDD.partitionBy(new HashPartitioner(2)) .saveAsTextFile("output") sc.stop() } - reduceByKey
1）函数签名
def reduceByKey(func: (V, V) => V): RDD[(K, V)] def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)] 2）函数说明
可以将数据按照相同的Key对Value进行聚合
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- reduceByKey val rdd = sc.makeRDD(List( ("a", 1), ("a", 2), ("a", 3), ("b", 4) )) // reduceByKey: 相同的key的数据进行value数据的聚合操作 // scala语言中的聚合操作是两两聚合, spark是基于scala开发的, 所以它的聚合操作也是两两聚合 // reduceByKey中如果 key的数据只有一个, 是不会参与运算的 val reduceRDD = rdd.reduceByKey((x: Int, y: Int) => { x + y }) reduceRDD.collect().foreach(println) sc.stop() } - groupByKey
1）函数签名
def groupByKey(): RDD[(K, Iterable[V])] def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])] def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])] 2）函数说明
将数据源的数据根据key对value进行分组
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- groupByKey val rdd = sc.makeRDD(List( ("a", 1), ("a", 2), ("a", 3), ("b", 4) )) // groupByKey : 将数据源中的数据,相同的key的数据分在一个组中,形成 一个对偶元组 // 元组中的第一个元素就是key // 元组中的第二个元素就是相同的key的value的集合 val groupRDD = rdd.groupByKey() groupRDD.collect().foreach(println) sc.stop() } reduceByKey和groupByKey的区别？
从shuffle 的角度：reduceByKey 和groupByKey 都存在shuffle 的操作，但是reduceByKey可以在shuffle 前对分区内相同key的数据进行预聚合（combine）功能，这样会减少落盘的数据量，而groupByKey只是进行分组，不存在数据量减少的问题reduceByKey性能比较高。
从功能的角度：reduceByKey其实包含分组和聚合的功能。GroupByKey只能分组，不能聚合，所以在分组聚合的场合下，推荐使用reduceByKey，如果仅仅是分组而不需要聚合。那么还是只能使用groupByKey
- aggregateByKey
1）函数签名
def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)] 2）函数说明
将数据根据不同的规则进行分区内计算和分区间计算
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- aggregateByKey val rdd = sc.makeRDD(List( ("a", 1), ("a", 2), ("a", 3), ("a", 4) ), 2) //[a,[1,2]] [a,[3,4]] // (a, 2) (a, 4) // aggregateByKey存在函数柯里化, 有两个参数列表 // 第一个参数列表 需要传递 一个参数 表示为初始值 // 主要用于碰到第一个key和value进行分区内的计算 // 第二个参数列表 需要传递两个参数 // 第一个参数表示分区内的计算规则 // 第二个参数表示分区间的计算规则 rdd.aggregateByKey(0)( (x, y) => math.max(x, y), (x, y) => x + y ).collect().foreach(println) sc.stop() } - foldByKey
1）函数签名
def foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)] 2）函数说明
当分区内计算规则和分区间计算规则相同时，aggregateByKey就可以简化为foldByKey
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- foldByKey val rdd = sc.makeRDD(List( ("a", 1), ("a", 2), ("a", 3), ("a", 4) ), 2) // 如果聚合计算时, 分区内和分区间的计算规则相同, spark提供了简化的方法 rdd.foldByKey(0)(_+_).collect().foreach(println) sc.stop() } - combineByKey
1）函数签名
def combineByKey[C]( createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C): RDD[(K, C)] 2）函数说明
最通用的对key-value型rdd进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。
小练习：将数据List((“a”, 88), (“b”, 95), (“a”, 91), (“b”, 93), (“a”, 95), (“b”, 98))求每个 key 的平
均值
val list: List[(String, Int)] = List(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)) val input: RDD[(String, Int)] = sc.makeRDD(list, 2) val combineRdd: RDD[(String, (Int, Int))] = input.combineByKey( (_, 1), (acc: (Int, Int), v) => (acc._1 + v, acc._2 + 1), (acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2) ) reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别？
reduceByKey: 相同 key 的第一个数据不进行任何计算，分区内和分区间计算规则相同
FoldByKey: 相同 key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同
AggregateByKey：相同 key 的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同
CombineByKey:当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。
- sortByKey
1）函数签名
def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length) : RDD[(K, V)] 2）函数说明
在一个(K,V)的RDD上调用，K必须实现Ordered接口(特质)，返回一个按照key进行排序的
- join
1）函数签名
def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))] 2）函数说明
在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素连接在一起的(K,(V,W))的 RDD
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- join val rdd1 = sc.makeRDD(List( ("a", 1), ("b", 2), ("c", 3) )) val rdd2 = sc.makeRDD(List( ("a", 4), ("b", 5), ("c", 6) )) // join : 两个不同数据源的数据, 相同的key的value会连接在一起, 形成元组 // 如果两个数据源的key没有匹配上, 那么数据不会出现在结果中 // 如果两个数据源中key有多个相同的, 会依次匹配, 可能会出现 笛卡儿积, 数据量会几何倍数增长, 会导致性能降低 val joinRDD = rdd1.join(rdd2) joinRDD.collect().foreach(println) sc.stop() } - leftOuterJoin
1）函数签名
def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))] 2）函数说明
类似于SQL语句的左外连接
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- leftOuterJoin rightOuterJoin val rdd1 = sc.makeRDD(List( ("a", 1), ("b", 2), ("c", 3) )) val rdd2 = sc.makeRDD(List( ("a", 4), ("b", 5), ("c", 6) )) val leftJoinRDD = rdd1.leftOuterJoin(rdd2) val rightJoinRDD = rdd1.rightOuterJoin(rdd2) leftJoinRDD.collect().foreach(println) rightJoinRDD.collect().foreach(println) sc.stop() } - cogroup
1）函数签名
def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))] 2）函数说明
在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // 交集、并集、差集需要要求两个数据类型保持一致 // 拉链操作两个数据源的类型可以不一致 // TODO 算子 -- cogroup(分组连接) val rdd1 = sc.makeRDD(List( ("a", 1), ("b", 2), ("c", 3) )) val rdd2 = sc.makeRDD(List( ("a", 4), ("b", 5), ("c", 6) )) val cgRDD = rdd1.cogroup(rdd2) cgRDD.collect().foreach(println) sc.stop() } RDD行动算子
- reduce
1）函数签名
def reduce(f: (T, T) => T): T 2）函数说明
聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) val rdd = sc.makeRDD(List(1,3,4,2)) // TODO - 行动算子 // reduce val i = rdd.reduce(_ + _) println(i) // collect : 方法会将不同分区的数据按照分区顺序采集到Driver端内存中, 形成数组 val ints = rdd.collect() println(ints.mkString(",")) // count : 数据源中数据的个数 val cnt = rdd.count() println(cnt) // first : 获取数据源中数据的第一个 val first = rdd.first() println(first) // take : 获取N个数据 val ints1 = rdd.take(3) println(ints1.mkString(",")) // takeOrdered : 数据排序后, 取3个数据 val ints2 = rdd.takeOrdered(3) println(ints2.mkString(",")) sc.stop() } - collect
1）函数签名
def collect(): Array[T] 2）函数说明
在驱动程序中，以数组Array的形式返回数据集的所有元素
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) val rdd = sc.makeRDD(List(1,2,3,4)) // TODO - 行动算子 // 所谓的行动算子, 其实就是触发作业(Job)执行的方法 // 底层代码调用的是环境对象的run.Job方法 // 底层代码中会创建Action.Job, 并提交执行 rdd.collect(),foreach(println) sc.stop() } - count
1）函数签名
def count(): Long 2）函数说明
返回RDD中元素的个数
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 返回RDD中元素的个数 val countResult: Long = rdd.count() - first
1）函数签名
def first(): T 2）函数说明
返回RDD中的第一个元素
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 返回RDD中元素的个数 val firstResult: Int = rdd.first() println(firstResult) - take
1）函数签名
def take(num: Int): Array[T] 2）函数说明
返回一个由RDD的前n个元素组成的数组
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 返回RDD中元素的个数 val takeResult: Array[Int] = rdd.take(2) println(takeResult.mkString(",")) - takeOrdered
1）函数签名
def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T] 2）函数说明
返回该RDD排序后的前n个元素组成的数组
val rdd: RDD[Int] = sc.makeRDD(List(1,3,2,4)) // 返回RDD中元素的个数 val result: Array[Int] = rdd.takeOrdered(2) - aggregate
1）函数签名
def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U 2）函数说明
分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) val rdd = sc.makeRDD(List(1,2,3,4), 2) // TODO - 行动算子 aggregate // aggregateByKey : 初始值只会参与分区内计算 // aggregate : 初始值会参与分区内计算, 并且也参与分区间计算 // 10 + 13 + 17 = 40 val result = rdd.aggregate(10)(_ + _, _ + _) println(result) sc.stop() } - fold
1）函数签名
def fold(zeroValue: T)(op: (T, T) => T): T 2）函数说明
折叠操作，aggregate的简化版操作
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) val rdd = sc.makeRDD(List(1,2,3,4), 2) // TODO - 行动算子 fold // aggregateByKey : 初始值只会参与分区内计算 // aggregate : 初始值会参与分区内计算, 并且也参与分区间计算 // 10 + 13 + 17 = 40 val result = rdd.fold(10)(_ + _) println(result) sc.stop() } - countByKey
1）函数签名
def countByKey(): Map[K, Long] 2）函数说明
统计每种key的个数
def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator") val sc = new SparkContext(sparkConf) // val rdd = sc.makeRDD(List(1,2,3,4), 2) val rdd = sc.makeRDD(List( ("a", 1), ("a", 1), ("a", 1) )) // TODO - 行动算子 countByKey // val intToLong = rdd.countByValue() // println(intToLong) val stringToLong = rdd.countByKey() println(stringToLong) sc.stop() } - save 相关算子
1）函数签名
def saveAsTextFile(path: String): Unit def saveAsObjectFile(path: String): Unit def saveAsSequenceFile( path: String, codec: Option[Class[_ <: CompressionCodec]] = None): Unit 2）函数说明
将数据保存到不同格式的文件中
// 保存成Text文件 rdd.saveAsTextFile("output") // 序列化成对象保存到文件 rdd.saveAsObjectFile("output1") // 保存成Sequencefile文件 rdd.map((_,1)).saveAsSequenceFile("output2") - foreach
1）函数签名
def foreach(f: T => Unit): Unit = withScope { val cleanF = sc.clean(f) sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF)) } 2）函数说明
分布式遍历RDD中的每一个元素，调用指定函数
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 收集后打印 rdd.map(num=>num).collect().foreach(println) println("****************") // 分布式打印 rdd.foreach(println) RDD 序列化
1）闭包检查
从计算的角度, 算子以外的代码都是在Driver端执行, 算子里面的代码都是在Executor端执行。那么在scala的函数式编程中，就会导致算子内经常会用到算子外的数据，这样就形成了闭包的效果，如果使用的算子外的数据无法序列化，就意味着无法传值给Executor端执行，就会发生错误，所以需要在执行任务计算前，检测闭包内的对象是否可以进行序列化，这个操作我们称之为闭包检测。Scala2.12版本后闭包编译方式发生了改变
- 序列化方法和属性
从计算的角度, 算子以外的代码都是在Driver端执行, 算子里面的代码都是在Executor端执行
object serializable02_function { def main(args: Array[String]): Unit = { //1.创建SparkConf并设置App名称 val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]") //2.创建SparkContext，该对象是提交Spark App的入口 val sc: SparkContext = new SparkContext(conf) //3.创建一个RDD val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", "hive", "atguigu")) //3.1创建一个Search对象 val search = new Search("hello") //3.2 函数传递，打印：ERROR Task not serializable search.getMatch1(rdd).collect().foreach(println) //3.3 属性传递，打印：ERROR Task not serializable search.getMatch2(rdd).collect().foreach(println) //4.关闭连接 sc.stop() } } class Search(query:String) extends Serializable { def isMatch(s: String): Boolean = { s.contains(query) } // 函数序列化案例 def getMatch1 (rdd: RDD[String]): RDD[String] = { //rdd.filter(this.isMatch) rdd.filter(isMatch) } // 属性序列化案例 def getMatch2(rdd: RDD[String]): RDD[String] = { //rdd.filter(x => x.contains(this.query)) rdd.filter(x => x.contains(query)) //val q = query //rdd.filter(x => x.contains(q)) } } - Kryo序列化框架
参考地址: https://github.com/EsotericSoftware/kryo
Java的序列化能够序列化任何的类。但是比较重（字节多），序列化后，对象的提交也
比较大。Spark出于性能的考虑，Spark2.0开始支持另外一种Kryo序列化机制。Kryo速度是Serializable的10倍。当RDD在Shuffle数据的时候，简单数据类型、数组和字符串类型已经在Spark内部使用Kryo来序列化。
注意：即使使用Kryo序列化，也要继承Serializable接口。
object serializable_Kryo { def main(args: Array[String]): Unit = { val conf: SparkConf = new SparkConf() .setAppName("SerDemo") .setMaster("local[*]") // 替换默认的序列化机制 .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer") // 注册需要使用 kryo 序列化的自定义类 .registerKryoClasses(Array(classOf[Searcher])) val sc = new SparkContext(conf) val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello atguigu", "atguigu", "hahah"), 2) val searcher = new Searcher("hello") val result: RDD[String] = searcher.getMatchedRDD1(rdd) result.collect.foreach(println) } } case class Searcher(val query: String) { def isMatch(s: String) = { s.contains(query) } def getMatchedRDD1(rdd: RDD[String]) = { rdd.filter(isMatch) } def getMatchedRDD2(rdd: RDD[String]) = { val q = query rdd.filter(_.contains(q)) } } RDD 依赖关系
（1）RDD血缘关系
RDD只支持粗粒度转换，即在大量记录上执行的单个操作。将创建RDD的一系列Lineage（血统）记录下来，以便恢复丢失的分区。RDD的Lineage会记录RDD的元数据信息和转换行为，当该RDD的部分分区数据丢失时，它可以根据这些信息来重新运算和恢复丢失的数据分区。
val fileRDD: RDD[String] = sc.textFile("input/1.txt") println(fileRDD.toDebugString) println("----------------------") val wordRDD: RDD[String] = fileRDD.flatMap(_.split(" ")) println(wordRDD.toDebugString) println("----------------------") val mapRDD: RDD[(String, Int)] = wordRDD.map((_,1)) println(mapRDD.toDebugString) println("----------------------") val resultRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_) println(resultRDD.toDebugString) resultRDD.collect() （2）RDD 依赖关系
这里所谓的依赖关系，其实就是两个相邻RDD之间的关系
val sc: SparkContext = new SparkContext(conf) val fileRDD: RDD[String] = sc.textFile("input/1.txt") println(fileRDD.dependencies) println("----------------------") val wordRDD: RDD[String] = fileRDD.flatMap(_.split(" ")) println(wordRDD.dependencies) println("----------------------") val mapRDD: RDD[(String, Int)] = wordRDD.map((_,1)) println(mapRDD.dependencies) println("----------------------") val resultRDD: RDD[(String, Int)] = mapRDD.reduceByKey(_+_) println(resultRDD.dependencies) resultRDD.collect() （3）RDD 窄依赖
窄依赖表示每一个父(上游)RDD的Partition最多被子（下游）RDD的一个Partition使用，
窄依赖我们形象的比喻为独生子女。
class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd) （4）RDD 宽依赖
宽依赖表示同一个父（上游）RDD的Partition被多个子（下游）RDD的Partition依赖，会引起Shuffle，总结：宽依赖我们形象的比喻为多生。
（5）RDD 阶段划分
DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向，不会闭环。
（6）RDD 阶段划分源码
try { // New stage creation may throw an exception if, for example, jobs are run on a // HadoopRDD whose underlying HDFS files have been deleted. finalStage = createResultStage(finalRDD, func, partitions, jobId, callSite) } catch { case e: Exception => logWarning("Creating new stage failed due to exception - job: " + jobId, e) listener.jobFailed(e) return } …… private def createResultStage( rdd: RDD[_], func: (TaskContext, Iterator[_]) => _, partitions: Array[Int], jobId: Int, callSite: CallSite): ResultStage = { val parents = getOrCreateParentStages(rdd, jobId) val id = nextStageId.getAndIncrement() val stage = new ResultStage(id, rdd, func, partitions, parents, jobId, callSite) stageIdToStage(id) = stage updateJobIdStageIdMaps(jobId, stage) stage } …… private def getOrCreateParentStages(rdd: RDD[_], firstJobId: Int): List[Stage] = { getShuffleDependencies(rdd).map { shuffleDep => getOrCreateShuffleMapStage(shuffleDep, firstJobId) }.toList } …… private[scheduler] def getShuffleDependencies( rdd: RDD[_]): HashSet[ShuffleDependency[_, _, _]] = { val parents = new HashSet[ShuffleDependency[_, _, _]] val visited = new HashSet[RDD[_]] val waitingForVisit = new Stack[RDD[_]] waitingForVisit.push(rdd) while (waitingForVisit.nonEmpty) { val toVisit = waitingForVisit.pop() if (!visited(toVisit)) { visited += toVisit toVisit.dependencies.foreach { case shuffleDep: ShuffleDependency[_, _, _] => parents += shuffleDep case dependency => waitingForVisit.push(dependency.rdd) } } } parents } （7）RDD 任务划分
RDD任务切分中间分为：Application、Job、Stage和Task
- Application：初始化一个SparkContext即生成一个Application；
- Job：一个Action算子就会生成一个Job；
- Stage：Stage 等于宽依赖(ShuffleDependency)的个数加1；
- Task：一个Stage阶段中，最后一个RDD的分区个数就是Task的个数。
注意：Application->Job->Stage->Task 每一层都是 1 对 n 的关系。
（8）RDD 任务划分源码
val tasks: Seq[Task[_]] = try { stage match { case stage: ShuffleMapStage => partitionsToCompute.map { id => val locs = taskIdToLocations(id) val part = stage.rdd.partitions(id) new ShuffleMapTask(stage.id, stage.latestInfo.attemptId, taskBinary, part, locs, stage.latestInfo.taskMetrics, properties, Option(jobId), Option(sc.applicationId), sc.applicationAttemptId) } case stage: ResultStage => partitionsToCompute.map { id => val p: Int = stage.partitions(id) val part = stage.rdd.partitions(p) val locs = taskIdToLocations(id) new ResultTask(stage.id, stage.latestInfo.attemptId, taskBinary, part, locs, id, properties, stage.latestInfo.taskMetrics, Option(jobId), Option(sc.applicationId), sc.applicationAttemptId) } } …… val partitionsToCompute: Seq[Int] = stage.findMissingPartitions() …… override def findMissingPartitions(): Seq[Int] = { mapOutputTrackerMaster .findMissingPartitions(shuffleDep.shuffleId) .getOrElse(0 until numPartitions) } RDD 持久化
- RDD Cache 缓存
RDD 通过 Cache 或者 Persist 方法将前面的计算结果缓存，默认情况下会把数据以缓存在 JVM 的堆内存中。但是并不是这两个方法被调用时立即缓存，而是触发后面的 action 算子时，该 RDD 将会被缓存在计算节点的内存中，并供后面重用
// cache 操作会增加血缘关系，不改变原有的血缘关系 println(wordToOneRdd.toDebugString) // 数据缓存。 wordToOneRdd.cache() // 可以更改存储级别 //mapRdd.persist(StorageLevel.MEMORY_AND_DISK_2) 存储级别
Spark 会自动对一些 Shuffle 操作的中间数据做持久化操作(比如：reduceByKey)。这样做的目的是为了当一个节点 Shuffle 失败了避免重新计算整个输入。但是，在实际使用的时候，如果想重用数据，仍然建议调用 persist 或 cache
- RDD CheckPoint 检查点
所谓的检查点其实就是通过将 RDD 中间结果写入磁盘
由于血缘依赖过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果检查点之后有节点出现问题，可以从检查点开始重做血缘，减少了开销。
对 RDD 进行 checkpoint 操作并不会马上被执行，必须执行 Action 操作才能触发
// 设置检查点路径 sc.setCheckpointDir("./checkpoint1") // 创建一个 RDD，读取指定位置文件:hello atguigu atguigu val lineRdd: RDD[String] = sc.textFile("input/1.txt") // 业务逻辑 val wordRdd: RDD[String] = lineRdd.flatMap(line => line.split(" ")) val wordToOneRdd: RDD[(String, Long)] = wordRdd.map { word => { (word, System.currentTimeMillis()) } } // 增加缓存,避免再重新跑一个 job 做 checkpoint wordToOneRdd.cache() // 数据检查点：针对 wordToOneRdd 做检查点计算 wordToOneRdd.checkpoint() // 触发执行逻辑 wordToOneRdd.collect().foreach(println) - 缓存和检查点区别
1）Cache 缓存只是将数据保存起来，不切断血缘依赖。Checkpoint 检查点切断血缘依赖。
2）Cache 缓存的数据通常存储在磁盘、内存等地方，可靠性低。Checkpoint 的数据通常存储在 HDFS 等容错、高可用的文件系统，可靠性高。
3）建议对 checkpoint()的 RDD 使用 Cache 缓存，这样 checkpoint 的 job 只需从 Cache 缓存中读取数据即可，否则需要再从头计算一次 RDD
RDD 分区器
Spark 目前支持 Hash 分区和 Range 分区，和用户自定义分区。Hash 分区为当前的默认分区。分区器直接决定了 RDD 中分区的个数、RDD 中每条数据经过 Shuffle 后进入哪个分区，进而决定了 Reduce 的个数。
Hash 分区：对于给定的 key，计算其 hashCode,并除以分区个数取余
class HashPartitioner(partitions: Int) extends Partitioner { require(partitions >= 0, s"Number of partitions ($partitions) cannot be negative.") def numPartitions: Int = partitions def getPartition(key: Any): Int = key match { case null => 0 case _ => Utils.nonNegativeMod(key.hashCode, numPartitions) } override def equals(other: Any): Boolean = other match { case h: HashPartitioner => h.numPartitions == numPartitions case _ => false } override def hashCode: Int = numPartitions }Range 分区：将一定范围内的数据映射到一个分区中，尽量保证每个分区数据均匀，而
且分区间有序class RangePartitioner[K : Ordering : ClassTag, V]( partitions: Int, rdd: RDD[_ <: Product2[K, V]], private var ascending: Boolean = true) extends Partitioner { // We allow partitions = 0, which happens when sorting an empty RDD under the default settings. require(partitions >= 0, s"Number of partitions cannot be negative but found $partitions.") private var ordering = implicitly[Ordering[K]] // An array of upper bounds for the first (partitions - 1) partitions private var rangeBounds: Array[K] = { ... } def numPartitions: Int = rangeBounds.length + 1 private var binarySearch: ((Array[K], K) => Int) = CollectionsUtils.makeBinarySearch[K] def getPartition(key: Any): Int = { val k = key.asInstanceOf[K] var partition = 0 if (rangeBounds.length <= 128) { // If we have less than 128 partitions naive search while (partition < rangeBounds.length && ordering.gt(k, rangeBounds(partition))) { partition += 1 } } else { // Determine which binary search method to use only once. partition = binarySearch(rangeBounds, k) // binarySearch either returns the match location or -[insertion point]-1 if (partition < 0) { partition = -partition-1 } if (partition > rangeBounds.length) { partition = rangeBounds.length } } if (ascending) { partition } else { rangeBounds.length - partition } } override def equals(other: Any): Boolean = other match { ... } override def hashCode(): Int = { ... } @throws(classOf[IOException]) private def writeObject(out: ObjectOutputStream): Unit = Utils.tryOrIOException { ... } @throws(classOf[IOException]) private def readObject(in: ObjectInputStream): Unit = Utils.tryOrIOException { ... } }用户自定义分区
import org.apache.spark.{Partitioner, SparkConf, SparkContext} object Spark01_RDD_part { def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD") val sc = new SparkContext(sparkConf) val rdd = sc.makeRDD(List( ("nba", "xxxxxxxxxxxx"), ("cba", "xxxxxxxxxxxx"), ("wnba", "xxxxxxxxxxxx"), ("nba", "xxxxxxxxxxxx") )) val partRDD = rdd.partitionBy(new MyPartitioner) partRDD.saveAsTextFile("output") sc.stop() } /** * 自定义分区器 * 1、继承Partitioner * 2、重写方法 */ class MyPartitioner extends Partitioner { // 分区数量 override def numPartitions: Int = 3 // 根据数据的key值, 返回数据的分区索引（从0开始） override def getPartition(key: Any): Int = { key match { case "nba" => 0 case "cba" => 1 case _ => 2 } } } }
RDD 文件读取与保存
Spark 的数据读取及数据保存可以从两个维度来作区分：文件格式以及文件系统。
- 文件格式分为：text 文件、csv 文件、sequence 文件以及 Object 文件；
- 文件系统分为：本地文件系统、HDFS、HBASE 以及数据库。
text 文件
// 读取输入文件 val inputRDD: RDD[String] = sc.textFile("input/1.txt") // 保存数据 inputRDD.saveAsTextFile("output")sequence 文件
SequenceFile 文件是 Hadoop 用来存储二进制形式的 key-value 对而设计的一种平面文件(Flat File)。在 SparkContext 中，可以调用 sequenceFile[keyClass, valueClass](path)。 // 保存数据为 SequenceFile dataRDD.saveAsSequenceFile("output") // 读取 SequenceFile 文件 sc.sequenceFile[Int,Int]("output").collect().foreach(println)object 对象文件
对象文件是将对象序列化后保存的文件，采用 Java 的序列化机制。可以通过 objectFile[T: ClassTag](path)函数接收一个路径，读取对象文件，返回对应的 RDD，也可以通过调用saveAsObjectFile()实现对对象文件的输出。因为是序列化所以要指定类型。// 保存数据 dataRDD.saveAsObjectFile("output") // 读取数据 sc.objectFile[Int]("output").collect().foreach(println)
累加器
实现原理
累加器用来把 Executor 端变量信息聚合到 Driver 端。在 Driver 程序中定义的变量，在Executor 端的每个 Task 都会得到这个变量的一份新的副本，每个 task 更新这些副本的值后，传回 Driver 端进行 merge。
基础编程
系统累加器
val rdd = sc.makeRDD(List(1,2,3,4,5)) // 声明累加器 var sum = sc.longAccumulator("sum"); rdd.foreach( num => { // 使用累加器 sum.add(num) } ) // 获取累加器的值 println("sum = " + sum.value) 自定义累加器
import org.apache.spark.util.AccumulatorV2 import org.apache.spark.{SparkConf, SparkContext} import scala.collection.mutable object Spark04_Acc_WordCount { def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD") val sc = new SparkContext(sparkConf) val rdd = sc.makeRDD(List("hello", "spark", "hello", "scala")) // 累加器 : wordcount // 创建累加器对象 val wcAcc = new MyAccumulator // 向spark进行注册 sc.register(wcAcc, "wordcountAcc") rdd.foreach( word => { // 数据的累加 (使用累加器) wcAcc.add(word) } ) // 获取累加器的结果 println(wcAcc.value) sc.stop() } /** * 自定义累加器 : wordcount * 1、继承AccumulatorV2, 定义泛型 * IN : 累加器输入的数据类型 String * OUT : 累加器返回的数据类型 Map * * 2、重写方法 */ class MyAccumulator extends AccumulatorV2[String, mutable.Map[String, Long]] { private var wcMap = mutable.Map[String, Long]() // 判断是否为初始状态 override def isZero: Boolean = { wcMap.isEmpty } override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = { new MyAccumulator } override def reset(): Unit = { wcMap.clear() } // 获取累加器需要计算的值 override def add(word: String): Unit = { val newCnt = wcMap.getOrElse(word, 0L) + 1 wcMap.update(word, newCnt) } // 合并累加器 override def merge(other: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = { val map1 = this.wcMap val map2 = other.value map2.foreach { case (word, count) => { val newCount = map1.getOrElse(word, 0L) + count map1.update(word, newCount) } } } // 累加器结果 override def value: mutable.Map[String, Long] = { wcMap } } } 广播变量
实现原理
广播变量用来高效分发较大的对象。向所有工作节点发送一个较大的只读值，以供一个或多个 Spark 操作使用。比如，如果你的应用需要向所有节点发送一个较大的只读查询表，广播变量用起来都很顺手。在多个并行操作中使用同一个变量，但是Spark 会为每个任务分别发送。
基础编程
import org.apache.spark.{SparkConf, SparkContext} import scala.collection.mutable object Spark02_Bc { def main(args: Array[String]): Unit = { val sparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD") val sc = new SparkContext(sparkConf) val rdd1 = sc.makeRDD(List( ("a", 1), ("b", 2), ("c", 3) )) val map = mutable.Map(("a", 4), ("b", 5), ("c", 6)) // 封装广播变量 val bc = sc.broadcast(map) rdd1.map { case (w, c) => { // 使用广播变量 val l = bc.value.getOrElse(w, 0) (w, (c, l)) } }.collect().foreach(println) sc.stop() } } 