Kafka案例

已于 2024-04-17 17:42:19 修改
阅读量401 收藏 6
点赞数 5
文章标签： kafka spark
于 2024-04-03 23:43:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42969753/article/details/137360615
版权

案例

kafka中读取数据

package com.xyf.demo2
​
​
import org.apache.spark.sql.{SaveMode, SparkSession}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import java.util.Properties
​
import com.xyf.utils.NumberUtils
object SparkStreamingDemo02_读取kafka {
  def main(args: Array[String]): Unit = {
​
    val spark = SparkSession.builder()
      .master("local[2]")
      .appName("streaming")
      .getOrCreate()
    val sc = spark.sparkContext
    import spark.implicits._
​
    // 设置批的持续时间
    val batchDuration = Seconds(2)
​
    val ssc = new StreamingContext(sc, batchDuration)
    ssc.checkpoint("C:\\Users\\xinyaofeng\\Desktop\\checkpoint")
    //                         kafka中消息的kv类型
    //  def createDirectStream[K, V](
    //      ssc: StreamingContext,
    //      locationStrategy: LocationStrategy,
    //      consumerStrategy: ConsumerStrategy[K, V]
    //    ): InputDStream[ConsumerRecord[K, V]] =
    val topics = Iterable("topic-file-6")
    val consumerProps = Map(
      "bootstrap.servers" -> "bd1471:9092,bd1472:9092,bd1473:9092",
      "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "group.id" -> "test22",
      "auto.offset.reset" -> "earliest"
    )
​
    val dStream = KafkaUtils.createDirectStream[String, String](
      ssc,
      // 设置消费的位置策略，让所有执行器轮询的读取所有的分区
      LocationStrategies.PreferConsistent,
      // 设置消费者配置
      ConsumerStrategies.Subscribe[String, String](
        topics,
        consumerProps
      )
    )
​
    val props = new Properties()
    props.setProperty("user", "root")
    props.setProperty("password", "123456")
​
    val part1 = dStream
      .filter(_.value.split(" ").length > 9)
​
//    part1.map(_.value()).print()
​
    part1
      .map(r => {
        val fields = r.value().split(" ")
        //      ip 访问量  成功访问次数 失败访问次数 上传流量 下载流量
        val count200 = if ("200" == fields(8)) 1 else 0
        val count404 = if ("404" == fields(8)) 1 else 0
​
        val ip = fields(0)
        (ip, AccessLog(
          ip, 1, count200, count404,
          NumberUtils.toLong(fields(9)),
          NumberUtils.toLong(fields.last)))
      })
      .foreachRDD(rdd => {
        val accessLog = rdd.map(_._2)
          .toDS()
​
        accessLog.show()
​
      })
​
    ssc.start()
    ssc.awaitTermination()
  }
}
​
case class AccessLog(
                      ip: String,
                      var uv: Long,
                      var count200: Long,
                      var count404: Long,
                      var up: Long,
                      var down: Long
                    ) extends Serializable {
  
}
​

向数据库追加

