SparkStreaming高级算子应用【combineByKey、transform，checkpoint】

一.combineByKey算子简介

　　功能：实现分组自定义求和及计数。

　　特点：用于处理(key,value)类型的数据。

　　实现步骤：

　　　　1.对要处理的数据进行初始化，以及一些转化操作

　　　　2.检测key是否是首次处理，首次处理则添加，否则则进行分区内合并【根据自定义逻辑】

　　　　3.分组合并，返回结果

二.combineByKey算子代码实战

package big.data.analyse.scala.arithmetic

import org.apache.spark.sql.SparkSession
/**
  * Created by zhen on 2019/9/7.
  */
object CombineByKey {
  def main (args: Array[String]) {
    val spark = SparkSession.builder().appName("CombineByKey").master("local[2]").getOrCreate()
    val sc = spark.sparkContext
    sc.setLogLevel("error")

    val initialScores = Array((("hadoop", "R"), 1), (("hadoop", "java"), 1),
                              (("spark", "scala"), 1), (("spark", "R"), 1), (("spark", "java"), 1))

    val d1 = sc.parallelize(initialScores)

    val result = d1.map(x => (x._1._1, (x._1._2, x._2))).combineByKey(
      (v : (String, Int)) => (v : (String, Int)), // 初始化操作，当key首次出现时初始化以及执行一些转化操作
      (c : (String, Int), v : (String, Int)) => (c._1 + "," + v._1, c._2 + v._2), // 分区内合并，非首次出现时进行合并
      (c1 : (String,Int),c2 : (String,Int)) => (c1._1 + "," + c2._1, c1._2 + c2._2)) // 分组合并
      .collect()

    result.foreach(println)
  }
}

三.combineByKey算子执行结果

　　

四.transform算子简介

　　在spark streaming中使用，用于实现把一个DStream转化为另一个DStream。

五.transform算子代码实现

package big.data.analyse.streaming

import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * Created by zhen on 2019/09/21.
  */
object StreamingSocket {

  def functionToCreateContext():StreamingContext = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("StreaingTest")
    val ssc = new StreamingContext(conf, Seconds(10))
    val lines = ssc.socketTextStream("192.168.245.137", 9999)

    val words = lines.flatMap(_.split(" "))
    val pairs = words.map(word=>(word,1))

    /**
      * 过滤内容
      */
    val filter = ssc.sparkContext.parallelize(List("money","god","oh","very")).map(key => (key,true))

    val result = pairs.transform(rdd => { // transform：把一个DStream转化为另一个SDtream
      val leftRDD = rdd.leftOuterJoin(filter)
      val word = leftRDD.filter( tuple =>{
        val y = tuple._2
        if(y._2.isEmpty){
          true
        }else{
          false
        }
      })
      word.map(tuple =>(tuple._1,1))
    }).reduceByKey(_+_)

    result.foreachRDD(rdd => {
      if(!rdd.isEmpty()){
        rdd.foreach(println)
      }
    })
    ssc.checkpoint("D:\checkpoint")
    ssc
  }
  Logger.getLogger("org").setLevel(Level.WARN) // 设置日志级别
  def main(args: Array[String]) {
    val ssc = StreamingContext.getOrCreate("D:\checkpoint", functionToCreateContext _)

    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }
}

六.transform算子执行结果

　　输入：

　　　　　　

　　输出：

　　　　

　　备注：若在执行流计算时报：Some blocks could not be recovered as they were not found in memory. To prevent such data loss, enable Write Ahead Log (see programming guide for more details.，可以清空checkpoint目录下对应的数据【当前执行生成的数据】，可以解决这个问题。