Kafka API 学习

最新推荐文章于 2024-05-29 18:08:45 发布
最新推荐文章于 2024-05-29 18:08:45 发布
阅读量605 收藏
点赞数
分类专栏： 大数据 文章标签： kafka 学习 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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.csdn.net/lingdu_789/article/details/108345584

  • https://blog.csdn.net/zp17834994071/article/details/108137736

风老魔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
快速学习-Kafka API
01-07
第 4 章 Kafka API 4.1 Producer API 4.1.1 消息发送流程 Kafka 的 Producer 发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程，以及一个线程共享变量——...
【Kafka笔记】4.Kafka API详细解析 Java版本（Producer API，Consumer API，拦截器等）
菜鸟sdut的博客
11-24 1218
简介 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 223
点击下方名片，设为星标！回复“1024”获取2TB学习资源！前面介绍了 Kafka服务器 Broker、生产者 Producer、消费者 Consumer、控制器 Controller、主题与分区相关的知识点，今天我将详细的为大家介绍 Kafka API的使用相关知识，希望大家能够从中收获多多！如有帮助，请点在看、转发支持一波！！！Producer API消息发送流程Kafka 的 Produ...
11、Kafka ------ Kafka 核心API 及 生产者API 讲解
Java 领域技术分享
01-20 1554
Kafka ------ Kafka 核心API 及 生产者API 讲解
2、java调用kafka api
05-29
了解了Java调用Kafka API的基本概念和操作后，可以进一步学习Kafka的重要概念，如分区、副本、消费者组以及如何使用监控工具Kafka-Eagle进行性能监控和问题排查。通过深入理解这些概念和工具，可以更高效地利用Kafka...
Kafka学习笔记
09-27
在正式学习Kafka之前，我们首先需要了解消息系统应具备的基本功能。消息系统需要实现消息的发布和订阅，存储消息流，并具备容错性。消息系统的消费者需要能够实时处理消息，具备历史消息的获取能力，并且消息源无需...
kafka学习材料
03-20
5. **Kafka的API**：Kafka提供了Java和Scala的生产者和消费者API，以及其他语言的客户端库，方便开发者集成到各种应用中。 6. **Kafka Streams**：Kafka提供了一个轻量级的流处理库，可以直接在Kafka topic之间进行...
Kafka完整教程学习
03-23
### Kafka完整教程学习 #### 一、Kafka简介与应用场景 Kafka是一种开源的分布式事件流平台(Event Streaming Platform)，主要用于构建高性能的数据管道、流分析、数据集成以及支持关键任务的应用程序。在大数据处理...
Kafka API
qq_37200262的博客
06-24 1009
Topic基本的dml操作，如何创建，删除，查询一个topic含有哪些东西 创建生产者API 创建生产者模拟发送消息，发送消息的时候需要指定消息所属的topic和消息k,v.因为创建topic的时候指定了分区数量，所以会根据消息的key指定消息所属的分区。发送消息有两种方式，即同步和异步。 创建消费者API 创建消费者，指定消费者组，消费者所属的组。指定消费者消费的topic，在这里，消费者具体消费哪一个分区的内容是根据消费者的分区分配策略指定的。 自定义消费者组分区 在这里没有指定消费者所属的group,
Kafka的 API 编程
CyAurora的博客
08-21 349
目录 创建⼯程 java版本 kafka生产者的api操作 kafka消费者的api操作 工具类 Scala版本 工具类 生产者和消费着 创建⼯程 创建⼯程略，导⼊Pom依赖 <!-- 下⾯的依赖，包含了上⾯的kafka-clients，所以只需要引⼊下⾯即可 --> <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka_2.1
Kafka原生API
kevin
06-18 832
一、依赖 <dependencies> <!-- kafka依赖 --> <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka_2.12</artifactI...
Kafka_5_ API_同异步
qq_61809177的博客
04-11 593
回调函数会在producer收到ack时调用，为异步调用，该方法有两个参数，分别RecordMetadata和Exception，如果Exception为null，说明消息发送成功，如果Exception不为null，说明消息发送失败。由于send方法返回的是一个Future对象，根据Futrue对象的特点，我们也可以实现同步发送的效果，只需在调用Future对象的get方发即可。同步发送的意思就是，一条消息发送之后，会阻塞当前线程，直至返回ack。System.out.println(“真正发送”);
Kafka API与SpringBoot调用
初心不改
08-12 1490
Spring 是通过 KafkaTemplate 来完成对 Kafka 的操作的。@Autowired// 从配置文件读取自定义属性// 由于是提交数据，所以使用Post方式Spring 是通过监听方式实现消费者的。Spring Kafka 是通过 KafkaListener 监听方式来完成消息订阅与接收的。当监听到有指定主题的消息时，就会触发@KafkaListener 注解所标注的方法的执行@Component。
Kafka原生API使用Java代码-生产者-异步发送消息&回调
最新发布
小丁的博客
05-29 530
Kafka原生API使用Java代码-生产者-异步发送消息&回调。
Kafka API 三大API基本使用
lisus2007的专栏
09-15 380
/ 如果改为 sarama.OffsetOldest 则会从最旧的消息开始消费，即每次重启 consumer 都会把该 topic 下的所有消息消费一次。nextOffset, _ := partitionOffsetManager.NextOffset() // 取得下一消息的偏移量作为本次消费的起点。// 参数3 offset 从哪儿开始消费起走，正常情况下每次消费完都会将这次的offset提交到kafka。// 根据 kafka 中记录的上次消费的 offset 开始+1的位置接着消费。
Kafka详解（下）——Kafka核心API、通过Spring Boot 集成Kafka、集群搭建
weixin_43816711的博客
07-07 1274
Kafka包括以下核心API： 4-1 Producer API ​ KafkaProducer API 的核心部分是类，使用类发送数据。KafkaProducer是线程安全的，可以在多个线程之间共享生产者实例。​ KafkaProducer类提供了方法将消息异步发送到主题。在消息发送过程中，涉及两个线程：线程和线程，以及一个线程共享变量。main线程将消息发送给RecordAccmulator，Sender线程不断地从RecordAccumulator中拉取消息发送给Kafka broker。​ Kafk
Day450&451&452.Kafka架构深入&KafkaAPI -kafa
阿昌爱Java
11-14 2412
Kafka 架构深入 一、Kafka 工作流程及文件存储机制 工作流程 每个分区中，对应的offset偏移量为区内有序，不是全局有序 Kafka 中消息是以 topic进行分类的，生产者生产消息，消费者消费消息，都是面向 topic的。 topic 是逻辑上的概念，partition 是物理上的概念。 每个 partition 对应于一个 log 文件，该 log 文件中存储的就是 producer 生产的数据。 Producer 生产的数据会被不断追加到该log 文件末端，且每条数据都有自己的 o
Kafka API详解
@小刘同学nice
06-22 2521
Producer API 消息发送流程 Kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到Kafka broker。 相关参...
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、付费专栏及课程。

余额充值