Spark Streaming

最新推荐文章于 2023-12-08 00:02:26 发布
最新推荐文章于 2023-12-08 00:02:26 发布
阅读量136 收藏
点赞数
分类专栏： bigdata 大数据 文章标签： spark spark Streaming bigdata 流处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43655644/article/details/94588439
版权

什么是Spark Streaming

Spark Streaming 是Spark Core的扩展，可以实现实时数据流的可扩展，高吞吐，容错流处理。数据来源有很多（如Kafka、Flume、Kinesis、TCP套接字）中获取，并且可以使用以高级函数（map、reduce、join和window）表示的复杂算法进行处理。最后，处理后的数据可以推送到文件系统、数据库和实施dashboards。

在这里插入图片描述
Spark Streaming就收实时输入的数据流并将数据分成批处理，然后由Spark引擎处理以批量生成最终结果流。在这里插入图片描述
Spark Streaming提供称为离散流或DStream的高级抽象，表示连续的数据流。DStream可以从来自Kafka，Flume和Kinesis等源的输入数据流创建，也可以通过在其他DStream上应用高级操作来创建。在内部DStream表示为一系列RDD。

备注:Spark Streaming 因为底层使用批处理模拟流处理，因此在实时性上大打折扣，这就导致了Spark Streaming在流处理领域有者着先天的劣势。虽然Spark Streaming 在实时性上不如一些专业的流处理引擎(Storm/Flink)但是Spark Stream在使用吸取RDD设计经验，提供了比较友好的API算子，使得使用RDD做批处理的程序员可以平滑的过渡到流处理。

针对于Spark Streaming的微观的批处理问题，目前大数据处理领域又诞生了新秀Flink，该大数据处理引擎，在API易用性上和实时性上都有一定的兼顾，但是与spark最大的差异是Flink底层的处理引擎是流处理引擎，因此Flink天生就是流处理，但是Spark因为底层是批处理，导致了Spark Streaming在实时性上就没法和其他的专业流处理框架对比了。

sparkStreaming和storm对比
在这里插入图片描述

入门案例

  • 依赖
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-core_2.11</artifactId>
    <version>2.4.3</version>
</dependency>
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.11</artifactId>
    <version>2.4.3</version>
</dependency>
  • SparkStreamWordCount
package demo1

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

object WordCountStream {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[5]").setAppName("WordCountStream")
    val context = new StreamingContext(conf,Seconds(1))//初始化StreamingContext，他是所有SparkStream功能的主要入口
    context.sparkContext.setLogLevel("FATAL")
    context.socketTextStream("CentOS641",9999)
      .flatMap(line=>line.split(" "))
      .map((_,1))
      .reduceByKey(_+_)
      .print()

    context.start()
    context.awaitTermination()
  }
}

这里使用socketTextStream需要安装nc:[root@CentOS ~]# yum install -y nc启动nc服务[root@CentOS ~]# nc -lk 9999,注意在调用改程序的时候，需要设置local[n],n>1

概念介绍

通过上述案例的运行，现在我们来一起探讨一些流处理的概念。在处理流计算的时候，除去spark-core依赖以外我们还需要引入spark-streaming模块。要从Spark Streaming核心API中不存在的Kafka，Flume和Kinesis等源中提取数据，您必须将相应的工件spark-streaming-xyz_2.11添加到依赖项中。例如Kafka

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
    <version>2.4.3</version>
</dependency>

初始化StreamingContext
要初始化SparkStreaming程序，必须创建一个StreamingContext对象，他是所有SparkStreaming功能的主要入口点。

import org.apache.spark._
import org.apache.spark.streaming._

val conf = new SparkConf().setAppName(appName).setMaster(master)
val ssc = new StreamingContext(conf, Seconds(1))

