kafka offset判断

最新推荐文章于 2022-03-05 18:12:29 发布
最新推荐文章于 2022-03-05 18:12:29 发布
阅读量1.5w 收藏 12
点赞数
分类专栏： BIGDATA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rongyongfeikai2/article/details/50727661
版权

在使用Spark streaming读取kafka数据时，为了避免数据丢失，我们会在zookeeper中保存kafka的topic对应的partition的offset信息（每次执行成功后，才更新zk中的offset信息）；从而保证执行失败的下一轮，可以从特定的offset开始读。

实现方式类似下面文章所示：

http://blog.csdn.net/rongyongfeikai2/article/details/49784785

但，kafka的topic是可能会被删除的，而更糟糕的情况是，用户又新建了一个相同名字的topic。这是，zk中保存的offset信息会已经不再准确了，此时就需要与kafka的broker保存的offset信息进行比对，从而把zk中的offset信息修正成功。

实现方式如下：

1.用一个类来保存特定topic的leader信息，以及partition的offset信息

import java.io.Serializable;
import java.util.HashMap;

/**
 * @function:kafka记录类
 */
public class KafkaTopicOffset implements Serializable{
    private String topicName;
    private HashMap<Integer,Long> offsetList;
    private HashMap<Integer,String> leaderList;

    public KafkaTopicOffset(String topicName){
        this.topicName = topicName;
        this.offsetList = new HashMap<Integer,Long>();
        this.leaderList = new HashMap<Integer, String>();
    }

    public String getTopicName() {
        return topicName;
    }

    public HashMap<Integer, Long> getOffsetList() {
        return offsetList;
    }

    public void setTopicName(String topicName) {
        this.topicName = topicName;
    }

    public void setOffsetList(HashMap<Integer, Long> offsetList) {
        this.offsetList = offsetList;
    }

    public HashMap<Integer, String> getLeaderList() {
        return leaderList;
    }

    public void setLeaderList(HashMap<Integer, String> leaderList) {
        this.leaderList = leaderList;
    }

    public String toString(){
        return "topic:"+topicName+",offsetList:"+this.offsetList+",leaderList:"+this.leaderList;
    }
}


2.从kafka的broker中得到topic-partition的offset信息（主要是利用SimpleConsumer发送相应的Request） 

import java.io.Serializable;
import java.util.*;
import com.nsfocus.bsaips.common.Constant;
import com.nsfocus.bsaips.model.KafkaTopicOffset;
import kafka.javaapi.OffsetResponse;
import kafka.api.PartitionOffsetRequestInfo;
import kafka.common.TopicAndPartition;
import kafka.javaapi.TopicMetadataRequest;
import kafka.javaapi.consumer.SimpleConsumer;
import kafka.javaapi.TopicMetadata;
import kafka.javaapi.PartitionMetadata;

/**
 * @function:kafka相关工具类
 */
public class KafkaUtil implements Serializable {
    private static KafkaUtil kafkaUtil = null;

    private KafkaUtil(){}

    public static KafkaUtil getInstance(){
        if(kafkaUtil == null){
            kafkaUtil = new KafkaUtil();
        }
        return kafkaUtil;
    }

    private String[] getIpsFromBrokerList(String brokerlist){
        StringBuilder sb = new StringBuilder();
        String[] brokers = brokerlist.split(",");
        for(int i=0;i<brokers.length;i++){
            brokers[i] = brokers[i].split(":")[0];
        }
        return brokers;
    }

    private Map<String,Integer> getPortFromBrokerList(String brokerlist){
        Map<String,Integer> map = new HashMap<String,Integer>();
        String[] brokers = brokerlist.split(",");
        for(String item:brokers){
            String[] itemArr = item.split(":");
            if(itemArr.length > 1){
                map.put(itemArr[0],Integer.parseInt(itemArr[1]));
            }
        }
        return map;
    }

