Streaming的重要算子

最新推荐文章于 2024-07-30 14:37:58 发布

14yhuang

最新推荐文章于 2024-07-30 14:37:58 发布

阅读量398

点赞数

CC 4.0 BY-SA版权

分类专栏：大数据知识文章标签： spark

本文链接：https://blog.youkuaiyun.com/qq_36459386/article/details/86661441

大数据知识专栏收录该内容

53 篇文章

订阅专栏

本文深入探讨了Apache Spark Streaming中的关键操作，包括Transform、UpdateStateByKey、ForeachRDD及Windows等，展示了如何通过这些操作处理实时流数据，实现数据聚合、状态更新、外部数据源保存及窗口计算等功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Transform

transform操作，应用在DStream上时，可以用于执行任意的RDD到RDD的转换操作。它可以用于实现，DStream API中所没有提供的操作。比如说，DStream API中，并没有提供将一个DStream中的每个batch，与一个特定的RDD进行join的操作。但是我们自己就可以使用transform操作来实现该功能，返回值还是Dstream。

package com.ruozedata.bigdata.streaming03

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

import scala.collection.mutable.ListBuffer

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

    val blackTuple=new ListBuffer[(String,Boolean)]
    blackTuple.append(("doudou",true))
    blackTuple.append(("huahua",true))
    val blacksRDD=ssc.sparkContext.parallelize(blackTuple)


    val lines=ssc.socketTextStream("hadoop000",9999)
    //xx,xx info => (xx,(xx,xx info))
    //返回Dstream
    lines.map(x=>(x.split(",")(0),x)).transform(rdd=>{
      rdd.leftOuterJoin(blacksRDD).filter(x=>{
        x._2._2.getOrElse(false) !=true
      }).map(_._2._1)
    }).print()


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

UpdateStateByKey

相当于对不同批次的累加和更新，可以下一批次把之前批次的数据都参与计算。需要开启checkpoint记录批次数据。

package com.ruozedata.bigdata.streaming03

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


import scala.collection.mutable.ListBuffer

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

    //记录以前批次的,指定到当前目录
    ssc.checkpoint("hdfs://hadoop000:9000/ss/logs")

    val lines=ssc.socketTextStream("hadoop000",9999)
    val results=lines.flatMap(_.split(",")).map((_,1))

    val state = results.updateStateByKey(updateFunction)
    state.print()

    ssc.start()
    ssc.awaitTermination()
  }

  def updateFunction(currentValues:Seq[Int],preValues:Option[Int]):Option[Int] = {
    val curr = currentValues.sum
    val pre = preValues.getOrElse(0)

    Some(curr + pre)
  }

}

ForeachRDDApp

保存Dstream的所有rdd的数据到外部数据源。
流数据主要是存放在外部数据源上，而不是hadoop上。


package com.ruozedata.bigdata.streaming03

import java.sql.DriverManager

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

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


    val lines=ssc.socketTextStream("hadoop000",9999)
    val results=lines.flatMap(_.split(",")).map((_,1)).reduceByKey(_+_)

    //(ruoze,2)(jepson,1)
    results.foreachRDD(rdd =>{
      rdd.foreachPartition(partition=>{
        val connection = createConnection()

        partition.foreach(pair=>{
                  val sql=s"insert into wc(word,count) values('${pair._1}',${pair._2})"
                  connection.createStatement().execute(sql)
                  connection.close()
        })
      })


//      rdd.foreach(pair =>{
//        //connection必须在worker端创建，但是会导致每条rdd都会创建一次，所以应当用foreachpartition
//        val connection = createConnection()
//        val sql=s"insert into wc(word,count) values('${pair._1}',${pair._2})"
//        connection.createStatement().execute(sql)
//        connection.close()
//      })
    })

    ssc.start()
    ssc.awaitTermination()
  }

  def createConnection() ={
    Class.forName("com.mysql.jdbc.Driver")
    DriverManager.getConnection("jdbc:mysql://hadoop000:3306/g5_spark","root","123456")
  }
}

WindowsApp

实现一阶段内的累加，而不是程序启动时
假设每隔5s 1个batch,上图中窗口长度为15s，窗口滑动间隔10s。窗口长度和滑动间隔必须是batchInterval的整数倍。如果不是整数倍会检测报错。
在这里插入图片描述

package com.ruozedata.bigdata.streaming03

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

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

    val lines = ssc.socketTextStream("hadoop000",9999)
    lines.flatMap(_.split(",")).map((_,1)).reduceByKeyAndWindow((a:Int,b:Int)=>(a+b),Seconds(10),Seconds(5)).print()

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

<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.27</version>
    </dependency>

http://blog.51cto.com/xpleaf/2115343?source=dra