appName参数是应用程序在集群UI上显示的名称。 master是Spark，YARN群集URL，或者是在本地模式下运行的特殊"local []"字符串。实际上，在群集上运行时，您不希望在程序中对master进行硬编码，而是使用spark-submit启动指定–master配置。但是，对于本地测试和单元测试，您可以传递“local []”以在进程中运行Spark Streaming（系统会自动检测本地系统的核的数目）。
请注意ssc会在内部创建一个SparkContext（所有Spark功能的起点），如果需要获取SparkContext对象用户可以调用ssc.sparkContext访问。例如用户使用SparkContext关闭日志。

val conf = new SparkConf()
	.setMaster("local[5]")
	.setAppName("wordCount")
val ssc = new StreamingContext(conf,Seconds(1))
//关闭其他日志
ssc.sparkContext.setLogLevel("FATAL")

必须根据应用程序的延迟要求和可用的群集资源设置批处理间隔。要使群集上运行的Spark Streaming应用程序保持稳定，系统应该能够以接收数据的速度处理数据。换句话说，批处理数据应该在生成时尽快处理。通过监视流式Web UI中的处理时间可以找到是否适用于应用程序，其中批处理时间应小于批处理间隔。

val conf = new SparkConf()
.setMaster("local[5]")
.setAppName("wordCount")
val sc = new SparkContext(conf)
val ssc = new StreamingContext(sc,Seconds(1))

当用户创建完StreamingContext对象之后，用户需要完成以下步骤

  • 定义数据源，用于创建输入的 DStreams.
  • 定义流计算算子，通过定义这些算子实现对DStream数据转换和输出
  • 调用streamingContext.start()启动数据.
  • 等待计算结束 (人工结束或者是错误) 调用 streamingContext.awaitTermination().
  • 如果是人工结束，程序应当调用 streamingContext.stop()结束流计算.
    重要因素需要谨记
  • 一旦流计算启动，无法再往计算流程中添加计算算子
  • 一旦SparkContext对象被stop后，无法重启。
  • 一个JVM系统中只能实例化一个StreamingContext对象。
  • SparkContext被stop()后，内部创建的SparkContext也会被stop.如果仅仅是想Stop StreamingContext, 可以设置stop() 中的可选参数 stopSparkContext=false即可.
ssc.stop(stopSparkContext = false)

一个SparkContext 可以重复使用并且创建多个StreamingContexts, 前提是上一个启动的StreamingContext 被停止了(但是并没有关闭 SparkContext对象) 。

Discretized Streams (DStreams)

Discretized Stream或DStream是Spark Streaming提供的基本抽象。它表示连续的数据流，可以是从源接收的输入数据流，也可以是通过转换输入流生成的已处理数据流。在内部，DStream由一系列连续的RDD表示，这是Spark对不可变分布式数据集的抽象。DStream中的每个RDD都包含来自特定时间间隔的数据，如下图所示。在这里插入图片描述
应用于DStream的任何操作都转换为底层RDD上的操作。例如，在先前Quick Start示例中，flatMap操作应用于行DStream中的每个RDD以生成单词DStream的RDD。如下图所示。
在这里插入图片描述
这些底层RDD转换由Spark引擎计算。 DStream操作隐藏了大部分细节，并为开发人员提供了更高级别的API以方便使用。

InputStream & Receivers

InputDStream表示流计算的输入，Spark中默认提供了两类的InputStream:

  • BaiscSource:如filesystem、scoket
  • AdvanceSource：如Kafka、Flume等外围系统数据
    除filesystem以外，其他的InputDStream默认都会占用一个core（计算资源），在测试或者生产环境下，分配给计算应用的Core数目必须大于Receivers个数。（本质上除filesystem源以外，其他的输入都是Receiver抽象类的实现。）了例如socketTextStream底层封装了SocketReceiver
Basic Source

