kafka-streaming偏移量管理

本文详细介绍使用Kafka进行数据生产和消费的过程,包括通过RuozeKafkaProducer发送数据至特定主题,以及如何利用checkpoint和MySQL存储偏移量,确保数据的准确处理。探讨了不同消费模式(At most once、At least once、Exactly once)的影响,并演示了如何通过Spark Streaming实现偏移量的持久化。

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

RuozeKafkaProducer.java

先写一个kafka制造数据的东东

package com.ruozedata.bigdata.kafka;


import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;

import java.util.Properties;
import java.util.UUID;

//kafka数据发送,producer
public class RuozeKafkaProducer {

    public static void main(String[] args) {

        Properties properties = new Properties();
        properties.put("serializer.class","kafka.serializer.StringEncoder");
        properties.put("metadata.broker.list","hadoop000:9092,hadoop000:9093,hadoop000:9094");

        ProducerConfig producerConfig = new ProducerConfig(properties);
        Producer<String,String> producer = new Producer<String, String>(producerConfig);

        String topic ="ruozeg5sparkkafka";
        for (int index=0; index<100;index++){
            producer.send(new KeyedMessage<String, String>(topic,index+"",index+"ruozeshuju:"+ UUID.randomUUID()));
        }

        System.out.println("若泽数据Kafka生产者生产数据完毕...");

    }

}

在消费者里可以看到数据

bin/kafka-console-consumer.sh \
--zookeeper 192.168.137.190:2181,192.168.137.190:2182,192.168.137.190:2183/kafka \
--topic ruozeg5sparkkafka --from-beginning

在这里插入图片描述

用checkpoint记录偏移量

package com.ruozedata.bigdata.streaming05

import kafka.serializer.StringDecoder
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Duration, Seconds, StreamingContext}

object CheckpointOffsetApp {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("CheckpointOffsetApp")

    //没有会自动创建
    val checkpointPath = "hdfs://hadoop000:9000/offset_g5/checkpoint"
    val topic="ruozeg5sparkkafka"
    val interval =10
    val kafkaParams = Map[String, String]("metadata.broker.list"->"hadoop000:9092","metadata.broker.list"->"hadoop000:9093","metadata.broker.list"->"hadoop000:9094","auto.offset.reset"->"smallest")
    val topics = topic.split(",").toSet


    def function2CreateStreamingContext()={
      val ssc = new StreamingContext(conf,Seconds(10))
      //[]里是[key class], [value class], [key decoder(解码) class], [value decoder class] ]
      //(streamingContext, [map of Kafka parameters], [set of topics to consume])
      val messages = KafkaUtils.createDirectStream[String,String,StringDecoder,StringDecoder](ssc,kafkaParams, topics)
      ssc.checkpoint(checkpointPath)
      messages.checkpoint(Duration(8*10.toInt*1000))

      messages.foreachRDD(rdd=>{
        if (!rdd.isEmpty()){
          println("------asd------"+rdd.count())
        }
      })
      ssc
    }

    //如果检查点数据存在就根据检查点数据重建context,如果不存在就根据第二个参数构建context
    val ssc =StreamingContext.getOrCreate(checkpointPath,function2CreateStreamingContext)
    ssc.start()
    ssc.awaitTermination()


  }

}

这里之所以要对topic做split,1是因为topic可以不止为1个,而且,就算只有一个不split结果会有问题。

At most once: Each record will be either processed once or not processed at all.
At least once: Each record will be processed one or more times. This is stronger than at-most once as it ensure that no data will be lost. But there may be duplicates.
Exactly once: Each record will be processed exactly once - no data will be lost and no data will be processed multiple times. This is obviously the strongest guarantee of the three.

之所以要split是因为
可以读多个topic,同时

在这里插入图片描述
smallest : 自动把offset设为最小的offset;
largest : 自动把offset设为最大的offset;
anything else: 抛出异常;

代码结果
跑100条,得到100条记录
再跑0条,得不到记录,说明偏移量起作用了,没有读所有的数据。

用mysql记录偏移量

scalalikeJDBC
在这里插入图片描述
写一个获得配置里参数的object用来读取application.conf的其他参数

 package com.ruozedata.bigdata.streaming05

import com.typesafe.config.ConfigFactory
object ValueUtils {
  //加载application.conf
  val load=ConfigFactory.load()

  def getStringValue(key:String,defaultValue:String="")={
    load.getString(key)
  }

  def main(args: Array[String]): Unit = {
    println(getStringValue("kafka.topics"))
  }

}

创建mysql表和权限

create table if not exists offsets_storage(
topic varchar(50),
groupid varchar(20),
partitions int,
offset bigint,
primary key(topic,groupid,partitions)
);

MysqlOffsetApp

package com.ruozedata.bigdata.streaming05

import kafka.common.TopicAndPartition
import kafka.message.MessageAndMetadata
import kafka.serializer.StringDecoder
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka.{HasOffsetRanges, KafkaUtils}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import scalikejdbc._
import scalikejdbc.config.DBs

object MySQLOffsetApp {

  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[2]").setAppName("MysqlOffsetApp")

    //从application.conf加载配置信息
    DBs.setup()

