Spark详解(05-1) - SparkCore实战案例

Spark详解(05-1) - SparkCore实战案例

数据准备

1）数据格式

本项目的数据是采集电商网站的用户行为数据，主要包含用户的4种行为：搜索、点击、下单和支付。

（1）数据采用_分割字段

（2）每一行表示用户的一个行为，所以每一行只能是四种行为中的一种。

（3）如果点击的品类id和产品id是-1表示这次不是点击

（4）针对下单行为，一次可以下单多个产品，所以品类id和产品id都是多个，id之间使用逗号分割。

如果本次不是下单行为，则他们相关数据用null来表示。

（5）支付行为和下单行为格式类似

2）数据详细字段说明

编号	字段名称	字段类型	字段含义
1	date	String	用户点击行为的日期
2	user_id	Long	用户的ID
3	session_id	String	Session的ID
4	page_id	Long	某个页面的ID
5	action_time	String	动作的时间点
6	search_keyword	String	用户搜索的关键词
7	click_category_id	Long	点击某一个商品品类的ID
8	click_product_id	Long	某一个商品的ID
9	order_category_ids	String	一次订单中所有品类的ID集合
10	order_product_ids	String	一次订单中所有商品的ID集合
11	pay_category_ids	String	一次支付中所有品类的ID集合
12	pay_product_ids	String	一次支付中所有商品的ID集合
13	city_id	Long	城市 id

需求1：Top10热门品类

需求说明：品类是指产品的分类，大型电商网站品类分多级，本项目中品类只有一级，不同的公司可能对热门的定义不一样。按照每个品类的点击、下单、支付的量来统计热门品类。

鞋            点击数 下单数 支付数

衣服        点击数 下单数 支付数

电脑        点击数 下单数 支付数

例如，综合排名 = 点击数*20% + 下单数*30% + 支付数*50%

本项目需求优化为：先按照点击数排名，靠前的就排名高；如果点击数相同，再比较下单数；下单数再相同，就比较支付数。

需求分析（方案一）分步计算

思路：分别统计每个品类点击的次数，下单的次数和支付的次数。

（品类，点击总数）（品类，下单总数）（品类，支付总数）

缺点：统计3次，需要启动3个job，每个job都有对原始数据遍历一次，效率低。

需求分析（方案二）常规算子

采用常规算子的方式实现。

需求分析（方案三）样例类

采用样例类的方式实现。

需求实现（方案三）

1）用来封装用户行为的样例类

1. //用户访问动作表
2. case class UserVisitAction(date: String,//用户点击行为的日期
3.                            user_id: Long,//用户的ID
4.                            session_id: String,//Session的ID
5.                            page_id: Long,//某个页面的ID
6.                            action_time: String,//动作的时间点
7.                            search_keyword: String,//用户搜索的关键词
8.                            click_category_id: Long,//某一个商品品类的ID
9.                            click_product_id: Long,//某一个商品的ID
10.                            order_category_ids: String,//一次订单中所有品类的ID集合
11.                            order_product_ids: String,//一次订单中所有商品的ID集合
12.                            pay_category_ids: String,//一次支付中所有品类的ID集合
13.                            pay_product_ids: String,//一次支付中所有商品的ID集合
14.                            city_id: Long)//城市 id
15. // 输出结果表
16. case class CategoryCountInfo(categoryId: String,//品类id
17.                              clickCount: Long,//点击次数
18.                              orderCount: Long,//订单次数
19.                              payCount: Long)//支付次数

注意：样例类的属性默认是val修饰，不能修改；需要修改属性，需要采用var修饰。

1. case class CategoryCountInfo(var categoryId: String,//品类id
2.                              var clickCount: Long,//点击次数
3.                              var orderCount: Long,//订单次数
4.                              var payCount: Long)//支付次数

2）核心业务代码实现

