Spark学习（七）：SparkStreaming

最新推荐文章于 2025-05-17 21:23:34 发布
原创 最新推荐文章于 2025-05-17 21:23:34 发布 · 543 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了SparkStreaming的基础知识，包括其与Storm的区别、初始设置、DStream的操作以及核心概念如transformation和action算子。此外，文章还探讨了SparkStreaming在Kafka环境下的整合，包括配置、代码实现和实际应用案例，帮助读者深入理解SparkStreaming在实时数据处理中的应用。

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

目录

1  什么是SparkStreaming

1.1 SparkStreaming简介、

1.2 SparkStreaming与Storm的区别

2  SparkStreaming初始

2.1 官方自带的WordCount程序

2.2 IDEA编程

2.3 StreamingContext的cores配置

2.4 DStream中的transformation和action算子

2.4.1 transformation算子

2.4.2 action算子

2.5 Driver HA（Standalone或者Mesos）

3.kafka

3.1 简介：

3.2 kafka中的术语

3.3 kafka集群的部署

4  SparkStreaming+kafka

4.1 streaming和kafka整合

4.2 代码实现

4.3 streaming-kafka-wordcount

1  什么是SparkStreaming

1.1 SparkStreaming简介、

官网：http://spark.apache.org/streaming/

特点：

  • 便于使用
  • 容错
  • spark集成

SparkStreaming是流式处理框架，是Spark API的扩展，支持可扩展、高吞吐量、容错的实时数据流处理，实时数据的来源可以是：Kafka, Flume, Twitter, ZeroMQ或者TCP sockets，并且可以使用高级功能的复杂算子来处理流数据。例如：map,reduce,join,window 。最终，处理后的数据可以存放在文件系统，数据库等，方便实时展现。

和Spark基于RDD的概念很相似，Spark Streaming使用离散化流(discretized stream)作为抽象表示，叫作DStream。DStream 是随时间推移而收到的数据的序列。在内部，每个时间区间收到的数据都作为 RDD 存在，而 DStream 是由这些 RDD 所组成的序列(因此 得名“离散化”)。

DStream 可以从各种输入源创建，比如 Flume、Kafka 或者 HDFS。创建出来的DStream 支持两种操作，一种是转化操作(transformation)，会生成一个新的DStream，另一种是输出操作(output operation)，可以把数据写入外部系统中。DStream 提供了许多与 RDD 所支持的操作相类似的操作支持，还增加了与时间相关的新操作，比如滑动窗口。

Discretized Stream or DStream 是 Spark Streaming 提供的基本抽象. 它代表了一个连续的数据流, 无论是从 source（数据源）接收到的输入数据流, 还是通过转换输入流所产生的处理过的数据流. 在内部, 一个 DStream 被表示为一系列连续的 RDDs, 在一个 DStream 中的每个 RDD 包含来自一定的时间间隔的数据，所以说应用与DStream的任何操作转化在底层来说都是对于RDDs的操作：如下图所示.

1.2 SparkStreaming与Storm的区别

  1. Storm是纯实时的流式处理框架，SparkStreaming是准实时的处理框架（微批处理）。因为微批处理，SparkStreaming的吞吐量比Storm要高。
  2. Storm 的事务机制要比SparkStreaming的要完善。
  3. Storm支持动态资源调度。(spark1.2开始和之后也支持)
  4. SparkStreaming擅长复杂的业务处理，Storm不擅长复杂的业务处理，擅长简单的汇总型计算。

2  SparkStreaming初始

2.1 官方自带的WordCount程序

[root@hadoop103 ~]# nc -lk 9999

-bash: nc: command not found     //如果出现这个提示

[root@hadoop103 ~]# yum -y install nc     //安装即可

 然后在另一台节点上监听hadoop103节点的9999端口，运行下面spark自带的WordCount程序

$SPARK_HOME/bin/run-example streaming.NetworkWordCount hadoop103 9999

注意：如果虚拟机的cores 只有一个，sparkstreaming的程序就不能读取数据，详解往下面看

2.2 IDEA编程

操作SparkStreaming首先导入下面的依赖

<!-- 导入SparkStreaming的依赖 -->
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.11</artifactId>
    <version>2.2.0</version>
</dependency>

// 配置日志的显示级别，
Logger.getLogger("org").setLevel(Level.ERROR)   //具体日志信息问题：请点这里

