020 Spark中分组后的TopN，以及Spark的优化（重点）

一：准备

1.源数据

　　

2.上传数据

　　

二：TopN程序编码

1.程序

 package com.ibeifeng.bigdata.spark.core

 import java.util.concurrent.ThreadLocalRandom

 import org.apache.spark.{SparkConf, SparkContext}

 /**
   * 分组TopN：按照第一个字段分组；同一组中，按照第二个字段进行排序；每一组中，获取出现最多的前K个数据。
   * Created by ibf on 01/15.
   */
 object GroupedTopN {
   def main(args: Array[String]): Unit = {
     val conf = new SparkConf()
       .setMaster("local[*]")
       .setAppName("grouped-topn")
       //.set("spark.eventLog.enabled", "true")
       //.set("spark.eventLog.dir", "hdfs://hadoop-senior01:8020/spark-history")

     val sc = SparkContext.getOrCreate(conf)

     // ==========具体代码逻辑========================
     // 原始数据存储的路径, 需要自己上传
     val path = "/user/beifeng/spark/groupedtopk/groupsort.txt"
     val K = 3

     // 构建rdd
     val rdd = sc.textFile(path)

     // rdd操作
     val word2CountRDD = rdd
       .filter((line: String) => {
         // 过滤空字符串，所以非空的返回true
         !line.isEmpty
       })
       .map(line => {
         // 按照空格分隔字段
         val arr = line.split(" ")
         // 将数据转换为二元组
         (arr(0), arr(1).toInt)
       })

     // 如果一个RDD被多次使用，该RDD需要进行缓存操作
     word2CountRDD.cache()

     // 直接使用groupByKey函数进行统计，这种方式存在OOM的情况
     /*
     val resultRDD = word2CountRDD
       .groupByKey() // 按照第一个字段进行分组
       .map(tuple => {
       // 同一组的数据中获取前K个元素
       // 获取对应分组
       val word = tuple._1
       // 获取前K个元素(最大的k个元素), list默认排序是升序, 所以采用takeRight从后往前获取K个元素(此时的K个元素就是最大的K个元素); 最后对K个元素进行反转，最终结果元素是从大到小排序的
       val topk = tuple._2.toList.sorted.takeRight(K).reverse
       // 返回结果
       (word, topk)
     })
     */

     /*
     * groupByKey存在OOM异常
     * 解决方案：采用两阶段聚合操作
     * 两阶段聚合可以解决的一些常见：
     *   1. 聚合操作中存储的OOM异常
     *   2. 聚合操作中存在的数据倾斜问题
     * 聚合操作：分区、排序、reduceByKey.....
     * */
     val random = ThreadLocalRandom.current()
     val resultRDD2 = word2CountRDD
       .map(tuple => {
         // 第一阶段第一步：在key前加一个随机数
         ((random.nextInt(100), tuple._1), tuple._2)
       })
       .groupByKey() // 第一阶段的第二步：按照修改后的key进行聚合操作
       .flatMap(tuple => {
       // 第一阶段的第三步：对一组value进行聚合操作
       // 获取对应分组
       val word = tuple._1._2
       // 获取前K个
       val topk = tuple._2.toList.sorted.takeRight(K).reverse
       // 返回结果
       topk.map(count => (word, count))
     })
       .groupByKey() // 第二阶段第一步：按照原本的key进行聚合操作
       .map(tuple => {
       // 第二阶段第二步: 获取前k个元素
       val word = tuple._1
       val topk = tuple._2.toList.sorted.takeRight(K).reverse
       // 返回结果
       (word, topk)
     })

     // 结果输出
     resultRDD2.foreach(println)
     /*
     resultRDD2.foreachPartition(iter => {
       // foreachPartition该函数常用于将RDD的数据输出到第三方的数据存储系统中，比如：redis、mongoDB
       /*
       * 1. 创建连接
       * 2. 对iter进行迭代，进行数据输出
       * 3. 关闭连接
       * */
       iter.foreach(println)
     })
     */

     // 如果RDD有cache，需要去除cache
     word2CountRDD.unpersist()

     // ==========具体代码逻辑========================

     sc.stop()
   }
 }

2.结果

　　

3.注意点

　　Spark中不支持二次排序，如果想实现二次排序，需要根据业务的执行逻辑使用两阶段聚合来进行操作

二：优化

1.两阶段聚合