Spark——实现统计TOP-N的5种方法使用累加器规避shuffle

1========================================================================

package com.rdd.topn

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object HotCategoryTop10Analysis {
def main(args: Array[String]): Unit = {
//TODO Top10热门品类
val conf: SparkConf = new SparkConf().setMaster(“local[*]”).setAppName(“HotCategoryTop10Analysis”)
val sc = new SparkContext(conf)
val actionRDD: RDD[String] = sc.textFile(“in/user_visit_action.txt”)
//首先对数据进行过滤清洗先统计点击事件 品类ID不能为-1 如果是-1就不是点击事件
//1.统计品类的点击数量（品类ID,点击数量） 当第六个字段不是-1时，是点击事件
val clickActionRDD: RDD[String] = actionRDD.filter {
data => {
val arr = data.split("")
arr(6) != “-1” //如果第六个字段不是-1 就不是点击事件 直接过滤掉无用数据
}
}
val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(
action => {
var datas = action.split("")
(datas(6), 1)
}
).reduceByKey(_ + )
//2.统计品类的下单、数量（品类ID,下单数量） 如果第八个字段肯定不能为Null
val orderActionRDD: RDD[String] = actionRDD.filter {
data => {
val arr = data.split("")
arr(8) != “null” //如果第六个字段不是-1 就不是点击事件 直接过滤掉无用数据
}
}
val orderCountRDD: RDD[(String, Int)] = orderActionRDD.flatMap(
action => {
val datas = action.split("")
val cid = datas(8) //扁平化操作
val cids = cid.split(",")
cids.map(id => (id, 1))
}
).reduceByKey( + )
//3.统计品类的支付数量（品类ID,支付数量）
val payActionRDD: RDD[String] = actionRDD.filter {
data => {
val arr = data.split("")
arr(10) != “null” //如果第六个字段不是-1 就不是点击事件 直接过滤掉无用数据
}
}
val payCountRDD: RDD[(String, Int)] = payActionRDD.flatMap(
action => {
val datas = action.split("")
val cid = datas(10) //扁平化操作
val cids = cid.split(",")
cids.map(id => (id, 1))
}
).reduceByKey( + )
//4将品类进行排序，并去除前十名
//（品类（点击数量，下单数量,支付数量））
//不同的数据源连接
//Join （参考内连接 丢失数据）多个数据源中数据不对等 有可能点击了 没下单 Join要求两边数据源相同KEY连接 可能丢失数据
// zip 要求分区中的数量位置有关系 不能用
// leftOuterJoin 以左边表为主 数据不合适
// cogroup 在自己的数据源中分组 再连接其他数据源 connect+group
// 组 点击数量 下单数量 支付数量
val cogroupRDD: RDD[(String, (Iterable[Int], Iterable[Int], Iterable[Int]))] = clickCountRDD.cogroup(orderCountRDD,payCountRDD)
val analysisRDD= cogroupRDD.mapValues {
case (clickIter, orderIter, payIter) => {
var clickCnt = 0
val iter1: Iterator[Int] = clickIter.iterator
if (iter1.hasNext) {
clickCnt = iter1.next()
}
var orderCnt = 0
val iter2: Iterator[Int] = orderIter.iterator
if (iter2.hasNext) {
orderCnt = iter2.next()
}
var payCnt = 0
val iter3: Iterator[Int] = payIter.iterator
if (iter3.hasNext) {
payCnt = iter3.next()
}
(clickCnt,orderCnt,payCnt)
}
}
val resultRDD= analysisRDD.sortBy(._2,false).take(10)
resultRDD.foreach(println)
//5先按照点击 再按照下单 再支付
//元组排序 多个无关数据组成元组 先比较第一个 再第二个 一次类推
sc.stop()
}
}
2=====================================
使用类似union
package com.rdd.topn

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