def main(args: Array[String]): Unit = {
  val conf = new SparkConf().setMaster("local[*]").setAppName(this.getClass.getSimpleName)
  val sc = new SparkContext(conf)

  val ssc: StreamingContext = new StreamingContext(sc,Seconds(2))  //Seconds() 设置一个批次的时间间隔

  //读取socket端口的数据
  val textStream: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop103",9999)

  //对读取到的数据进行处理
  val result: DStream[(String, Int)] = textStream.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)

  //调用action算子
  result.print()  //默认打印10行

  //Spark Streaming 程序的必备
  ssc.start()
  //阻塞程序，挂起
  ssc.awaitTermination()
}

2.3 StreamingContext的cores配置

如果程序给定的cores 只有一个：

// master 需要至少 2 个核, 以防止饥饿情况（starvation scenario）.

val conf = new SparkConf().setMaster("local[1]").setAppName(this.getClass.getSimpleName)

//如果给一个cores，会警告如下：

19/04/06 13:38:27 WARN StreamingContext: spark.master should be set as local[n], n > 1 in local mode if you have receivers to get data, otherwise Spark jobs will not get resources to process the received data.

一个StreamingContext创建多个input Dstream，会创建多个Receiver，Spark会为每个Receiver 分配一个core用于其运行。 

故若SparkStreaming 程序一共分配了k个core，运行n个Receiver，应保证k>n，这时会有n个core用于运行Receiver接收外部数据，k-n个core用于真正的计算。 

一个Receiver 占用了一个core，这里两个Receiver占用了2个core，如果这个job的启动资源是 --master "local[4]" 那么真正能用于运算的core只有两个了。

val ssc: StreamingContext = new StreamingContext(sc,Seconds(2))
// 读取socket端口的数据，  需要一个cores
val textStream: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop103",9999)
// 占用一个cores  
val textStream2: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop102",9999)

2.4 DStream中的transformation和action算子

2.4.1 transformation算子

lazy执行，生成新的DStream算子，一些常用的转换算子

transform(func)

通过对源 DStream 的每个 RDD 应用 RDD-to-RDD 函数

无状态转化：

比如：map(),flatMap(),filiter(),repartition()

有状态转化

updateStateByKey

作用：

  1. 为SparkStreaming中每一个Key维护一份state状态，state类型可以是任意类型的，可以是一个自定义的对象，更新函数也可以是自定义的。
  2. 通过更新函数对该key的状态不断更新，对于每个新的batch（时间片段）而言，SparkStreaming会在使用updateStateByKey的时候为已经存在的key进行state的状态更新。

使用到updateStateByKey要开启checkpoint机制和功能。

多久会将内存中的数据写入到磁盘一份？

如果batchInterval设置的时间小于10秒，那么10秒写入磁盘一份。如果batchInterval设置的时间大于10秒，那么就会batchInterval时间间隔写入磁盘一份。

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

object StateFulWordCount {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val ssc = new StreamingContext(conf,Seconds(3))
    //设置checkpoint路径（持久化）
    ssc.checkpoint("spark_day01/WordCount")

    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop103",9999)

    val pairs = lines.flatMap(_.split(" ")).map((_,1))
    //val result = pairs.reduceByKey(_+_)
    //使用updateStateByKey替换reduceBykey来更新状态，统计从运行开始以来单词总的次数
    val result: DStream[(String, Int)] = pairs.updateStateByKey(updateFunc)
    result.print()

    ssc.start()
    ssc.awaitTermination()

  }
  //定义更新状态方法，参数values为当前批次单词频度，state为以往批次单词的频度
  def updateFunc = (values: Seq[Int], state: Option[Int]) => {
    val currentCount = values.sum
    val previousCount = state.getOrElse(0)
    Some(currentCount + previousCount)
  }
}

窗口操作

窗口操作理解图

假设每隔5s 1个batch,上图中窗口长度为15s，窗口滑动间隔10s。(即每隔10s打印一次窗口内聚合的结果)

  1. 窗口长度和滑动间隔必须是batchInterval的整数倍。如果不是整数倍会检测报错。
  2. 优化后的window操作要保存状态所以要设置checkpoint路径，没有优化的window操作可以不设置checkpoint路径。
  3. 优化后的window窗口操作示意图：

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