因为在快速入门案例中已经使用了socketTextStream，后续我们只测试一下filesystem对于从与HDFS API兼容的任何文件系统（即HDFS，S3，NFS等）上的文件读取数据，可以通过StreamingContext.fileStream [KeyClass，ValueClass，InputFormatClass]创建DStream。文件流不需要运行Receiver，因此不需要为接收文件数据分配任何core。对于简单的文本文件，最简单的方法是StreamingContext.textFileStream（dataDirectory）

package demo4

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

object TextFileStream {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("TextFileStream")
    val ssc = new StreamingContext(conf,Seconds(3))
    ssc.sparkContext.setLogLevel("FATAL")
    val lines = ssc.textFileStream("hdfs://CentOS641:9000/test1")
    lines.flatMap(_.split(" "))
      .map((_,1))
      .reduceByKey(_+_)
      .print()
    ssc.start()
    ssc.awaitTermination()
  }
}

在HDFS上创建目录

[root@CentOS ~]# hdfs dfs -mkdir -p /test1/t_words
[root@CentOS ~]# hdfs dfs -put t_words /test/t_words
Queue of RDDs as a Stream(测试)

为了使用测试数据测试Spark Streaming应用程序，还可以使用streamingContext.queueStream（queueOfRDDs）基于RDD队列创建DStream。推入队列的每个RDD将被视为DStream中的一批数据，并像流一样处理。

package demo3

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

import scala.collection.mutable

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

    val queue = new mutable.Queue[RDD[String]]()
    val lines = ssc.queueStream(queue)
    lines.flatMap(_.split(" "))
      .map((_,1))
      .reduceByKey(_+_)
      .print()

    ssc.start()

    for (i<- 1 to 30){
      queue+=ssc.sparkContext.makeRDD(List("zhang hao nan","fan en ming"))
      Thread.sleep(500)
    }
    ssc.stop()

  }
}
Advance Source Kafka

Kafka对接Spark Streaming

package demo2


import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.{KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.kafka010.ConsumerStrategies._
import org.apache.spark.streaming.{Seconds, StreamingContext}

object KafkaWordCount {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaWordCount")
    val ssc = new StreamingContext(conf,Seconds(1))
    //关闭日志打印
    ssc.sparkContext.setLogLevel("FATAL")

    val kafkaParam = Map[String,Object](
      "bootstrap.servers" -> "CentOS641:9092",
      "key.deserializer" ->classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id"->"group1",
      "enable.auto.commit" -> (false:java.lang.Boolean)
    )

    KafkaUtils.createDirectStream(ssc,
      LocationStrategies.PreferConsistent,//设置数据加载位置策略
      Subscribe[String,String](Array("topic01"),kafkaParam))
      .map(record=>record.value())
      .flatMap(line=>line.split(" "))
      .map((_,1))
      .reduceByKey(_+_)
      .print()

    ssc.start()
    ssc.awaitTermination()

  }
}

Spark Stream主要算子

  • transform(func)
    可以将DStream的数据转变成RDD，用户操作流数据就像操作RDD感觉是一样的。
 val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
      val ssc = new StreamingContext(conf, Seconds(1))
      val kafkaParams = Map[String, Object](
        "bootstrap.servers" -> "CentOS:9092",
        "key.deserializer" -> classOf[StringDeserializer],
        "value.deserializer" -> classOf[StringDeserializer],
        "group.id" -> "group1",
        "enable.auto.commit" -> (false: java.lang.Boolean)
      )
   
    val cacheRDD = ssc.sparkContext.makeRDD(List("001 zhangsan", "002 lisi", "003 zhaoliu"))
      .map(item => (item.split("\\s+")(0), item.split("\\s+")(1)))
      .distinct()
      .cache()


      //001 apple
      KafkaUtils.createDirectStream(ssc,
        LocationStrategies.PreferConsistent,
        Subscribe[String,String](Array("topic01"),kafkaParams))
        .map(record => record.value())
        .map(value=>{
          val tokens = value.split("\\s+")
          (tokens(0),tokens(1))
        })
       .transform(rdd=>{rdd.rightOuterJoin(cacheRDD)})
      .filter(t=> {t._2._1!=None})
        .print()

    ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
    ssc.start()
    ssc.awaitTermination()
  • UpdateStateByKey