package com.xyf.demo2
​
​
import org.apache.spark.sql.{SaveMode, SparkSession}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import java.util.Properties
​
import com.xyf.utils.NumberUtils
​
​
object SparkStreamingDemo02_读取kafka {
  def main(args: Array[String]): Unit = {
​
    val spark = SparkSession.builder()
      .master("local[2]")
      .appName("streaming")
      .getOrCreate()
    val sc = spark.sparkContext
    import spark.implicits._
​
    // 设置批的持续时间
    val batchDuration = Seconds(2)
​
    val ssc = new StreamingContext(sc, batchDuration)
    ssc.checkpoint("C:\\Users\\xinyaofeng\\Desktop\\checkpoint")
    //                         kafka中消息的kv类型
    //  def createDirectStream[K, V](
    //      ssc: StreamingContext,
    //      locationStrategy: LocationStrategy,
    //      consumerStrategy: ConsumerStrategy[K, V]
    //    ): InputDStream[ConsumerRecord[K, V]] =
    val topics = Iterable("topic-file-6")
    val consumerProps = Map(
      "bootstrap.servers" -> "bd1471:9092,bd1472:9092,bd1473:9092",
      "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "group.id" -> "test22",
      "auto.offset.reset" -> "earliest"
    )
​
    val dStream = KafkaUtils.createDirectStream[String, String](
      ssc,
      // 设置消费的位置策略，让所有执行器轮询的读取所有的分区
      LocationStrategies.PreferConsistent,
      // 设置消费者配置
      ConsumerStrategies.Subscribe[String, String](
        topics,
        consumerProps
      )
    )
​
    val props = new Properties()
    props.setProperty("user", "root")
    props.setProperty("password", "123456")
​
    val part1 = dStream
      .filter(_.value.split(" ").length > 9)
​
//    part1.map(_.value()).print()
​
    part1
      .map(r => {
        val fields = r.value().split(" ")
        //      ip 访问量  成功访问次数 失败访问次数 上传流量 下载流量
        val count200 = if ("200" == fields(8)) 1 else 0
        val count404 = if ("404" == fields(8)) 1 else 0
​
        val ip = fields(0)
        (ip, AccessLog(
          ip, 1, count200, count404,
          NumberUtils.toLong(fields(9)),
          NumberUtils.toLong(fields.last)))
      })
      .foreachRDD(rdd => {
        val accessLog = rdd.map(_._2)
          .toDS()
​
        accessLog.show()
​
        accessLog
          .write
          .mode(SaveMode.Overwrite)
          .jdbc(
            "jdbc:mysql://bd1471:3306/spark_test",
            "accessLog",
            props
          )
      })
​
    ssc.start()
    ssc.awaitTermination()
  }
}
​
case class AccessLog(
                      ip: String,
                      var uv: Long,
                      var count200: Long,
                      var count404: Long,
                      var up: Long,
                      var down: Long
                    ) extends Serializable {
​
}
​

进行状态合并

package com.xyf.demo2
​
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
​
object SparkStreamingDemo03_流的状态更新 {
  def main(args: Array[String]): Unit = {
    // 程序入口 StreamingContext
    // 数据抽象 DStream
    val conf = new SparkConf()
      .setAppName("streaming")
      .setMaster("local[2]")
    // 设置批的持续时间
    val batchDuration = Seconds(5)
​
    val ssc = new StreamingContext(conf, batchDuration)
    ssc.checkpoint("C:\\Users\\Amos\\Desktop\\checkpoint")
    // ssc加载数据创建流
    val dStream = ssc.socketTextStream(
      "bd0701", 23456)
​
    // 打印dStream中的数据
    dStream
      .flatMap(x => {
        x.split("\\s+")
      })
      .map((_, 1))
      //  DStream[(K,V)]
​
      //  def updateStateByKey[S: ClassTag](
      //      updateFunc: (Seq[V], Option[S]) => Option[S]
      //    ): DStream[(K, S)] =
      .updateStateByKey[Long](
        (values: Seq[Int], state: Option[Long]) => {
          Some(values.sum + state.getOrElse(0L))
        }
      )
      .print()
​
    // SparkStreaming中的流默认不带状态
    // 不带状态:每个批次之间的数据相互独立
    // 如果希望跨批进行数据累加，则需要让上游RDD将数据传递到下游RDD
    //  传递称之为状态的更新
​
    // updateStateByKey
    // updateFunc: (
    //  Seq[V]  当前批中 相同key对应的所有value
    // , Option[S]  上一个批 传递下来的状态
    //) => Option[S]  当前批 更新后的状态
​
    // 启动流
    ssc.start()
​
    // 设置流的状态为 等待关闭
    ssc.awaitTermination()
​
  }
}
​

最终代码