1. object require01_top10Category_method3 {
2.  
3.     def main(args: Array[String]): Unit = {
4.  
5.         //1.创建SparkConf并设置App名称
6.         val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[1]")
7.         //2.创建SparkContext，该对象是提交Spark App的入口
8.         val sc: SparkContext = new SparkContext(conf)
9.  
10.         //3 需求一：top10热门品类
11.         //3.1 获取原始数据
12.         val lineRDD: RDD[String] = sc.textFile("input/user_visit_action.txt")
13.         //3.2 将原始数据进行转换（分解）
14.         val actionRDD: RDD[UserVisitAction] = lineRDD.map(
15.             line => {
16.                 // 获取一行数据
17.                 val datas: Array[String] = line.split("_")
18.                 // 将解析的数据封装到 UserVisitAction
19.                 UserVisitAction(
20.                     datas(0),
21.                     datas(1).toLong,
22.                     datas(2),
23.                     datas(3).toLong,
24.                     datas(4),
25.                     datas(5),
26.                     datas(6).toLong,
27.                     datas(7).toLong,
28.                     datas(8),
29.                     datas(9),
30.                     datas(10),
31.                     datas(11),
32.                     datas(12).toLong
33.                 )
34.             }
35.         )
36.  
37.         //CategoryCountInfo(鞋,1,0,0)
38.         //CategoryCountInfo(鞋,0,1,0)
39.         //CategoryCountInfo(鞋,0,0,1)
40.         //=>希望变成：CategoryCountInfo(鞋,1,1,1)
41.         //3.3 将转换结构后的数据进行分解成CategoryCountInfo
42.         val infoRDD: RDD[CategoryCountInfo] = actionRDD.flatMap {
43.             case act: UserVisitAction => {
44.                 if (act.click_category_id != -1) { // 点击信息处理
45.                     List(CategoryCountInfo(act.click_category_id.toString, 1, 0, 0))
46.                 } else if (act.order_category_ids != "null") { // 订单信息处理
47.                     val list: ListBuffer[CategoryCountInfo] = new ListBuffer[CategoryCountInfo]
48.                     val ids: Array[String] = act.order_category_ids.split(",")
49.                     for (id <- ids) {
50.                         list.append(CategoryCountInfo(id, 0, 1, 0))
51.                     }
52.                     list
53.                 } else if (act.pay_category_ids != "null") { // 支付信息处理
54.                     val list: ListBuffer[CategoryCountInfo] = new ListBuffer[CategoryCountInfo]
55.                     val ids: Array[String] = act.pay_category_ids.split(",")
56.                     for (id <- ids) {
57.                         list.append(CategoryCountInfo(id, 0, 0, 1))
58.                     }
59.                     list
60.                 } else {
61.                     Nil
62.                 }
63.             }
64.         }
65.  
66.         //3.4 将相同的品类分成一组
67.         val groupRDD: RDD[(String, Iterable[CategoryCountInfo])] = infoRDD.groupBy(info => info.categoryId)
68.         //3.5 将分组后的数据进行聚合处理: (品类id, (品类id, clickCount, OrderCount, PayCount))
69.         val mapRDD: RDD[CategoryCountInfo] = groupRDD.mapValues(
70.  
71.             datas => {
72.                 datas.reduce(
73.                     (info1, info2) => {
74.                         info1.orderCount = info1.orderCount + info2.orderCount
75.                         info1.clickCount = info1.clickCount + info2.clickCount
76.                         info1.payCount = info1.payCount + info2.payCount
77.                         info1
78.                     }
79.                 )
80.             }
81.         ).map(_._2)
82.  
83.         //3.6 将聚合后的数据排序，取前10名
84.         val sortRDD: RDD[CategoryCountInfo] = mapRDD.sortBy(info => (info.clickCount, info.orderCount, info.payCount), false)
85.         val takeRDD: Array[CategoryCountInfo] = sortRDD.take(10)
86.  
87.         //3.7 打印
88.         takeRDD.foreach(println)
89.         //4.关闭连接
90.         sc.stop()
91.     }
92. }