    //用来构建stream的参数,详情看源码
    val fromOffsets= DB.readOnly(implicit session =>{
      sql"select * from offsets_storage".map(rs => {
        (TopicAndPartition(rs.string("topic"), rs.int("partitions")), rs.long("offset"))
      }).list().apply()
    }).toMap


    val topic = ValueUtils.getStringValue("kafka.topics")
    val interval=10

    val kafkaParams=Map(
      "metadata.broker.list"->ValueUtils.getStringValue("metadata.broker.list"),
      "auto.offset.reset"->ValueUtils.getStringValue("auto.offset.reset"),
      "group.id"->ValueUtils.getStringValue("group.id")
    )
    val topics =topic.split(",").toSet
    val ssc=new StreamingContext(conf,Seconds(10))



    ////TODO... 去MySQL里面获取到topic对应的partition的offset

    //没有offset从头消费
    val messages=if(fromOffsets.size==0){
      KafkaUtils.createDirectStream(ssc,kafkaParams,topics)
      //有offset从指定位置消费
    }else{
      //把数据和元数据转换成需要的类型,模板
      val messageHandler = (mm:MessageAndMetadata[String,String]) => (mm.key(),mm.message())
      KafkaUtils.createDirectStream[String,String,StringDecoder,StringDecoder,(String,String)](ssc,kafkaParams,fromOffsets,messageHandler)
    }

    messages.foreachRDD(rdd=>{
      if(!rdd.isEmpty()){
        println("---the count---"+rdd.count())

        val offsetRanges=rdd.asInstanceOf[HasOffsetRanges].offsetRanges
        offsetRanges.foreach(x=>{
          println(s"--${x.topic}---${x.partition}---${x.fromOffset}---${x.untilOffset}---")

          //替换到mysql最新的offset
          DB.autoCommit(implicit session =>{
            sql"replace into offsets_storage(topic,groupid,partitions,offset) values(?,?,?,?)"
              .bind(x.topic,ValueUtils.getStringValue("group.id"),x.partition,x.untilOffset)
              .update().apply()
          })
        })
      }
    })

    ssc.start()
    ssc.awaitTermination()
  }

}

根据TopicAndPartition写fromoffsets
在这里插入图片描述
在这里插入图片描述
可以通过offsetRange拿到Dstream的offset之类的
在这里插入图片描述

查看mysql结果
在这里插入图片描述

### Flink StreamingKafka 偏移量管理方式 在 Apache Flink 的流处理框架中,Kafka 是一种常见的数据源。为了确保消息消费的一致性和可靠性,Flink 提供了多种机制来管理和控制 Kafka 消息的偏移量Offset)。以下是关于 Flink 如何管理 Kafka 偏移量的关键点: #### 自动提交与手动提交 Flink 支持两种主要的方式来提交 Kafka偏移量:自动提交和手动提交。 - **自动提交** 当启用自动提交模式时,Flink 将定期把当前已消费的消息偏移量保存到 Kafka 或 Zookeeper 中。这种行为可以通过 `setAutoCommitOffset` 配置项开启或关闭[^1]。然而,需要注意的是,即使启用了自动提交功能,Flink 并不完全依赖这些外部存储的偏移量来进行容错恢复操作;它们仅用于监控目的。 - **手动提交** 更推荐的方式是在程序逻辑内部显式调用 API 来完成偏移量的手动提交。这种方式提供了更细粒度的控制能力,并且能够更好地配合 checkpointing 功能一起工作以达成端到端恰好一次 (exactly-once) 处理语义。 #### Checkpoint 和 Savepoint 对 Offset 的影响 除了上述提到的传统意义上的 offset 提交外,在实际生产环境中更为重要的一种做法是利用 Flink 的内置特性——checkpoint 和 savepoint 来持久化包括 kafka offsets 在内的整个应用程序状态。 每当触发一个新的 checkpoint 过程时,所有 tasklet 执行完毕后的最新位置都会被捕获下来并存入分布式文件系统之中作为后续可能发生的失败重试依据之一[^2]。因此只要合理设置 checkpoint 时间间隔参数以及保障 fs 容器服务正常运转即可实现高可用性的需求而无需额外关心具体某个时刻对应的具体数值变化情况。 #### 实现自定义反序列化过程中的注意事项 当从 Kafka 接收 JSON 数据并将之映射为目标 POJO 类型实例对象之前还需要注意一些细节问题: 如果打算采用 flink streaming api 构建 job graph,则必须提供一个实现了 DeserializationSchema<T> 接口的对象给对应的 source function 使用 。下面给出了一段基于 gson 库解析 json 字符串转为 java bean 的示范代码片段 : ```java public class VideoDataDeserializer implements DeserializationSchema<VideoData> { private final Gson gson = new Gson(); @Override public VideoData deserialize(byte[] message) throws IOException { String jsonString = new String(message, StandardCharsets.UTF_8); return gson.fromJson(jsonString, VideoData.class); } @Override public boolean isEndOfStream(VideoData nextElement) { return false; } @Override public TypeInformation<VideoData> getProducedType() { return TypeInformation.of(new TypeHint<VideoData>() {}); } } ``` 此方法接受原始字节数组形式的数据包作为输入参数并通过标准字符编码转换成字符串表示后再进一步借助第三方库的功能最终得到目标实体类实例[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值