object SparkWindow {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName(this.getClass.getSimpleName)
    val ssc = new StreamingContext(conf, Seconds(3))
    //设置持久化checkpoint的路径
    ssc.checkpoint("spark_day01/WordCount1")

    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop103", 9999)
    val pairs: DStream[(String, Int)] = lines.flatMap(_.split(" ")).map((_, 1))
    //窗口大小为9s，步长为6s
    //无优化的窗口操作，当使用无优化的窗口操作可以不设置checkpoint
    //val stateDStream: DStream[(String, Int)] = pairs.reduceByKeyAndWindow(
    // (a: Int,b: Int) => a + b,Seconds(9),Seconds(6))


    //使用窗口操作进行优化，把单词作为key，次数作为value，会把输入的所有单词当前窗口状态输出
    val stateDStream: DStream[(String, Int)] = pairs.reduceByKeyAndWindow(
      (a: Int, b: Int) => a + b, (a: Int, b: Int) => a - b, Seconds(9), Seconds(6))
    stateDStream.print()

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

2.4.2 action算子

一些常用的action算子，只有当触发action算子后才会执行任务。

2.5 Driver HA（Standalone或者Mesos）

因为SparkStreaming是7*24小时运行，Driver只是一个简单的进程，有可能挂掉，所以实现Driver的HA就有必要（如果使用的Client模式就无法实现Driver HA ，这里针对的是cluster模式）。Yarn平台cluster模式提交任务，AM(AplicationMaster)相当于Driver，如果挂掉会自动启动AM。这里所说的DriverHA针对的是Spark standalone和Mesos资源调度的情况下。实现Driver的高可用有两个步骤:

第一：提交任务层面，在提交任务的时候加上选项 --supervise,当Driver挂掉的时候会自动重启Driver。

第二：代码层面，使用JavaStreamingContext.getOrCreate（checkpoint路径，JavaStreamingContextFactory）

Driver中元数据包括：

  1. 创建应用程序的配置信息。
  2. DStream的操作逻辑。
  3. job中没有完成的批次数据，也就是job的执行进度。

3.kafka

3.1 简介：

Apache Kafka是分布式发布-订阅消息系统（分布式消息队列）。特点是生产者消费者模式，先进先出（FIFO）保证顺序，自己不丢数据，默认每隔7天清理数据。消息列队常见场景：系统之间解耦合、峰值压力缓冲、异步通信。

MQ: message queue

传统消息中间件服务RabbitMQ、Apache ActiveMQ（免费）等。IBMMQ (收费)

Apache Kafka与传统消息系统相比，有以下不同：

  1. 它是分布式系统，易于向外扩展；
  2. 它同时为发布和订阅提供高吞吐量；
  3. 它支持多订阅者，当失败时能自动平衡消费者；
  4. 它将消息持久化到磁盘，因此可用于批量消费，例如ETL，以及实时应用程序。

3.2 kafka中的术语

术语

解释

Broker

Kafka集群包含一个或多个服务器，这种服务器被称为broker

Topic

 

每条发布到Kafka集群的消息都有一个类别，这个类别被称为Topic。（物理上不同Topic的消息分开存储，逻辑上一个Topic的消息虽然保存于一个或多个broker上但用户只需指定消息的Topic即可生产或消费数据而不必关心数据存于何处）

Partition

Partition是物理上的概念，每个Topic包含一个或多个Partition.

Producer

负责发布消息到Kafka broker

Consumer

消息消费者，向Kafka broker读取消息的客户端

Consumer Group

每个Consumer属于一个特定的Consumer Group（可为每个Consumer指定group name，若不指定group name则属于默认的group）

replica

partition 的副本，保障 partition 的高可用

leader

replica 中的一个角色， producer 和 consumer 只跟 leader 交互

follower

replica 中的一个角色，从 leader 中复制数据

controller

Kafka 集群中的其中一个服务器，用来进行 leader election 以及各种 failover

3.3 kafka集群的部署

  1. 上传kafka_2.10-0.8.2.2.tgz包到三个不同节点上，解压。
  2. 配置../ kafka_2.10-0.8.2.2/config/server.properties文件

    1. broker.id=1  

      delete.topic.enable=true     

      listeners=PLAINTEXT://hadoop101:9092

      log.dirs=/opt/module/kafka_2.11-0.11.0.0/logs/

      num.partitions=3

      zookeeper.connect=hadoop101:2181,hadoop102:2181,hadoop103:2181

  3. 分发安装包，然后修改broker.id以及listeners
  4. 启动zookeeper集群。
  5. 在三个节点上启动kafka