需求分析（方案四）样例类+算子优化

针对方案三中的groupBy，没有提前聚合的功能，替换成reduceByKey

需求实现（方案四）

1）样例类代码和方案三一样。（详见方案三）

2）核心代码实现

1. object require01_top10Category_method4 {
2.  
3.     def main(args: Array[String]): Unit = {
4.  
5.         //1.创建SparkConf并设置App名称
6.         val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
7.  
8.         //2.创建SparkContext，该对象是提交Spark App的入口
9.         val sc: SparkContext = new SparkContext(conf)
10.  
11.  
12.         //3.1 获取原始数据
13.         val dataRDD: RDD[String] = sc.textFile("input/user_visit_action.txt")
14.  
15.         //3.2 将原始数据进行转换
16.         val actionRDD: RDD[UserVisitAction] = dataRDD.map {
17.             data => {
18.                 val datas: Array[String] = data.split("_")
19.  
20.                 UserVisitAction(
21.                     datas(0),
22.                     datas(1).toLong,
23.                     datas(2),
24.                     datas(3).toLong,
25.                     datas(4),
26.                     datas(5),
27.                     datas(6).toLong,
28.                     datas(7).toLong,
29.                     datas(8),
30.                     datas(9),
31.                     datas(10),
32.                     datas(11),
33.                     datas(12).toLong
34.                 )
35.             }
36.         }
37.         //3.3 将转换结构后的数据进行分解成：(品类,CategoryCountInfo)
38.         val infoRDD: RDD[(String, CategoryCountInfo)] = actionRDD.flatMap {
39.             action => {
40.                 action match {
41.                     case act: UserVisitAction => {
42.                         if (act.click_category_id != -1) {
43.                             List((act.click_category_id.toString, CategoryCountInfo(act.click_category_id.toString, 1, 0, 0)))
44.                         } else if (act.order_category_ids != "null") {
45.                             val list: ListBuffer[(String, CategoryCountInfo)] = new ListBuffer[(String, CategoryCountInfo)]
46.  
47.                             val ids: Array[String] = act.order_category_ids.split(",")
48.  
49.                             for (id <- ids) {
50.                                 list.append((id, CategoryCountInfo(id, 0, 1, 0)))
51.                             }
52.                             list
53.                         } else if (act.pay_category_ids != "null") {
54.  
55.                             val list: ListBuffer[(String, CategoryCountInfo)] = new ListBuffer[(String, CategoryCountInfo)]
56.                             val ids: mutable.ArrayOps[String] = act.pay_category_ids.split(",")
57.  
58.                             for (id <- ids) {
59.                                 list.append((id, CategoryCountInfo(id, 0, 0, 1)))
60.                             }
61.  
62.                             list
63.                         } else {
64.                             Nil
65.                         }
66.                     }
67.                     case _ => Nil
68.                 }
69.             }
70.         }
71.  
72.         //3.4 按照品类id相同，进行两两聚合
73.         val mapRDD: RDD[CategoryCountInfo] = infoRDD.reduceByKey(
74.             (info1, info2) => {
75.                 info1.orderCount = info1.orderCount + info2.orderCount
76.                 info1.clickCount = info1.clickCount + info2.clickCount
77.                 info1.payCount = info1.payCount + info2.payCount
78.  
79.                 info1
80.             }
81.         ).map(_._2)
82.  
83.         //3.6 将聚合后的数据排序，取前10名
84.         val sortRDD: RDD[CategoryCountInfo] = mapRDD.sortBy(info =>(info.clickCount,info.orderCount,info.payCount),false)
85.         val takeRDD: Array[CategoryCountInfo] = sortRDD.take(10)
86.  
87.         //3.7 打印
88.         takeRDD.foreach(println)
89.  
90.         //4.关闭连接
91.         sc.stop()
92.     }
93. }

