Spark Stream之DStream的三个特殊原语updateStateByKey、transform、window operations

updateStateByKey：将历史结果应用到当前批次。

import org.apache.spark.{HashPartitioner, SparkConf}
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
  * 在用历史结果应用到当前批次的需求时，可以用updateStateByKey原语实现
  * 实现历史批次累加功能也可以借助数据库来实现
  * updateStateByKey只有获取历史批次结果应用到当前批次中的功能，该原语是没有存储历史批次结果的功能的
  * 所以，实现批次累加必须要进行checkpoint----streaming中，checkpoint具有存储历史结果的功能
  */
object AccSparkStreamingWC {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("AccSparkStreamingWC").setMaster("local[2]")
    val ssc = new StreamingContext(conf, Seconds(5))

    // 做checkpoint
    ssc.checkpoint("hdfs://node01:9000/cp-20190110-1")

    // 获取数据
    val dStream = ssc.socketTextStream("node01", 8888)

    // 开始统计
    val tups: DStream[(String, Int)] = dStream.flatMap(_.split(" ")).map((_, 1))
    // 调用updateStateByKey原语进行批次累加
    val result: DStream[(String, Int)] = tups.updateStateByKey(func, new HashPartitioner(ssc.sparkContext.defaultParallelism), true)

    result.print()

    ssc.start()
    ssc.awaitTermination()
  }

  /**
    * 迭代器中，
    * 第一个参数：数据中的key
    * 第二个参数：当前批次中相同key对应的value  Seq(1,1,1,1,1)
    * 第三个参数：历史结果中相同key对应的value  Some(2)
    */
  val func = (it: Iterator[(String, Seq[Int], Option[Int])]) => {
    it.map(x => {
      (x._1, x._2.sum + x._3.getOrElse(0))
    })
  }
}

transform：用于操作DStream里面的rdd。

import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.{Milliseconds, StreamingContext}

/**
  * 用transform可以操作DStream里面的rdd
  */
object TransformDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("transformdemo").setMaster("local[2]")
    val ssc = new StreamingContext(conf, Milliseconds(2000))

    val dstream = ssc.socketTextStream("node01", 8888)
    val res: DStream[(String, Int)] = dstream.transform(rdd => {
      rdd.flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _)
    })
    res.print()

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

window operations：运用在需要展示的结果范围与批次间隔不一致时。
窗口操作window operations：
窗口（window）是指展示数据结果的范围，是streaming中用来描述展示批次间隔的结果范围的，所以一个窗口往往会包含多个批次间隔的结果范围。
窗口操作：一段时间内数据发生的变化
窗口操作的过程中，需要我们指定两个参数：
窗口长度：是指窗口的持续时间（每次展示的结果范围）
滑动间隔：是指窗口的间隔（窗口从一个地方滑动到另一个地方的时间间隔）
注意：这两个参数需要是Dstream批次间隔的倍数。
应用场景：
需要展示的结果范围与批次间隔不一致时。
比如批次间隔为2秒，但是我需要每次展示1个小时的结果范围，类似于这样的需求就需要窗口操作。如果把批次间隔直接调整为1小时，可能会因为分析的数据太多出现延迟甚至出现OOM。

import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Milliseconds, Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.DStream

object WindowOperationsDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("WindowOperationsDemo").setMaster("local[2]")
    val ssc = new StreamingContext(conf, Milliseconds(2000))

    val dstream = ssc.socketTextStream("node01", 8888)
    val tups: DStream[(String, Int)] = dstream.flatMap(_.split(" ")).map((_, 1))
    val res: DStream[(String, Int)] =
      tups.reduceByKeyAndWindow((x: Int, y: Int) => x + y, Seconds(10), Seconds(10))

    res.print()

    ssc.start()
    ssc.awaitTermination()

  }
}