    public KafkaTopicOffset topicMetadataRequest(String brokerlist,String topic){
        List<String> topics = Collections.singletonList(topic);
        TopicMetadataRequest topicMetadataRequest = new TopicMetadataRequest(topics);

        KafkaTopicOffset kafkaTopicOffset = new KafkaTopicOffset(topic);
        String[] seeds = getIpsFromBrokerList(brokerlist);
        Map<String,Integer> portMap = getPortFromBrokerList(brokerlist);

        for(int i=0;i<seeds.length;i++){
            SimpleConsumer consumer = null;
            try{
                consumer = new SimpleConsumer(seeds[i],
                        portMap.get(seeds[i]),
                        Constant.TIMEOUT,
                        Constant.BUFFERSIZE,
                        Constant.groupId);
                kafka.javaapi.TopicMetadataResponse resp = consumer.send(topicMetadataRequest);
                List<TopicMetadata> metaData = resp.topicsMetadata();
                for (TopicMetadata item : metaData) {
                    for (PartitionMetadata part : item.partitionsMetadata()) {
                        kafkaTopicOffset.getLeaderList().put(part.partitionId(),part.leader().host());
                        kafkaTopicOffset.getOffsetList().put(part.partitionId(),0L);
                    }
                }
            }catch(Exception ex){
                ex.printStackTrace();
            }finally{
                if(consumer != null){
                    consumer.close();
                }
            }
        }

        return kafkaTopicOffset;
    }

    public KafkaTopicOffset getLastOffsetByTopic(String brokerlist,String topic){
        KafkaTopicOffset kafkaTopicOffset = topicMetadataRequest(brokerlist, topic);
        String[] seeds = getIpsFromBrokerList(brokerlist);
        Map<String,Integer> portMap = getPortFromBrokerList(brokerlist);

        for(int i=0;i<seeds.length;i++){
            SimpleConsumer consumer = null;
            Iterator iterator = kafkaTopicOffset.getOffsetList().entrySet().iterator();

            try{
                consumer = new SimpleConsumer(seeds[i],
                        portMap.get(seeds[i]),
                        Constant.TIMEOUT,
                        Constant.BUFFERSIZE,
                        Constant.groupId);

                while(iterator.hasNext()){
                    Map.Entry<Integer,Long> entry = (Map.Entry<Integer, Long>) iterator.next();
                    int partitonId = entry.getKey();

                    if(!kafkaTopicOffset.getLeaderList().get(partitonId).equals(seeds[i])){
                        continue;
                    }

                    TopicAndPartition topicAndPartition = new TopicAndPartition(topic,
                            partitonId);
                    Map<TopicAndPartition,PartitionOffsetRequestInfo> requestInfo =
                            new HashMap<TopicAndPartition, PartitionOffsetRequestInfo>();

                    requestInfo.put(topicAndPartition,
                            new PartitionOffsetRequestInfo(kafka.api.OffsetRequest.LatestTime(),1)
                    );
                    kafka.javaapi.OffsetRequest request = new kafka.javaapi.OffsetRequest(
                            requestInfo, kafka.api.OffsetRequest.CurrentVersion(),
                            Constant.groupId);
                    OffsetResponse response = consumer.getOffsetsBefore(request);
                    long[] offsets = response.offsets(topic,partitonId);
                    if(offsets.length > 0){
                        kafkaTopicOffset.getOffsetList().put(partitonId,offsets[0]);
                    }
                }
            }catch(Exception ex){
                ex.printStackTrace();
            }finally{
                if(consumer != null){
                    consumer.close();
                }
            }
        }

        return kafkaTopicOffset;
    }

    public Map<String,KafkaTopicOffset> getKafkaOffsetByTopicList(String brokerList,List<String> topics){
        Map<String,KafkaTopicOffset> map = new HashMap<String,KafkaTopicOffset>();
        for(int i=0;i<topics.size();i++){
            map.put(topics.get(i),getLastOffsetByTopic(brokerList, topics.get(i)));
        }
        return map;
    }

    public static void main(String[] args){
        try{
              System.out.println(KafkaUtil.getInstance().getKafkaOffsetByTopicList(
                      ConfigUtil.getInstance().getKafkaConf().get("brokerlist"),
                      Arrays.asList(new String[]{"pj_test_tmp","test"})));
        }catch(Exception ex) {
            ex.printStackTrace();
        }
    }
}