需求分析（方案五）累加器

需求实现（方案五）

1）累加器实现

1. //品类行为统计累加器
2. // ((鞋,click),1)
3. // ((鞋,order),1)
4. // ((鞋,pay),1)
5. // ((衣服,pay),1)
6. //3.3 继承AccumulatorV2，声明泛型
7. //3.4 重写方法
8. class CategoryCountAccumulator extends AccumulatorV2[UserVisitAction, mutable.Map[(String, String), Long]] {
9.  
10.     var map = mutable.Map[(String, String), Long]()
11.  
12.     override def isZero: Boolean = map.isEmpty
13.  
14.     override def copy(): AccumulatorV2[UserVisitAction, mutable.Map[(String, String), Long]] = {
15.         new CategoryCountAccumulator()
16.     }
17.  
18.     override def reset(): Unit = map.clear()
19.  
20.     override def add(action: UserVisitAction): Unit = {
21.         // 鞋 click + 鞋 click ...+ 鞋 click => ((鞋,click),100)
22.         // 鞋 order + 鞋 order ...+ 鞋 order =>((鞋,order),50)
23.         if (action.click_category_id != -1) {
24.             val key = (action.click_category_id.toString, "click")
25.  
26.             map(key) = map.getOrElse(key, 0L) + 1L
27.         } else if (action.order_category_ids != "null") {
28.             val ids: Array[String] = action.order_category_ids.split(",")
29.  
30.             for (id <- ids) {
31.                 val key = (id, "order")
32.                 map(key) = map.getOrElse(key, 0L) + 1L
33.             }
34.         } else if (action.pay_category_ids != "null") {
35.             val ids: Array[String] = action.pay_category_ids.split(",")
36.  
37.             for (id <- ids) {
38.                 val key = (id, "pay")
39.                 map(key) = map.getOrElse(key, 0L) + 1L
40.             }
41.         }
42.     }
43.  
44.     override def merge(other: AccumulatorV2[UserVisitAction, mutable.Map[(String, String), Long]]): Unit = {
45.  
46.         other.value.foreach {
47.             case (category, count) => {
48.                 map(category) = map.getOrElse(category, 0L) + count
49.             }
50.         }
51.     }
52.  
53.     override def value: mutable.Map[(String, String), Long] = map
54. }

2）核心逻辑实现

1. object require01_top10Category_method5 {
2.  
3.     def main(args: Array[String]): Unit = {
4.  
5.         //1.创建SparkConf并设置App名称
6.         val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
7.  
8.         //2.创建SparkContext，该对象是提交Spark App的入口
9.         val sc: SparkContext = new SparkContext(conf)
10.  
11.         //3.1 获取原始数据
12.         val lineRDD: RDD[String] = sc.textFile("input/user_visit_action.txt")
13.  
14.         //3.2 将原始数据进行转换
15.         val actionRDD: RDD[UserVisitAction] = lineRDD.map {
16.             line => {
17.                 val datas: Array[String] = line.split("_")
18.  
19.                 UserVisitAction(
20.                     datas(0),
21.                     datas(1).toLong,
22.                     datas(2),
23.                     datas(3).toLong,
24.                     datas(4),
25.                     datas(5),
26.                     datas(6).toLong,
27.                     datas(7).toLong,
28.                     datas(8),
29.                     datas(9),
30.                     datas(10),
31.                     datas(11),
32.                     datas(12).toLong
33.                 )
34.             }
35.         }
36.  
37.         //3.5 创建累加器
38.         val acc: CategoryCountAccumulator = new CategoryCountAccumulator()
39.  
40.         //3.6 注册累加器
41.         sc.register(acc, "CategoryCountAccumulator")
42.  
43.         //3.7 累加器添加数据
44.         actionRDD.foreach(action => acc.add(action))
45.  
46.         //3.8 获取累加器的值
47.         // ((鞋,click),10)
48.         // ((鞋,order),5)
49.         // =>(鞋，(click,order,pay))=>CategoryCountInfo
50.         val accMap: mutable.Map[(String, String), Long] = acc.value
51.  
52.         // 3.9 将累加器的值进行结构的转换
53.         val group: Map[String, mutable.Map[(String, String), Long]] = accMap.groupBy(_._1._1)
54.  
55.         val infoes: immutable.Iterable[CategoryCountInfo] = group.map {
56.             case (id, map) => {
57.                 val click = map.getOrElse((id, "click"), 0L)
58.                 val order = map.getOrElse((id, "order"), 0L)
59.                 val pay = map.getOrElse((id, "pay"), 0L)
60.  
61.                 CategoryCountInfo(id, click, order, pay)
62.             }
63.         }
64.  
65.         //3.10 将转换后的数据进行排序（降序），取前10
66.         infoes.toList.sortWith(
67.             (left,right)=>{
68.                 if (left.clickCount > right.clickCount){
69.                     true
70.                 }else if(left.clickCount == right.clickCount){
71.                     if (left.orderCount > right.orderCount){
72.                         true
73.  
74.                     }else if(left.orderCount == right.orderCount){
75.                         left.payCount > right.payCount
76.                     }else {
77.                         false
78.                     }
79.                 }else{
80.                     false
81.                 }
82.             }
83.         ).take(10).foreach(println)
84.  
85.         //4.关闭连接
86.         sc.stop()
87.     }
88. }

