Java修仙传之Kafka篇

一键三联鸭~

已于 2023-10-27 08:51:43 修改

阅读量179

点赞数 1

文章标签： 1024程序员节

于 2023-10-24 19:14:22 首次发布

本文链接：https://blog.csdn.net/weixin_50914566/article/details/134019509

版权

大道三千，最近修Kafka

架构图及基本概念

每台服务器,可以拥有一个或多个broker

每个broker可以拥有一个或多个主题

每个主题可以拥有多个分区（每个分区有序存储一部分数据，即：每个分区数据不同）

每个分区拥有一个或多个副本

一个Kafka的broker每秒可以处理数十万次读写，每个broker都可以处理TB消息而不影响性能

早期：broker是无状态（Sateless）的，它们是通过ZooKeeper来维护集群状态
现在：kafka不需要ZooKeeper来维护集群状态

一个Kafka的集群通常由多个broker组成，这样才能实现负载均衡、以及容错

生产者

<!-- kafka客户端工具 -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>2.4.1</version>
    </dependency>

public class MyProduce {
    public static void main(String[] args) {
        //1:添加配置
        Properties props = new Properties();
        props.put("bootstrap.servers", "192.168.88.100:9092");
        //指定Broker地址。如有多个Broker,逗号间隔"192.168.88.100:9092,192.168.88.101:9092,192.168.88.102:9092...
        props.put("acks", "all");
        // 消息应答机制.
        //  0:管发不管收,存在消息丢失风险。
        //  1:主节点保存后,返回成功消息,存在消息丢失风险。因为子节点可能还没保存,主节点就宕机了
        //  all(-1):主节点及所有子节点都保存成功后,返回成功消息,理论上不丢消息(但性能拉跨)
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //  指定了消息Key和Value的序列化器，: 这里用的String类型序列化器.消息发送接收时均为String类型. String消息->字节数组->String消息

        //2:创建生产者，并植入配置
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        //3:封装消息,并指定topic,key,value(消息本体),patation分区. key和Partition 都是为了分区,只要有一个即可
        ProducerRecord<String, String> msg = new ProducerRecord<>("myTopic", "myKey", "msg");
        // new ProducerRecord<String, String>("myTopic", 1, "mykey", "myMsg"); 1=Partition

        try {
        //4:生产者对象调用send方法,并发送消息.返回一个Future对象(可基于Future对象获取消息结果).  这里抛异常代表消息发送失败
        Future<RecordMetadata> future = producer.send(msg);
            //future.isDone();
            //isDone()：判断消息是否已经发送完成，即是否已经收到了发送结果。返回 true 表示发送完成，返回 false 表示还未完成。
            //get()：阻塞当前线程，直到接收到发送结果，然后返回结果。如果发送成功，它会返回 RecordMetadata 对象；如果发送过程中发生异常，它会抛出异常。
            //get(long timeout, TimeUnit unit)：阻塞当前线程，最多等待指定的时间，直到 [Something went wrong, please try again later.]

        //5:调用一个Future.get()方法等待响应.  是否获取对象都可以,对象为元数据信息,包含主题,偏移量等
            RecordMetadata recordMetadata = future.get(); //这里抛异常说明发送失败
            //RecordMetadata是Kafka提供的一个类，表示消息的元数据信息，包括消息所属的Topic、Partition、Offset等
//            recordMetadata.offset();
//            recordMetadata.partition();
//            recordMetadata.topic();
        }catch (Exception e){
            e.printStackTrace();
        }
        //6:关闭生产者
        producer.close();
    }
}

异步使用带有回调函数方法生产消息

