sparksql分组排序 spark 分组 topn

转载

mob64ca1404ed65 2023-10-29 09:54:34

文章标签 sparksql分组排序 spark 大数据数据代码实现 文章分类 Spark 大数据

前言

在实际开发过程中，我们会经常碰到求TopN这样常见的需求，那在Spark中，是如何实现求TopN呢？带着这个问题，就来看一下TopN的实现方式都有哪些！

方式1：采用groupByKey

思路：

按照key对数据进行聚合（groupByKey）
对同组的key的所有value先转换为List，然后进行排序，最后取TopN

代码实现：

// 构造上下文
val conf = new SparkConf().setMaster("local").setAppName("topn")
val sc = SparkContext.getOrCreate(conf)

// 创建rdd
val path = "datas/groupsort.txt"
val rdd = sc.textFile(path)

// rdd操作得出结果
val rdd2 = rdd.map(_.split(" "))

val result = rdd2.map(arr => (arr(0).trim, arr(1).trim.toInt))
    .groupByKey()
    .map {
        case (key, values) => {
            // 对values中的数据进行排序，然后获取最大的前三个数据
            val sortedValues = values.toList.sorted
            val top3Values = sortedValues.takeRight(3).reverse
            (key, top3Values)
        }
    }
// 打印输出
result.collect().foreach(println)
sc.stop()

方式2：采用两阶段聚合优化

思路：

第一阶段给每个key加上一个随机值前缀，然后进行局部的聚合操作
第二阶段去除每个key的前缀，然后进行全局的聚合操作

代码实现：

// 构造上下文
val conf = new SparkConf().setMaster("local").setAppName("topn")
val sc = SparkContext.getOrCreate(conf)

// 创建rdd
val path = "datas/groupsort.txt"
val rdd = sc.textFile(path)

// rdd操作得出结果
val rdd2 = rdd.map(_.split(" "))

val result = rdd2.mapPartitions(iter => {
      val random = Random
      iter.map(arr => {
        val key = arr(0).trim
        val value = arr(1).trim.toInt
        ((random.nextInt(5),key),value)
      })
    }).groupByKey()
      .flatMap{
          case ((_,key),values) => {
            val sortedValues = values.toList.sorted
            val top3Values = sortedValues.takeRight(3).reverse
            top3Values.map(count => (key,count))
          }
        }
        .groupByKey()
        .flatMap{
          case (key, values) => {
            val sortedValues = values.toList.sorted
            val top3Values = sortedValues.takeRight(3).reverse
            top3Values.map((key,_))
          }
        }
// 打印输出
result.collect().foreach(println)
sc.stop()

方式3：先获取每个分区的TopN，后获取全局TopN

思路：

对于每一个key获取每个分区中的TopN
做全局的数据聚合操作，获取TopN

代码实现：

// 构造上下文
val conf = new SparkConf().setMaster("local").setAppName("topn")
val sc = SparkContext.getOrCreate(conf)

// 创建rdd
val path = "datas/groupsort.txt"
val rdd = sc.textFile(path)

// rdd操作得出结果
val rdd2 = rdd.map(_.split(" "))

val result3 = rdd2.map(arr => {
    val key = arr(0).trim
    val count = arr(1).trim.toInt
    (key, count)
})
.mapPartitions(iter => {
    import scala.collection.mutable

    val temp = iter.foldLeft(mutable.Map[String, ArrayBuffer[Int]]())((a, b) => {
        val key = b._1
        val count = b._2
        val buf = a.getOrElseUpdate(key, new mutable.ArrayBuffer[Int]())
        buf += count
        if (buf.size > 3) {
            val max3Vals = buf.sorted.takeRight(3)
            a(key) = max3Vals
        }
        a
    })
    val top3IterPrePartition = temp.toList.flatMap {
        case (key, countIters) => countIters.map(count => (key, count))
    }
    top3IterPrePartition.toIterator
})
.groupByKey()
.flatMap {
    case (key, values) => {
        val sorted = values.toList.sorted
        val top3 = sorted.takeRight(3).reverse
        top3.map((key, _))
    }
}
result3.foreachPartition(iter => iter.foreach(println))
sc.stop()

方式4：采用aggregateByKey

思路：

初始值为mutable.ArrayBufferInt
对每组key中的每个value和之前的聚合值进行聚合操作，就是在分区中，来一个value和上次取出的TopN进行一次排序，取出新的TopN
对每个分区操作后的局部聚合结果进行合并聚合操作，就是在分区间，来一个分区和上次取出的TopN进行一次合并排序，取出新的TopN

代码实现：

// 构造上下文
val conf = new SparkConf().setMaster("local").setAppName("topn")
val sc = SparkContext.getOrCreate(conf)

// 创建rdd
val path = "datas/groupsort.txt"
val rdd = sc.textFile(path)

// rdd操作得出结果
val rdd2 = rdd.map(_.split(" "))

import scala.collection.mutable
val result4 = rdd2.map(arr => {
    val key = arr(0).trim
    val count = arr(1).trim.toInt
    (key, count)
}).aggregateByKey(mutable.ArrayBuffer[Int]())(
    (u, v) => {
        u += v
        u.sorted.takeRight(3).reverse
    },
    (u1, u2) => {

        u1 ++= u2
        u1.sorted.takeRight(3).reverse
    }
).flatMap {
    case (key, values) => {
        values.toList.map((key, _))
    }
}
result4.foreachPartition(iter => iter.foreach(println))
sc.stop()