需求2：Top10热门品类中每个品类的Top10活跃Session统计

需求分析

需求实现

1）累加器实现

1. //品类行为统计累加器
2. // ((鞋,click),1)
3. // ((鞋,order),1)
4. // ((鞋,pay),1)
5. // ((衣服,pay),1)
6. //3.3 继承AccumulatorV2，声明泛型
7. //3.4 重写方法
8. class CategoryCountAccumulator extends AccumulatorV2[UserVisitAction, mutable.Map[(String, String), Long]] {
9.  
10.     var map = mutable.Map[(String, String), Long]()
11.  
12.     override def isZero: Boolean = map.isEmpty
13.  
14.     override def copy(): AccumulatorV2[UserVisitAction, mutable.Map[(String, String), Long]] = {
15.         new CategoryCountAccumulator()
16.     }
17.  
18.     override def reset(): Unit = map.clear()
19.  
20.     override def add(action: UserVisitAction): Unit = {
21.         // 鞋 click + 鞋 click ...+ 鞋 click => ((鞋,click),100)
22.         // 鞋 order + 鞋 order ...+ 鞋 order =>((鞋,order),50)
23.         if (action.click_category_id != -1) {
24.             val key = (action.click_category_id.toString, "click")
25.  
26.             map(key) = map.getOrElse(key, 0L) + 1L
27.         } else if (action.order_category_ids != "null") {
28.             val ids: Array[String] = action.order_category_ids.split(",")
29.  
30.             for (id <- ids) {
31.                 val key = (id, "order")
32.                 map(key) = map.getOrElse(key, 0L) + 1L
33.             }
34.         } else if (action.pay_category_ids != "null") {
35.             val ids: Array[String] = action.pay_category_ids.split(",")
36.  
37.             for (id <- ids) {
38.                 val key = (id, "pay")
39.                 map(key) = map.getOrElse(key, 0L) + 1L
40.             }
41.         }
42.     }
43.  
44.     override def merge(other: AccumulatorV2[UserVisitAction, mutable.Map[(String, String), Long]]): Unit = {
45.  
46.         other.value.foreach {
47.             case (category, count) => {
48.                 map(category) = map.getOrElse(category, 0L) + count
49.             }
50.         }
51.     }
52.  
53.     override def value: mutable.Map[(String, String), Long] = map
54. }

2）核心逻辑实现