3.再在KafkaCluster从zk中得到offset信息时，与从broker得到的offset信息中比对（假定调用KafkaUtil的getKafkaOffsetByTopicList得到的返回值放在了offsetMap中）：



经过讨论，已经知道early offset是最新的起始offset的值，而last offset则是最新的终止offset的值，所以应对过期的情况，应该是从最新的起始offset开始消费。所以应该发送的是EarliestOffsetRequest而非LastOffsetRequest。修改后的代码如下：

package com.nsfocus.bsaips.util;
import java.io.Serializable;
import java.util.*;
import com.nsfocus.bsaips.common.Constant;
import com.nsfocus.bsaips.model.KafkaTopicOffset;
import kafka.javaapi.OffsetResponse;
import kafka.api.PartitionOffsetRequestInfo;
import kafka.common.TopicAndPartition;
import kafka.javaapi.TopicMetadataRequest;
import kafka.javaapi.consumer.SimpleConsumer;
import kafka.javaapi.TopicMetadata;
import kafka.javaapi.PartitionMetadata;

/**
 * @function:kafka相关工具类
 */
public class KafkaUtil implements Serializable {
    private static KafkaUtil kafkaUtil = null;

    private KafkaUtil(){}

    public static KafkaUtil getInstance(){
        if(kafkaUtil == null){
            kafkaUtil = new KafkaUtil();
        }
        return kafkaUtil;
    }

    private String[] getIpsFromBrokerList(String brokerlist){
        StringBuilder sb = new StringBuilder();
        String[] brokers = brokerlist.split(",");
        for(int i=0;i<brokers.length;i++){
            brokers[i] = brokers[i].split(":")[0];
        }
        return brokers;
    }

    private Map<String,Integer> getPortFromBrokerList(String brokerlist){
        Map<String,Integer> map = new HashMap<String,Integer>();
        String[] brokers = brokerlist.split(",");
        for(String item:brokers){
            String[] itemArr = item.split(":");
            if(itemArr.length > 1){
                map.put(itemArr[0],Integer.parseInt(itemArr[1]));
            }
        }
        return map;
    }

    public KafkaTopicOffset topicMetadataRequest(String brokerlist,String topic){
        List<String> topics = Collections.singletonList(topic);
        TopicMetadataRequest topicMetadataRequest = new TopicMetadataRequest(topics);

        KafkaTopicOffset kafkaTopicOffset = new KafkaTopicOffset(topic);
        String[] seeds = getIpsFromBrokerList(brokerlist);
        Map<String,Integer> portMap = getPortFromBrokerList(brokerlist);

        for(int i=0;i<seeds.length;i++){
            SimpleConsumer consumer = null;
            try{
                consumer = new SimpleConsumer(seeds[i],
                        portMap.get(seeds[i]),
                        Constant.TIMEOUT,
                        Constant.BUFFERSIZE,
                        Constant.groupId);
                kafka.javaapi.TopicMetadataResponse resp = consumer.send(topicMetadataRequest);
                List<TopicMetadata> metaData = resp.topicsMetadata();
                for (TopicMetadata item : metaData) {
                    for (PartitionMetadata part : item.partitionsMetadata()) {
                        kafkaTopicOffset.getLeaderList().put(part.partitionId(),part.leader().host());
                        kafkaTopicOffset.getOffsetList().put(part.partitionId(),0L);
                    }
                }
            }catch(Exception ex){
                ex.printStackTrace();
            }finally{
                if(consumer != null){
                    consumer.close();
                }
            }
        }

        return kafkaTopicOffset;
    }