val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
val ssc = new StreamingContext(conf, Seconds(1))
ssc.checkpoint("hdfs://CentOS:9000/checkpoints")//在JVM启动参数中添加-DHADOOP_USER_NAME=root
def updateFun(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
   var total= newValues.sum+runningCount.getOrElse(0)
   Some(total)
}
ssc.socketTextStream("CentOS",9999)
    .flatMap(_.split("\\s+"))
    .map((_,1))
    .updateStateByKey(updateFun)
    .print()

ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
ssc.start()
ssc.awaitTermination()

因为UpdateStateByKey 算子每一次的输出都是全量输出，在做状态更新的时候代价较高，因此推荐大家使用mapWithState

  • mapWithState
val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
val ssc = new StreamingContext(conf, Seconds(1))
ssc.checkpoint("hdfs://CentOS:9000/checkpoints")
def updateFun(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
    var total= newValues.sum+runningCount.getOrElse(0)
    Some(total)
}
ssc.socketTextStream("CentOS",9999)
.flatMap(_.split("\\s+"))
.map((_,1))
.mapWithState(StateSpec.function((k:String,v:Option[Int],state:State[Int])=>{
    var total=0
    if(state.exists()){
        total=state.getOption().getOrElse(0)
    }
    total += v.getOrElse(1)
    state.update(total)//跟新状态
    (k,total)
}))
.print()

ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
ssc.start()
ssc.awaitTermination()

发生故障后恢复状态

var checkpointPath="hdfs://CentOS:9000/checkpoints"//设置检查点目录，一般将检查点目录存储在HDFS上
var ssc=StreamingContext.getOrCreate(checkpointPath,()=>{//第一次启时候初始化，一旦书写完成后，无法进行修改！
    println("=======init=======")
    val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
    val ssc = new StreamingContext(conf, Seconds(5))
    ssc.checkpoint(checkpointPath)
    def updateFun(newValues: Seq[Int], runningCount: Option[Int]): Option[Int] = {
        var total= newValues.sum+runningCount.getOrElse(0)
        Some(total)
    }
    ssc.socketTextStream("CentOS",9999)
    .flatMap(_.split("\\s+"))
    .map((_,1))
    .mapWithState(StateSpec.function((k:String,v:Option[Int],state:State[Int])=>{
        var total=0
        if(state.exists()){
            total=state.getOption().getOrElse(0)
        }
        total += v.getOrElse(1)
        state.update(total)//跟新状态
        (k,total)
    }))
    .checkpoint(Seconds(5))//设置状态持久化的频率，改频率不能高于 微批 拆分频率 ts>=5s
    .print()
    ssc
})
ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
ssc.start()
ssc.awaitTermination()

窗口（window）

spark Streaming提供了窗口计算，允许在滑动数据窗口上应用转换；Spark的流处理中要求窗口的长度以及滑动间隔必须是微批的整数倍。

val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
    val ssc = new StreamingContext(conf, Seconds(1))

    ssc.socketTextStream("CentOS",9999)
      .flatMap(_.split("\\s+"))
      .map((_,1))
      .reduceByKeyAndWindow((v1:Int,v2:Int)=> v1+v2,Seconds(5),Seconds(5))
      .print()

    ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
    ssc.start()
    ssc.awaitTermination()

Output Operations

  • foreachRDD（func）
val conf = new SparkConf().setMaster("local[2]").setAppName("KafkaStreamWordCount")
val ssc = new StreamingContext(conf, Seconds(1))