1. object require02_top10Category_sessionTop10 {
2.  
3.     def main(args: Array[String]): Unit = {
4.  
5.         //1.创建SparkConf并设置App名称
6.         val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
7.  
8.         //2.创建SparkContext，该对象是提交Spark App的入口
9.         val sc: SparkContext = new SparkContext(conf)
10.  
11.         //3.1 获取原始数据
12.         val dataRDD: RDD[String] = sc.textFile("input/user_visit_action.txt")
13.  
14.         //3.2 将原始数据进行转换
15.         val actionRDD: RDD[UserVisitAction] = dataRDD.map {
16.             data => {
17.                 val datas: Array[String] = data.split("_")
18.  
19.                 UserVisitAction(
20.                     datas(0),
21.                     datas(1).toLong,
22.                     datas(2),
23.                     datas(3).toLong,
24.                     datas(4),
25.                     datas(5),
26.                     datas(6).toLong,
27.                     datas(7).toLong,
28.                     datas(8),
29.                     datas(9),
30.                     datas(10),
31.                     datas(11),
32.                     datas(12).toLong
33.                 )
34.             }
35.         }
36.  
37.         //3.5 创建累加器
38.         val acc: CategoryCountAccumulator = new CategoryCountAccumulator()
39.  
40.         //3.6 注册累加器
41.         sc.register(acc, "CategoryCountAccumulator")
42.  
43.         //3.7 累加器添加数据
44.         actionRDD.foreach(action => acc.add(action))
45.  
46.         //3.8 获取累加器的值
47.         // ((鞋,click),10)
48.         // ((鞋,order),5)
49.         // =>(鞋，(click,order,pay))=>CategoryCountInfo
50.         val accMap: mutable.Map[(String, String), Long] = acc.value
51.  
52.         // 3.9 将累加器的值进行结构的转换
53.         val group: Map[String, mutable.Map[(String, String), Long]] = accMap.groupBy(_._1._1)
54.  
55.         val infoes: immutable.Iterable[CategoryCountInfo] = group.map {
56.             case (id, map) => {
57.                 val click = map.getOrElse((id, "click"), 0L)
58.                 val order = map.getOrElse((id, "order"), 0L)
59.                 val pay = map.getOrElse((id, "pay"), 0L)
60.  
61.                 CategoryCountInfo(id, click, order, pay)
62.             }
63.         }
64.  
65.         //3.10 将转换后的数据进行排序（降序），取前10
66.         val sort: List[CategoryCountInfo] = infoes.toList.sortWith(
67.             (left, right) => {
68.                 if (left.clickCount > right.clickCount) {
69.                     true
70.                 } else if (left.clickCount == right.clickCount) {
71.                     if (left.orderCount > right.orderCount) {
72.                         true
73.  
74.                     } else if (left.orderCount == right.orderCount) {
75.                         left.payCount > right.payCount
76.                     } else {
77.                         false
78.                     }
79.                 } else {
80.                     false
81.                 }
82.             }
83.         )
84.  
85.         val top10Info: List[CategoryCountInfo] = sort.take(10)
86.  
87.         //********************需求二********************************
88.         //4.1 获取Top10热门品类
89.         val ids: List[String] = top10Info.map(_.categoryId)
90.  
91.         //4.2 ids变成广播变量
92.         val broadcastIds: Broadcast[List[String]] = sc.broadcast(ids)
93.  
94.         //4.3 将原始数据进行过滤（保留前10热门品类的数据，保留点击数据）
95.         val filterActionRDD: RDD[UserVisitAction] = actionRDD.filter(
96.             action => {
97.                 if (action.click_category_id != -1) {
98.                     broadcastIds.value.contains(action.click_category_id.toString)
99.                 } else {
100.                     false
101.                 }
102.             }
103.         )
104.  
105.         //4.4 对session点击次数进行转换：(categoryid-session, 1)
106.         val idAndSessionToOneRDD: RDD[(String, Int)] = filterActionRDD.map(
107.             action => (action.click_category_id + "--" + action.session_id, 1)
108.         )
109.  
110.         //4.5 对session点击次数进行统计：(categoryid-session, sum)
111.         val idAndSessionToSumRDD: RDD[(String, Int)] = idAndSessionToOneRDD.reduceByKey(_+_)
112.  
113.         //4.6 将统计结果进行结构的转换：(categoryid, (session,sum))
114.         val idToSessionAndSumRDD: RDD[(String, (String, Int))] = idAndSessionToSumRDD.map {
115.             case (key, sum) => {
116.                 val keys: Array[String] = key.split("--")
117.  
118.                 (keys(0), (keys(1), sum))
119.             }
120.         }
121.  
122.         //4.7 将转换结构后的数据根据品类进行分组：(categoryid, Iterator[(session,sum)])
123.         val idToSessionAndSumGroupRDD: RDD[(String, Iterable[(String, Int)])] = idToSessionAndSumRDD.groupByKey()
124.  
125.         //4.8 将分组后的数据进行排序（降序），取前10名
126.         val resultRDD: RDD[(String, List[(String, Int)])] = idToSessionAndSumGroupRDD.mapValues {
127.             datas => {
128.                 datas.toList.sortWith(
129.                     (left, right) => {
130.                         left._2 > right._2
131.                     }
132.                 ).take(10)
133.             }
134.         }
135.         resultRDD.foreach(println)
136.  
137.         //5.关闭连接
138.         sc.stop()
139.     }
140. }