简述：producer.send(msg, new Callback() {

...

}

即：在普通发送消息时，send里new出Callback匿名函数。

通过Exception：获取异常

通过RecordMetadata：获取出现问题的主题分区等.

发送失败：RecordMetadata返回失败的主题分区等

发送成功：RecordMetadata返回成功的主题分区等

package cn.itcast.kafka;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Properties;
import java.util.concurrent.Future;

public class MyProduce {
    public static void main(String[] args) {
        //1:添加配置
        Properties props = new Properties();
        props.put("bootstrap.servers", "192.168.88.100:9092");
        //指定Broker地址。如有多个Broker,逗号间隔"192.168.88.100:9092,192.168.88.101:9092,192.168.88.102:9092...
        props.put("acks", "all");
        // 消息应答机制.
        //  0:管发不管收,存在消息丢失风险。
        //  1:主节点保存后,返回成功消息,存在消息丢失风险。因为子节点可能还没保存,主节点就宕机了
        //  all(-1):主节点及所有子节点都保存成功后,返回成功消息,理论上不丢消息(但性能拉跨)
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //  指定了消息Key和Value的序列化器，: 这里用的String类型序列化器.消息发送接收时均为String类型. String消息->字节数组->String消息

        //2:创建生产者，并植入配置
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        //3:封装消息,并指定topic,key,value(消息本体),patation分区. key和Partition 都是为了分区,只要有一个即可
        ProducerRecord<String, String> msg = new ProducerRecord<>("myTopic", "myKey", "msg");
        // new ProducerRecord<String, String>("myTopic", 1, "mykey", "myMsg"); 1=Partition

        try {
        //4:生产者对象调用send方法,并发送消息.返回一个Future对象(可基于Future对象获取消息结果).  这里抛异常代表消息发送失败
        Future<RecordMetadata> future = producer.send(msg, new Callback() {
            @Override
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if(exception != null) {
                    System.out.println("发送消息出现异常");
                }
                else {
                    String topic = metadata.topic();
                    int partition = metadata.partition();
                    long offset = metadata.offset();

                    System.out.println("发送消息到Kafka中的名字为" + topic + "的主题，第" + partition + "分区，第" + offset + "条数据成功!");
                }
            }
        });
            //future.isDone();
            //isDone()：判断消息是否已经发送完成，即是否已经收到了发送结果。返回 true 表示发送完成，返回 false 表示还未完成。
            //get()：阻塞当前线程，直到接收到发送结果，然后返回结果。如果发送成功，它会返回 RecordMetadata 对象；如果发送过程中发生异常，它会抛出异常。
            //get(long timeout, TimeUnit unit)：阻塞当前线程，最多等待指定的时间，直到 [Something went wrong, please try again later.]

        //5:调用一个Future.get()方法等待响应.  是否获取对象都可以,对象为元数据信息,包含主题,偏移量等
            RecordMetadata recordMetadata = future.get(); //这里抛异常说明发送失败
            //RecordMetadata是Kafka提供的一个类，表示消息的元数据信息，包括消息所属的Topic、Partition、Offset等
//            recordMetadata.offset();
//            recordMetadata.partition();
//            recordMetadata.topic();
        }catch (Exception e){
            e.printStackTrace();
        }
        //6:关闭生产者
        producer.close();
    }
}

消费者

备注：不使用死循环接收消息，则需关闭消费者kafkaConsumer.close();

public class MyConsumer {
    public static void main(String[] args) {
        //1 创建消费者配置
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "node1.itcast.cn:9092");
        //消费者要连接到的kafka地址(必填)
        props.setProperty("group.id", "test");
        //消费者所属的消费者组的唯一标识符。相同 group.id 的多个消费者将协同处理消息。(必填)
        props.setProperty("enable.auto.commit", "true");
        //开启自动化提交消费位移（offset）,根据下面一条定时提交. 如果设置为flase,则需要手动提交,手动提交存在重复消费问题(手动编写代码提交逻辑)
        props.setProperty("auto.commit.interval.ms", "1000");
        //自动提交消费位移间隔.单位是毫秒  offset:消费位移,偏移量。记录消费者,消费到的条数位置(当前条数,下一条).方便后续消费
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        //消息的key跟Value的反序列化.字节数组转化后为字符串

        //2 创建kafka消费者并植入配置   KafkaConsumer<String, String> = KafkaConsumer<k, v>需要与上文的反序列化其匹配
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(props);

