SparkStreaming学习之——无状态与有状态转化、遍历kafka的topic消息、WindowOperations

已于 2023-04-25 20:49:23 修改
阅读量1.1k 收藏
点赞数
分类专栏： # Spark 文章标签： kafka 学习 分布式
于 2023-04-25 19:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Helen_1997_1997/article/details/130363644
版权

目录

一、状态转化

二、kafka topic A→SparkStreaming→kafka topic B

(一)rdd.foreach与rdd.foreachPartition

(二)案例实操1

1.需求：

2.代码实现：

3.运行结果

(三)案例实操2

1.需求：

2.代码实现：

3.运行结果

三、WindowOperations

1.WindowOperations 窗口概述

2.代码示例

3.运行结果

一、状态转化

        无状态转化操作就是把简单的 RDD 转化操作应用到每个批次上，也就是转化 DStream 中的每一个 RDD。

        有状态转化操作就是窗口与窗口之间的数据有关系。上次一UpdateStateByKey 原语用于记录历史记录，有时，我们需要在 DStream 中跨批次维护状态(例如流计算中累加 wordcount)。针对这种情况，updateStateByKey()为我们提供了对一个状态变量的访问，用于键值对形式的 DStream。给定一个由(键，事件)对构成的 DStream，并传递一个指 定如何根据新的事件更新每个键对应状态的函数，它可以构建出一个新的 DStream，其内部数据为(键，状态) 对。

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object SparkStreamingKafkaSource {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setAppName("sparkKafkaStream").setMaster("local[*]")
    val streamingContext = new StreamingContext(conf, Seconds(5))

    streamingContext.checkpoint("checkpoint")
    val kafkaParams = Map(
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "lxm147:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG -> "sparkstreamgroup1")
    )

    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      streamingContext,
      LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe(Set("sparkkafkastu"), kafkaParams)
    )

    // TODO 无状态：每个窗口数据独立
    /*val wordCountStream: DStream[(String, Int)] = kafkaStream.flatMap(_.value().toString.split("\\s+"))
      .map((_, 1))
      .reduceByKey(_ + _)
    wordCountStream.print()*/

    // TODO 有状态：窗口与窗口之间的数据有关系
    val sumStateStream: DStream[(String, Int)] = kafkaStream.flatMap(x => x.value().toString.split("\\s+"))
      .map((_, 1))
      .updateStateByKey {
        case (seq, buffer) => {
          println("进入到updateStateByKey函数中")
          println("seqvalue:", seq.toList.toString())
          println("buffer:", buffer.getOrElse(0).toString)
          val sum: Int = buffer.getOrElse(0) + seq.sum
          Option(sum)
        }
      }
    sumStateStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

有状态转化会将之前的历史记录与当前输入的数据进行计算：

二、kafka topic A→SparkStreaming→kafka topic B

(一)rdd.foreach与rdd.foreachPartition

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerConfig, ProducerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

import java.util

/**
 * 将数据从kafka的topic A取出数据后加工处理，之后再输出到kafka的topic B中
 */
object SparkStreamKafkaSourceToKafkaSink {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setAppName("sparkKafkaStream2").setMaster("local[*]")
    val streamingContext = new StreamingContext(conf, Seconds(5))
    streamingContext.checkpoint("checkpoint")

    streamingContext.checkpoint("checkpoint")
    val kafkaParams = Map( // TODO 连接生产者端的topic
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "lxm147:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG -> "kfkgroup2")
    )

    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      streamingContext,
      LocationStrategies.PreferConsistent,
      // 如果没有topic需要创建
      // kafka-topics.sh --create --zookeeper lxm147:2181 --topic sparkkafkademoin --partitions 1 --replication-factor 1
      ConsumerStrategies.Subscribe(Set("sparkkafkademoin"), kafkaParams)
    )

    println("1.配置spark消费kafkatopic")
    // TODO 使用foreachRDD太过消耗资源——不推荐
    kafkaStream.foreachRDD( // 遍历
      rdd => {
         println("2.遍历spark DStream中每个RDD")// 每隔5秒输出一次
        /* rdd.foreach(
          y => { // y:kafka中的keyValue对象
            println(y.getClass + " 遍历RDD中的每一条kafka的记录")
            val props = new util.HashMap[String, Object]()// TODO 连接消费者端的topic
            props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "lxm147:9092")
            props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
            props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
            val producer = new KafkaProducer[String, String](props)
            val words: Array[String] = y.value().toString.trim.split("\\s+") // hello world
            for (word <- words) {
              val record = new ProducerRecord[String, String]("sparkkafkademoout", word + ",1")
              producer.send(record)
            }
          }
        )  */
        rdd.foreachPartition(
          rdds => { // rdds是包含rdd某个分区内的所有元素
            println("3.rdd 每个分区内的所有kafka记录集合")
            val props = new util.HashMap[String, Object]() // TODO 连接消费者端的topic
            props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "lxm147:9092")
            props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
            props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
            val producer = new KafkaProducer[String, String](props)
            rdds.foreach(
              y => {
                println("4.遍历获取rdd某一个分区内的每一条消息")
                val words: Array[String] = y.value().trim.split("\\s+")
                for (word <- words) {
                  val record = new ProducerRecord[String, String]("sparkkafkademoout", word + ",1")
                  producer.send(record)
                }
              }
            )
          }
        )
      }
    )
    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