    public KafkaTopicOffset getLastOffsetByTopic(String brokerlist,String topic){
        KafkaTopicOffset kafkaTopicOffset = topicMetadataRequest(brokerlist, topic);
        String[] seeds = getIpsFromBrokerList(brokerlist);
        Map<String,Integer> portMap = getPortFromBrokerList(brokerlist);

        for(int i=0;i<seeds.length;i++){
            SimpleConsumer consumer = null;
            Iterator iterator = kafkaTopicOffset.getOffsetList().entrySet().iterator();

            try{
                consumer = new SimpleConsumer(seeds[i],
                        portMap.get(seeds[i]),
                        Constant.TIMEOUT,
                        Constant.BUFFERSIZE,
                        Constant.groupId);

                while(iterator.hasNext()){
                    Map.Entry<Integer,Long> entry = (Map.Entry<Integer, Long>) iterator.next();
                    int partitonId = entry.getKey();

                    if(!kafkaTopicOffset.getLeaderList().get(partitonId).equals(seeds[i])){
                        continue;
                    }

                    TopicAndPartition topicAndPartition = new TopicAndPartition(topic,
                            partitonId);
                    Map<TopicAndPartition,PartitionOffsetRequestInfo> requestInfo =
                            new HashMap<TopicAndPartition, PartitionOffsetRequestInfo>();

                    requestInfo.put(topicAndPartition,
                            new PartitionOffsetRequestInfo(kafka.api.OffsetRequest.LatestTime(),1)
                    );
                    kafka.javaapi.OffsetRequest request = new kafka.javaapi.OffsetRequest(
                            requestInfo, kafka.api.OffsetRequest.CurrentVersion(),
                            Constant.groupId);
                    OffsetResponse response = consumer.getOffsetsBefore(request);
                    long[] offsets = response.offsets(topic,partitonId);
                    if(offsets.length > 0){
                        kafkaTopicOffset.getOffsetList().put(partitonId,offsets[0]);
                    }
                }
            }catch(Exception ex){
                ex.printStackTrace();
            }finally{
                if(consumer != null){
                    consumer.close();
                }
            }
        }

        return kafkaTopicOffset;
    }

    public KafkaTopicOffset getEarlyOffsetByTopic(String brokerlist,String topic){
        KafkaTopicOffset kafkaTopicOffset = topicMetadataRequest(brokerlist, topic);
        String[] seeds = getIpsFromBrokerList(brokerlist);
        Map<String,Integer> portMap = getPortFromBrokerList(brokerlist);

        for(int i=0;i<seeds.length;i++){
            SimpleConsumer consumer = null;
            Iterator iterator = kafkaTopicOffset.getOffsetList().entrySet().iterator();

            try{
                consumer = new SimpleConsumer(seeds[i],
                        portMap.get(seeds[i]),
                        Constant.TIMEOUT,
                        Constant.BUFFERSIZE,
                        Constant.groupId);

                while(iterator.hasNext()){
                    Map.Entry<Integer,Long> entry = (Map.Entry<Integer, Long>) iterator.next();
                    int partitonId = entry.getKey();

                    if(!kafkaTopicOffset.getLeaderList().get(partitonId).equals(seeds[i])){
                        continue;
                    }

                    TopicAndPartition topicAndPartition = new TopicAndPartition(topic,
                            partitonId);
                    Map<TopicAndPartition,PartitionOffsetRequestInfo> requestInfo =
                            new HashMap<TopicAndPartition, PartitionOffsetRequestInfo>();

                    requestInfo.put(topicAndPartition,
                            new PartitionOffsetRequestInfo(kafka.api.OffsetRequest.EarliestTime(),1)
                    );
                    kafka.javaapi.OffsetRequest request = new kafka.javaapi.OffsetRequest(
                            requestInfo, kafka.api.OffsetRequest.CurrentVersion(),
                            Constant.groupId);
                    OffsetResponse response = consumer.getOffsetsBefore(request);
                    long[] offsets = response.offsets(topic,partitonId);
                    if(offsets.length > 0){
                        kafkaTopicOffset.getOffsetList().put(partitonId,offsets[0]);
                    }
                }
            }catch(Exception ex){
                ex.printStackTrace();
            }finally{
                if(consumer != null){
                    consumer.close();
                }
            }
        }

        return kafkaTopicOffset;
    }