        //3 消费者订阅主题(从哪个主题拉数据)  生产者发到一个主题,消费者自然要从对应的主题拉取
        kafkaConsumer.subscribe(Arrays.asList("MyTopic")); //这里需要填写一个主题集合,即可以选订阅一个主题，也可以选择订阅多个主题
        // kafkaConsumer.poll(Duration.ofSeconds(10));   每个10秒从鼓起拉取一次消息。 如果10S内没有消息,则拉取到一个空对象
        // kafkaConsumer.commitSync(); 同步提交当前偏移量。这个方法将等待服务器确认提交成功。 一般手动提交用此(或者下面一条)
        // commitAsync(OffsetCommitCallback callback)：异步提交当前偏移量，并在提交完成时调用回调函数。该方法立即返回，不必等待服务器响应。
//        kafkaConsumer.commitAsync(new OffsetCommitCallback() {
//            @Override
//            public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception exception) {
//                if (exception != null) {
//                    // 处理提交偏移量时出现的异常
//                } else {
//                    // 处理提交成功的情况
//                }
//            }
//        });
        // kafkaConsumer.seek(new TopicPartition("my-topic", 0), 100); 将消费者的读取位置设置为一个特定的偏移量(从哪个主题,哪个分区,的哪个偏移量开始读取)
        // 我们将消费者的读取位置设置为名为 "my-topic" 的主题的第 0 分区（TopicPartition）的偏移量为 100 的位置。这意味着消费者将从该偏移量处开始读取消息。
        // kafkaConsumer.assignment()：获取当前消费者负责的所有主题分区。
        // kafkaConsumer.unsubscribe()：取消订阅消费者订阅的所有主题，停止消费消息

        // 4.使用一个while循环，不断从Kafka的topic中拉取消息
        while (true) {
            // Kafka的消费者一次拉取一批的数据
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(5));
            // 5.将将记录（record）的offset、key、value都打印出来   consumerRecord:相当于分页查询的Record,很多信息都封装在这
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                // 主题
                String topic = consumerRecord.topic();
                // offset：这条消息处于Kafka分区中的哪个位置
                long offset = consumerRecord.offset();
                // key\value
                String key = consumerRecord.key();
                String value = consumerRecord.value();

                System.out.println("topic: " + topic + " offset:" + offset + " key:" + key + " value:" + value);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();//线程休眠异常。 InterruptedException:线程休眠时,被外部程序打断,抛此异常
            }
        }
    }
}

卡夫卡工具Kafka Tools

连接kafka

创建topic

kafka概念详解

producer（生产者）

l 生产者负责将数据推送给broker的topic

consumer（消费者）

l 消费者负责从broker的topic中拉取数据，并自己进行处理

consumer group（消费者组）

l consumer group是kafka提供的可扩展且具有容错性的消费者机制

l 一个消费者组可以包含多个消费者

l 一个消费者组有一个唯一的ID（group Id）

l 组内的消费者一起消费主题的所有分区数据

分区（Partitions）

在Kafka集群中，主题被分为多个分区

一个主题下,有多个分区,每个分区都存储着这个主题的一部分数据

图上：broker0,分为1，2分区，每个分区存储一部分数据

副本（Replicas）：就是一主两从的从

l 副本可以确保某个服务器出现故障时，确保数据依然可用

就是子节点，主写从读，主挂了从选举新主

主题（Topic）

大白话：一类消息的一个题目.A类消息往A主题发，B类往....

l 主题是一个逻辑概念，用于生产者发布数据，消费者拉取数据

l Kafka中的主题必须要有标识符，而且是唯一的，Kafka中可以有任意数量的主题，没有数量上的限制

l 在主题中的消息是有结构的，一般一个主题包含某一类消息

l 一旦生产者发送消息到主题中，这些消息就不能被更新（更改）

偏移量（offset）

l offset记录着下一条将要发送给Consumer的消息的序号

l 默认Kafka将offset存储在ZooKeeper中

l 在一个分区中，消息是有顺序的方式存储着，每个在分区的消费都是有一个递增的id。这个就是偏移量offset

