一文详解：Kafka的常用API

Posted 2021-05-02 黑马程序员视频库

黑马程序员视频库

传智播客旗下互联网资讯、学习资源免费分享平台

1

消息发送

1、异步发送

• 导入依赖

<dependency>

<groupId>org.apache.kafka</groupId>

<artifactId>kafka-clients</artifactId>

<version>0.11.0.0</version>

</dependency>

• 编写代码

需要用到的类：

KafkaProducer：需要创建一个生产者对象，用来发送数据

ProducerConfig：获取所需的一系列配置参数

ProducerRecord：每条数据都要封装成一个ProducerRecord对象

• 不带回调函数的API

package com.heima.kafka;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

import java.util.concurrent.ExecutionException;

public class CustomProducer {

   public static void main(String[] args) throws ExecutionException, InterruptedException {

       Properties props = new Properties();

       props.put("bootstrap.servers", "hadoop102:9092");//kafka集群，broker-list

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

       props.put("retries", 1);//重试次数

       props.put("batch.size", 16384);//批次大小

       props.put("linger.ms", 1);//等待时间

       props.put("buffer.memory", 33554432);//RecordAccumulator缓冲区大小

       props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");

       props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

       Producer<String, String> producer = new KafkaProducer<>(props);

       for (int i = 0; i < 100; i++) {

           producer.send(new ProducerRecord<String, String>("first", Integer.toString(i), Integer.toString(i)));

       }

       producer.close();

   }

}

• 带回调函数的API

回调函数会在producer收到ack时调用，为异步调用，该方法有两个参数，分别是RecordMetadata和Exception，如果Exception为null，说明消息发送成功，如果Exception不为null，说明消息发送失败。

注意：消息发送失败会自动重试，不需要我们在回调函数中手动重试。

package com.heima.kafka;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

import java.util.concurrent.ExecutionException;

public class CustomProducer {

   public static void main(String[] args) throws ExecutionException, InterruptedException {

       Properties props = new Properties();

       props.put("bootstrap.servers", "hadoop102:9092");//kafka集群，broker-list

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

       props.put("retries", 1);//重试次数

       props.put("batch.size", 16384);//批次大小

       props.put("linger.ms", 1);//等待时间

       props.put("buffer.memory", 33554432);//RecordAccumulator缓冲区大小

       props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");

       props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

       Producer<String, String> producer = new KafkaProducer<>(props);

       for (int i = 0; i < 100; i++) {

           producer.send(new ProducerRecord<String, String>("first", Integer.toString(i), Integer.toString(i)), new Callback() {

               //回调函数，该方法会在Producer收到ack时调用，为异步调用

               @Override

               public void onCompletion(RecordMetadata metadata, Exception exception) {

                   if (exception == null) {

                       System.out.println("success->" + metadata.offset());

                   } else {

                       exception.printStackTrace();

                   }

               }

           });

       }

       producer.close();

   }

}

2

同步发送

同步发送的意思就是，一条消息发送之后，会阻塞当前线程，直至返回ack。

由于send方法返回的是一个Future对象，根据Futrue对象的特点，我们也可以实现同步发送的效果，只需在调用Future对象的get方即可。

package com.heima.kafka;

import org.apache.kafka.clients.producer.KafkaProducer;

import org.apache.kafka.clients.producer.Producer;

import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

import java.util.concurrent.ExecutionException;

public class CustomProducer {

   public static void main(String[] args) throws ExecutionException, InterruptedException {

       Properties props = new Properties();

       props.put("bootstrap.servers", "hadoop102:9092");//kafka集群，broker-list

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

       props.put("retries", 1);//重试次数

       props.put("batch.size", 16384);//批次大小

       props.put("linger.ms", 1);//等待时间

       props.put("buffer.memory", 33554432);//RecordAccumulator缓冲区大小

       props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");

       props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

       Producer<String, String> producer = new KafkaProducer<>(props);

       for (int i = 0; i < 100; i++) {

           producer.send(new ProducerRecord<String, String>("first", Integer.toString(i), Integer.toString(i))).get();

       }

       producer.close();

   }

}

3

消息消费

Consumer消费数据时的可靠性是很容易保证的，因为数据在Kafka中是持久化的，故不用担心数据丢失问题。

由于consumer在消费过程中可能会出现断电宕机等故障，consumer恢复后，需要从故障前的位置的继续消费，所以consumer需要实时记录自己消费到了哪个offset，以便故障恢复后继续消费。所以offset的维护是Consumer消费数据是必须考虑的问题。

1、自动提交offset

• 导入依赖

<dependency>

<groupId>org.apache.kafka</groupId>

<artifactId>kafka-clients</artifactId>

<version>0.11.0.0</version>

</dependency>

• 编写代码

需要用到的类：

KafkaConsumer：需要创建一个消费者对象，用来消费数据

ConsumerConfig：获取所需的一系列配置参数

ConsuemrRecord：每条数据都要封装成一个ConsumerRecord对象

为了使我们能够专注于自己的业务逻辑，Kafka提供了自动提交offset的功能。

自动提交offset的相关参数：

enable.auto.commit：是否开启自动提交offset功能

auto.commit.interval.ms：自动提交offset的时间间隔

以下为自动提交offset的代码：

package com.heima.kafka;

import org.apache.kafka.clients.consumer.ConsumerRecord;

import org.apache.kafka.clients.consumer.ConsumerRecords;

import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;

import java.util.Properties;

public class CustomConsumer {

   public static void main(String[] args) {

       Properties props = new Properties();

       props.put("bootstrap.servers", "hadoop102:9092");

       props.put("group.id", "test");

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

       props.put("auto.commit.interval.ms", "1000");

       props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

       consumer.subscribe(Arrays.asList("first"));

       while (true) {

           ConsumerRecords<String, String> records = consumer.poll(100);

           for (ConsumerRecord<String, String> record : records)

               System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());

       }

   }

}