    public Map<String,KafkaTopicOffset> getKafkaOffsetByTopicList(String brokerList,List<String> topics){
        Map<String,KafkaTopicOffset> map = new HashMap<String,KafkaTopicOffset>();
        for(int i=0;i<topics.size();i++){
            map.put(topics.get(i),getLastOffsetByTopic(brokerList, topics.get(i)));
        }
        return map;
    }

    public Map<String,KafkaTopicOffset> getKafkaEarlyOffsetByTopicList(String brokerList,List<String> topics){
        Map<String,KafkaTopicOffset> map = new HashMap<String,KafkaTopicOffset>();
        for(int i=0;i<topics.size();i++){
            map.put(topics.get(i),getEarlyOffsetByTopic(brokerList, topics.get(i)));
        }
        return map;
    }

    public static void main(String[] args){
        try{
//            System.out.println(KafkaUtil.getInstance().topicMetadataRequest(
//                    ConfigUtil.getInstance().getKafkaConf().get("brokerlist"),
//                    "pj_test_tmp"));
//            System.out.println(KafkaUtil.getInstance().getLastOffsetByTopic(
//                    ConfigUtil.getInstance().getKafkaConf().get("brokerlist"),
//                    "bsaips"));
//              System.out.println(KafkaUtil.getInstance().getKafkaOffsetByTopicList(
//                      ConfigUtil.getInstance().getKafkaConf().get("brokerlist"),
//                      Arrays.asList(new String[]{"bsa_sys_tmp"})));
              //last offset是最新的终止offset的值，early offset是最新的起始offset的值
              System.out.println(KafkaUtil.getInstance().getKafkaEarlyOffsetByTopicList(
                      ConfigUtil.getInstance().getKafkaConf().get("brokerlist"),
                      Arrays.asList(new String[]{"bsa_sys_tmp"})));
        }catch(Exception ex) {
            ex.printStackTrace();
        }
    }
}

判断逻辑为：