(二)案例实操1

1.需求：

清洗前：
user            ,                        friends
3197468391,1346449342 3873244116 4226080662 1222907620

清洗后：
user             ,friends                  目标topic:user_friends2
3197468391,1346449342
3197468391,3873244116
3197468391,4226080662
3197468391,1222907620

2.代码实现：

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerConfig, ProducerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}

import java.util

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

    val kafkaParams = Map( // TODO 连接生产者端的topic
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "lxm147:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG -> "sparkuf3"),
      (ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "earliest")
    )

    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      streamingContext,
      LocationStrategies.PreferConsistent,
      // 如果没有topic需要创建
      // kafka-topics.sh --create --zookeeper lxm147:2181 --topic user_friends2 --partitions 1 --replication-factor 1
      ConsumerStrategies.Subscribe(Set("user_friends_raw"), kafkaParams)
    )

    kafkaStream.foreachRDD(
      rdd => {
        rdd.foreachPartition(x => {
          val props = new util.HashMap[String, Object]() // TODO 连接消费者端的topic
          props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "lxm147:9092")
          props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
          props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
          val producer = new KafkaProducer[String, String](props)
          x.foreach(y => {
            val splits: Array[String] = y.value().split(",")
            if (splits.length == 2) {
              val userid: String = splits(0)
              val friends: Array[String] = splits(1).split("\\s+")
              for (friend <- friends) {
                val record = new ProducerRecord[String, String]("user_friends2", userid + "," + friend)
                producer.send(record)
              }
            }
          })
        })
      })
    
    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

3.运行结果

(三)案例实操2

1.需求：

清洗前：

event           ,                   yes               ,        maybe   ,              invited               ,no
1159822043,1975964455 3973364512,2733420590 ,1723091036 795873583,3575574655

清洗前后：

eventid        ,friendid        ,status
1159822043,1975964455,yes
1159822043,3973364512,yes
1159822043,2733420590,maybe
1159822043,1723091036,invited

1159822043,795873583,invited

1159822043,3575574655,no

2.代码实现：

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerConfig, ProducerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

import java.util

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

    val kafkaParams = Map( // TODO 连接生产者端的topic
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "lxm147:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG -> "sparkevent"),
      (ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "earliest")
    )

    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      streamingContext,
      LocationStrategies.PreferConsistent,
      // 如果没有topic需要创建
      // kafka-topics.sh --create --zookeeper lxm147:2181 --topic event2 --partitions 1 --replication-factor 1
      ConsumerStrategies.Subscribe(Set("event_attendees_raw"), kafkaParams)
    )

    kafkaStream.foreachRDD(
      rdd => {
        rdd.foreachPartition(x => {
          val props = new util.HashMap[String, Object]() // TODO 连接消费者端的topic
          props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "lxm147:9092")
          props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
          props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
          val producer = new KafkaProducer[String, String](props)

          x.foreach(y => { // todo 遍历获取rdd某一个分区内的每一条消息
            val splits: Array[String] = y.value().split(",")
            val eventID: String = splits(0)

            if (eventID.trim.nonEmpty) {
              if (splits.length >= 2) {
                val yesarr: Array[String] = splits(1).split("\\s+")
                for (yesID <- yesarr) {
                  val yes = new ProducerRecord[String, String]("event2", eventID + "," + yesID + ",yes")
                  producer.send(yes)
                }
              }
              if (splits.length >= 3) {
                val maybearr: Array[String] = splits(2).split("\\s+")
                for (maybeID <- maybearr) {
                  val yes = new ProducerRecord[String, String]("event2", eventID + "," + maybeID + ",maybe")
                  producer.send(yes)
                }
              }
              if (splits.length >= 4) {
                val invitedarr: Array[String] = splits(3).split("\\s+")
                for (invitedID <- invitedarr) {
                  val invited = new ProducerRecord[String, String]("event2", eventID + "," + invitedID + ",invited")
                  producer.send(invited)
                }
              }
              if (splits.length >= 5) {
                val noarr: Array[String] = splits(4).split("\\s+")
                for (noID <- noarr) {
                  val no = new ProducerRecord[String, String]("event2", eventID + "," + noID + ",no")
                  producer.send(no)
                }
              }
            }
          })
        })
      })
    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