l 偏移量在分区中才是有意义的。在分区之间，offset是没有任何意义的

A消费者读到第10条断了，下次再从这第10条开始读，读取11条。这个10就是偏移量

Kafka生产者幂等性与事务

幂等性：多次操作结果一致。

增：多次操作，出现相同数据，则可能出现问题（如重复名称）这种就不具备幂等性

删：删一次库里没了，再删仍然没了，再删也一样，幂等性

改：可能会出现重复名称等信息

不具备幂等性的卡夫卡现象：一条消息如果未及时回复ACK，则会被再次发送，重复保存

kafka解决幂等性的方式：基于PID（生产者唯一ID），Sequence Number（特定生产者发送到指定分区的递增消息序号）

大白话：存储前校验消息的PID及序列号。如果库里有就不存了，直接让broker返回ACK

Kafka事务(手动编写提交,且发生问题回滚)

Kafka事务指的是生产者生产消息以及消费者提交offset的操作可以在一个原子操作中，要么都成功，要么都失败。

这五个方法全部由生产者对象调用

生产者配置

生产者负责开启事务，配置事务id

// 配置事务的id，开启了事务会默认开启幂等性

props.put("transactional.id", "first-transactional");

 // 1. 配置生产者带有事务配置的属性
        Properties props = new Properties();
        props.put("bootstrap.servers", "192.168.200.130:9092");
        props.put("acks", "all");
        // 开启事务必须要配置事务的ID
        props.put("transactional.id", "dwd_user");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 2. 构建生产者
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);

消费者配置

消费者需要设置隔离级别及关闭自动提交（因为事务都是手动提交的）

// 1. 消费者需要设置隔离级别

props.put("isolation.level","read_committed");

// 2. 关闭自动提交

props.put("enable.auto.commit", "false");

 // 1. 配置消费者的属性（添加对事务的支持）
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.200.130:9092");
        props.setProperty("group.id", "ods_user");
        // 配置事务的隔离级别
        props.put("isolation.level","read_committed");
        // 关闭自动提交，一会我们需要手动来提交offset，通过事务来维护offset
        props.setProperty("enable.auto.commit", "false");
        // 反序列化器
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        // 2. 构建消费者对象
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(props);

        // 3. 订阅一个topic
        kafkaConsumer.subscribe(Arrays.asList("ods_user"));

使用案例

public static void main(String[] args) {
        Consumer<String, String> consumer = createConsumer();
        Producer<String, String> producer = createProducer();
        // 初始化事务
        producer.initTransactions();

        while(true) {
            try {
                // 1. 开启事务
                producer.beginTransaction();
                // 2. 定义Map结构，用于保存分区对应的offset
                Map<TopicPartition, OffsetAndMetadata> offsetCommits = new HashMap<>();
                // 2. 拉取消息
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(2));
                for (ConsumerRecord<String, String> record : records) {
                    // 3. 保存偏移量
                    offsetCommits.put(new TopicPartition(record.topic(), record.partition()),
                            new OffsetAndMetadata(record.offset() + 1));
                    // 4. 进行转换处理
                    String[] fields = record.value().split(",");
                    fields[1] = fields[1].equalsIgnoreCase("1") ? "男":"女";
                    String message = fields[0] + "," + fields[1] + "," + fields[2];
                    // 5. 生产消息到dwd_user
                    producer.send(new ProducerRecord<>("dwd_user", message));
                }
                // 6. 提交偏移量到事务
                producer.sendOffsetsToTransaction(offsetCommits, "ods_user");
                // 7. 提交事务
                producer.commitTransaction();
            } catch (Exception e) {
                // 8. 放弃事务
                producer.abortTransaction();
            }
        }
    }

生产者分区写入策略

生产者写入消息到topic，Kafka将依据不同的策略将数据分配到不同的分区中

1. 轮询分区策略（存在乱序问题）

2. 随机分区策略（存在乱序问题）

3. 按key分区分配策略（有序,但存在分配不均问题）