    bin/kafka-server-start.sh   config/server.properties

  6. kafka相关命令

创建topic：

./kafka-topics.sh --zookeeper hadoop101:2181,hadoop102:2181,hadoop103:2181  --create --topic first --partitions 3  --replication-factor 3

用一台节点控制台来当kafka的生产者：

./kafka-console-producer.sh  --topic  topic2017 --broker-list hadoop101:2181,hadoop102:2181,hadoop103:2181

用另一台节点控制台来当kafka的消费者：

./kafka-console-consumer.sh --zookeeper hadoop101:2181,hadoop102:2181,hadoop103:2181 --topic first

查看kafka中topic列表:

./kafka-topics.sh  --list --zookeeper hadoop101:2181,hadoop102:2181,hadoop103:2181

查看kafka中topic的描述：

./kafka-topics.sh --describe --zookeeper node3:2181,node4:2181,node5:2181  --topic first

查看zookeeper中topic相关信息：

启动zookeeper客户端：

./zkCli.sh

查看topic相关信息：

ls /brokers/topics/

查看消费者相关信息：

ls /consumers

删除kafka中的数据

./kafka-topics.sh --zookeeper hadoop101:2181,hadoop102:2181,hadoop103:2181 --delete --topic first

在每台broker节点上删除当前这个topic对应的真实数据。

进入zookeeper客户端，删除topic信息

rmr /brokers/topics/first

删除zookeeper中被标记为删除的topic信息

rmr /admin/delete_topics/first

4  SparkStreaming+kafka

4.1 streaming和kafka整合

官方文档：http://spark.apache.org/docs/2.2.0/streaming-kafka-integration.html

在kafka0-10版本已经不再支持receiver DStream模式

导入下面的依赖：

<!--streaming 集成  kafka的依赖jar包-->
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
    <version>2.2.0</version>
</dependency>

val kafkaParams = Map[String, Object](

//要连接的 服务器:端口号
    "bootstrap.servers" -> "Hadoop101:9092,hadoop102:9092,hadoop103:9092",

//设置消费（k,v）格式的数据类型

//rdd中的数据类型是 ConsumerRecord[数据类型, 数据类型]
    "key.deserializer" -> classOf[StringDeserializer],
    "value.deserializer" -> classOf[StringDeserializer],

//消费者组
    "group.id" -> "hello_topic_group",

//可以设置从哪里读取数据
    "auto.offset.reset" -> "earliest",

// 是否可以自动提交偏移量   自定义
    "enable.auto.commit" -> (false: java.lang.Boolean)
  )

4.2 代码实现

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.kafka010._
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe

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

    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "hadoop101:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "use_a_separate_group_id_for_each_stream",
      "auto.offset.reset" -> "latest",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )

    //可以设置读取多个主题
    val topics = Array("first","second")
    val stream = KafkaUtils.createDirectStream[String, String](
      ssc,
      //在可用的executors上均匀分区
      PreferConsistent,
      Subscribe[String, String](topics, kafkaParams)
    )

    stream.foreachRDD(rdd => {
      rdd.foreach(println)
    })

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

groupId：

同一个组中，可以有多个consumer，但是多个consumer只能消费不同分区的数据，

也就是说一条数据，只能被一个consumer去消费。

还可以为每一个group中的consumer指定一个名称，即group.name

4.3 streaming-kafka-wordcount

在hadoop101节点启动kafka生产者，向topic second中写数据

在hadoop102节点上向主题first中写入数据

 在IDEA中编写程序，主题first和second中的数据

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe

object SparkAndKafkaWordCount {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName(this.getClass.getSimpleName)

    val ssc=  new StreamingContext(conf,Seconds(2))

    // kafka的参数配置
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "hadoop101:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "hello_topic_group",
      // 从哪个位置开始读取数据
      "auto.offset.reset" -> "earliest",
      // 是否可以自动提交偏移量   自定义
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )

    // streaming 支持 读取kafka的多个主题
    val topics = Array("second")
    // 指定泛型约定
    val stream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
      ssc,
      // 我们的broker和executor在同一台机器上
      // LocationStrategies.PreferBrokers
      // 资源会平均分配
      LocationStrategies.PreferConsistent,
      // PreferConsistent,
      // 消费者 订阅哪些主题
      Subscribe[String, String](topics, kafkaParams)
    )

    stream.foreachRDD(rdd=>{
      // rdd中的数据类型是 ConsumerRecord[String, String]   拿到这里的value
      val result = rdd.flatMap(_.value().split(" ")).map((_,1)).reduceByKey(_+_)
      result.foreach(println)
    })

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