rongyongfeikai2
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[Kafka基础]-- auto.offset.reset介绍
欢迎来到我的博客，一起探索代码里的世界！
12-17 8534
我们先看看最新的官方文档说明： What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server (e.g. because that data has been deleted): earliest: automatically ...
Kafka详解
最新发布
qq_41644412的博客
05-25 863
consumer 提交offset的时候，kafka Offset manager会首先追加一条新的conmit消息到 _consumer_offset topic中，然后更新对应的缓存，读offset时从缓存中读取，而不是直接读取 _consumer_offset topic。如查找368801的offset消息。同一个Topic的每个分区中的数据是不重复的，partition的表现形式是一个一个文件夹。文件，每个 .log文件 的大小是一样的，但是里面存储的消息条数可能不相同（可能消息的大小不一致）。
关于怎么获取kafka指定位置offset消息
weixin_33738555的博客
07-10 1030
2019独角兽企业重金招聘Python工程师标准>>> ...
kafka-python消费者读取数据时自定义偏移量，自定义数据读取的顺序
呆萌的代Ma
03-05 3547
kafka-python的安装、基本使用与zookeeper启动等请参考：使用python连接kafka 自定义consumer读取的offset写法 注意在kafka-python中使用消费者自定义offset的读取顺序时，消费者的写法： from kafka import KafkaConsumer from kafka.structs import TopicPartition consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
kafka offset 机制
stuliper的专栏
08-30 4551
kafka消息处理类：MessageAndOffset case class MessageAndOffset(message: Message, offset: Long) { /**   * Compute the offset of the next message in the log   */  def nextOffset: Long = offset + 1 } ...
Java Kafka面试专题
10-01
Kafka consumer 消费消息时，向 broker发出"fetch"请求去消费特定分区的消息，consumer 指定消息在日志中的偏移量（offset），就可以消费从这个位置开始的消息，customer 拥有了 offset 的控制权，可以向后回滚去...
Kafka面试专题 消息中间件
06-15
Kafka Consumer 消费消息时，向 Broker 发出"fetch"请求去消费特定分区的消息，Consumer 指定消息在日志中的偏移量（offset），就可以消费从这个位置开始的消息，Consumer 拥有了 offset 的控制权，可以向后回滚去...
Kafka面试专题.pdf
01-04
Kafka 判断节点是否存活的两个关键条件： 1. **ZooKeeper 连接**: 节点必须保持与 ZooKeeper 的心跳连接。 2. **follower 同步**: 如果节点是 follower，它需要及时同步 leader 的写操作。 **消息传递** 1. **...
Kafka 17道面试题和答案.docx
06-14
- 消费者可以指定消费特定分区的消息，通过offset控制消息的消费位置，实现消息重播。 8. **消息格式和存储**： - 消息由固定长度的头部和可变长度的消息体组成，包含长度、版本号、CRC32校验码等。 - Kafka ...
kafka常见问题
我是明星的专栏
08-09 1万+
kafka常见问题
Kafka之获取指定Topic-Partition的lastOffset
TomAndersen的博客
03-21 2091
前言 kafka版本：2.11-2.1.1 基于Kafka Java API 主要是通过封装Conusmer.endOffsets方法实现此功能 代码 /** * <p>根据指定的Topic-Partition获取对应的endOffset. * 主要是封装了KafkaConsumer的{@link KafkaConsumer#endOffsets}方法. ...
使用JAVA获取KAFKA中指定TOPIC的OFFSET
weixin_34088598的博客
07-25 1437
2019独角兽企业重金招聘Python工程师标准>>> ...
关于Kafka 的消息日志Offset 的了解
热门推荐
顾晓艳的专栏
12-18 1万+
之前在做Kafka 整合Storm的时候，因为对Kafka 不是很熟，考虑过这样的一个场景问题，针对一个Topic,Kafka消息日志中有个offset信息来标注消息的位置，Storm每次从kafka 消费数据，都是通过zookeeper存储的数据offset，来判断需要获取消息在消息日志里的起始位置。 而Kafla 有个参数log.retention.hours会根据设定的小时，来清理日志文件
kafka 消费者offset记录位置和方式
weixin_30783913的博客
08-22 1361
我们大家都知道，kafka消费者在会保存其消费的进度，也就是offset，存储的位置根据选用的kafka api不同而不同。 首先来说说消费者如果是根据javaapi来消费，也就是【kafka.javaapi.consumer.ConsumerConnector】，我们会配置参数【zookeeper.connect】来消费。这种情况下，消费者的offset会更新到zookeeper的【co...
解决java.lang.ClassNotFoundException: kafka.api.OffsetRequest问题
Blossom
11-04 2226
问题描述 在使用构建的AdvertisingTopology进行提交时，出现如下错误： 问题解决 AdvertisingTopology项目中将kafka 2.0.0降低到版本0.8.2.1，并指定kafka-client版本。（主要应该是kafka2.0.0版本的问题） <dependency> <group...
Kafka （三） acks 与 手动提交 offset
weixin_38399962的博客
05-10 1万+
新手解除 kafka，很容易把 acks 和提交 ack搞混了。 acks (0, 1, 'all') 代表kafka收到消息的答复数,0就是不要答复,爱收到没收到.1就是有一个leader broker答复就行,all是所有broker都要收到才行 0: Producer不等待kafka服务器的答复,消息立刻发往socket buffer,这种方式不能保证kafka收到消息,设置成这个...
spark streaming从指定offset处消费Kafka数据
Jacob
10-29 3698
原文地址:http://blog.csdn.net/high2011/article/details/53706446       首先很感谢原文作者，看到这篇文章我少走了很多弯路，转载此文章是为了保留一份供复习用，请大家支持原作者，移步到上面的连接去看，谢谢 一、情景：当Spark streaming程序意外退出时，数据仍然再往Kafka中
kafkaoffset详解
07-28
当leader接收到消息后，会先判断isr中成员的offset，如果不是最大+1，代表isr中有成员还没有接收到这条消息，则不会更改高水位。只有当isr中的每台机器的offset都比leader大1时，leader才会更新高水位，并将更新高...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值