package com.xyf.demo2
​
​
import org.apache.spark.sql.{SaveMode, SparkSession}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import java.util.Properties
​
import com.xyf.utils.NumberUtils
​
object SparkStreamingDemo02_读取kafka {
  def main(args: Array[String]): Unit = {
​
    val spark = SparkSession.builder()
      .master("local[2]")
      .appName("streaming")
      .getOrCreate()
    val sc = spark.sparkContext
    import spark.implicits._
​
    // 设置批的持续时间
    val batchDuration = Seconds(2)
​
    val ssc = new StreamingContext(sc, batchDuration)
    ssc.checkpoint("C:\\Users\\xinyaofeng\\Desktop\\checkpoint")
    //                         kafka中消息的kv类型
    //  def createDirectStream[K, V](
    //      ssc: StreamingContext,
    //      locationStrategy: LocationStrategy,
    //      consumerStrategy: ConsumerStrategy[K, V]
    //    ): InputDStream[ConsumerRecord[K, V]] =
    val topics = Iterable("topic-file-6")
    val consumerProps = Map(
      "bootstrap.servers" -> "bd1471:9092,bd1472:9092,bd1473:9092",
      "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "group.id" -> "test1",
      "auto.offset.reset" -> "earliest"
    )
​
    val dStream = KafkaUtils.createDirectStream[String, String](
      ssc,
      // 设置消费的位置策略，让所有执行器轮询的读取所有的分区
      LocationStrategies.PreferConsistent,
      // 设置消费者配置
      ConsumerStrategies.Subscribe[String, String](
        topics,
        consumerProps
      )
    )
​
    val props = new Properties()
    props.setProperty("user", "root")
    props.setProperty("password", "123456")
​
    val part1 = dStream
      .filter(_.value.split(" ").length > 9)
​
//    part1.map(_.value()).print()
​
    part1
      .map(r => {
        val fields = r.value().split(" ")
        //      ip 访问量  成功访问次数 失败访问次数 上传流量 下载流量
        val count200 = if ("200" == fields(8)) 1 else 0
        val count404 = if ("404" == fields(8)) 1 else 0
​
        val ip = fields(0)
        (ip, AccessLog(
          ip, 1, count200, count404,
          NumberUtils.toLong(fields(9)),
          NumberUtils.toLong(fields.last)))
      })
      .updateStateByKey[AccessLog](
        (values: Seq[AccessLog], state: Option[AccessLog]) => {
          if (values.nonEmpty) {
            val accessLog = values.reduce((v1, v2) => v1.merge(v2))
            state match {
              case Some(log) => Some(log.merge(accessLog))
              case None => Some(accessLog)
            }
          } else {
            state
          }
        }
      )
      .foreachRDD(rdd => {
        val accessLog = rdd.map(_._2)
          .toDS()
​
        accessLog.show()
​
        accessLog
          .write
          .mode(SaveMode.Overwrite)
          .jdbc(
            "jdbc:mysql://bd1471:3306/spark_test",
            "accessLog",
            props
          )
      })
​
    ssc.start()
    ssc.awaitTermination()
  }
}
​
case class AccessLog(
                      ip: String,
                      var uv: Long,
                      var count200: Long,
                      var count404: Long,
                      var up: Long,
                      var down: Long
                    ) extends Serializable {
  def merge(o: AccessLog): AccessLog = {
    this.uv += o.uv
    this.count200 += o.count200
    this.count404 += o.count404
    this.up += o.up
    this.down += o.down
    this
  }
}
​

工具类

