使用SparkStreaming来消费Kafka中的topic主题,并对主题做一些转换

最新推荐文章于 2023-12-10 11:13:46 发布
最新推荐文章于 2023-12-10 11:13:46 发布
阅读量592 收藏 1
点赞数
文章标签： spark streaming kafka 大数据
本文链接：https://blog.csdn.net/alisa_ge/article/details/115357924
版权

写在前面，需要先开启虚拟机，开启zookeeper进程和kafka服务。

命令如下：

zkServer.sh start

kafka-server-start.sh /opt/software/kafka211/config/server.properties

1.新建一个maven工程——mySparkstreaming。

2.配置好pom.xml文件。

windows下安装的spark版本为2.4.4版本，但是在这个例子中，需要降低其版本，否则会报以下错误：

Exception in thread "main" java.lang.AbstractMethodError

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spark.version>2.1.0</spark.version>
    <kafka.version>2.0.0</kafka.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-core -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>${spark.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>${spark.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming_2.11</artifactId>
      <version>${spark.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka -->
    <dependency>
      <groupId>org.apache.kafka</groupId>
      <artifactId>kafka_2.12</artifactId>
      <version>${kafka.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
    <dependency>
      <groupId>org.apache.kafka</groupId>
      <artifactId>kafka-clients</artifactId>
      <version>${kafka.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming-kafka-0-10 -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
      <version>${kafka.version}</version>
    </dependency>

  </dependencies>

3.新建一个scala文件——ReadKafkaTopic.scala

①现在有一个test主题，内容字段为user,event,invited,timestamp

需求：打印出test主题中的内容。

package cn.alisa.mySparkstreaming

import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
//使用SparkStreaming消费kafka的某个主题topic
object ReadKafkaTopic {
  def main(args: Array[String]): Unit = {
    val sc = new SparkConf().setMaster("local[*]").setAppName("read test")
      .set("spark.serializer","org.apache.spark.serializer.KryoSerializer")
    val ssc = new StreamingContext(sc, Seconds(1))
    ssc.checkpoint("e:/ck")
    val kafkaParams=Map(
       //建立与kafka集群的连接
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG->"192.168.21.130:9092",
      //消费组名字
      ConsumerConfig.GROUP_ID_CONFIG->"alisa",
      //每次最大消费消息数量
      ConsumerConfig.MAX_POLL_RECORDS_CONFIG->"500",
        //消费者通过反序列化将kafka收到的字节数组转换成相应的对象
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG->"earliest"
    )
    val ku = KafkaUtils.createDirectStream(ssc,
      //本地化策略：executor均匀分布分区
      LocationStrategies.PreferConsistent,
      //读 test 主题
            ConsumerStrategies.Subscribe[String, String](Set("test"), kafkaParams))
         //打印出topic主题中的test的内容
    ku.foreachRDD(rdd=>{
      rdd.foreach(rec=>println(rec.value()))
    })
    ku.print()
    ssc.start()
    ssc.awaitTermination()
  }
}

运行结果如下：

②现在有一个user_friends_raw主题，字段分别是user,friends

需求：把user_friends_raw中先按逗号分隔开，再将friends按空格分割，遍历出来，形成一个人对应一个朋友

package cn.alisa.mySparkstreaming

import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.clients.producer.KafkaProducer
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

//使用SparkStreaming消费kafka的某个主题topic
object ReadKafkaTopic {
  def main(args: Array[String]): Unit = {
    val sc = new SparkConf().setMaster("local[*]").setAppName("read test")
      .set("spark.serializer","org.apache.spark.serializer.KryoSerializer")
    val ssc = new StreamingContext(sc, Seconds(1))
    ssc.checkpoint("e:/ck")
    val kafkaParams=Map(
      //建立与kafka集群的连接
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG->"192.168.21.130:9092",
      //消费组名字
      ConsumerConfig.GROUP_ID_CONFIG->"alisa",
      //每次最大消费消息数量
      ConsumerConfig.MAX_POLL_RECORDS_CONFIG->"500",
      //消费者通过反序列化将kafka收到的字节数组转换成相应的对象
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG->"earliest"
    )
    val ku = KafkaUtils.createDirectStream(ssc,
      //本地化策略：executor均匀分布分区
      LocationStrategies.PreferConsistent,
    //读 user_friends_raw 主题
ConsumerStrategies.Subscribe[String,String](Set("user_friends_raw"),kafkaParams))
        ku.filter(ln=>{
          var reg=",$".r
      !reg.findAllMatchIn(ln.value()).hasNext
    }).flatMap(line=>{
      val info = line.value().split(",")
      info(1).split(" ").map(fid => {
        (info(0), fid)
      })
    }).foreachRDD(rdd=>rdd.foreach(println))
    ku.print()
    ssc.start()
    ssc.awaitTermination()
  }
}

运行结果如下：

③现在有一个event_attendees_raw 主题，字段是event,yes,maybe,invited,no

需求：将event_attendees_raw 主题分割成一个eventid userid action

package cn.alisa.mySparkstreaming

import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.clients.producer.KafkaProducer
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

//使用SparkStreaming消费kafka的某个主题topic
object ReadKafkaTopic {
  def main(args: Array[String]): Unit = {
    val sc = new SparkConf().setMaster("local[*]").setAppName("read test")
      .set("spark.serializer","org.apache.spark.serializer.KryoSerializer")
    val ssc = new StreamingContext(sc, Seconds(1))
    ssc.checkpoint("e:/ck")
    val kafkaParams=Map(
      //建立与kafka集群的连接
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG->"192.168.21.130:9092",
      //消费组名字
      ConsumerConfig.GROUP_ID_CONFIG->"alisa",
      //每次最大消费消息数量
      ConsumerConfig.MAX_POLL_RECORDS_CONFIG->"500",
      //消费者通过反序列化将kafka收到的字节数组转换成相应的对象
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG->"earliest"
    )
    val ku = KafkaUtils.createDirectStream(ssc,
      //本地化策略：executor均匀分布分区
      LocationStrategies.PreferConsistent,
 //读 event_attendees_raw 主题
      ConsumerStrategies.Subscribe[String,String](Set("event_attendees_raw"),kafkaParams))
    //将event_attendees_raw 主题分割成一个eventid userid action
    ku.flatMap(line=>{
      var info = line.value().split(",", -1)
      //[(123,456,yes),(123,456,yes)......]
      var yes = info(1).filter(_!="").split(" ").map(us=>(info(0),us,"yes"))
      var maybe =info(2).filter(_!="").split(" ").map(us=>(info(0),us,"maybe"))
      var invited = info(3).filter(_!="").split(" ").map(us=>(info(0),us,"invited"))
      var no = info(4).filter(_!="").split(" ").map(us=>(info(0),us,"no"))
      yes++maybe++invited++no
    }).foreachRDD(rdd=>rdd.foreach(println))
    ku.print()
    ssc.start()
    ssc.awaitTermination()
  }
}

运行结果如下：

榴芒姐姐
关注
Spark Streaming 结合kafka流式数据处理代码案例（含精确消费一次结果保存到mysql）
xiaohu21的博客
12-06 1875
Spark Streaming 结合kafka流式数据处理代码案例 1. 背景 在当前大数据处理中，根据数据处理类型可以分为离线数据处理和实时数据处理。不过目前主流的实时数据处理spark streaming和flink，其实前者只能算是准实时处理技术 在国内，spark streaming做实时数据处理，一般都是结合kafka来进行数据消息缓存框架，包括spark官方案例也着重讲了这一点 spark 官方文档 http://spark.apache.org/docs/latest/streaming-k
11SparkStreaming消费kafka以及offset提交
yangbllove的博客
04-19 926
spark streaming流式处理kafka中的数据，第一步是先把数据接收过来，转换为spark streaming中的数据结构Dstream。接收数据的方式有两种：1.利用Receiver接收数据，2.直接从kafka读取数据。 一、Receiver方式消费kafka 这种方式利用接收器（Receiver）来接收kafka中的数据，其最基本是使用Kafka高阶用户API接口。对于所有的接收器...
SparkStream之与Kafka整合
lixinkuan的博客
10-13 1443
一、receiver模式 receiver模式原理图 receiver模式理解： 在SparkStreaming程序运行起来后，Executor中会有receiver tasks接收kafka推送过来的数据。数据会被持久化，默认级别为MEMORY_AND_DISK_SER_2,这个级别也可以修改。receiver task对接收过来的数据进行存储和备份，这个过程会有节点之间的数据传输。...
spark消费kafka多主题并注册为表进行sql处理
第一片心意的博客
03-05 465
spark消费kafka多主题并注册为表进行sql处理
Spark-Streaming 消费 Kafka 多 Topic 多 Partition
storm_fury
07-23 1618
package com.cloudera.test import com.cloudera.utils.{JedisPoolUtils, PropertiesScalaUtils} import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord} import org.apache.kafka.common.Top...
解析kafka topic中的数据，序列化成传输对象
java技术专家全栈成长之路
09-15 1074
/** * * * @param consumerRecordList kafka消息内容 * @return 传输对象列表 */ private List<NewsEventDTO> parse(List<ConsumerRecord<String, String>> consumerRecordList) { return consumerRecordList.stream().map(record -> JSONObject.parseO.
【SparkStreaming_整合kafka】
weixin_47922102的博客
01-17 741
2.kafka 0.10.0版本之后 direct stream的方式加载kafka数据 【效率高、代码开发简单】spark 3.x => kafka : 1.kafka版本： 0.10.0 or higher ok。1.获取kafka offset =》 处理kafka数据 =》 “提交offset的操作” 没有。一个数据 来自于 kafka sss 读取形成 DStream数据 【量大】 主业务 =》 主表。“消费完kafka的数据 程序重启之后接着从上次消费的位置接着消费 ”
scala编写，以spark stream方式监听消费kafka的topic，同步写入elasticsearch
11-06
在这个项目中，我们使用Scala编程语言，结合Spark Streaming来监听和消费Kafka的特定主题，然后将处理后的数据实时写入Elasticsearch进行存储和检索。 首先，Scala是一种静态类型的函数式编程语言，它在Java虚拟机...
Spark-Streaming+Kafka+mysql实战示例
最新发布
zcs2312852665的博客
12-10 726
本文将介绍一个使用Spark Streaming和Kafka进行实时数据处理的示例。通过该示例，读者将了解到如何使用Spark Streaming和Kafka处理实时数据流，以及如何将处理后的数据保存到MySQL数据库中。示例涵盖了从环境搭建到代码实现的全过程，帮助读者快速上手实时数据处理的开发。Spark Streaming是Apache Spark的一个组件，用于实时流数据处理。它提供了高级别的API，可以使用类似于批处理的方式处理实时数据流。
spark streaming 结合kafka 精确消费一次将结果保存到hbase
xiaohu21的博客
12-06 969
spark streaming 结合kafka 精确消费一次将结果保存到hbase 1. 环境 scala 2.12.12 jdk 1.8 idea 2020.1 maven 3.6.3 spark 3.0.1 kafka 0.10 hadoop 3.2.1 hbase 2.2.5 （另外一个明细数据幂等处理，保存到habse） redis 5.0 pom <!-- 定义了一些常量 --> <properties> <maven.compiler.s
SparkStreaming 有几种方式消费 Kafka 中的数据（与 kafka 集成的方式）
星空下的那个人影
06-19 523
SparkStreaming 有哪几种方式消费 Kafka 中的数据，它们之间的区别是什么？
Spark-Streaming处理Kafka数据——封装成对象处理
Ganymede的Hadoop世界
05-22 2825
Spark-Streaming处理Kafka数据格式基本上都是字符串类型的，我们如何封装成对象处理呢
Spark kafka + streaming自适应topic partitions变化
mojolang
04-25 1165
背景 spark streaming + kafka 有两种方案接收kafka数据-基于receiver的方案和direct方案(no receiver方案)。 基于receiver的方案，属于比较老的方案，其采用Kafka’s high-level API通过专门的Rceiver去接收kafka数据。 采用 KafkaUtils.createStream direct方案，是当...
spark streaming读取kafka内容并进行反序列化
m0_67614284的博客
05-04 2196
import org.apache.spark.sql.ForeachWriter import com.fasterxml.jackson.module.scala.DefaultScalaModule import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper import com.fasterxml.jackson.databind.ObjectMapper import com.fasterxml.jackson.
SparkStreaming消费Kafka项目实战（JAVA版）
iTennis柠檬
09-20 1923
原文连接 http://notes.itennishy.com/article/43 一 项目需求 1、统计用户访问直播的uv数、pv数？ 2、统计用户跳转直播间的统计排名，即我的粉丝从哪个直播间过来到哪个直播间去？ 3、统计评论数和评论人数？ 4、统计引导进店数和引导进店人数？ 5、直播数据查询等。 二 整体方案设计图 三 开发过程中关键点总结 3.1 过程优化 1、采用队列方式，通过队列...
spark streaming去读取kafka各个topic中的文件数据
dontlikerabbit的博客
03-31 317
pom文件添加的依赖： <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency>
Spark streaming消费Kafka的正确姿势
weixin_45268144的博客
02-08 833
前言 在游戏项目中，需要对每天千万级的游戏评论信息进行词频统计，在生产者一端，我们将数据按照每天的拉取时间存入了Kafka当中，而在消费者一端，我们利用了spark streaming从kafka中不断拉取数据进行词频统计。本文首先对spark streaming嵌入kafka的方式进行归纳总结，之后简单阐述Spark streaming+kafka在舆情项目中的应用，最后将自己在Spark Streaming+kafka的实际优化中的一些经验进行归纳总结。（如有任何纰漏欢迎补充来踩，我会第一时间改正v）
Streaming消费Kafka数据的两种方式
小黑的博客
03-20 1246
1.receiver模式 Receiver接收固定时间间隔的数据，放在Spark executors内存中操作，使用kafka高级API，自动维护偏移量，达到固定时间才能进行处理，效率低下，并且容易丢失数据。 数据备份两次，保存到hdfs，每次使用须从hdfs读取，导致效率低下。 如果数据量特别大的情况下，容量不够就会造成数据丢失。receiver通过WAL，设置本地存储，会存放到本地，保证数据不...
SparkStreaming读取KafKa数据
zengxingyuluo的博客
03-15 848
import org.apache.kafka.common.serialization.StringDeserializer import org.apache.spark.SparkConf import org.apache.spark.streaming.kafka010.KafkaUtils import org.apache.spark.streaming.kafka010.Loca...
如何使用 Spark Streaming 从 Kafka 中读取数据，并对数据进行实时处理和分析。
05-25
使用 Spark Streaming 从 Kafka 中读取数据并进行实时处理和分析可以分为以下几个步骤： 1. 引入相关依赖 需要在项目中引入以下依赖： ```xml <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-streaming_2.11</artifactId> <version>2.4.0</version> </dependency> <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-streaming-kafka-0-10_2.11</artifactId> <version>2.4.0</version> </dependency> ``` 2. 创建 SparkConf 和 StreamingContext 对象 ```java SparkConf conf = new SparkConf().setAppName("KafkaSparkStreamingDemo").setMaster("local[*]"); StreamingContext streamingContext = new StreamingContext(conf, Durations.seconds(5)); ``` 3. 定义 Kafka 参数 需要定义 Kafka 参数，包括 Kafka 集群地址、消费组 ID、要读取的 Topic 等。 ```java Map<String, Object> kafkaParams = new HashMap<>(); kafkaParams.put("bootstrap.servers", "localhost:9092"); kafkaParams.put("group.id", "test"); kafkaParams.put("auto.offset.reset", "latest"); Set<String> topics = Collections.singleton("test"); ``` 4. 读取 Kafka 数据 使用 KafkaUtils.createDirectStream 方法读取 Kafka 中的数据，并将其转换为 DStream。 ```java JavaInputDStream<ConsumerRecord<String, String>> kafkaStream = KafkaUtils.createDirectStream( streamingContext, LocationStrategies.PreferConsistent(), ConsumerStrategies.<String, String>Subscribe(topics, kafkaParams) ); ``` 5. 对数据进行处理和分析 可以使用 Spark Streaming 的各种算子对数据进行处理和分析，例如 map、filter、reduceByKey 等。 ```java JavaDStream<String> lines = kafkaStream.map(ConsumerRecord::value); JavaDStream<String> words = lines.flatMap(x -> Arrays.asList(x.split(" ")).iterator()); JavaPairDStream<String, Integer> wordCounts = words.mapToPair(s -> new Tuple2<>(s, 1)) .reduceByKey((i1, i2) -> i1 + i2); ``` 6. 启动 StreamingContext ```java streamingContext.start(); streamingContext.awaitTermination(); ``` 完整的示例代码如下： ```java import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Set; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.common.serialization.StringDeserializer; import org.apache.spark.SparkConf; import org.apache.spark.streaming.Durations; import org.apache.spark.streaming.api.java.JavaInputDStream; import org.apache.spark.streaming.api.java.JavaPairDStream; import org.apache.spark.streaming.api.java.JavaStreamingContext; import org.apache.spark.streaming.kafka010.ConsumerStrategies; import org.apache.spark.streaming.kafka010.KafkaUtils; import org.apache.spark.streaming.kafka010.LocationStrategies; import scala.Tuple2; public class KafkaSparkStreamingDemo { public static void main(String[] args) throws InterruptedException { SparkConf conf = new SparkConf().setAppName("KafkaSparkStreamingDemo").setMaster("local[*]"); JavaStreamingContext streamingContext = new JavaStreamingContext(conf, Durations.seconds(5)); Map<String, Object> kafkaParams = new HashMap<>(); kafkaParams.put("bootstrap.servers", "localhost:9092"); kafkaParams.put("key.deserializer", StringDeserializer.class); kafkaParams.put("value.deserializer", StringDeserializer.class); kafkaParams.put("group.id", "test"); kafkaParams.put("auto.offset.reset", "latest"); kafkaParams.put("enable.auto.commit", false); Set<String> topics = Collections.singleton("test"); JavaInputDStream<ConsumerRecord<String, String>> kafkaStream = KafkaUtils.createDirectStream( streamingContext, LocationStrategies.PreferConsistent(), ConsumerStrategies.<String, String>Subscribe(topics, kafkaParams) ); JavaPairDStream<String, Integer> wordCounts = kafkaStream.map(ConsumerRecord::value) .flatMap(line -> Arrays.asList(line.split(" ")).iterator()) .mapToPair(word -> new Tuple2<>(word, 1)) .reduceByKey((count1, count2) -> count1 + count2); wordCounts.print(); streamingContext.start(); streamingContext.awaitTermination(); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值