object HotCategoryTop10Analysis2 {
def main(args: Array[String]): Unit = {
//TODO Top10热门品类
val conf: SparkConf = new SparkConf().setMaster(“local[*]”).setAppName(“HotCategoryTop10Analysis”)
val sc = new SparkContext(conf)
val actionRDD: RDD[String] = sc.textFile(“in/user_visit_action.txt”)
//首先对数据进行过滤清洗先统计点击事件 品类ID不能为-1 如果是-1就不是点击事件
//优化1 actionRDD数据重复使用 解决方案 缓存或者检查点
actionRDD.cache()
//1.统计品类的点击数量（品类ID,点击数量） 当第六个字段不是-1时，是点击事件
val clickActionRDD: RDD[String] = actionRDD.filter {
data => {
val arr = data.split("")
arr(6) != “-1” //如果第六个字段不是-1 就不是点击事件 直接过滤掉无用数据
}
}
val clickCountRDD: RDD[(String, Int)] = clickActionRDD.map(
action => {
var datas = action.split("")
(datas(6), 1)
}
).reduceByKey(_ + )
//2.统计品类的下单、数量（品类ID,下单数量） 如果第八个字段肯定不能为Null
val orderActionRDD: RDD[String] = actionRDD.filter {
data => {
val arr = data.split("")
arr(8) != “null” //如果第六个字段不是-1 就不是点击事件 直接过滤掉无用数据
}
}
val orderCountRDD: RDD[(String, Int)] = orderActionRDD.flatMap(
action => {
val datas = action.split("")
val cid = datas(8) //扁平化操作
val cids = cid.split(",")
cids.map(id => (id, 1))
}
).reduceByKey( + )
//3.统计品类的支付数量（品类ID,支付数量）
val payActionRDD: RDD[String] = actionRDD.filter {
data => {
val arr = data.split("")
arr(10) != “null” //如果第六个字段不是-1 就不是点击事件 直接过滤掉无用数据
}
}
val payCountRDD: RDD[(String, Int)] = payActionRDD.flatMap(
action => {
val datas = action.split("")
val cid = datas(8) //扁平化操作
val cids = cid.split(",")
cids.map(id => (id, 1))
}
).reduceByKey( + _)
//4将品类进行排序，并去除前十名
//（品类（点击数量，下单数量,支付数量））
//不同的数据源连接
//Join （参考内连接 丢失数据）多个数据源中数据不对等 有可能点击了 没下单 Join要求两边数据源相同KEY连接 可能丢失数据
// zip 要求分区中的数量位置有关系 不能用
// leftOuterJoin 以左边表为主 数据不合适
// cogroup 在自己的数据源中分组 再连接其他数据源 ==connect+group
// 组 点击数量 下单数量 支付数量

//变化数据结构
//品类（点击数量，0,0）
//品类（下单数量，0,0）
//品类（支付数量，0,0）
val rdd1: RDD[(String, (Int, Int, Int))] = clickCountRDD.map {
  case (cid, cnt) => {
    (cid, (cnt, 0, 0))
  }
}
val rdd2: RDD[(String, (Int, Int, Int))] = orderCountRDD.map {
  case (cid, cnt) => {
    (cid, ( 0, cnt,0))
  }
}
val rdd3: RDD[(String, (Int, Int, Int))] = payCountRDD.map {
  case (cid, cnt) => {
    (cid, (0, 0, cnt))
  }
}
//将3个数据源连接在一起统一聚合计算

val sourceRDD: RDD[(String, (Int, Int, Int))] = rdd1.union(rdd2).union(rdd3)
val analysisRDD: RDD[(String, (Int, Int, Int))] = sourceRDD.reduceByKey {
  (t1, t2) => {
    (t1._1 + t2._1,
      t2._2 + t2._2,
      t1._3 + t2._3)
  }
}
val resultRDD= analysisRDD.sortBy(_._2,false).take(10)
resultRDD.foreach(println)
//5先按照点击 再按照下单 再支付
//元组排序 多个无关数据组成元组 先比较第一个 再第二个 一次类推
sc.stop()

}
}
3=============================================
package com.rdd.topn

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