4. 自定义分区策略

乱序问题：

随机：因为随机所以乱序

轮询：本来是在一个分区1，2，3，4，5的数据，被分配到三个分区,A1 B2 C3，下一轮A14 C25，可不就乱序了吗

分配不均问题：

有的key消息多，有的key消息少，

都发一个key去了，这个分区消息爆了

其他分区一条没有，闲得慌,可不是分配不均吗

自定义分区策略实现：

步骤：

1：新建类，并实现Partitioner 接口

2：重写configure，partition，close三个方法

3：partition，接收配置。 partition：分区逻辑。 close：分区关闭清理数据

// 备注:此处为自定义分区类.如某个生产者希望使用这个方式进行分区存储。
// 请加入配置:props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,MyRandomPartitionerPattern.class.getName());
public class MyRandomPartitionerPattern implements Partitioner {

    private Random random;

    @Override
    public void configure(Map<String, ?> map) {
        random = new Random();
    }

    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        //luster.partitionCountForTopic表示获取指定topic的分区数量
        //random.nextInt(1000):随机返回一个0-1000之间的整数
        //合起来:随机整数对分区数量取余(求得索要存储的分区)
        return random.nextInt(1000) % cluster.partitionCountForTopic(topic);
    }

    @Override
    public void close() {

    }

    //configure(Map<String, ?> map) 方法：
    //
    //该方法在分区器初始化时被调用，用于进行一些配置和初始化操作。
    //在这个例子中，configure 方法接收一个 Map 对象作为参数，用于传递配置信息。但是在代码中，并没有使用这个参数。
    //在 configure 方法中，通过实例化 Random 对象来初始化 random 成员变量，以便后续的分区计算中使用。
    //partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) 方法：
    //
    //这是分区器的核心方法，用于根据指定的主题、键和值等信息计算消息应该发送到哪个分区。
    //topic 是消息所属的主题名称。
    //key 和 keyBytes 是消息的键，可以为空。
    //value 和 valueBytes 是消息的值，以字节数组形式提供。
    //cluster 是一个 Kafka 集群对象，用于获取有关集群的元数据信息，例如分区数量等。
    //在这个例子中，通过调用 random.nextInt(1000) % cluster.partitionCountForTopic(topic) 的方式，根据随机数和主题的分区数量来计算将消息发送到哪个分区。
    //返回的结果是一个整数，代表分区的编号。
    //close() 方法：
    //
    //这个方法在分区器关闭时被调用，用于进行一些清理操作。
    //在这个例子中，close 方法为空，即没有实际的清理操作。
    //通过实现 Partitioner 接口，并定义这三个方法，可以自定义 Kafka 分区器的行为。根据实际需求，可以编写适合特定场景的分区逻辑，以满足消息的分发需求。
}

消费组Consumer Group Rebalance机制（再分配）

再均衡：在某些情况下，消费者组中的消费者消费的分区会产生变化，会导致消费者分配不均匀（例如：有两个消费者消费3个，因为某个partition崩溃了，还有一个消费者当前没有分区要削峰），Kafka Consumer Group就会启用rebalance机制，重新平衡这个Consumer Group内的消费者消费的分区分配。
触发时机

- 消费者数量发生变化

- - 某个消费者crash
  - 新增消费者

- topic的数量发生变化

- - 某个topic被删除

- partition的数量发生变化

- - 删除partition
  - 新增partition

不良影响

- 发生rebalance，所有的consumer将不再工作，共同来参与再均衡，直到每个消费者都已经被成功分配所需要消费的分区为止（rebalance结束）

消费者的分区分配策略

分区分配策略：保障每个消费者尽量能够均衡地消费分区的数据，不能出现某个消费者消费分区的数量特别多，某个消费者消费的分区特别少

range分配策略：

1. Range分配策略（范围分配策略）：Kafka默认的分配策略

- n：分区的数量 / 消费者数量
- m：分区的数量 % 消费者数量
- 前m个消费者消费n+1个分区
- 剩余的消费者消费n个分区

