RDD
核心属性执行原理RDD创建RDD并行度与分区RDD转换算子
Value 类型
mapmapPartitionsmap 和 mapPartitions 的区别mapPartitionsWithIndexflatMapglomgroupByfiltersampledistinctcoalescerepartitionsortBy 双 Value 类型
intersectionunionsubtractzip Key-Value 类型
partitionByreduceByKeygroupByKeyreduceByKey 和 groupByKey 的区别？aggregateByKeyfoldByKeycombineByKeyreduceByKey、foldByKey、aggregateByKey、combineByKey的区别？sortByKeyjoinleftOuterJoincogroup 案例实 *** RDD行动算子
reducecollectcountfirsttaketakeOrderedaggregatefoldcountByKeysave相关算子foreach RDD序列化
闭包检查序列化方法和属性Kryo序列化框架 RDD依赖关系
RDD 血缘关系RDD 依赖关系RDD 窄依赖RDD 宽依赖RDD 阶段划分RDD 阶段划分源码RDD 任务划分RDD 任务划分源码 RDD持久化
RDD Cache缓存RDD CheckPoint 检查点缓存和检查点区别 RDD分区器RDD文件读取与保存 累加器
实现原理基础编程
系统累加器自定义累加器 广播变量
实现原理基础编程 Spark案例实 ***
Top10热门品类Top10热门品类中每个品类的Top10活跃Session统计页面单跳转换率统计
Spark计算框架为了能够进行高并发和高吞吐的数据处理，封装了三大数据结构，用于处理不同的应用场景
三大数据结构 :
RDD : d性分布式数据集累加器：分布式共享只写变量广播变量：分布式共享只读变量 RDD
RDD（Resilient Distributed Dataset）叫做d性分布式数据集，是Spark中最基本的数据处理模型
代码中是一个抽象类，它代表一个d性的、不可变、可分区、里面的元素可并行计算的集合
d性
存储的d性：内存与磁盘的自动切换
容错的d性：数据丢失可以自动恢复
计算的d性：计算出错重试机制
分片的d性：可根据需要重新分片
分布式：数据存储在大数据集群不同节点上数据集：RDD 封装了计算逻辑，并不保存数据数据抽象：RDD 是一个抽象类，需要子类具体实现不可变：RDD 封装了计算逻辑，是不可以改变的，想要改变，只能产生新的RDD，在新的RDD里面封装计算逻辑可分区、并行计算 核心属性
分区列表
RDD数据结构中存在分区列表，用于执行任务时并行计算，是实现分布式计算的重要属性
protected def getPartitions: Array[Partition]
分区计算函数
Spark在计算时，是使用分区函数对每一个分区进行计算
def compute(split: Partition, context: TaskContext): Iterator[T]
RDD之间的依赖关系
RDD是计算模型的封装，当需求中需要将多个计算模型进行组合时，就需要将多个RDD建立依赖关系
protected def getDependencies: Seq[Dependency[]] = deps
分区器（可选）
当数据为KV类型数据时，可以通过设定分区器自定义数据的分区
@transient val partitioner: Option[Partitioner] = None
首选位置（可选）
计算数据时，可以根据计算节点的状态选择不同的节点位置进行计算
protected def getPreferredLocations(split: Partition): Seq[String] = Nil执行原理
从计算的角度来讲，数据处理过程中需要计算资源（内存 & CPU）和计算模型（逻辑）。执行时，需要将计算资源和计算模型进行协调和整合
Spark框架在执行时，先申请资源，然后将应用程序的数据处理逻辑分解成一个一个的计算任务。然后将任务发到已经分配资源的计算节点上, 按照指定的计算模型进行数据计算。最后得到计算结果
RDD 是Spark框架中用于数据处理的核心模型
在 Yarn 环境中，RDD 的工作原理 :
启动 Yarn 集群环境
Spark 通过申请资源创建调度节点和计算节点
Spark框架根据需求将计算逻辑根据分区划分成不同的任务
调度节点将任务根据计算节点状态发送到对应的计算节点进行计算
RDD 在整个流程中主要用于将逻辑进行封装，并生成 Task 发送给 Executor 节点执行计算
RDD创建Spark 中创建 RDD 的创建方式 :
从集合（内存）中创建 RDD从外部存储（文件）创建 RDD从其他 RDD 创建直接创建 RDD（new）
从集合（内存）中创建RDD
Spark 主要两个方法：
parallelizemakeRDD
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: ClassTaq](seq: Seq[T],
numSlices: Int = defaultParallelism): RDD[T] = withScope{
parallelize(seq, numSlices)
}
从外部存储（文件）创建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()
读取内存数据时，数据可以按照并行度的设定进行数据的分区 *** 作
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 文件读取的规则进行切片分区，而切片规则和数据读取的规则有些差异
public InputSplit[] getSplits(JobConf job, int numSplitc) throws IOException {
long totalSize = 0;
for (FileStatus file : 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
def map[U: ClassTag](f: T => U): RDD[U]
将处理的数据逐条进行映射转换，可类型的转换 或 值的转换
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
}
)
例子 : 从服务器日志数据 apache.log 中获取用户请求 URL 资源路径
mapPartitionsdef mapPartitions[U: ClassTag](
f: Iterator[T] => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
将待处理的数据以分区为单位发送到计算节点进行任意处理，如 : 过滤数据
val dataRDD1: RDD[Int] = dataRDD.mapPartitions(
datas => {
datas.filter(_ == 2)
}
)
例子 : 获取每个数据分区的最大值
map 和 mapPartitions 的区别数据处理角度
Map 算子 : 分区内一个数据一个数据的执行，类似于串行 *** 作mapPartitions 算子 : 以分区为单位进行批处理 *** 作
功能的角度
Map 算子 : 将数据源中的数据进行转换和改变。但是不会减少或增多数据MapPartitions 算子 : 需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据
性能的角度
Map 算子因为类似于串行 *** 作，所以性能比较低mapPartitions 算子 类似于批处理，所以性能较高mapPartitions 算子会长时间占用内存，可能导致内存不够用，出现内存溢出的错误内存有限的情况下，使用 map *** 作 mapPartitionsWithIndex
def mapPartitionsWithIndex[U: ClassTag]( f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false): RDD[U]
将待处理的数据以分区为单位发送到计算节点进行任意处理，在处理同时可以获取当前分区索引，如 : 过滤数据
val dataRDD1 : dataRDD.mapPartitionsWithIndex(
(index, datas) => {
datas.map(index, _)
}
)
例子 : 获取第二个数据分区的数据
flatMapdef flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
val dataRDD = sparkContext.makeRDD(List( List(1, 2), List(3, 4) ), 1) val dataRDD1 = dataRDD.flatMap( list => list )
例子 : 将 List( List(1, 2), 3, List(4, 5) ) 进行扁平化 *** 作
glomdef glom(): RDD[Array[T]]
将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4), 1) val dataRDD1: RDD[Array[Int]] = dataRDD.glom()
例子 : 计算所有分区最大值求和（分区内取最大值，分区间最大值求和）
groupBydef groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合( shuffle )
极限情况下，数据可能被分在同一个分区中
一个组的数据在一个分区中，但一个分区中不一定只有一个组
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4), 1) val dataRDD1 = dataRDD.groupBy( _ % 2 )
例子 ：将 List(“Hello”, “hive”, “hbase”, “Hadoop”) 根据单词首写字母进行分组
例子 ：从服务器日志数据 apache.log 中获取每个时间段访问量
例子 ：WordCount
filterdef filter(f: T => Boolean): RDD[T]
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃
当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡 ( 数据倾斜 )
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4), 1) val dataRDD1 = dataRDD.filter(_ % 2 == 0)
例子 ：从服务器日志数据 apache.log 中获取2022年5月17日的请求路径
sampledef sample(withReplacement: Boolean, fraction: Double, seed: Long = Utils.random.nextLong): RDD[T]
根据指定的规则从数据集中抽取数据
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4), 1) val dataRDD1 = dataRDD.sample(false, 0.5) val dataRDD2 = dataRDD.sample(true, 2)
例子 ：有啥用，抽奖吗？
distinctdef distinct()(implicit ord: Ordering[T] = null): RDD[T]
def distinct(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
将数据集中重复的数据去重
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4, 1, 2), 1) val dataRDD1 = dataRDD.distinct() val dataRDD2 = dataRDD.distinct(2)
例子 ：如果不用该算子，你有什么办法实现数据去重？
coalescedef coalesce(numPartitions: Int, shuffle: Boolean = false, partitionCoalescer: Option[PartitionCoalescer] = Option.empty) (implicit ord: Ordering[T] = null)
根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率
当 Spark 中，存在过多的小任务时，可以通过 coalesce 方法，收缩合并分区，减少分区的个数，减小任务调度成本
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4), 6) val dataRDD1 = dataRDD.coalesce(2)
例子 ：我想要扩大分区，怎么办？
repartitiondef repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T]
该 *** 作内部其实执行的是 coalesce *** 作，参数 shuffle 的默认值为 true
可将分区数的RDD，多转少或 少转多，经 shuffle 过程，repartition *** 作都可以完成
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4, 1, 2), 2) val dataRDD1 = dataRDD.repartition(4)
例子 ：coalesce和repartition区别？
sortBydef sortBy[K](f: (T) => K, ascending: Boolean = true, numPartitions: Int = this.partitions.length) (implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[T]
用于排序数据。在排序之前，可以将数据通过 f 函数进行处理，之后按照 f 函数处理的结果进行排序，默认为升序排列。
排序后新产生的 RDD 的分区数与原 RDD 的分区数一致。中间存在 shuffle 的过程
val dataRDD = sparkContext.makeRDD(List(1, 2, 3, 4, 1, 2), 2) val dataRDD1 = dataRDD.sortBy(num => num, false, 4)双 Value 类型 intersection
def intersection(other: RDD[T]): RDD[T]
对源 RDD 和参数 RDD 求交集后返回一个新的 RDD
val dataRDD1 = sparkContext.makeRDD(List(1, 2, 3, 4)) val dataRDD2 = sparkContext.makeRDD(List(3, 4, 5, 6)) val dataRDD = dataRDD1.intersection(dataRDD2)
例子 ：如果两个RDD数据类型不一致怎么办？
uniondef union(other: RDD[T]): RDD[T]
对源 RDD 和参数 RDD 求并集后返回一个新的 RDD
val dataRDD1 = sparkContext.makeRDD(List(1, 2, 3, 4)) val dataRDD2 = sparkContext.makeRDD(List(3, 4, 5, 6)) val dataRDD = dataRDD1.union(dataRDD2)subtract
def subtract(other: RDD[T]): RDD[T]
以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集
val dataRDD1 = sparkContext.makeRDD(List(1, 2, 3, 4)) val dataRDD2 = sparkContext.makeRDD(List(3 ,4, 5, 6)) val dataRDD = dataRDD1.subtract(dataRDD2)zip
def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]
将两个 RDD 中的元素，以键值对的形式进行合并。
其中，键值对中的 Key 为第1个 RDD 中的元素，Value 为第2个 RDD 中的相同位置的元素
val dataRDD1 = sparkContext.makeRDD(List(1, 2, 3, 4)) val dataRDD2 = sparkContext.makeRDD(List(3 ,4, 5, 6)) val dataRDD = dataRDD1.zip(dataRDD2)
如果两个RDD数据类型不一致怎么办？
如果两个RDD数据分区不一致怎么办？
如果两个RDD分区数据数量不一致怎么办？
Key-Value 类型 partitionBydef partitionBy(partitioner: Partitioner): RDD[(K, V)]
将数据按照指定 Partitioner 重新进行分区。Spark 默认的分区器是 HashPartitioner
val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "aa"), (2, "bb"), (3, "cc")), 3) import org.apache.spark.HashPartitioner val rdd2: RDD[(Int, String)] = rdd.partitionBy(new HashPartitioner(2))
问题 :
如果重分区的分区器和当前RDD的分区器一样怎么办？
Spark还有其他分区器吗？
如果想按照自己的方法进行数据分区怎么办？
reduceByKeydef reduceByKey(func: (V, V) => V): RDD[(K, V)] def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
可以将数据按照相同的Key对Value进行聚合
val dataRDD1 = sparkContext.makeRDD(List(("a",1), ("b",2), ("c",3)))
val dataRDD2 = dataRDD1.reduceByKey(_ + _)
val dataRDD3 = dataRDD1.reduceByKey(_ + _, 2)
问题 :
WordCount
groupByKeydef groupByKey(): RDD[(K, Iterable[V])] def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])] def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]
将数据源的数据根据 key 对 value 进行分组
val dataRDD1 = sparkContext.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val dataRDD2 = dataRDD1.groupByKey()
val dataRDD3 = dataRDD1.groupByKey(2)
val dataRDD4 = dataRDD1.groupByKey(new HashPartitioner(2))
reduceByKey 和 groupByKey 的区别？
从 shuffle 的角度：
reduceByKey 和 groupByKey 都存在 shuffle 的 *** 作reduceByKey 可以在 shuffle 前对分区内相同 key 的数据进行预聚合（combine）功能，可减少落盘的数据量groupByKey 只分组，不减数据量，reduceByKey 性能比较高
从功能的角度：
reduceByKey 其实包含分组****和聚合的功能。groupByKey 只分组，不聚合，分组不聚合，使用groupByKey分组聚合下，使用 reduceByKey aggregateByKey
def aggregateByKey[U: ClassTag](zeroValue: U)(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]
将数据根据不同的规则进行分区内计算和分区间计算
val dataRDD1 = sparkContext.makeRDD(List(("a", 1),("b", 2),("c", 3)))
val dataRDD2 = dataRDD1.aggregateByKey(0)(_ + _, _ + _)
取出每个分区内相同 key 的最大值然后分区间相加
val rdd = sc.makeRDD(List(("a", 1), ("a", 2), ("c", 3),
("b",4),("c",5),("c",6)
), 2)
val resultRDD = rdd.aggregateByKey(10)(
(x, y) => math.max(x, y),
(x, y) => x + y
)
resultRDD.collet().foreach(println)
例子 :
分区内计算规则和分区间计算规则相同怎么办？（WordCount）
foldByKeydef foldByKey(zeroValue: V)(func: (V, V) => V): RDD[(K, V)]
当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为 foldByKey
val dataRDD1 = sparkContext.makeRDD(List(("a", 1),("b", 2),("c", 3)))
val dataRDD2 = dataRDD1.foldByKey(0)(_ + _)
combineByKey
def combineByKey[C](createCombiner: V => C, mergevalue: (C, V) => C, mergeCombiners: (C, C) => C): RDD[(K, C)]
对 key-value 型 rdd 进行聚集 *** 作的聚集函数（aggregation function）
类似于aggregate()，combineByKey() 允许用户返回值的类型与输入不一致
小练习：
将数据求每个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 : 当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同
sortByKeydef sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length) : RDD[(K, V)]
在一个(K, V) 的 RDD 上调用，K 必须实现 Ordered 接口(特质)，返回一个按照 key 进行排序
val dataRDD1 = sparkContext.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)
val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)
例子 :
设置key为自定义类User
joindef join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]
在类型为 (K, V) 和 (K, W) 的 RDD 上调用，返回一个相同 key 对应的所有元素连接在一起的 (K, (V, W)) 的 RDD
val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c"))) val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6))) rdd.join(rdd1).collect().foreach(println)
问题 :
如果key存在不相等呢？
leftOuterJoindef leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]
类似于SQL语句的左外连接
val dataRDD1 = sparkContext.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val dataRDD2 = sparkContext.makeRDD(List(("a", 1), ("b", 2), ("c", 3)))
val rdd: RDD[(String, (Int, Option[Int]))] = dataRDD1.leftOuterJoin(dataRDD2)
cogroup
def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]
在类型为 (K, V) 和 (K, W) 的 RDD 上调用，返回一个 (K, (Iterable, Iterable)) 类型的 RDD
val dataRDD1 = sparkContext.makeRDD(List(("a", 1), ("a", 2), ("c", 3)))
val dataRDD2 = sparkContext.makeRDD(List(("a", 1), ("c", 2), ("c", 3)))
val value: RDD[(String, (Iterable[Int], Iterable[Int]))] = dataRDD1.cogroup(dataRDD2)
案例实 ***
数据准备
agent.log：时间戳，省份，城市，用户，广告，中间字段使用空格分隔
需求描述
统计出每一个省份每个广告被点击数量排行的 Top3
RDD行动算子 reducedef reduce(f: (T, T) => T): T
聚集 RDD 中的所有元素，先聚合分区内数据，再聚合分区间数据
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4)) // 聚合数据 val reduceResult: Int = rdd.reduce(_ + _)collect
def collect(): Array[T]
在驱动程序（Driver）中，以数组 Array 的形式返回数据集的所有元素
val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4)) // 收集数据到Driver rdd.collect().foreach(println)count
def count(): Long
返回 RDD 中元素的个数
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4)) // 返回RDD中元素的个数 val countResult: Long = rdd.count()first
def first(): T
返回 RDD 中的第一个元素
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4)) // 返回RDD中元素的个数 val firstResult: Int = rdd.first() println(firstResult)take
def take(num: Int): Array[T]
返回一个由 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
def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]
返回该 RDD 排序后的前 n 个元素组成的数组
val rdd: RDD[Int] = sc.makeRDD(List(1, 3, 2, 4)) // 返回RDD中元素的个数 val result: Array[Int] = rdd.takeOrdered(2)aggregate
def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U
分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 8) // 将该 RDD 所有元素相加得到结果 //val result: Int = rdd.aggregate(0)(_ + _, _ + _) val result: Int = rdd.aggregate(10)(_ + _, _ + _)fold
def fold(zeroValue: T)(op: (T, T) => T): T
折叠 *** 作，aggregate 的简化版 *** 作
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4)) val foldResult: Int = rdd.fold(0)(_ + _)countByKey
def countByKey(): Map[K, Long]
统计每种 key 的个数
val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2, "b"), (3, "c"), (3, "c"))) // 统计每种key的个数 val result: collection.Map[Int, Long] = rdd.countByKey()save相关算子
def saveAsTextFile(path: String): Unit
def saveAsObjectFile(path: String): Unit
def saveAsSequenceFile(path: String, codec: Option[Class[_ <: CompressionCodec]] = None): Unit
将数据保存到不同格式的文件中
// 保存成Text文件
rdd.saveAsTextFile("output")
// 序列化成对象保存到文件
rdd.saveAsObjectFile("output1")
// 保存成 Sequencefile 文件
rdd.map((_, 1)).saveAsSequenceFile("output2")
foreach
def foreach(f: T => Unit): Unit = withScope {
val cleanF = sc.clean(f)
sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF))
}
分布式遍历RDD中的每一个元素，调用指定函数
val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
// 收集后打印
rdd.map(num => num).collect().foreach(println)
println("****************")
// 分布式打印
rdd.foreach(println)
RDD序列化
闭包检查
从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor 端执行
在 Scala 的函数式编程中，就会导致算子内经常会用到算子外的数据，这样就形成了闭包的效果
如果使用的算子外的数据无法序列化，就意味着无法传值给 Executor 端执行，就会发生错误，所以需要在执行任务计算前，检测闭包内的对象是否可以进行序列化 ( 闭包检测 )
Scala2.12 版本后闭包编译方式发生了改变
序列化方法和属性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", "cpucode"))
//3.1创建一个Search对象
val search = new Search("hello")
//3.2 函数传递，打印：ERROR Task not serializable
search.getMetch1(rdd).collect().foreach(println)
//3.3 属性传递，打印：ERROR Task not serializable
search.getMetch2(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序列化框架
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 cpucode", "cpucode", "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依赖关系
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()
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()
RDD 窄依赖
窄依赖 表示每一个父(上游) RDD 的 Partition 最多被子（下游）RDD 的一个 Partition 使用，窄依赖我们形象的比喻为独生子女
class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd)RDD 宽依赖
宽依赖表示同一个父（上游）RDD 的 Partition 被多个子（下游）RDD 的 Partition 依赖，会引起 Shuffle，总结：宽依赖我们形象的比喻为多生
class ShuffleDependency[K: ClassTag, V: ClassTag, C: ClassTag](
@transient private val _rdd: RDD[_ <: Product2[K, V]],
val partitioner: Partitioner,
val serializer: Serializer = SparkEnv.get.serializer,
val keyOrdering: Option[Ordering[K]] = None,
val aggregator: Option[Aggregator[K, V, C]] = None,
val mapSideCombine: Boolean = false) extends Dependency[Product2[K, V]]
RDD 阶段划分
DAG（Directed Acyclic Graph）有向无环图是由点和线组成的拓扑图形，该图形具有方向，不会闭环。例如，DAG 记录了 RDD 的转换过程和任务的阶段
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
}
RDD 任务划分
RDD任务切分中间分为：
Application : 初始化一个 SparkContext 即生成一个 ApplicationJob : 一个 Action 算子就会生成一个 JobStage : Stage 等于宽依赖( ShuffleDependency )的个数加 1Task : 一个 Stage 阶段中，最后一个 RDD 的分区个数就是 Task 的个数
注意：Application -> Job -> Stage -> Task 每一层都是 1 对 n 的关系
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)
存储级别
object StorageLevel {
val NONE = new StorageLevel(false, false, false, false)
val DISK_onLY = new StorageLevel(true, false, false, false)
val DISK_ONLY_2 = new StorageLevel(true, false, false, false, 2)
val MEMORY_onLY = new StorageLevel(false, true, false, true)
val MEMORY_ONLY_2 = new StorageLevel(false, true, false, true, 2)
val MEMORY_ONLY_SER = new StorageLevel(false, true, false, false)
val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, false, 2)
val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)
val MEMORY_AND_DISK_2 = new StorageLevel(true, true, false, true, 2)
val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false, false)
val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2)
val OFF_HEAP = new StorageLevel(true, true, true, false, 1)
缓存有可能丢失，或者存储于内存的数据由于内存不足而被删除，RDD 的缓存容错机制保证了即使缓存丢失也能保证计算的正确执行
通过基于 RDD 的一系列转换，丢失的数据会被重算，由于 RDD 的各个 Partition 是相对独立的，因此只需要计算丢失的部分即可，并不需要重算全部 Partition
Spark 会自动对一些 Shuffle *** 作的中间数据做持久化 *** 作(如：reduceByKey )。这样做的目的是为了当一个节点 Shuffle 失败了避免重新计算整个输入。但是，在实际使用的时候，如果想重用数据，仍然建议调用 persist 或 cache
RDD CheckPoint 检查点检查点 : 通过将 RDD 中间结果写入磁盘
由于血缘依赖过长会造成容错成本过高，这样就不如在中间阶段做检查点容错，如果检查点之后有节点出现问题，可以从检查点开始重做血缘，减少了开销
对 RDD 进行 checkpoint *** 作并不会马上被执行，必须执行 Action *** 作才能触发
// 设置检查点路径
sc.setCheckpointDir("./checkpoint1")
// 创建一个RDD，读取指定位置文件:hello cpucode cpu
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)
缓存和检查点区别
Cache 缓存 : 将数据保存，不切断血缘依赖。Checkpoint : 检查点切断血缘依赖Cache : 存储在磁盘、内存，可靠性低。Checkpoint { 存储在HDFS 等容错、高可用的文件系统，可靠性高建议对 checkpoint() 的 RDD 使用 Cache 缓存，这样 checkpoint 的 job 只需从Cache 缓存中读取数据即可，否则需要再从头计算一次 RDD RDD分区器
Spark 目前支持分区器 :
Hash 分区Range 分区用户自定义分区
Hash 分区为当前的默认分区。分区器直接决定了 RDD 中分区的个数、RDD 中每条数据经过 Shuffle 后进入哪个分区，进而决定了 Reduce 的个数
只有 Key-Value 类型的 RDD 才有分区器，非 Key-Value 类型的 RDD 分区的值是 None
每个 RDD 的分区ID范围：0 ~ (numPartitions - 1)，决定这个值是属于那个分区的
- Hash分区：对于给定的key，计算其 hashCode , 并除以分区个数取余
lass 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 {
//...
}
}
RDD文件读取与保存
Spark 的数据读取及数据保存可以从两个维度来作区分：
文件格式文件系统
文件格式分为：
text 文件csv 文件sequence 文件Object 文件
- 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)
自定义累加器
// 自定义累加器
// 1. 继承AccumulatorV2，并设定泛型
// 2. 重写累加器的抽象方法
class WordCountAccumulator extends AccumulatorV2[String, mutable.Map[String, Long]]{
var map : mutable.Map[String, Long] = mutable.Map()
// 累加器是否为初始状态
override def isZero: Boolean = {
map.isEmpty
}
// 复制累加器
override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = {
new WordCountAccumulator
}
// 重置累加器
override def reset(): Unit = {
map.clear()
}
// 向累加器中增加数据 (In)
override def add(word: String): Unit = {
// 查询map中是否存在相同的单词
// 如果有相同的单词，那么单词的数量加1
// 如果没有相同的单词，那么在map中增加这个单词
map(word) = map.getOrElse(word, 0L) + 1L
}
// 合并累加器
override def merge(other: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = {
val map1 = map
val map2 = other.value
// 两个Map的合并
map = map1.foldLeft(map2)(( innerMap, kv ) => {
innerMap(kv._1) = innerMap.getOrElse(kv._1, 0L) + kv._2
innerMap
}
)
}
// 返回累加器的结果（Out）
override def value: mutable.Map[String, Long] = map
}
广播变量
实现原理
广播变量用来高效分发较大的对象。向所有工作节点发送一个较大的只读值，以供一个或多个 Spark *** 作使用
如 : 向所有节点发送一个较大的只读查询表，广播变量用起来都很顺手。在多个并行 *** 作中使用同一个变量，但是 Spark 会为每个任务分别发送
基础编程val rdd1 = sc.makeRDD(List(("a", 1), ("b", 2), ("c", 3), ("d", 4)), 4)
val list = List(("a",4), ("b", 5), ("c", 6), ("d", 7))
// 声明广播变量
val broadcast: Broadcast[List[(String, Int)]] = sc.broadcast(list)
val resultRDD: RDD[(String, (Int, Int))] = rdd1.map {
case (key, num) => {
var num2 = 0
// 使用广播变量
for ((k, v) <- broadcast.value) {
if (k == key) {
num2 = v
}
}
(key, (num, num2))
}
}
Spark案例实 ***
从数据文件中截取的一部分内容，表示为电商网站的用户行为数据
用户的 4 种行为：
搜索点击下单支付
数据规则如下：
数据文件中每行数据采用下划线分隔数据每一行数据表示用户的一次行为，这个行为只能是 4 种行为的一种如果搜索关键字为 null , 表示数据不是搜索数据如果点击的品类 ID 和产品 ID 为 -1，表示数据不是点击数据针对于下单行为，一次可以下单多个商品，所以品类 ID 和产品 ID 可以是多个，id 之间采用逗号分隔，如果本次不是下单行为，则数据采用 null 表示支付行为和下单行为类似
详细字段说明：
样例类：
//用户访问动作表
case class UserVisitAction(
date: String, //用户点击行为的日期
user_id: Long, //用户的ID
session_id: String, //Session的ID
page_id: Long, //某个页面的ID
action_time: String, //动作的时间点
search_keyword: String, //用户搜索的关键词
click_category_id: Long, //某一个商品品类的ID
click_product_id: Long, //某一个商品的ID
order_category_ids: String, //一次订单中所有品类的ID集合
order_product_ids: String, //一次订单中所有商品的ID集合
pay_category_ids: String, //一次支付中所有品类的ID集合
pay_product_ids: String, //一次支付中所有商品的ID集合
city_id: Long //城市 id
)
Top10热门品类
需求说明 :
品类是指产品的分类，大型电商网站品类分多级，咱们的项目中品类只有一级，不同的公司可能对热门的定义不一样
按照每个品类的点击、下单、支付的量来统计热门品类
鞋 : 点击数 , 下单数 , 支付数
衣服 : 点击数 , 下单数 , 支付数
电脑 : 点击数 , 下单数 , 支付数
如 : 综合排名 = 点击数 * 20% + 下单数 * 30% + 支付数 * 50%
本项目需求优化为：
先按照点击数排名，靠前的就排名高如果点击数相同，再比较下单数下单数再相同，就比较支付数 Top10热门品类中每个品类的Top10活跃Session统计
增加每个品类用户 session 的点击统计
页面单跳转换率统计页面单跳转化率
页面单跳转换率 : 统计页面点击的概率
如：一个用户在一次 Session 过程中访问的页面路径 3, 5, 7, 9, 10, 21，那么页面 3 跳到页面 5 叫一次单跳，7-9 也叫一次单跳
如：3-5 的单跳转化率 : B / A，先获取符合条件的 Session 对于页面 3 的访问次数（PV）为 A，然后获取符合条件的 Session 中访问了页面 3 又紧接着访问了页面 5 的次数为 B
统计页面单跳转化率意义
产品经理和运营总监，可以根据这个指标，去尝试分析，整个网站，产品，各个页面的表现怎么样，是不是需要去优化产品的布局；吸引用户最终可以进入最后的支付页面数据分析师，可以此数据做更深一步的计算和分析企业管理层，可以看到整个公司的网站，各个页面的之间的跳转的表现如何，可以适当调整公司的经营战略或策略
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）