需求3：页面单跳转化率统计

需求分析

1）页面单跳转化率

计算页面单跳转化率，什么是页面单跳转换率，比如一个用户在一次 Session 过程中访问的页面路径 3,5,7,9,10,21，那么页面 3 跳到页面 5 叫一次单跳，7-9 也叫一次单跳，那么单跳转化率就是要统计页面点击的概率。

比如：计算 3-5 的单跳转化率，先获取符合条件的 Session 对于页面 3 的访问次数（PV）为 A，然后获取符合条件的 Session 中访问了页面 3 又紧接着访问了页面 5 的次数为 B，那么 B/A 就是 3-5 的页面单跳转化率。

2）统计页面单跳转化率意义

产品经理和运营总监，可以根据这个指标，去尝试分析，整个网站，产品，各个页面的表现怎么样，是不是需要去优化产品的布局；吸引用户最终可以进入最后的支付页面。

数据分析师，可以此数据做更深一步的计算和分析。

企业管理层，可以看到整个公司的网站，各个页面的之间的跳转的表现如何，可以适当调整公司的经营战略或策略。

3）需求详细描述

在该模块中，需要根据查询对象中设置的Session过滤条件，先将对应得Session过滤出来，然后根据查询对象中设置的页面路径，计算页面单跳转化率，比如查询的页面路径为：3、5、7、8，那么就要计算3-5、5-7、7-8的页面单跳转化率。

需要注意的一点是，页面的访问是有先后的，要做好排序。

1、2、3、4、5、6、7

1-2/ 1 2-3/2 3-4/3 4-5/4 5-6/5 6-7/6

4）需求分析

用户行为数据采集模拟

需求实现

1）代码实现