2. RoundRobin分配策略（轮询分配策略）

- 消费者挨个分配消费的分区

3. Striky粘性分配策略

- 在没有发生rebalance跟轮询分配策略是一致的
- 发生了rebalance，轮询分配策略，重新走一遍轮询分配的过程。而粘性会保证跟上一次的尽量一致，只是将新的需要分配的分区，均匀的分配到现有可用的消费者中即可
- 减少上下文的切换

上面如果consumer2崩溃了，此时需要进行rebalance。如果是Range分配和轮询分配都会重新进行分配，例如：

副本机制（保存机制,从节点如何保存，ACK如何返回）

props.put("acks", "all");

acks配置为0（管发不管收）

acks配置为1（只管主节点保存，不管从节点是否保存）

acks配置为-1或者all（主从节点都保存完好，才返回ACK）

高级（High Level）API与低级（Low Level）API

高级（High Level）：自动化

l 上面是之前编写的代码，消费Kafka的消息很容易实现，写起来比较简单

l 不需要执行去管理offset，直接通过ZK管理；也不需要管理分区、副本，由Kafka统一管理

l 消费者会自动根据上一次在ZK中保存的offset去接着获取数据

l 在ZK中，不同的消费者组（group）同一个topic记录不同的offset，这样不同程序读取同一个topic，不会受offset的影响

高级API的缺点

l 不能控制offset，例如：想从指定的位置读取

l 不能细化控制分区、副本、ZK等

public class _2ConsumerTest {
    public static void main(String[] args) {
        // 1. 创建Kafka消费者配置
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "192.168.88.100:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "true");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        // 2. 创建Kafka消费者
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

        // 3. 订阅要消费的主题
        consumer.subscribe(Arrays.asList("test"));

        // 4. 使用一个while循环，不断从Kafka的topic中拉取消息
        while (true) {
            // 定义100毫秒超时
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records)
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        }
    }
}

低级（Low Level）：半自动（手动）

通过使用低级API，我们可以自己来控制offset，想从哪儿读，就可以从哪儿读。而且，可以自己控制连接分区，对分区自定义负载均衡。而且，之前offset是自动保存在ZK中，使用低级API，我们可以将offset不一定要使用ZK存储，我们可以自己来存储offset。例如：存储在文件、MySQL、或者内存中。但是低级API，比较复杂，需要执行控制offset，连接到哪个分区，并找到分区的leader。

手动消费分区数据（基于assign消费）

我们需要指定要消费的分区，例如：

l 如果某个程序将某个指定分区的数据保存到外部存储中，例如：Redis、MySQL，那么保存数据的时候，只需要消费该指定的分区数据即可

l 如果某个程序是高可用的，在程序出现故障时将自动重启(例如：后面我们将学习的Flink、Spark程序)。这种情况下，程序将从指定的分区重新开始消费数据。

1.不再使用之前的 subscribe 方法订阅主题，而使用 「assign」方法指定想要消费的消息

     String topic = "test";
     TopicPartition partition0 = new TopicPartition(topic, 0);
     TopicPartition partition1 = new TopicPartition(topic, 1);
     consumer.assign(Arrays.asList(partition0, partition1));
2.一旦指定了分区，就可以就像前面的示例一样，在循环中调用「poll」方法消费消息

注意

1. 当手动管理消费分区时，即使GroupID是一样的，Kafka的组协调器都将不再起作用

2. 如果消费者失败，也将不再自动进行分区重新分配

一键三联鸭~

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java修仙传之Kafka篇

随机：因为随机所以乱序轮询：本来是在一个分区1，2，3，4，5的数据，被分配到三个分区,A1 B2 C3，下一轮A14 C25，可不就乱序了吗有的key消息多，有的key消息少，都发一个key去了，这个分区消息爆了其他分区一条没有，闲得慌,可不是分配不均吗步骤：1：新建类，并实现Partitioner 接口2：重写configure，partition，close三个方法3：partition，接收配置。partition：分区逻辑。close：分区关闭清理数据。
复制链接

扫一扫