2、手动提交offset

虽然自动提交offset十分简洁便利，但由于其是基于时间提交的，开发人员难以把握offset提交的时机。因此Kafka还提供了手动提交offset的API。

手动提交offset的方法有两种：分别是commitSync（同步提交）和commitAsync（异步提交）。两者的相同点是，都会将本次poll的一批数据最高的偏移量提交；不同点是，commitSync阻塞当前线程，一直到提交成功，并且会自动失败重试（由不可控因素导致，也会出现提交失败）；而commitAsync则没有失败重试机制，故有可能提交失败。

• 同步提交offset

由于同步提交offset有失败重试机制，故更加可靠，以下为同步提交offset的示例。

package com.heima.kafka.consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;

import org.apache.kafka.clients.consumer.ConsumerRecords;

import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;

import java.util.Properties;

/**

* @author liubo

*/

public class CustomComsumer {

   public static void main(String[] args) {

       Properties props = new Properties();

       props.put("bootstrap.servers", "hadoop102:9092");//Kafka集群

       props.put("group.id", "test");//消费者组，只要group.id相同，就属于同一个消费者组

       props.put("enable.auto.commit", "false");//关闭自动提交offset

       props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

       consumer.subscribe(Arrays.asList("first"));//消费者订阅主题

       while (true) {

           ConsumerRecords<String, String> records = consumer.poll(100);//消费者拉取数据

           for (ConsumerRecord<String, String> record : records) {

               System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());

           }

          consumer.commitSync();//同步提交，当前线程会阻塞知道offset提交成功

       }

   }

}

• 异步提交offset

虽然同步提交offset更可靠一些，但是由于其会阻塞当前线程，直到提交成功。因此吞吐量会收到很大的影响。因此更多的情况下，会选用异步提交offset的方式。

以下为异步提交offset的示例：

package com.heima.kafka.consumer;

import org.apache.kafka.clients.consumer.*;

import org.apache.kafka.common.TopicPartition;

import java.util.Arrays;

import java.util.Map;

import java.util.Properties;

/**

* @author liubo

*/

public class CustomConsumer {

   public static void main(String[] args) {

       Properties props = new Properties();

       props.put("bootstrap.servers", "hadoop102:9092");//Kafka集群

       props.put("group.id", "test");//消费者组，只要group.id相同，就属于同一个消费者组

       props.put("enable.auto.commit", "false");//关闭自动提交offset

       props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

       consumer.subscribe(Arrays.asList("first"));//消费者订阅主题

       while (true) {

           ConsumerRecords<String, String> records = consumer.poll(100);//消费者拉取数据

           for (ConsumerRecord<String, String> record : records) {

               System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());

           }

           consumer.commitAsync(new OffsetCommitCallback() {

               @Override

               public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception exception) {

                   if (exception != null) {

                       System.err.println("Commit failed for" + offsets);

                   }

               }

           });//异步提交

       }

   }

}

3、自定义存储offset

Kafka 0.9版本之前，offset存储在zookeeper，0.9版本之后，默认将offset存储在Kafka的一个内置的topic中。除此之外，Kafka还可以选择自定义存储offset。

Offset的维护是相当繁琐的，因为需要考虑到消费者的Rebalace。

当有新的消费者加入消费者组、已有的消费者推出消费者组或者所订阅的主题的分区发生变化，就会触发到分区的重新分配，重新分配的过程叫做Rebalance。

消费者发生Rebalance之后，每个消费者消费的分区就会发生变化。因此消费者要首先获取到自己被重新分配到的分区，并且定位到每个分区最近提交的offset位置继续消费。

要实现自定义存储offset，需要借助ConsumerRebalanceListener，以下为示例代码，其中提交和获取offset的方法，需要根据所选的offset存储系统自行实现。

package com.heima.kafka.consumer;

import org.apache.kafka.clients.consumer.*;

import org.apache.kafka.common.TopicPartition;

import java.util.*;

/**

* @author liubo

*/

public class CustomConsumer {

   private static Map<TopicPartition, Long> currentOffset = new HashMap<>();

   public static void main(String[] args) {

       Properties props = new Properties();

       props.put("bootstrap.servers", "hadoop102:9092");//Kafka集群

       props.put("group.id", "test");//消费者组，只要group.id相同，就属于同一个消费者组

       props.put("enable.auto.commit", "false");//关闭自动提交offset

       props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

       KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

       consumer.subscribe(Arrays.asList("first"), new ConsumerRebalanceListener() {

           

           //该方法会在Rebalance之前调用

           @Override

           public void onPartitionsRevoked(Collection<TopicPartition> partitions) {

               commitOffset(currentOffset);

           }

           //该方法会在Rebalance之后调用

           @Override

           public void onPartitionsAssigned(Collection<TopicPartition> partitions) {

               currentOffset.clear();

               for (TopicPartition partition : partitions) {

                   consumer.seek(partition, getOffset(partition));//定位到最近提交的offset位置继续消费

               }

           }

       });

       while (true) {

           ConsumerRecords<String, String> records = consumer.poll(100);//消费者拉取数据

           for (ConsumerRecord<String, String> record : records) {

               System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());

               currentOffset.put(new TopicPartition(record.topic(), record.partition()), record.offset());

           }

           commitOffset(currentOffset);

       }

   }

   //获取某分区的最新offset

   private static long getOffset(TopicPartition partition) {

       return 0;

   }

   //提交该消费者所有分区的offset

   private static void commitOffset(Map<TopicPartition, Long> currentOffset) {

   }

}

推荐阅读：

我就知道你会 “在看”

▼点击 阅读原文抢基础班免费名额