1. object require03_PageFlow {
2.  
3.     def main(args: Array[String]): Unit = {
4.  
5.         //1.创建SparkConf并设置App名称
6.         val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
7.  
8.         //2.创建SparkContext，该对象是提交Spark App的入口
9.         val sc: SparkContext = new SparkContext(conf)
10.  
11.         //3.1 获取原始数据
12.         val lineRDD: RDD[String] = sc.textFile("input/user_visit_action.txt")
13.  
14.         //3.2 将原始数据进行转换
15.         val actionRDD: RDD[UserVisitAction] = lineRDD.map {
16.             line => {
17.                 val datas: Array[String] = line.split("_")
18.  
19.                 UserVisitAction(
20.                     datas(0),
21.                     datas(1).toLong,
22.                     datas(2),
23.                     datas(3).toLong,
24.                     datas(4),
25.                     datas(5),
26.                     datas(6).toLong,
27.                     datas(7).toLong,
28.                     datas(8),
29.                     datas(9),
30.                     datas(10),
31.                     datas(11),
32.                     datas(12).toLong
33.                 )
34.             }
35.         }
36.  
37.         //3.3 定义要统计的页面（只统计集合中规定的页面跳转率）
38.         val ids = List(1, 2, 3, 4, 5, 6, 7)
39.         // 准备过滤数据
40.         val idZipList: List[String] = ids.zip(ids.tail).map {
41.             case (pageId1, pageId2) => {
42.                 pageId1 + "-" + pageId2
43.             }
44.         }
45.  
46.         //4 计算分母
47.         val idsMap: Map[Long, Long] = actionRDD
48.             // 过滤出要统计的page_id(由于最后一个页面总次数，不参与运算，所以也过滤了)
49.             .filter(action => ids.init.contains(action.page_id))
50.             // 结构变换
51.             .map(action => (action.page_id, 1L))
52.             // 统计每个页面的总次数
53.             .reduceByKey(_ + _).collect().toMap
54.  
55.         //5 计算分子
56.         //5.1 将原始数据根据Session进行分组：(session,Iterable[UserVisitAction])
57.         val sessionGroupRDD: RDD[(String, Iterable[UserVisitAction])] = actionRDD.groupBy(_.session_id)
58.  
59.         //5.2 将分组后的数据根据时间进行排序（升序）:List((pageId1-pageId2))
60.         val pageFlowRDD: RDD[List[String]] = sessionGroupRDD.mapValues(
61.             datas => {
62.                 //5.2.1 对分组后的数据进行排序
63.                 val actions: List[UserVisitAction] = datas.toList.sortWith(
64.                     (left, right) => {
65.                         left.action_time < right.action_time
66.                     }
67.                 )
68.  
69.                 //5.2.2 获取PageId
70.                 val pageidList: List[Long] = actions.map(_.page_id)
71.  
72.                 //5.2.3 形成单跳元组(pageId1, pageId2)  (1,2,3,4…).zip((2,3,4…))
73.                 val pageToPageList: List[(Long, Long)] = pageidList.zip(pageidList.tail)
74.  
75.                 //5.2.4 变换结构
76.                 //=>List((pageId1-pageId2),(pageId2-pageId3),(pageId3-pageId4),(pageId4-pageId5),(pageId5-pageId6),(pageId6-pageId7))
77.                 val pageJumpCounts: List[String] = pageToPageList.map {
78.                     case (pageId1, pageId2) => {
79.                         pageId1 + "-" + pageId2
80.                     }
81.                 }
82.  
83.                 //5.2.5 再次进行过滤，减轻计算负担
84.                 // 1-2 2-3 3-4 4-5 5-6 6-7
85.                 pageJumpCounts.filter(data => idZipList.contains(data))
86.             }
87.         ).map(_._2)
88.  
89.         // pageFlowRDD.foreach(println)
90.  
91.         //6.聚合统计结果：(pageId1-pageId2, sum)
92.         val pageFlowMapRDD: RDD[(String, Long)] = pageFlowRDD.flatMap(list => list).map((_, 1L)).reduceByKey(_ + _)
93.  
94.         //7 计算页面单跳转换率
95.         pageFlowMapRDD.foreach {
96.             case (pageflow, sum) => {
97.                 val pageIds: Array[String] = pageflow.split("-")
98.                 val pageIdSum: Long = idsMap.getOrElse(pageIds(0).toLong, 1L)
99.  
100.                 println(pageflow + "=" + sum.toDouble / pageIdSum)
101.             }
102.         }
103.  
104.         //8.关闭连接
105.         sc.stop()
106.     }
107. }