RDD方法又称为RDD算子
RDD转换算子
RDD 根据数据处理方式的不同将算子整体上分为Value 类型、双 Value 类型和Key-Value类型。
一、单Value类型（一个数据源）
1. map函数
函数签名：def map[U: ClassTag](f: T => U): RDD[U]
函数说明：将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。
示例：
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark_RDD_Operator_Transform {
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))
// 1,2,3,4 => 2,4,6,8
def mapFunction(num:Int): Int = {
num * 2
}
//转换算子，将一个旧的RDD加上(num * 2)获得一个新的RDD
val mapRDD: RDD[Int] = rdd.map(mapFunction)
mapRDD.collect().foreach(println)
sc.stop()
}
}1.1 小功能：从服务器日志数据 apache.log 中获取用户请求URL 资源路径
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark_RDD_Operator_Transform_Test {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = map
val rdd = sc.textFile("datas/apache.log")
//长字符串 =>短字符串
val mapRDD: RDD[String] = rdd.map(
line => {
val datas = line.split(" ")
datas(6)
}
)
mapRDD.collect().foreach(println)
sc.stop()
}
}补充：分区内有序执行，分区外无序执行。
2. mapPartitions函数
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark02_RDD_Operator_Transform {
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)
//mapPartitions可以以分区为单位进行转换操作
//但是会将整个分区的数据加载到内存进行引用
//如果处理完的数据是不会被释放掉，存在对象的引用。
//在内存较小，数据量较大的场合下，容易出现内存溢出。
val mpRDD: RDD[Int] = rdd.mapPartitions(
iter => {
println(">>>>>>>>>>>>>")
iter.map(_ * 2)
}
)
mpRDD.collect().foreach(println)
sc.stop()
}
}函数签名：
def mapPartitions[U: ClassTag]( f: Iterator[T] => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
函数说明：将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。
2.1 获取每个数据分区的最大值。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark02_RDD_Operator_Transform_test {
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)
//[1,2],[3,4]两个分区
//mapPartitions因为是以分区为单位，所以可以获得每个分区的最大值：[2],[4]
val mpRDD = rdd.mapPartitions(
iter => {
List(iter.max).iterator
}
)
mpRDD.collect().foreach(println)
sc.stop()
}
}2.2 map和mapPartitions的区别：
- 数据处理角度：Map 算子是分区内一个数据一个数据的执行，类似于串行操作。而 mapPartitions 算子是以分区为单位进行批处理操作。
- 功能角度：Map 算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions 算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变， 所以可以增加或减少数据。
- 性能角度： Map 算子因为类似于串行操作，所以性能比较低，而是 mapPartitions 算子类似于批处理，所以性能较高。但是mapPartitions 算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用 map 操作。
3. mapPartitionsWithIndex函数
函数签名：
def mapPartitionsWithIndex[U: ClassTag]( f: (Int, Iterator[T]) => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
函数说明：将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。
3.1 小功能：获取第二个数据分区的数据
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark03_RDD_Operator_Transform {
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)
//[1,2],[3,4],保留第二个数据
val mpiRDD = rdd.mapPartitionsWithIndex(
(index,iter) => {
if(index == 1) {
iter
} else {
Nil.iterator
}
}
)
mpiRDD.collect().foreach(println)
sc.stop()
}
}4. flatMap函数
函数签名：def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
函数说明：将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark04_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = map
val rdd:RDD[List[Int]] = sc.makeRDD(List(
List(1,2),List(3,4)
))
//想要的最终结果是把1,2,3,4独立拿出来使用
val flatRDD: RDD[Int] = rdd.flatMap(
list => {
list
}
)
flatRDD.collect().foreach(println)
sc.stop()
}
}4.1 小功能：将 List(List(1,2),3,List(4,5))进行扁平化操作
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark04_RDD_Operator_Transform1 {
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(List(1,2),3,List(4,5)))
//小功能：将 List(List(1,2),3,List(4,5))进行扁平化操作
//因为数据有不同的类型，进行模式匹配：case
val flatRDD = rdd.flatMap(
data => {
data match {
case list: List[_] => list
case dat => List(dat)
}
}
)
flatRDD.collect().foreach(println)
sc.stop()
}
}5. glom方法
函数签名：def glom(): RDD[Array[T]]
函数说明：将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark05_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = glom
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
//list => int
//int => array
val glomRDD: RDD[Array[Int]] = rdd.glom()
glomRDD.collect().foreach(data => println(data.mkString(",")))
//将一个分区的数据形成一个数组
sc.stop()
}
}5.1 小功能：计算所有分区最大值求和（分区内取最大值，分区间最大值求和）
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark05_RDD_Operator_Transform_test {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = glom
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
//[1,2],[3,4]
//计算所有分区最大值求和（分区内取最大值，分区间最大值求和）
//最大值：[2],[4],
// 分区间求和：[6]
val glomRDD: RDD[Array[Int]] = rdd.glom()
val maxRDD: RDD[Int] = glomRDD.map(
Array => {
Array.max
}
)
println(maxRDD.collect().sum)
//将一个分区的数据形成一个数组
sc.stop()
}
}6. groupBy方法
函数签名：def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
函数说明：将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中。一个组的数据在一个分区中，但是并不是说一个分区中只有一个组。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark06_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = groupBy
//实现分组
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4),2)
/*
groupBy会将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组
相同的key值的数据会放置在同一个组中
*/
def groupFunction(num:Int) = {
num % 2
}
val groupRDD: RDD[(Int,Iterable[Int])] = rdd.groupBy(groupFunction)
groupRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(0,CompactBuffer(2, 4))
(1,CompactBuffer(1, 3))
余数是0的放在一起，余数是1的放在一起。
*/6.1 小功能：将 List("Hello", "hive", "hbase", "Hadoop")根据单词首写字母进行分组。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark06_RDD_Operator_Transform_1 {
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", "hive", "hbase", "Hadoop"),2)
/*
groupBy会将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组
相同的key值的数据会放置在同一个组中
*/
val groupRDD = rdd.groupBy(_.charAt(0))
groupRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(h,CompactBuffer(hive, hbase))
(H,CompactBuffer(Hello, Hadoop))
*/7. filter函数
函数签名：def filter(f: T => Boolean): RDD[T]
函数说明：将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark07_RDD_Operator_Transform {
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()
}
}
/*
结果：
1
3
*/7.1 小功能：从服务器日志数据 apache.log 中获取 2015 年 5 月 17 日的请求路径
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark07_RDD_Operator_Transform_test {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = filter
//实现分组
val rdd = sc.textFile("datas/apache.log")
//从服务器日志数据 apache.log 中获取 2015 年 5 月 17 日的请求路径
rdd.filter(
line => {
val datas = line.split(" ")
datas
val time = datas(3)
time.startsWith("17/05/2015")
}
).collect().foreach(println)
sc.stop()
}
}8. sample函数
函数签名：
def sample( withReplacement: Boolean, fraction: Double,
seed: Long = Utils.random.nextLong): RDD[T]
函数说明：根据指定的规则从数据集中抽取数据。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark08_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = sample
//实现分组
val rdd = sc.makeRDD(List(1,2,3,4,5,6,7,8,9,10))
//实现：根据指定的规则从数据集中抽取数据
/*
sample有三个参数：
1. 表示抽取数据是否放回
2.表示每条数据可能被抽取的概率
如果抽取不放回，该参数代表数据源中每条数据被抽取的概率
如果抽取放回，该参数代表数据源中的每条数据被抽取的可能次数
2.1 基准值的概念：
3.表示抽取的数据的随机算法的种子
3.1 如果不传递第三个参数，那么使用的是当前系统时间
*/
println(rdd.sample(
true,
//0.4,
1
).collect().mkString(","))
sc.stop()
}
}
/*
结果：
4,8,8,9
多次运行会发现，该随机数是伪随机，就是多次的结果一样
也就是第二个参数确定，则随机种子就确定，值确定
*/用途：来检验数据倾斜是由于哪些数据造成的。
9. distinct函数
函数签名：
def distinct()(implicit ord: Ordering[T] = null): RDD[T]
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
函数说明：将数据集中重复的数据去重。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark09_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = sample
//实现分组
val rdd = sc.makeRDD(List(1,2,3,4,1,2,3,4))
//实现：将数据集中重复的数据去重
val rdd1: RDD[Int] = rdd.distinct()
rdd1.collect().foreach(println)
sc.stop()
}
}
/*
结果：
1,2,3,4
*/10. coalesce函数
函数签名：
def coalesce(numPartitions: Int, shuffle: Boolean = false,
partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null)
: RDD[T]
函数说明：根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率，当 spark 程序中，存在过多的小任务的时候，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark10_RDD_Operator_Transform {
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处理,也就是将第二个参数改成true
*/
val newRDD: RDD[Int] = rdd.coalesce(2,true)
newRDD.saveAsTextFile("output")
sc.stop()
}
}
/*
结果：
*/11. reparation函数
函数签名：def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
函数说明：该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true。无论是将分区数多的RDD 转换为分区数少的RDD，还是将分区数少的 RDD 转换为分区数多的RDD，repartition 操作都可以完成，因为无论如何都会经 shuffle 过程。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark11_RDD_Operator_Transform {
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)
//实现：扩大分区
/*
底层代码就是用的coalesce
*/
val newRDD: RDD[Int] = rdd.repartition(3)
newRDD.saveAsTextFile("output")
sc.stop()
}
}
/*
结果：
*/12. sortBy
函数说明：该操作用于排序数据。在排序之前，可以将数据通过 f 函数进行处理，之后按照 f 函数处理的结果进行排序，默认为升序排列。排序后新产生的 RDD 的分区数与原RDD 的分区数一致。中间存在 shuffle 的过程。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark12_RDD_Operator_Transform {
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(6,5,4,3,2,1),2)
val newRDD: RDD[Int] = rdd.sortBy(num => num)
newRDD.saveAsTextFile("output")
sc.stop()
}
}
/*
结果：
*/二、双Value类型（两个数据源）
13. intersection函数（交集）
函数签名：def intersection(other: RDD[T]): RDD[T]
函数说明：对源RDD 和参数RDD 求交集后返回一个新的RDD，求交集。
14. union函数（并集）
函数签名：def union(other: RDD[T]): RDD[T]
函数说明：对源RDD 和参数RDD 求并集后返回一个新的RDD，求并集。
15. subtract函数（差集）
函数签名：def subtract(other: RDD[T]): RDD[T]
函数说明：以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集。
16. zip函数（拉链）
函数签名：def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]
函数说明：将两个 RDD 中的元素，以键值对的形式进行合并。其中，键值对中的Key 为第 1 个 RDD中的元素，Value 为第 2 个 RDD 中的相同位置的元素。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark13_RDD_Operator_Transform {
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))
//交集 [3,4]
val rdd3: RDD[Int] = rdd1.intersection(rdd2)
println(rdd3.collect().mkString(","))
//并集 [1,2,3,4,3,4,5,6]
val rdd4: RDD[Int] = rdd1.union(rdd2)
println(rdd4.collect().mkString(","))
//差集 [1,2]
val rdd5: RDD[Int] = rdd1.subtract(rdd2)
println(rdd5.collect().mkString(","))
//拉链 [1-3,2-4,3-5,4-6]
val rdd6: RDD[(Int,Int)] = rdd1.zip(rdd2)
println(rdd6.collect().mkString(","))
sc.stop()
}
}
/*
结果：
*/- 交集并集差集要求两个数据源的数据类型保存一致。
- 拉链操作两个数据源类型可以不一致，但要求两个数据源的分区数量保持一致，并且每一个分区数据数量要相同。
三、Key-Value类型
17. partitionBy函数
函数签名：def partitionBy(partitioner: Partitioner): RDD[(K, V)]
函数说明：将数据按照指定Partitioner 重新进行分区。Spark 默认的分区器是HashPartitioner。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}
object Spark17_RDD_Operator_Transform {
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))
//partitionBy根据指定的分区规则对数据进行重分区
mapRDD.partitionBy(new HashPartitioner(2)).saveAsTextFile("output")
//该方法是在PairRDDFunctions里面的
//隐式转换（二次编译），将一个类型变成另外一个类型
sc.stop()
}
}
/*
结果：
(2,1)
(4,1)
(1,1)
(3,1)
*/18. reduceByKey
函数签名：def reduceByKey(func: (V, V) => V): RDD[(K, V)]
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
函数说明：可以将数据按照相同的Key 对Value 进行聚合。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}
object Spark18_RDD_Operator_Transform {
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(
("a",1),("a",2),("a",3),("b",4)
))
//reduceByKey:相同的Key进行value操作
//scala中的菊科一般都是两两聚合，spark基于scala开发的，所以它也是两两聚合
val reduceRDD = rdd.reduceByKey((x: Int, y: Int) => {
x + y
})
//reduceByKey中如果key的数据只有一个，则不会参与运算。
reduceRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(a,6)
(b,4)
*/19. groupByKey函数
函数说明：将数据源的数据根据 key 对 value 进行分组。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark19_RDD_Operator_Transform {
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(
("a",1),("a",2),("a",3),("b",4)
))
//groupByKey:将相同数据源中的数据，相同key的数据放在一个组中，形成一个对偶元组
// 元组中的第一个元素就是key，第二个元素就是相同key的value的集合
val groupRDD = rdd.groupByKey()
groupRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(a,CompactBuffer(1, 2, 3))
(b,CompactBuffer(4))
*/19.1 reduceByKey 和 groupByKey 的区别？
- 从 shuffle 的角度：reduceByKey 和 groupByKey 都存在 shuffle 的操作，但是reduceByKey 可以在 shuffle 前对分区内相同 key 的数据进行预聚合（combine）功能，这样会减少落盘的数据量，而groupByKey 只是进行分组，不存在数据量减少的问题，reduceByKey 性能比较高。
- spark中，shuffle操作必须落盘处理（就是存到文件当中进行等待），不能在内存中进行数据等待，会导致内存溢出。
- 从功能的角度：reduceByKey 其实包含分组和聚合的功能。GroupByKey 只能分组，不能聚合，所以在分组聚合的场合下，推荐使用 reduceByKey，如果仅仅是分组而不需要聚合。那么还是只能使用groupByKey。
20. aggregateByKey函数
函数说明：将数据根据不同的规则进行分区内计算和分区间计算。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark20_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-aggregateByKey
val rdd = sc.makeRDD(List(
("a",1),("a",2),("a",3),("a",4)
),2)
//分区内相同的key求最大值，分区间相同的key求和
//aggregateByKey存在参数的柯里化
//第一个参数列表：需要传递一个参数，表示为初始值
// 主要用于当碰见第一个key的时候，和value进行分区内的计算
//第二个参数列表：需要传递两个参数
// 第一个参数表示分区内计算规则
// 第二个参数表示分区间计算规则
rdd.aggregateByKey(0)(
(x,y) => math.max(x,y),
(x,y) => x+y
).collect().foreach(println)
sc.stop()
}
}
/*
结果：
(a,6)
*/20.1 求数据平均值
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark20_RDD_Operator_Transform_test {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-aggregateByKey
val rdd = sc.makeRDD(List(
("a",1),("a",2),("b",3),
("b",4),("b",5),("a",6)
),2)
//获取相同key的数据的平均值
val newRDD = rdd.aggregateByKey((0, 0))(
(t, v) => {
(t._1 + v, t._2 + 1)
},
(t1, t2) => {
(t1._1 + t2._1, t1._2 + t2._2)
}
)
val resRDD = newRDD.mapValues {
case (num, cnt) => {
num / cnt
}
}
resRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(b,4)
(a,3)
*/21. foldByKey函数
函数说明：当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为foldByKey。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark21_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-foldByKey
val rdd = sc.makeRDD(List(
("a",1),("a",2),("b",3),
("b",4),("b",5),("a",6)
),2)
//如果聚合计算时，分区内和分区间计算规则相同，spark提供了简化的方法foldByKey
rdd.foldByKey(0)(_+_).collect().foreach(println)
sc.stop()
}
}
/*
结果：
(b,12)
(a,9)
*/22. combineByKey函数
函数说明：最通用的对key-value 型 rdd 进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark22_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-combineByKey
val rdd = sc.makeRDD(List(
("a",1),("a",2),("b",3),
("b",4),("b",5),("a",6)
),2)
//获取相同key的数据的平均值
/*
combineByKey方法需要三个参数:
第一个参数：将相同key的第一个数据进行结构的转换，实现操作
第二个参数：分区内的计算规则
第三个参数：分区间的计算规则
*/
val newRDD = rdd.combineByKey(
v =>(v,1),
(t:(Int,Int), v) => {
(t._1 + v, t._2 + 1)
},
(t1:(Int,Int), t2:(Int,Int)) => {
(t1._1 + t2._1, t1._2 + t2._2)
}
)
val resRDD = newRDD.mapValues {
case (num, cnt) => {
num / cnt
}
}
resRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(b,4)
(a,3)
*/思考：reduceByKey、foldByKey、aggregateByKey、combineByKey 的区别
- reduceByKey: 相同 key 的第一个数据不进行任何计算，分区内和分区间计算规则相同。
- FoldByKey: 相同 key 的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同。
- AggregateByKey：相同 key 的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同。
- CombineByKey:当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。
24. join函数
函数签名：def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]。
函数说明：在类型为(K,V)和(K,W)的RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的RDD。
将两个数据源中的数据相同的key连接在一起。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark24_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-combineByKey
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 resRDD = rdd1.join(rdd2)
resRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(a,(1,4))
(b,(2,5))
(c,(3,6))
*/25. leftOuterJoin函数
函数签名：def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
函数说明：类似于 SQL 语句的左外连接。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark25_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-combineByKey
val rdd1 = sc.makeRDD(List(
("a",1),("b",2),("c",3)
))
val rdd2 = sc.makeRDD(List(
("a",4),("b",5)//,("c",6)
))
val resRDD = rdd1.leftOuterJoin(rdd2)
//val rightRDD = rdd1.rightOuterJoin(rdd2)
resRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(a,(1,Some(4)))
(b,(2,Some(5)))
(c,(3,None))
*/26. rightOuterJoin函数
函数说明：类似于 SQL 语句的右外连接。
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark25_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-combineByKey
val rdd1 = sc.makeRDD(List(
("a",1),("b",2)//,("c",3)
))
val rdd2 = sc.makeRDD(List(
("a",4),("b",5),("c",6)
))
//val resRDD = rdd1.leftOuterJoin(rdd2)
val rightRDD = rdd1.rightOuterJoin(rdd2)
rightRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(a,(Some(1),4))
(b,(Some(2),5))
(c,(None,6))
*/27. cogroup函数
函数说明：在类型为(K,V)和(K,W)的RDD 上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的 RDD。
可以实现分组+连接：
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.{SparkConf, SparkContext}
object Spark27_RDD_Operator_Transform {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 算子 = Key-Value类型-combineByKey
val rdd1 = sc.makeRDD(List(
("a",1),("b",2)//,("c",3)
))
val rdd2 = sc.makeRDD(List(
("a",4),("b",5),("c",6),("c",6)
))
/*
cogroup:connect+group,连接+分组
*/
val coRDD = rdd1.cogroup(rdd2)
coRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(a,(CompactBuffer(1),CompactBuffer(4)))
(b,(CompactBuffer(2),CompactBuffer(5)))
(c,(CompactBuffer(),CompactBuffer(6, 6)))
*/算子案例实操
package cn.gfs.sparkCore.rdd.operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}
object Spark_final_RDD_Req {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
// TODO 案例实操
/*
数据准备：时间戳，省份，城市，用户，广告，中间字段使用空格分隔。
需求描述：统计出每一个省份每个广告被点击数量排行的 Top3
*/
//思路设计：
//1. 获取原始数据
val dataRDD = sc.textFile("datas/agent.log")
//2. 将原始数据进行结构的转换，方便统计：((省份，广告)，1)
val mapRDD = dataRDD.map(
line => {
val datas = line.split(" ")
((datas(1), datas(4)), 1)
}
)
//3. 将转换后的数据进行分组聚合：((省份，广告)，sun)
val reduceRDD: RDD[((String,String),Int)] = mapRDD.reduceByKey(_+_)
//4. 将聚合的结果进行结构的转换：(省份，(广告，sum))
val newmapRDD = reduceRDD.map{
case ((prv,ad),sum) =>{
(prv,(ad,sum))
}
}
//5. 将转换后的数据根据省份进行分组：(省份，((广告A，sum)，(广告B，sum)))
val groupRDD = newmapRDD.groupByKey()
//6. 将分组后的数据进行组内排序，降序取前三
val resultRDD = groupRDD.mapValues(
iter => {
iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
}
)
//7. 采集数据，打印控制台
resultRDD.collect().foreach(println)
sc.stop()
}
}
/*
结果：
(4,List((12,25), (2,22), (16,22)))
(8,List((2,27), (20,23), (11,22)))
(6,List((16,23), (24,21), (22,20)))
(0,List((2,29), (24,25), (26,24)))
(2,List((6,24), (21,23), (29,20)))
(7,List((16,26), (26,25), (1,23)))
(5,List((14,26), (21,21), (12,21)))
(9,List((1,31), (28,21), (0,20)))
(3,List((14,28), (28,27), (22,25)))
(1,List((3,25), (6,23), (5,22)))
*/RDD行动算子
行动算子就是触发整个计算的执行。
底层代码调用的是环境对象的runjob方法，底层代码中会创建ActionJob，并提交执行。
1. reduce方法
函数签名：def reduce(f: (T, T) => T): T
函数说明：聚集RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据。（求和）
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark01_RDD_Operator_Action {
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 - 行动算子： reduce
val reRDD = rdd.reduce(_ + _)
println(reRDD)
sc.stop()
}
}
/*
结果：
10
*/2. collect方法
函数签名：def collect(): Array[T]
函数说明：在驱动程序中，以数组Array 的形式返回数据集的所有元素。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark02_RDD_Operator_Action {
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 - 行动算子：
//collect:会将不同分区的数据按照分区顺序采集回来，形成数组
val reRDD = rdd.collect()
println(reRDD.mkString(","))
sc.stop()
}
}
/*
结果：
1,2,3,4
*/3. count方法
函数说明：返回RDD 中元素的个数。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark03_RDD_Operator_Action {
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 - 行动算子：
val reRDD = rdd.count()
println(reRDD)
sc.stop()
}
}
/*
结果：
4
*/4. first方法
函数说明：返回RDD 中的第一个元素。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark04_RDD_Operator_Action {
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 - 行动算子：
//first:获取数据源中的第一个
val reRDD = rdd.first()
println(reRDD)
sc.stop()
}
}
/*
结果：
1
*/5. take方法
函数说明：返回一个由RDD 的前 n 个元素组成的数组。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark05_RDD_Operator_Action {
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 - 行动算子：
//take:取多少个
val reRDD = rdd.take(3)
println(reRDD.mkString(","))
sc.stop()
}
}
/*
结果：
1,2,3
*/6. takeOrdered方法
函数说明：返回该 RDD 排序后的前 n 个元素组成的数组。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark06_RDD_Operator_Action {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
val rdd = sc.makeRDD(List(4,2,3,1))
//TODO - 行动算子：
//takeOrderd:先进行排序，再取多少个
val reRDD = rdd.takeOrdered(3)
println(reRDD.mkString(","))
sc.stop()
}
}
/*
结果：
1,2,3
*/7. aggregate方法
函数说明：分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark07_RDD_Operator_Action {
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 - 行动算子：
val reRDD = rdd.aggregate(0)(_+_,_+_)
println(reRDD)
sc.stop()
}
}
/*
结果：
10
*/8. fold方法
函数说明：折叠操作，aggregate 的简化版操作。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark08_RDD_Operator_Action {
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:分区内和分区间计算规则相同
val reRDD = rdd.fold(10)(_+_)
println(reRDD)
sc.stop()
}
}
/*
结果：
40
*/9. countByKey方法
函数说明：统计每种 key 的个数。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark09_RDD_Operator_Action {
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,1,1,4),2)
//TODO - 行动算子：
//countByValue:每个值出现几次
//val reRDD = rdd.countByValue()
//countByKey:
val rdd = sc.makeRDD(List(("a",1),("a",1),("a",1),("b",1)),2)
val countRDD = rdd.countByKey()
println(countRDD)
sc.stop()
}
}
/*
结果：
countByValue:List(1,2,3,4)
Map(4 -> 1, 2 -> 1, 1 -> 1, 3 -> 1)
countByKey
Map(b -> 1, a -> 3)
*/10. save相关算子
函数说明：将数据保存到不同格式的文件中。
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark10_RDD_Operator_Action {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
val sc = new SparkContext(sparkConf)
//countByKey:
val rdd = sc.makeRDD(List(("a",1),("a",1),("a",1),("b",1)),2)
rdd.saveAsTextFile("output")
rdd.saveAsObjectFile("output1")
//saveAsSequenceFile这个方法要求数据的格式必须为k-v类型
rdd.saveAsSequenceFile("output2")
//println(countRDD)
sc.stop()
}
}
/*
结果：
*/11. foreach方法
函数说明： 分布式遍历RDD 中的每一个元素，调用指定函数。
12. 总结：实现wordcount的几种方法
package cn.gfs.sparkCore.rdd.operator.action
import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.mutable
object Spark_RDD_Operator_WordCount {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")
val sc = new SparkContext(sparkConf)
wordcount1(sc)
wordcount2(sc)
wordcount3(sc)
wordcount4(sc)
wordcount5(sc)
wordcount6(sc)
wordcount7(sc)
wordcount8(sc)
sc.stop()
}
//groupBy
def wordcount1(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val group = words.groupBy(word => word)
val wordCount = group.mapValues(iter => iter.size)
}
//groupByKey
def wordcount2(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map((_,1))
val group = wordOne.groupByKey()
val wordCount = group.mapValues(iter => iter.size)
}
//reduceByKey
def wordcount3(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map((_,1))
val wordCount = wordOne.reduceByKey(_ + _)
}
//aggregateByKey
def wordcount4(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map((_,1))
val wordCount = wordOne.aggregateByKey(0)(_+_,_+_)
}
//foldByKey
def wordcount5(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map((_,1))
val wordCount = wordOne.foldByKey(0)(_ + _)
}
//combineByKey
def wordcount6(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map((_,1))
val wordCount = wordOne.combineByKey(
v=>v,
(x:Int,y)=>x+y,
(x:Int,y:Int)=>x+y
)
}
//countByKey
def wordcount7(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
val wordOne = words.map((_,1))
val wordCount = wordOne.countByKey()
}
//countByKey
def wordcount8(sc : SparkContext):Unit = {
val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
val words = rdd.flatMap(_.split(" "))
//val wordOne = words.map((_,1))
val wordCount = words.countByValue()
}
//reduce
// def wordcount9(sc : SparkContext):Unit = {
// val rdd = sc.makeRDD(List("Hello Scala", "Hello Spark"))
// val words = rdd.flatMap(_.split(" "))
// val mapWord = words.map(
// word => {
// mutable.Map[String, Long]((word, 1))
// }
// )
// //val wordOne = words.map((_,1))
// val wordCount = mapWord.reduce(
// (map1,map2) => {
// map2.foreach{
// case (word,count)=>{
// val newCount = map1.getOrElse(word,OL)+count
// map1.update(word,newCount)
// }
// }
// map1
// }
// )
// println(wordCount)
// }
}
/*
结果：
)
*/算子概念回顾
算子：Operator（操作）
RDD的方法和scala集合对象的方法不一样，
集合对象的方法都是在同一个节点的内存中完成的。
RDD的方法可以将计算逻辑分发到Executor端（分布式节点）上执行。
为了区分不同的处理效果，所以将RDD的方法称之为算子。
RDD的方法外部的操作都是在Driver端执行的，而方法内部的逻辑代码是在Executor端执行。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