3.运行结果

三、WindowOperations

1.WindowOperations 窗口概述

        Window Operations 可以设置窗口的大小和滑动窗口的间隔来动态的获取当前Steaming 的允许状态。所有基于窗口的操作都需要两个参数，分别为窗口时长以及滑动步长。

➢ 窗口时长：计算内容的时间范围；

➢ 滑动步长：隔多久触发一次计算。

注意：这两者都必须为采集周期大小的整数倍。

2.代码示例

import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}

object SparkWindowDemo1 {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setAppName("sparkwindow1").setMaster("local[*]")
    val streamingContext = new StreamingContext(conf, Seconds(3))
    streamingContext.checkpoint("checkpoint")

    val kafkaParams = Map( // TODO 连接生产者端的topic
      (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "lxm147:9092"),
      (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> "org.apache.kafka.common.serialization.StringDeserializer"),
      (ConsumerConfig.GROUP_ID_CONFIG -> "sparkwindow"),
      (ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "latest")
    )

    val kafkaStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      streamingContext,
      LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe(Set("sparkkafkastu"), kafkaParams)
    )
    val winStream: DStream[(String, Int)] = kafkaStream.flatMap(x => x.value().trim.split("\\s+"))
      .map((_, 1))
      .window(Seconds(9), Seconds(3))
    winStream.print()

    streamingContext.start()
    streamingContext.awaitTermination()
  }
}

注意：window的步长不进行设置，默认是采集周期

3.运行结果

 

