Kafka API 学习

最新推荐文章于 2025-02-25 07:43:38 发布
最新推荐文章于 2025-02-25 07:43:38 发布
阅读量629 收藏
点赞数
分类专栏： 大数据 文章标签： kafka 学习 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hj1993/article/details/128809792
版权

1. Producer 生产者

1.1 消息发送流程

Kafka 的 Producer发送消息采用的是 异步发送 的方式。在消息发送的过程中，涉及到了
两个线程 main线程和 Sender线程 ，以及 一个线程共享变量 RecordAccumulator。
main线程将消息发送给 RecordAccumulator Sender线程不断从 RecordAccumulator中拉取
消息发送到 Kafka broker

  • batch.size：只有数据积累到batch.size 之后，sender 才会发送数据。
  • linger.ms：如果数据迟迟未达到batch.size，sender 等待linger.time 之后就会发送数据
  • 若两个参数都配置了，哪个条件先达到都会发送

1.2 异步发送 API

1、pom.xml

<dependencies>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>0.11.0.0</version>
    </dependency>
</dependencies>

2、用到的类

  • KafkaProducer：需要创建一个生产者对象，用来发送数据
  • ProducerConfig：获取所需的一系列配置参数
  • ProducerRecord：每条数据都要封装成一个ProducerRecord 对象

不带回调函数

package top.midworld;

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

import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class ProducerTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 将相关配置封装在 Properties，其中 key 可以从 ProducerConfig 类获取
        Properties props = new Properties();
        props.put("bootstrap.servers", "hadoop1:9092");
        props.put("acks", "all");
        props.put("retries", 1);    // 重试次数
        props.put("batch.size", 16384); // 批次大小
        props.put("linger.ms", 1);  // 等待时间
        props.put("buffer.memory", 33554432);  // 缓冲区大小
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        String topic = "first";
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        for (int i = 0; i <= 10; i++) {
            // ProducerRecord(String topic, K key, V value)
            producer.send(new ProducerRecord<>(topic, "kafka_test", "kafka test: " + Integer.toString(i)));
        }
        producer.close();
    }
}

需要将发送的每条数据 封装为 ProducerRecord，它接收三个参数，分别为：topic、key、value

consumer 消费者接收结果：

[hadoop@hadoop2 kafka]$ ./bin/kafka-console-consumer.sh --bootstrap-server hadoop2:9092 --from-beginning --topic first
first
second
kafka test: 0
kafka test: 1
kafka test: 2
kafka test: 3
kafka test: 4
kafka test: 5
kafka test: 6
kafka test: 7
kafka test: 8
kafka test: 9
kafka test: 10

带回调函数

producer.send() 可以带一个 callback，该方法会在 Producer 收到 ack 时调用，为异步调用。有两个参数，分别是：RecordMetadata 和 Exception，若 Exception 为空则表示发送成功，否则发送失败。消息发送失败会自动重试，不需要手动调用重试

package top.midworld;

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

import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class ProducerAsyncCallback {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop1:9092");
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.RETRIES_CONFIG, 1);    // 重试次数
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); // 批次大小
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);  // 等待时间
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);  // 缓冲区大小
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        String topic = "first";
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        for (int i = 0; i <= 10; i++) {
            // ProducerRecord(String topic, K key, V value)
            producer.send(new ProducerRecord<String, String>(topic, "kafka_test", "kafka_sender_callback: " + Integer.toString(i)), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    // sender 回调函数
                    if (e == null) {
                        System.out.println("success->" + recordMetadata.offset());
                    } else {
                        System.out.println("failed");
                        e.printStackTrace();
                    }
                }
            });
        }
        producer.close();
    }
}

consumer 消费结果

[hadoop@hadoop2 kafka]$ ./bin/kafka-console-consumer.sh --bootstrap-server hadoop2:9092 --from-beginning --topic first
first
second
kafka test: 0
kafka test: 1
kafka test: 2
kafka test: 3
kafka test: 4
kafka test: 5
kafka test: 6
kafka test: 7
kafka test: 8
kafka test: 9
kafka test: 10
kafka_sender_callback: 0
kafka_sender_callback: 1
kafka_sender_callback: 2
kafka_sender_callback: 3
kafka_sender_callback: 4
kafka_sender_callback: 5
kafka_sender_callback: 6
kafka_sender_callback: 7
kafka_sender_callback: 8
kafka_sender_callback: 9
kafka_sender_callback: 10