object HotCategoryTop10Analysis3 {
def main(args: Array[String]): Unit = {
//TODO Top10热门品类
val conf: SparkConf = new SparkConf().setMaster(“local[*]”).setAppName(“HotCategoryTop10Analysis”)
val sc = new SparkContext(conf)
val actionRDD: RDD[String] = sc.textFile(“in/user_visit_action.txt”)
//将数据转换结构 在同一条数据中
//点击场合（品类ID，（1,0,0））
//下单场合（品类ID，（0,1,0））
//支付场合（品类ID，（0,0,1））
//将相同的品类ID的数据进行分组聚合
//品类（点击数量，下单数量，支付数量）
val flatRDD: RDD[(String, (Int, Int, Int))] = actionRDD.flatMap {
action => {
val datas = action.split("_")
if (datas(6) != “-1”) {
List((datas(6), (1, 0, 0)))
}
else if (datas(8) != “null”) {
val ids = datas(8).split(",")
ids.map(id => (id, (0, 1, 0)))
}
else if (datas(10) != “null”) {
val ids = datas(10).split(",")
ids.map(id => (id, (0, 0, 1)))
}
else {
Nil
}
}
}
val analysisRDD: RDD[(String, (Int, Int, Int))] = flatRDD.reduceByKey((t1, t2) => {
(t1._1 + t2._1,
t2._2 + t2._2,
t1._3 + t2.3)
})
val resultRDD= analysisRDD.sortBy(._2,false).take(10)
resultRDD.foreach(println)
sc.stop()
}
}

package com.rdd.topn

import org.apache.spark.rdd.RDD
import org.apache.spark.util.AccumulatorV2
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.mutable

//使用累加器 拒绝shullfe
object HotCategoryTop10Analysis4 {
def main(args: Array[String]): Unit = {
//TODO Top10热门品类
val conf: SparkConf = new SparkConf().setMaster(“local[*]”).setAppName(“HotCategoryTop10Analysis”)
val sc = new SparkContext(conf)
val actionRDD: RDD[String] = sc.textFile(“in/user_visit_action.txt”)
val acc = new HotCategoryAccumulator
sc.register(acc,“hotCategor”)
actionRDD.foreach {
action => {
val datas = action.split("_")
if (datas(6) != “-1”) {
acc.add(datas(6),“click”)
}
else if (datas(8) != “null”) {
val ids = datas(8).split(",")
ids.foreach(
id=>{
acc.add((id,“order”))
}
)
}
else if (datas(10) != “null”) {
val ids = datas(10).split(",")
ids.foreach(
id=>{
acc.add((id,“pay”))
}
)
}
}
}

val accValu: mutable.Map[String, HotCategory] = acc.value
val categories: mutable.Iterable[HotCategory] = accValu.map((_._2))
val sort: List[HotCategory] = categories.toList.sortWith(
  (left, right) => {
    if (left.clickCnt > right.clickCnt) {
      true
    } else if (left.clickCnt == right.clickCnt) {
      if (left.orderCnt > right.orderCnt) {
        true
      } else if (left.orderCnt == right.orderCnt) {
        left.payCnt > right.payCnt
      } else {
        false
      }
    } else {
      false
    }
  }
)
sort.take(10).foreach(println)


sc.stop()

}
case class HotCategory(cid:String,var clickCnt:Int,var orderCnt:Int,var payCnt:Int)
//自定义累加器
//继承AccumulatorV2定义泛型IN(品类，行为类型)
// OUT:mutable.Map[String,Hotcategory]
class HotCategoryAccumulator extends AccumulatorV2[(String,String),mutable.Map[String,HotCategory]]{
//
private val hcMap: mutable.Map[String, HotCategory] = mutable.MapString,HotCategory
override def isZero: Boolean = {
hcMap.isEmpty
}

override def copy(): AccumulatorV2[(String, String), mutable.Map[String, HotCategory]] = {
  new HotCategoryAccumulator()
}

override def reset(): Unit = {
  hcMap.clear()
}
//添加数据
override def add(v: (String, String)): Unit = {
  val cid: String = v._1
  val actionType: String = v._2
  val category: HotCategory = hcMap.getOrElse(cid,HotCategory(cid,0,0,0))
  if(actionType=="click"){
    category.clickCnt+=1
  }else if(actionType =="order"){
    category.orderCnt+=1
  }else if(actionType=="pay"){
    category.payCnt+=1
  }
  hcMap.update(cid,category)
}

override def merge(other: AccumulatorV2[(String, String), mutable.Map[String, HotCategory]]): Unit = {
  val map1: mutable.Map[String, HotCategory] = this.hcMap
  val map2: mutable.Map[String, HotCategory] = other.value
  map2.foreach{
    case (cid,hc)=>{
      val category: HotCategory = map1.getOrElse(cid,HotCategory(cid,0,0,0))
      category.clickCnt+=hc.clickCnt
      category.orderCnt+=hc.orderCnt
      category.orderCnt+=hc.payCnt
      map1.update(cid,category)
    }
  }
}

override def value: mutable.Map[String, HotCategory] = hcMap

}
}