SparkStreaming-解析
weixin_44085996的博客
09-29 702
1.初始化StreamingContext //SparkStreaming程序入口 val conf: SparkConf = new SparkConf().setAppName("wordcount").setMaster("local[*]")//如果需要打包运行在服务器上，不需要指定master val sc = new SparkContext(conf) sc.setLogLevel("WARN") val ssc: StreamingContext = new StreamingCont
【Spark】（五）Spark Streaming 之 DStream 转换与输出
qianchun22的博客
01-04 901
一、DStream 转换 DStream 上的操作与 RDD 的类似，分为 Transformations（转换）和 Output Operations（输出）两种，此外转换操作中还有一些比较特殊的原语，如：updateStateByKey()、transform()以及各种 Window 相关的原语。 1、无状态转化操作 无状态转化操作就是把简单的 RDD 转化操作应用到每个批次上，也就是转化 DStream 中的每一个 RDD。部分无状态转化操作列在了下表中。注意，针对键值对的 DStream 转化操作
Spark Streaming后台挂载运行&异常监控并重启
sgyuanshi的博客
01-13 1232
后台挂载spark-streaming程序 我们在x-shell中通过yarn-client的方式提交spark-streaming程序时，会存在一个小问题：如果中断程序的运行或者将x-shell窗口关闭，spark-streaming程序也会中断。 为了解决这个问题，我们可以使用以下脚本命令命令： nohup /opt/client/hdclient/Spark2x/spark/bin/spar...
sparkstreaming对接kafka
WuBoooo的博客
11-01 403
sparkstreaming注意要点 sparkstreaming是一个微对比准实时的计算框架 flink与sparkstreaming不同的是,sparkstreaming中的task执行完之后就会被释放掉,而flink不会,进去之后就不会释放,可以重复使用,spark的task是临时工,flink的是合同工 sparkstreaming执行程序时构建完rdd需要开启开启任务并挂起任务才会开始执行程序和一直在后台挂起 ssc.start ssc.awaitTermination() sparkstream
sparkStream出现的错误
mn_kw的博客
04-24 313
java.lang.NoClassDefFoundError: org/apache/spark/SparkConf build.sbt文件中的libraryDependencies += "org.apache.spark" % "spark-core_2.11" % "2.1.1" % "provide" 改成libraryDependencies += "org.apache.spark" ...
spark学习笔记：Spark Streaming介绍
黄道婆的专栏
12-18 429
Spark Streaming介绍 1.1 Spark Streaming概述 1.1.1什么是Spark Streaming Spark Streaming类似于Apache Storm，用于流式数据的处理。根据其官方文档介绍，Spark Streaming有高吞吐量和容错能力强等特点。Spark Streaming支持的数据源有很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输入后可以用Spark的高度抽象操作如：map、reduce、join、w.
Spark - ML：开启大数据机器学习的神奇之门
最新发布
大雨的博客
05-17 918
Spark - ML 凭借其强大的分布式计算能力、丰富的算法库、灵活的特征工程工具和高效的模型评估机制，在大数据与机器学习领域展现出了巨大的优势。它已经在电商、金融、医疗等众多行业得到了广泛的应用，为企业和机构解决了实际业务中的关键问题，带来了显著的经济效益和社会效益。随着大数据和人工智能技术的不断发展，Spark - ML 也将迎来更广阔的发展前景。在未来，随着数据量的持续爆炸式增长，Spark - ML 将不断优化其性能，进一步提升在海量数据处理上的效率，以满足企业对实时性和准确性的更高要求。
Spark 学习之路，包含 Spark Core，Spark SQL，Spark Streaming，Spark mllib 学
05-15
Spark 学习之路，包含 Spark Core，Spark SQL，Spark Streaming，Spark mllib 学习笔记 * [spark core学习笔记及代码 * [spark sql学习笔记及代码 * [spark streaming学习笔记及代码 Spark 消息通信 ### Spark ...
Kafka指南
王者归来
12-10 1627
下载 https://kafka.apache.org/downloads kafka_2.13-2.6.0.tgz 启动 单节点zookeeper实例 bin/zookeeper-server-start.sh config/zookeeper.properties Kafka服务器 bin/kafka-server-start.sh config/server.properties 建立主题
kafka-console-consumer.sh使用2次grep管道无法过滤到数据的问题解决方案
weixin_41338112的博客
03-14 1026
使用kafka-console-consumer.sh后使用两次grep管道后查询结果有部分符合条件的数据未被筛选出来。多次grep 没有输出问题。
Spark Streaming介绍及基础操作
烙痕丷的博客
09-18 549
Spark Streaming介绍：     基于Spark之上的流处理（rdd）     流：source ==&gt; compute ==&gt; store     离线是特殊的流   letting you write streaming jobs,the same way you write batch jobs    out of the box  开箱即用 OOTB（内置的） D...
kafka消费者报错：Class org.apache.kafka.common.serialization.StringDeserializer could not be found.
热门推荐
yixiaoqi2010的专栏
04-03 1万+
org.apache.kafka.common.config.ConfigException: Invalid value org.apache.kafka.common.serialization.StringDeserializer for configuration key.deserializer: Class org.apache.kafka.common.serialization.S...
spark+kafka 小案例
weixin_30570101的博客
03-30 205
（1）下载kafka的jar包 http://kafka.apache.org/downloads spark2.1 支持kafka0.8.2.1以上的jar,我是spark2.0.2,下载的kafka_2.11-0.10.2.0 （2）Consumer代码 package com.sparkstreaming import org.apache.spark.SparkCon...
spark基于物品的推荐_大数据项目之电影推荐系统（下）
weixin_33954023的博客
12-21 2055
一、实时推荐服务建设1、实时推荐服务实时计算与离线计算应用于推荐系统上最大的不同在于实时计算推荐结果应该 反映最近一段时间用户近期的偏好，而离线计算推荐结果则是根据用户从第一次评 分起的所有评分记录来计算用户总体的偏好。 用户对物品的偏好随着时间的推移总是会改变的。比如一个用户 u 在某时刻对 电影 p 给予了极高的评分，那么在近期一段时候，u 极有可能很喜欢与电影 p 类 似的其他电影；而如果用...
Kafka+ Spark Streaming 创建stream编译报错
meiyoujiaru的博客
12-19 3284
今天按照spark官网的例子进行stream的运用代码是很简单 但是遇到了两个编译问题让我甚是难受啊 官网给的api为 mvn注入jar包 groupId = org.apache.spark artifactId = spark-streaming-kafka-0-10_2.11 version = 2.2.0代码部分 import org.apache.kafka.clie
实时流计算、Spark Streaming、Kafka、Redis、Exactly-once、实时去重
lin的专栏
04-04 1265
http://lxw1234.com/archives/2018/02/901.htm在实时流式计算中，最重要的是在任何情况下，消息不重复、不丢失，即Exactly-once。本文以Kafka–&gt;Spark Streaming–&gt;Redis为例，一方面说明一下如何做到Exactly-once，另一方面说明一下我是如何计算实时去重指标的。1. 关于数据源数据源是文本格式的日志，由Ngin...
将KafKa的偏移量写入Mysql
weixin_40155674的博客
06-21 3323
package SparkStreamingKafKa.OffSetMysql import java.sql.{DriverManager, ResultSet} import com.typesafe.config.{Config, ConfigFactory} import org.apache.kafka.clients.consumer.ConsumerRecord import o...
Spark Streaming快速入门系列（7）
一个有趣的人，咱们处处看！
08-05 1806
上一篇《SparkSQL快速入门系列（6）》，接下来给大家更新下一篇。 第一章 Spark Streaming引入 1.1. 新的场景需求 ●集群监控 一般的大型集群和平台, 都需要对其进行监控的需求。 要针对各种数据库, 包括 MySQL, HBase 等进行监控 要针对应用进行监控, 例如 Tomcat, Nginx, Node.js 等 要针对硬件的一些指标进行监控, 例如 CPU, 内存, 磁盘 等 ●还有很多很多 1.2. Spark Streaming介绍 ●官网 http://
Spark Streaming实战：提升大数据实时处理性能
大数据开发实战：SparkStreaming流计算开发深入解析 在这个章节中，我们将探讨大数据处理领域中Spark Streaming的角色，它是Apache Spark生态系统的一部分，特别针对实时和离线数据处理提供了强大的解决方案。Spark...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值