ssc.socketTextStream("CentOS",9999)
  .flatMap(_.split("\\s+"))
  .map((_,1))
  .window(Seconds(5),Seconds(5))
  .reduceByKey((v1:Int,v2:Int)=> v1+v2)
  .foreachRDD(rdd=>{
    rdd.foreachPartition(items=>{
        var jedisPool=new JedisPool("CentOS",6379)
        val jedis = jedisPool.getResource
        val pipeline = jedis.pipelined()//jedis批处理

        val map = items.map(t=>(t._1,t._2+"")).toMap.asJava
        pipeline.hmset("wordcount",map)

         pipeline.sync()
        jedis.close()
    })
  })


ssc.sparkContext.setLogLevel("FATAL")//关闭日志打印
ssc.start()
ssc.awaitTermination()
Rage范
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark Streaming源码解读之Receiver在Driver详解
snail_gesture的博客
05-20 1万+
一：Receiver启动的方式设想 1. Spark Streaming通过Receiver持续不断的从外部数据源接收数据，并把数据汇报给Driver端，由此每个Batch Durations就可以根据汇报的数据生成不同的Job。 2. Receiver属于Spark Streaming应用程序启动阶段，那么我们找Receiver在哪里启动就应该去找Spark Streaming的启动。
Spark Streaming自定义Receiver
u013939918的博客
07-25 312
一 背景 Spark社区为Spark Streaming提供了很多数据源接口，但是有些比较偏的数据源没有覆盖，由于公司技术栈选择，用了阿里云的MQ服务ONS，要做实时需求，要自己编写Receiver 二 技术实现 1.官网的例子已经比较详细，但是进入实践还需要慢慢调试，官方文档。 2.实现代码，由三部分组成，receiver，inputstream，util 3.receiver代码 import java.io.Serializable import java.util.Properti
spark.streaming.receiver
qq_41634872的博客
05-12 133
1.SocketReciever实现，一条一条读取，让Blockgenerator来收集。 2. RawNetworkreceiver实现，数据尽量读取，直接作为block存入。 三个最重要的类 Reciver:在onstart中接收数据，然后调用自己的store方法存数据。该方法是依赖 ReceiverSupervisor进行的，他里面对不同格式的数据采取不同的处理。 ReceiverSupervisor：处理数据的类，它可以依赖BlockGenerator来处理，也可
Spark Streaming-Receiver启动和数据接收
ZH519080的博客
12-05 632
养成一个记笔记的习惯！！！ 小案例： def fromsocket(ssc: StreamingContext): Unit ={ /**使用updateStateByKey前必须要设置checkpoint*/ ssc.checkpoint("hdfs://zhumaster:8020/data/checkpoint") /** 如使用socket网络嵌套字作为输入模式，使用命令...
Spark Streaming 的 Receiver和 Direct模式
u011500419的专栏
04-15 723
1 两种模式的原理和区别 Receiver模式 1. Receiver模式下的运行架构 1)InputDStream: 从流数据源接收的输入数据。 2)Receiver：负责接收数据流，并将数据写到本地。 3)Streaming Context：代表SparkStreaming，负责Streaming层面的任务调度，生成jobs发送到Spark engine处理。 4)Spark ...
Spark Streaming 示例
04-03
`SparkStreaming.zip` 文件可能包含了一个示例项目，演示了如何创建一个 Spark Streaming 应用来从 Kafka 消费数据。代码通常会包含以下步骤： 1. 创建 SparkConf 对象，配置 Spark 应用的属性，如应用程序名称、...
spark streaming
03-14
spark streaming streaming
SparkStreaming入门案例
06-22
Spark Streaming 入门案例 Spark Streaming 是一种构建在 Spark 上的实时计算框架，用来处理大规模流式数据。它将从数据源（如 Kafka、Flume、Twitter、ZeroMQ、HDFS 和 TCP 套接字）获得的连续数据流，离散化成一...
Spark Streaming的Receiver的那些事儿！
KLordy的博客
11-18 584
  这篇文章主要讲解Spark Streaming启动后，在StreamingContext中启动的ReceiverTracker以及这位大哥管理的Receiver的生成以及发布详细过程。我们先介绍Spark Streaming启动ReceiverTracker的过程，然后再提出一些问题，围绕这些问题对Receiver进行进一步的探索。   Spark Streaming启动时通过JobSched...
Spark Streaming Receiver学习
chncaesar的专栏
08-15 340
Receiver工作机制 以org.apache.spark.streaming.dstream.SocketReceiver为例。 一个数据流有一个receiver，在executor上启动。 Receiver监听端口，拉取数据，调用ReceiverSupervisor和BlockGenerator将数据加入BlockGenerator的缓存。在加入缓存前，调用限流器(RateLimite...
Spark Streaming中的Receiver方式和直连方式
while false
10-31 2173
Spark Streaming从Kafka中接受数据的时候有两种方式，一种是使用Receiver的老方法，另一种是使用直连的方法 1.Receiver方式 Receiver是使用Kafka高级消费者API实现的，与所有接收器一样，从Kafka通过Receiver接收的数据存储在Spark执行器中，然后由Spark Streaming启动的作业处理数据 但是，在默认配置下，此方法可能会在失败时...
[spark streaming]Receiver数据接收全过程详解
无
08-29 2996
一、Receiver启动过程回顾 如图，从ReceiverTracker的start方法开始，调用launchReceivers()方法，给endpoint发送消息，endpoint.send(StartAllReceivers(receivers))，endpoint就是ReceiverTrackerEndpoint，ReceiverTrackerEndpoint调用startReceiv...
SparkStreaming消费kafka（Receiver与Direct）
zx421311541的博客
12-26 495
Receiver receiver是使用kafka的高级consumer API来实现的，Receiver每个一段batch时间去kafka获取这段时间里最新的相应topic数据，从kafka哪里获取来的数据都存在Spark Excutor的内存中，然后Spark Streaming启动job去处理这些数据。 其中，谁来消费分区不是由SparkStreaming来决定的，而是由高阶消费者决定的，它...
[spark streaming]Receiver工作内幕源码分析
无
08-29 528
原创文章，转载请注明:转载自 听风居士博客(http://www.cnblogs.com/zhouyf/)       Spark streaming 程序需要不断接收新数据，然后进行业务逻辑处理，而用于接受数据的就是Recever。显然Receiver的正常运行对应整个Spark Streaming应用程序至关重要，如果Receiver出现异常，后面的业务逻辑就无从谈起。Spark Strea...
（一）sparkstreaming的两种数据接收方式
最新发布
u011250186的博客
12-08 94
（一）sparkstreaming的两种数据接收方式
Spark 图解源码系列之：SparkStreaming Receiver是如何接收数据的？
weixin_36630761的博客
10-07 149
假期不能闲着，水一篇文章，各位看官看过来~ 涉及到的几个主要的角色： ReceiverSupervisor ReceiverSupervisorImpl (实现类) Receiver BlockGenerator BlockManager ReceiverTracker 总体流程大致的说一下： 一切从 流 开始我们以 SocketInputDStream 为例子来讲解 下面的这个图是整个的流程详解：是在是没办法，转为图片6M+超过了可以上传的..
SparkStreaming入门介绍和运行架构
11号车厢
08-11 172
文章目录1、概述2、Basic Concepts2.1 Maven 添加依赖2.2 StreamingContext2.3 Discretized Streams (DStreams)2.4 Input DStreams、 Receiver2.5 Transformations on DStreams2.6 Output Operations on DStreams3、运行过程4、官网案例Word...
sparkstreaming sparkstreaming与kafka整合（两种receiver方式）
a3125504x的博客
09-09 581
sparkstreaming两种receiver方式sparkstreaming语义sparkstreaming整合kafka的两种方式Receiver-based ApproachDirect Approach (No Receivers)Direct Approach下sparkstreaming整合kafka0.8Direct Approach下sparkstreaming整合kafka1.0 sparkstreaming语义 sparkstreaming有三种语义 At most once 一

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值