雷神乐乐
关注
专栏目录
消息中间件学习总结（12）——Kafka与RocketMQ的多Topic对性能稳定性的影响比较分析
科技D人生
10-16 1570
引言 上期我们对比了RocketMQ和Kafka在多Topic场景下，收发消息的对比测试，RocketMQ表现稳定，而Kafka的TPS在64个Topic时可以保持13万，到了128个Topic就跌至0.85万，导致无法完成测试。我们不禁要问： 为什么看不到Kafka性能暴跌的趋势呢？ 今天的测试，就来排查一下这个问题，然后验证一下两个系统对外服务的稳定性。本次测试，要引入“稳定性测试”这个...
Spark(39) -- SparkStreaming -- 流式应用状态
erainm
10-12 164
流式应用状态 业务一：无状态Stateless 业务二：有状态State
201.Spark（八）：SparkStreaming基本概念，DStream创建，转换，输出，关闭
鹏哥哥Aaa
04-05 887
SparkStreaming基本概念，DStream创建，转换，输出，关闭
【Spark】 Spark Streaming的状态转换与输出
最新发布
weixin_44664746的博客
08-21 234
对每个分段的DStream数据的处理就是对DStream的转换操作。
【SparkStreaming】DStream创建和转换（无状态操作，有状态操作）
weixin_43923463的博客
09-21 722
专门的Executor读取数据，速度不统一跨机器传输数据，WALExecutor读取数据通过多个线程的方式，想要增加并行度，则需要多个流unionoffset存储在Zookeeper中Executor读取数据并计算增加Executor个数来增加消费的并行度offset存储​ a) CheckPoint(getActiveOrCreate方式创建StreamingContext)​ b) 手动维护(有事务的存储系统)
SparkStreaming（六）操作函数之Window Operations
myroncham的博客
01-04 1016
目录： 5.2、Window Operations 5.2.1、window(windowLength, slideInterval) 5.2.2、countByWindow(windowLength,slideInterval) 5.2.3、reduceByWindow(func, windowLength,      slideInterval) 5.2.4、reduceByKeyA...
SparkStreaming中的转化操作之--无状态操作
大白
04-06 533
没有数据的时候不会报错，它会一直等待，所以不需要进行判断   每个DStream在内部是由许多RDD(也叫批次)组成，且无状态转化操作是分别应用到每个RDD上的。  无状态转化操作的例子map、filter、等等，操作都是每个批次中的数据,但是DStream如果使用join,union等基于健的操作的话，那么所传的RDD就必须同样也是DStream才行SparkStreaming中无状态操作的例子...
Spark踩坑记——SparkStreaming+Kafka
02-25
在WeTest舆情项目中，需要对每天千万级的游戏评论信息进行词频统计，在生产者一端，我们...（如有任何纰漏欢迎补充来踩，我会第一时间改正^v^）用sparkstreaming流式处理kafka中的数据，第一步当然是先把数据接收过来，
Spark Streaming快速入门系列(4) | 无状态和有状态操作
Knight
09-06 450
目录一.无状态转换操作二.有状态转换操作updateStateByKey 一.无状态转换操作 官网 http://spark.apache.org/docs/2.1.1/streaming-programming-guide.html#transformations-on-dstreams transform 原语允许 DStream上执行任意的RDD-to-RDD函数。 可以用来执行一些 RDD 操作, 即使这些操作并没有在 SparkStreaming 中暴露出来. 该函数每一批次调度一次。其
有状态的sparkStreaming
xuehuagongzi000的博客
06-20 269
1、mapWithState 案例：是wordCount小程序，单词word持续增加，由5增加到100了，还会持续增加，因为用到了它的前置数据。必须checkPoint。 ssc.checkpoint("hdfs://linux-hadoop01.ibeifeng.com:8020/beifeng/spark/streaming/chkdir45254") def mappingFun...
大数据之sparkStreaming（三）：Spark Streaming的状态操作
汪雯琦的博客
03-15 1486
文章目录3、Spark Streaming的状态操作3.1 updateStateByKey案例：updateStateByKey3.2 Windows 3、Spark Streaming的状态操作 在Spark Streaming中存在两种状态操作 UpdateStateByKey Windows操作 使用有状态的transformation，需要开启Checkpoint spark st...
Spark之Spark Streaming
lslslslslss的博客
02-18 2270
Spark Streaming是什么 Spark Streaming用于流式数据处理 DStream是什么 Spark Streaming使用离散化流作为抽象表示，称作DStream，是随着时间的推移而得到的数据的序列。在DStream内部，每个时间区间收到的数据都作为RDD存在，DStream就是由这些RDD所组成的序列，DStream就是对RDD在实时处理场景中的一种封装。 架构图 DStream的创建 1.通过RDD队列 ...
Spark Streaming状态管理函数
willyan2007的博客
09-07 749
Spark Streaming状态管理函数引用
sparkStreaming带状态更新（scala）
韩利鹏
12-15 1578
带状态的更新是使用的updateStateByKey方法，里面传入一个函数，函数小自己写，注意需要设置checkpointpackage sparkStreaming__import org.apache.spark.streaming.kafka.KafkaUtils import org.apache.spark.streaming.{Seconds, StreamingContext} imp
Spark综合学习笔记（八）SparkStreaming案例2 状态管理
斯特凡今天也很帅的博客
11-23 7950
学习致谢： https://www.bilibili.com/video/BV1Xz4y1m7cv?p=42 需求： 对从Socket接收的数据做WordCoun并要求能够和历史数据进行累加! 如:先发了一个spark,得到spark,1然后不管隔多久再发一个spark,得到spark,2也就是说要对数据的历史状态进行维护! 实现思路： 一、updataStateByKey 先设置checkpoint存储状态status，使用updataStateByKey实现状态管理的单词统计，需要自己写一个updat
Spark Streaming ------ 有状态转化和无状态转化
https://blog.csdn.net/sinat_36710456
01-10 1737
无状态转化： 每次计算的时间，仅仅计算当前时间切片的内容，每个批次处理都不依赖于先前批次的数据。 如，每次只计算1s时间内产生的RDD。 有状态转化： 依赖之前的批次数据或者中间结果来计算当前批次的数据，不断的把当前的计算和历史时间切片的RDD进行累计。 如，计算某个单词出现的次数，需要把当前的状态与历史的状态相累加，随着时间的流逝， 数据规模会越来越大，包括updateStat...
【Spark】Spark Streaming编程实践（简单易懂 快速上手）
毕业于东北大学软件工程专业，现就职于字节跳动
12-31 5150
文章目录知识储备1 基本概念2 WordCount入门3 DStream的创建3.1 RDD队列3.1.1 用法3.1.2 案例3.2 自定义数据源3.3 Kafka数据源3.3.1 版本3.3.2 Kafka 0-10 Direct3.4 DStream转换3.4.1 无状态转化操作Transformjoin3.4.2 有状态转化操作windowOperations 知识储备 1、数据处理的方式： 流式数据处理（Streaming） 批量数据处理（batch） 2、数据处理延迟的长短 实时数据处理：
【Kafka】kafka 转换算子（详解）
beautiful_huang的博客
02-11 1325
1.stateless transformation 无状态的转换算子：流处理器不涉及状态的处理和存储 1.1 branch 分支 ：将一个stream转换为1到多个Stream stream----->stream[] //branch 分流 KStream<String, String>[] streams = kStream.branch((k, v...
SparkStreaming处理Kafka数据：实战与优化
"SparkStreaming与Kafka的整合在大数据实时处理中的应用及优化经验分享" 在WeTest的舆情分析项目中，面临的问题是如何处理每天数千万条的游戏评论数据，进行词频统计。在这个过程中，数据在生产端被存入Kafka，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值