1.3 同步发送

package top.midworld;

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

import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class ProducerSync {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop1:9092");
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.RETRIES_CONFIG, 1);    // 重试次数
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); // 批次大小
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);  // 等待时间
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);  // 缓冲区大小
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        String topic = "first";
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        for (int i = 0; i <= 10; i++) {
            // ProducerRecord(String topic, K key, V value)
            producer.send(
                    new ProducerRecord<>("first", "kafka_sync_test", "kafka_sync_test: " + Integer.toString(i))
            ).get();
        }
        producer.close();
    }
}

1.4 指定分区发送消息

// 给 topic=first 的 1 号分区发送消息
producer.send(new ProducerRecord<String, String>("first", 1,"kafka_test", "kafka_sender_callback: " + Integer.toString(i)), new Callback(){});

2. Consumer 消费者

2.1 自动提交 offset

package top.midworld;

import org.apache.kafka.clients.consumer.ConsumerConfig;
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;

/*
自动提交 offset
 */
public class ConsumerAutoOffset {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop1:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test1");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");    // 是否自动提交 offset
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "10000");  // 提交间隔，毫秒
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");  // 相当于从开始读 --from-beginning

        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(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.2 手动提交 offset

自动提交基于时间提交，很难把握 offset 提交的时机，因此 kafka 还提供了手动提交 offset 的 API

  • 同步提交 commitSync：会阻塞当前线程，一直到提交成功，并且有重试机制
  • 异步提交 commitAsync：没有重试机制，有可能会提交失败

两者的相同点是，都会将本次 poll 的一批数据最高的偏移量提交

重复消费和漏消费

无论是同步提交还是异步提交 offset，都有可能会造成数据的漏消费或者重复消费。先
提交 offset 后消费，有可能造成数据的漏消费；而先消费后提交 offset，有可能会造成数据
的重复消费

2.2.1 同步提交

package top.midworld;

import org.apache.kafka.clients.consumer.ConsumerConfig;
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 ConsumerAutoSyncOffset {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop1:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test1");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");    // 是否自动提交 offset
//        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "10000");  // 提交间隔，毫秒

        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(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());
            }

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

2.2.2 异步提交

同步影响吞吐量，实际开发中更多用的是异步提交：

package top.midworld;

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

import java.util.Arrays;
import java.util.Map;
import java.util.Properties;

public class ConsumerAutoAsyncOffset {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop1:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test1");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");    // 是否自动提交 offset
//        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "10000");  // 提交间隔，毫秒

        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(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());
            }

            // 异步提交，当前线程会阻塞 直到 offset 提交成功
            consumer.commitAsync(new OffsetCommitCallback() {
                @Override
                public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception e) {
                    if (e != null) {
                        System.out.println("Commit offset failed for: " + offsets);
                    }
                }
            });
        }
    }
}

2.2.3 示例消费数据持久化到数据库

package top.midworld;

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

import java.util.*;

public class ConsumerAutoAsyncOffset {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop1:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test4");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");    // 是否自动提交 offset
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "10000");  // 提交间隔，毫秒
//        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");  // 相当于从开始读 --from-beginning

        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

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

        consumer.subscribe(Arrays.asList("first"));
        final int minBatchSize = 26;
        List<ConsumerRecord<String, String>> buffer = new ArrayList<>();
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(1000);
            for (ConsumerRecord<String, String> record : records) {
                buffer.add(record);

                // 数据达到批量要求，就写入 db，同步确认 offset
                if (buffer.size() >= minBatchSize) {
                    System.out.println("*********************");
                    insertIntoDb(buffer);
                    consumer.commitSync();
                    buffer.clear();
                }
            }
        }
    }

    // 插入 db 中
    public static void insertIntoDb(List<ConsumerRecord<String, String>> consumerRecords) {
        System.out.println("正在插入 DB 中...");
        for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
            System.out.println("offset: " + consumerRecord.offset() + " key: " + consumerRecord.key() + " value: " + consumerRecord.value());
        }
    }
}

2.3 指定分区消费

package top.midworld;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.TopicPartition;

import java.util.Arrays;
import java.util.Properties;