package com.xyf.utils
​
object NumberUtils {
  def toLong(s: String): Long = {
    try {
      s.toLong
    } catch {
      case e: Exception => 0L
    }
  }
}
​
欧几里得-Euclidean
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Kafka入门实例
Evankaka的专栏
10-12 1万+
摘要:本文主要讲了Kafka的一个简单入门实例
kafka使用实例
luckyZQC的博客
04-29 954
Kafka是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。 这种动作（网页浏览，搜索和其他用户的行动）是在现代网络上的许多社会功能的一个关键因素。 这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。 对于像Hadoop一样的日志数据和离线分析系统，但又要求实时处理.........
kafka 案例
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
05-26 815
System . out . println("消息发送成功！");} else {System . out . println("消息发送失败：" + exception . getMessage());} } });} }System . out . println("消息发送成功！");} else {System . out . println("消息发送失败：" + exception . getMessage());} } });} }
kafka案例
qq_44885775的博客
03-15 3702
kafka上已经积累了两天的数据，如何从最新的offset开始消费？
(十三)ATP应用测试平台——springboot集成kafka案例实战
厉害哥哥的博客
11-05 615
前言 kafka消息中间键也是我们经常要用到的功能，尤其是在大数据、高并发的项目中，如日志收集、业务数据分发等等。其最核心的俩大功能作用是:①削峰填谷②异步解耦。本节我们主要介绍一下如何在springboot项目中集成kafka消息中间键，实现简单的数据分发以及消费的案例。 正文 kafka集群搭建 快速搭建一个kafka集群，我们这里以docker环境为例，搭建一个kafka集群，具体搭建过程请参考以下博客，这里不再赘述。 （六）史上最强ELK集群搭建系列教程——kafka集群搭建_北溟
kafka案例代码
03-24
在本文中，我们将深入探讨Apache Kafka，一个分布式流处理平台，通过分析提供的“kafka案例代码”。Kafka是由LinkedIn开发并随后贡献给Apache Software Foundation的一个开源项目，它被广泛用于实时数据流处理、消息...
watermark kafka案例
03-08
本案例聚焦于Kafka中的Watermark机制，尤其在多分区环境下的应用，这在处理时间序列数据和流计算时显得尤为重要。Watermark机制是Flink、Spark等流处理框架中的关键概念，用于解决乱序事件的问题。 Kafka本身并不...
Spring Cloud系列教程 Spring Boot Spring Cloud Stream 和 Kafka案例教程
09-18
Spring Cloud系列教程 Spring Boot Spring Cloud Stream 和 Kafka案例教程 SpringCloud系列教程、SpringBoot、 Stream、Kafka、案例教程
Spring Cloud系列教程 | 第十一篇：Spring Boot Spring Cloud Stream 和 Kafka案例教程-附件资源
03-02
Spring Cloud系列教程 | 第十一篇：Spring Boot Spring Cloud Stream 和 Kafka案例教程-附件资源
仿论坛项目--Kafka，构建TB级异步消息系统
weixin_52297290的博客
09-06 1008
Kafka可以应用于消息系统、日志收集、用户行为追踪、流式处理等多种场景：这也是正确的，Kafka由于其高性能和可扩展性，适用于多种应用场景，包括但不限于消息系统、日志收集、用户行为追踪和流式处理。Kafka具有高吞吐量、消息持久化、高可靠性、高扩展性等优点：这是正确的，Kafka的设计目标之一就是提供高吞吐量、消息持久化、高可用性和可扩展性的特性。Kafka是一个分布式的流媒体平台：这是正确的，Kafka是一个分布式的消息发布订阅平台，常用于构建实时的数据管道，以可靠地在应用程序之间传递数据。
kafka单条消息过大发送失败
IT深耕十余载，大道之简
09-07 532
在使用Apache Kafka时，如果单条消息过大，可能会导致发送失败。：Kafka的broker配置中，参数定义了broker能接受的最大消息大小（默认是1MB）。如果消息大小超过了这个值，broker会拒绝接受这个消息。：Producer的参数（默认与相同）定义了Producer发送给broker的请求的最大大小。这个大小包括了消息本身的大小以及任何可能的元数据或协议开销。
【kafka】消息队列
weixin_73815624的博客
09-10 494
②具有顺序的数据写入到了不同的partition里面，不同的消费者去消费，但是每个consumer的执行时间是不固定的，无法保证先读到消息的consumer一定先完成操作，这样就会出现消息并没有按照顺序执行，造成数据顺序错误。延迟队列：在kafka中创建一个消息队列，为队列设置延时时间，将消息推送到队列中打上时间戳，消息达到延时后自动被删除。从生产者的角度来说：使用确认机制，当发送消息后通过同步或者异步的方式直到成功接受才算发送成功，代替发后即忘的消息发送模式。7.怎么保证消息消费的顺序？
kafka单机安装
shuai的博客
09-06 1059
下载地址 官网：https://kafka.apache.org/ 最新版本下载页面：https://kafka.apache.org/downloads 说明 版本选择：3.0.0，kafka_2.12-3.0.0.tgz 下载地址：https://archive.apache.org/dist/kafka/3.0.0/kafka_2.12-3.0.0.tgz
Kafka【第一篇】Kafka集群搭建
2401_86940371的博客
09-05 1354
What is Kafka：它是一个分布式消息系统，由linkedin使用scala编写，用作LinkedIn的活动流（Activity Stream）和运营数据处理管道（Pipeline）的基础。具有高水平扩展和高吞吐量。
Kafka【十二】消费者拉取主题分区的分配策略
小小默：进无止境
09-06 1183
消费者想要拉取主题分区的数据，首先必须要加入到一个组中。但是一个组中有多个消费者的话，那么每一个消费者该如何消费呢，是不是像图中一样的消费策略呢？如果是的话，那假设消费者组中只有2个消费者或有4个消费者，和分区的数量不匹配，怎么办？当消费者加入群组的时候，会发送一个JoinGroup请求。群主负责给每一个消费者分配分区。每个消费者只知道自己的分配信息，只有群主知道群组内所有消费者的分配信息。
【kafka】kafka如何保证数据的可靠性，kafka如何保证数据不丢失
最新发布
xzb5566的专栏
09-10 200
1. 情况一，Producer向kafka发送消息的时候，ack设置的是0，（0就是producer向broker发生数据后，不需要ack确认）如果这个时候broker leader节点宕机，这个时候数据在broker leader中还没有存储，也没有同步到broker follower节点中，数据就会丢失。Producer默认的ack确认值是-1，就是leader接收消息后发生ack确认给producer。当cache满了才刷到磁盘上。2. 情况二，Producer向Kafka发生消息的时候，由于。
Spark2.x 入门：决策树分类器
跟着大数据和AI去旅行
09-06 436
一、方法简介 ​ 决策树（decision tree）是一种基本的分类与回归方法，这里主要介绍用于分类的决策树。决策树模式呈树形结构，其中每个内部节点表示一个属性上的测试，每个分支代表一个测试输出，每个叶节点代表一种类别。学习时利用训练数据，根据损失函数最小化的原则建立决策树模型；预测时，对新的数据，利用决策树模型进行分类。 决策树学习通常包括3个步骤：特征选择、决策树的生成和决策树的剪枝。
一文说清什么是数据仓库
ccddtomato的专栏
09-04 1390
本文对数据中台中的数据仓库进行介绍，包括数仓的概念定义、发展历程、建设数仓的必要性、价值以及数仓的应用场景。
Spark数据介绍
qq_41081716的博客
09-06 890
RDD适合需要高度定制化的数据处理逻辑，对容错性要求高的批处理任务。DataFrame适合处理结构化数据，需要快速开发周期，易于使用 SQL 查询的场景。Dataset：结合了 RDD 和 DataFrame 的优点，提供了类型安全和优化执行的能力，适合需要结构化数据处理同时需要一定程度自定义逻辑的情况。
sparkstreaming读取kafka案例
04-26
Sure, 我可以回答您关于SparkStreaming读取kafka案例的问题。 SparkStreaming通过集成Kafka来实现从Kafka中读取数据流，下面是一个实现的案例： 1.首先，在工程中加入以下依赖： ```xml <groupId>org.apache....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值