public class ConsumerPartition {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop1:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test4");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");    // 是否自动提交 offset
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "10000");  // 提交间隔，毫秒

        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

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

        // 只消费 first topic 1 号分区
        TopicPartition p = new TopicPartition("first", 1);
        consumer.assign(Arrays.asList(p));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(1000);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
            consumer.commitSync();
        }
    }
}

参考

  • https://blog.youkuaiyun.com/lingdu_789/article/details/108345584

  • https://blog.youkuaiyun.com/zp17834994071/article/details/108137736

Kafka异步发送API：实现高效消息传递
DeoSql的博客
09-22 209
在上述代码中，我们设置了一个10秒的超时时间，如果在超时时间内消息发送完成，则打印发送成功的信息，包括消息所在的主题、分区和偏移量。为了实现高效的消息传递，Kafka提供了异步发送API，允许生产者在发送消息时不进行阻塞等待。通过异步发送消息，我们可以最大程度地提高生产者的吞吐量，同时避免由于网络延迟等原因导致的阻塞等待。需要注意的是，由于异步发送是非阻塞的，如果在发送消息后立即关闭生产者，可能会导致部分消息未能发送成功。在本文中，我们将介绍Kafka异步发送API的使用方法，并提供相应的源代码示例。
从小白的角度讲解kafka并使用java、python_API实战
热门推荐
weixin_43178406的博客
04-29 5万+
1. 什么是kafka 1.1 基本概述 1.2 深度讲解 2. kafka的安全机制 3. python_API 3.1 作为生产者连接kafka并发送数据
Kafka3.0异步发送API
weixin_45417821的博客
06-01 247
1）需求：创建 Kafka 生产者，采用异步的方式发送到 Kafka Broker导入依赖 代码示例： 测试：在hadoop103 下输入消费者命令 在idea执行代码，查看回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是元数据信息（RecordMetadata）和异常信息（Exception），如果 Exception 为 null，说明消息发送成功，如果 Exception 不为 null，说明消息发送失败。基于异步代码，示例如下： 整体代码如下： 测试后，i
Kafka 基础教程 — 消费者API详解
最新发布
smart_an的专栏
02-25 706
Override//不做任何配置@Overrideint id;try {@Override//不需要关闭任何资源。
【Kafka笔记】4.Kafka API详细解析 Java版本（Producer API，Consumer API，拦截器等）
菜鸟sdut的博客
11-24 1298
简介 Kafka的API有Producer API，Consumer API还有自定义Interceptor (自定义拦截器)，以及处理的流使用的Streams API和构建连接器的Kafka Connect API。 Producer API Kafka的Producer发送消息采用的是异步发送的方式。在消息发送过程中，涉及两个线程：main线程和Sender线程，以及一个线程共享变量Recor...
一个基于Kafka客户端封装的工具，Kafka开发效率神器
zhangchuangzhuang的博客
11-21 2万+
topic列表topic创建topic删除topic的分区列表，分区和副本数删除groupId集群的节点列表消费者列表指定topic的活跃消费者列表生产数据到指定的topic,同步接口{"topic":"RULEa93304e6d844000","partition":1,"offset":681}生产数据到指定的topic，异步接口，默认回调生产数据到指定的topic，异步接口，自定义回调。
进击消息中间件系列（九）：Kafka 各类 API 使用
民工哥的博客
08-03 237
点击下方名片，设为星标！回复“1024”获取2TB学习资源！前面介绍了 Kafka服务器 Broker、生产者 Producer、消费者 Consumer、控制器 Controller、主题与分区相关的知识点，今天我将详细的为大家介绍 Kafka API的使用相关知识，希望大家能够从中收获多多！如有帮助，请点在看、转发支持一波！！！Producer API消息发送流程Kafka 的 Produ...
快速学习-Kafka API
01-07
第 4 章 Kafka API 4.1 Producer API 4.1.1 消息发送流程 Kafka 的 Producer 发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程，以及一个线程共享变量——...
2、java调用kafka api
05-29
了解了Java调用Kafka API的基本概念和操作后，可以进一步学习Kafka的重要概念，如分区、副本、消费者组以及如何使用监控工具Kafka-Eagle进行性能监控和问题排查。通过深入理解这些概念和工具，可以更高效地利用Kafka...
SpringBoot基础（五、整合Kafka及原生api使用）
yingqi的博客
11-07 2108
目录 Kafka原生API使用 创建生产者 利用生产者发送消息 ：无脑发模式 利用生产者发送消息 ：同步发送 利用生产者发送消息 ：异步发送 利用生产者发送消息 ：异步发送，并使用自定义分区分配器 创建消费者 配置信息 利用消费者消费信息：自动提交位移 利用消费者消费信息：手动提交位移 利用消费者消费信息：手动异步提交当前位移 利用消费者消费信息：手动异步提交位移带回测 ...
第11单元 KafkaApi实战1
08-08
Apache Kafka 是一个分布式流处理平台，常用于构建实时数据管道和流应用。在Java中，Kafka提供了丰富的API，...通过学习，你可以掌握如何在企业环境中利用Kafka进行实时数据传输和处理，从而提升系统性能和可扩展性。
KAFKA-03-kafka JAVA基本API使用
苍煜
05-10 817
文章目录1:topic操作api1：pom.xml导包2：创建topic3：查看topic列表4：查看topic详情5：删除topic2：生产者和消费者1：生产者1：普通异步发送2：带回调函数的异步发送3:同步发送4:prop参数名称 描述2：消费者1:消费者组初始化流程2：参数名称 描述3:订阅主题4：订阅分区3：自定义分区1：系统默认分区策略2：自定义分区策略1：分区策略默认实现Partitioner2:使用自定义分区策略4:序列化（重要）1：系统默认的序列化器2：自定义序列化1：自定义序列化器2:自定
Kafka原生API
kevin
06-18 879
一、依赖 <dependencies> <!-- kafka依赖 --> <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka_2.12</artifactI...
Kafka API 三大API基本使用
lisus2007的专栏
09-15 434
/ 如果改为 sarama.OffsetOldest 则会从最旧的消息开始消费，即每次重启 consumer 都会把该 topic 下的所有消息消费一次。nextOffset, _ := partitionOffsetManager.NextOffset() // 取得下一消息的偏移量作为本次消费的起点。// 参数3 offset 从哪儿开始消费起走，正常情况下每次消费完都会将这次的offset提交到kafka。// 根据 kafka 中记录的上次消费的 offset 开始+1的位置接着消费。
Kafka API详解
@小刘同学nice
06-22 2565
Producer API 消息发送流程 Kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到Kafka broker。 相关参...
Kafka代码实现--from-beginning，读取历史未消费的数据
Coding Road
07-29 3万+
Kafka实际环境有可能会出现Consumer全部宕机，虽然基于Kafka的高可用特性，消费者群组中的消费者可以实现再均衡，所有Consumer不处理数据的情况很少，但是还是有可能会出现，此时就要求Consumer重启的时候能够读取在宕机期间Producer发送的数据。基于消费者订阅模式默认是无法实现的，因为只能订阅最新发送的数据。 通过消费者命令行可以实现，只要在命令行中加上--from-be...
五、Kafka API 接口
猿小许的博客
06-03 5725
Kafka有5个核心API： Producer API 允许应用程序发送数据流到kafka集群中的topic。 Consumer API 允许应用程序从kafka集群的topic中读取数据流。 Streams API 允许从输入topic转换数据流到输出topic。 Connect API 通过实现连接器（connector），不断地从一些源系统或应用程序中拉取数据到kafka，或从kafka提交数据到宿系统（sink system）或应用程序。 Admin API 用于管理和检查topic，br
简单封装kafka相关的api
aipiannian6725的博客
07-18 320
一、针对于kafka版本 <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>0.8.2.2</version> <...
Kafka组件connector使用详解
u012604489的博客
09-13 8716
1、文件准备： 应用程序=>kafka.connector.hbase.jar 日志配置=>connect-log4j.properties Work启动配置=>connect-distributed.properties 2、文件 日志配置： log4j.rootLogger=INFO, stdout,debug log4j.appender.stdout...
Java调用Kafka API详解与实战教程
开发人员会学习如何创建`KafkaProducer`对象，设置属性配置，如连接Kafka服务器的Properties，然后创建`ProducerRecord`来包装要发送的数据。通过实例，他们会将1-100的数字消息写入名为`test`的Topic，使用`send`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

风老魔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值