kafka—生产者

已于 2022-10-23 10:28:42 修改
阅读量1.8k 收藏 2
点赞数 1
分类专栏： 大数据 文章标签： kafka 分布式 java
于 2022-10-23 10:19:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44604159/article/details/127471504
版权

学习目录

一、消息发送原理

在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程。在 main 线程中创建了一个缓冲双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。

在这里插入图片描述

工作流程：

  1. kafka Producer生产者生产数据，首先在main线程中创建一个Produce对象，然后调用send方法发送数据，发送数据过程中通过拦截器（一般不用）、序列化器、分区器进行发送数据
  2. 数据发送到 缓冲双端队列（RecordAccumulator）中，内存总大小为32M，其中分区器会将数据进行分区，一个分区创建一个队列（DQueue），对每个队列传送数据，每个批次大小为16k，然后进行存储（整个过程都是在内存中完成的）
  3. Sender 线程主动拉取双端队列的数据发送给kafka集群（前提满足下面两个条件的其中一个），kafka中的borker进行响应，如果borker没有及时响应则进行等待，最多可以拉取五次数据进行请求等待。

① batch.size：只有数据积累达到batch.size，sender才会发送数据。默认是16k
② linger.ms：如果数据未达到batch.size的默认大小，通过linger.ms设置等待的时间

  1. 当kafka集群收到数据以后会有一个应答机制（acks）级别如下：

0：生产者发送过来的数据，不需要等数据落盘应答
1：生产者发送过来的数据，Leader收到数据后应答
-1（all）：生产者发送过来的数据，Leader和ISR（即所有的Follower）队列里面的所有节点收齐数据后应答。-1和all等价

  1. 如果应答信息为成功，生产者就会清除请求和清理对应分区的数据；如果应答失败，默认会一直重试直到成功为止（重试次数可以进行修改）

二、异步发送 API

同步：效率低，需要等待才能进行下一步操作

异步：效率高，不需要等待，可以同时进行多步操作

同步发送：必须等待上一批外部的数据发送完成，才能继续发送下一批数据

异步发送：将外部的数据一批一批的放入缓冲双端队列中，不需要等待

1.普通异步发送

案例说明：在IDEA创建工程，创建Kafka 生产者，采用异步的方式发送到 Kafka Broker

（1）导入依赖

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

（2）启动集群及消费者

  1. 启动zookeeper
  2. 启动kafka集群
  3. 在hadoop103上启动消费者 主题为first1消费数据 命令为：bin/kafka-console-consumer.sh --bootstrap-server hadoop100:9092 --topic first1 --from-beginning

（3）创建不带回调函数的API代码

package com.kafka.producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author wangbo
 * @version 1.0
 */
public class CustomProducer {
    public static void main(String[] args) {
        //说明kafka集群需要启动
        //在hadoop103上启动消费者，消费数据
        //bin/kafka-console-consumer.sh --bootstrap-server hadoop100:9092 --topic first1 --from-beginning
        
        //配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop100:9092,hadoop102:9092");    //写两个节点是为了防止客户挂掉，另一个能够正常工作

        //指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        // 1.创建kafka生成对象
        // <String,String> 表示 k的数据类型，和v的数据类型
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2.发送数据
        for (int i = 0; i<5;i++){
            //第一个参数为生产者的主题名，第二个生产者生产的数据value，该方法还有其他配置选项
            kafkaProducer.send(new ProducerRecord<String, String>("first1","kafka"));
        }

        // 3.关闭资源
        kafkaProducer.close();
    }
}

2.带回调函数的异步发送

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

（1）（2）同上

（3）创建带回调函数的API代码

package com.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author wangbo
 * @version 1.0
 */

/**
 * 异步发送，创建带回调函数的API代码
 */
public class CustomProducerCallback {
    public static void main(String[] args) {
        //说明kafka集群需要启动
        //在hadoop103上启动消费者，消费数据
        //bin/kafka-console-consumer.sh --bootstrap-server hadoop100:9092 --topic first1 --from-beginning

        //配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop100:9092,hadoop102:9092");    //写两个节点是为了防止客户挂掉，另一个能够正常工作

        //指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        // 1.创建kafka生成对象
        // <String,String> 表示 k的数据类型，和v的数据类型
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2.发送数据
        for (int i = 0; i<5;i++){
            //第一个参数为生产者的主题名，第二个生产者生产的数据value,    new Callback()创建回调函数
            kafkaProducer.send(new ProducerRecord<String, String>("first1", "kafka" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null){
                        System.out.println("主题为：" + recordMetadata.topic() + " 分区为：" + recordMetadata.partition());
                    }
                }
            });
        }

        // 3.关闭资源
        kafkaProducer.close();
    }
}

三、同步发送 API

在send方法后面加一个调用get()方法即可

package com.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

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

/**
 * @author wangbo
 * @version 1.0
 */

/**
 1. 同步发送
 */
public class CustomProducerSync {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop100:9092,hadoop102:9092");    //写两个节点是为了防止客户挂掉，另一个能够正常工作

        //指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        // 1.创建kafka生成对象
        // <String,String> 表示 k的数据类型，和v的数据类型
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2.发送数据
        for (int i = 0; i<5;i++){
            //第一个参数为生产者的主题名，第二个生产者生产的数据value
            kafkaProducer.send(new ProducerRecord<String, String>("first1", "kafka" + i)).get();
        }

        // 3.关闭资源
        kafkaProducer.close();
    }
}

四、生产者分区

1.分区的好处

  1. 便于合理使用存储资源，每个Partition在一个Broker上存储，可以把海量的数据按照分区切割成一块一块数据存储在多台Broker上。合理控制分区的任务，可以实现负载均衡的效果。
  2. 提高并行度，生产者可以以分区为单位发送数据；消费者可以以分区为单位进行消费数据。

2. 生产者发送消息的分区策略

通过实现 ProducerRecord() 类的构造方法来确定分区

（1）指明partition的情况下，直接将指明的值作为partition值；
例如：partition=0，所有数据写入分区0

（2）没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值；
例如：key1的hash值=5， key2的hash值=6 ，topic的partition数=2，那 么key1 对应的value1写入1号分区，key2对应的value2写入0号分区。

（3）既没有partition值又没有key值的情况下，Kafka采用Sticky Partition（黏性分区器），会随机选择一个分区，并尽可能一直使用该分区，待该分区的batch（默认16k）已满或者已完成，Kafka再随机一个分区进行使用（和上一次的分区不同）
例如：第一次随机选择0号分区，等0号分区当前批次满了（默认16k）或者linger.ms设置的时间到， Kafka再随机一个分区进行使用（如果还是0会继续随机）

方式一：直接指明

注意：进行分区时，需要查看主题topic的分区数，如果是只有一个分区，那么只能指定的分区数为0

package com.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author wangbo
 * @version 1.0
 */

/**
 * 不同方式指定分区
 */
public class CustomProducerCallbackPartitions04 {
    public static void main(String[] args) {
        //配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop100:9092,hadoop102:9092");    //写两个节点是为了防止客户挂掉，另一个能够正常工作

        //指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        // 1.创建kafka生成对象
        // <String,String> 表示 k的数据类型，和v的数据类型
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2.发送数据
        for (int i = 0; i<5;i++){
            /*
            第一个参数：生产者的主题名
            第二个参数：指定几号分区
            第三个参数：key的值
            第四个参数：value的值
            ctrl + p 可以查看其构造函数
             */

            //new Callback()创建回调函数
            kafkaProducer.send(new ProducerRecord<String, String>("first3",1 ,"","kafka" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null){
                        System.out.println("主题为：" + recordMetadata.topic() + " 分区为：" + recordMetadata.partition());
                    }
                }
            });
        }

        // 3.关闭资源
        kafkaProducer.close();
    }
}

方式二：通过key的hash值与topic的partition数进行取余得到partition值

package com.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author wangbo
 * @version 1.0
 */

/**
 * 不同方式指定分区
 */
public class CustomProducerCallbackPartitions04 {
    public static void main(String[] args) {
        //配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop100:9092,hadoop102:9092");    //写两个节点是为了防止客户挂掉，另一个能够正常工作

        //指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        // 1.创建kafka生成对象
        // <String,String> 表示 k的数据类型，和v的数据类型
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2.发送数据
        for (int i = 0; i<5;i++){
            /*
            ctrl + p 可以查看其构造函数
             */

            //new Callback()创建回调函数,以a的hash值与topic的partition数进行取余得到分区数partition
            kafkaProducer.send(new ProducerRecord<String, String>("first3","a","kafka" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null){
                        System.out.println("主题为：" + recordMetadata.topic() + " 分区为：" + recordMetadata.partition());
                    }
                }
            });
        }

        // 3.关闭资源
        kafkaProducer.close();
    }
}

方式三：既没有指定分区也没指定key

package com.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author wangbo
 * @version 1.0
 */

/**
 * 不同方式指定分区
 */
public class CustomProducerCallbackPartitions04 {
    public static void main(String[] args) {
        //配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop100:9092,hadoop102:9092");    //写两个节点是为了防止客户挂掉，另一个能够正常工作

        //指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        // 1.创建kafka生成对象
        // <String,String> 表示 k的数据类型，和v的数据类型
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2.发送数据
        for (int i = 0; i<5;i++){
            /*
            ctrl + p 可以查看其构造函数
             */

            //new Callback()创建回调函数
            kafkaProducer.send(new ProducerRecord<String, String>("first3","kafka" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null){
                        System.out.println("主题为：" + recordMetadata.topic() + " 分区为：" + recordMetadata.partition());
                    }
                }
            });
        }

        // 3.关闭资源
        kafkaProducer.close();
    }
}

五、自定义分区器

首先定义一个myPartition类实现 Partitioner 接口，重写其中的方法

案例说明：如果数据包含kafka放入到1号分区，不包含放入2号分区（注意：主题的分区要有1，2号分区）

可以通过下面命令查看主题的详细信息：
bin/kafka-topics.sh --bootstrap-server hadoop100:9092 --describe --topic first3

myPatition类

package com.kafka.producer;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

import java.util.Map;

/**
 * @author wangbo
 * @version 1.0
 */

/**
 * topic 主题
 * key 消息的 key
 * keyBytes 消息的 key 序列化后的字节数组
 * value 消息的 value
 * valueBytes 消息的 value 序列化后的字节数组
 * cluster 集群元数据可以查看分区信息
 */

public class myPartitions05_1 implements Partitioner {
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {        //获取数据
        String value1 = value.toString();

        int Partition1;

        if (value1.contains("kafka")){
            Partition1 = 1;
        }else {
            Partition1 = 2;
        }

        return Partition1;
    }

    public void close() {

    }

    public void configure(Map<String, ?> map) {

    }
}

CustomProducerCallbackPartitions05_2 类

package com.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * @author wangbo
 * @version 1.0
 */

/**
 * 不同方式指定分区
 */
public class CustomProducerCallbackPartitions05_2 {
    public static void main(String[] args) {
        //配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop100:9092,hadoop102:9092");    //写两个节点是为了防止客户挂掉，另一个能够正常工作

        //指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        //关联自定义分区器
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.kafka.producer.myPartitions05_1");

        // 1.创建kafka生成对象
        // <String,String> 表示 k的数据类型，和v的数据类型
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2.发送数据
        for (int i = 0; i<5;i++){
            /*
            ctrl + p 可以查看其构造函数
             */

            //new Callback()创建回调函数
            kafkaProducer.send(new ProducerRecord<String, String>("first3","kafka1111" + i), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null){
                        System.out.println("主题为：" + recordMetadata.topic() + " 分区为：" + recordMetadata.partition());
                    }
                }
            });
        }

        // 3.关闭资源
        kafkaProducer.close();
    }
}
王博1999
关注
专栏目录
Kafka（四）：Kafka 生产者实现
在前进的路上
07-24 305
Kafka是一种分布式的发布（producer）/订阅（consumer）的消息系统，并支持实时和离线的数据处理、可扩展、持久的。 我们今天介绍通过java代码实现producer，包含了上一篇对参数的介绍，我们在发送Kafka主题时，参数配置也很重要，影响数据可靠性、吞吐量 对Kafka 介绍、部署、配置参数的介绍可以参考前面的文章，我们对代码先分解介绍 第一步：设置连接参数 Properties ...
【kafka】Producer笔记
一只皮皮熊
05-13 680
文章目录一、kafka简介二、生产者基本实现1.示意图2.具体实现:2.1 Fire-and-forget模式2.2 同步模式2.3 callback模式三、producer参数调优1. acks2. retries3. serializer.class4. compression.codec5. batch.num.messages & queue.buffering.max.ms四、分...
Kafka生产者
clyu的博客
05-05 890
需求：包含hello的进入0分区，否则进入1分区// 获取数据 String msgValues = value . toString();} else {} }关联自定义分区器// 关联自定义分区器 properties . put(ProducerConfig . PARTITIONER_CLASS_CONFIG , "com.atguigu.kafka.producer.MyPartitioner");
Kafka中生产者和消费者java实现
07-25
使用idea工具，使用mven编译工具，kafka的生产者和消费者的java版本的实现。
kafka之Producer
jannal专栏
12-18 311
文章目录Kafka版本Java API同步发送异步发送分区策略拦截器多线程多进程发送防止producer消息丢失 Kafka版本 kafka版本1.1.1，可能绝大部分也适用于kafka 0.10.x及以上版本。 Java API 发送的一般步骤 构造配置信息，即java.util.Properties对象 使用Properties对象构造KafkaProducer实例 构造待发送...
Java实现Kafka生产者消费者代码实例
08-19
Kafka生产者的代码实现一般包括创建Kafka生产者实例、构造消息并发送到指定主题等步骤。根据给定的代码片段，以下为生产者的关键知识点： 1. 创建KafkaProducer实例前需要配置生产者属性，包括Kafka集群的地址...
[C#]Kafka 生产者和消费者实现
12-14
Kafka 生产者和消费者实现源码 下载前你可以先看一下我的博文 https://blog.csdn.net/xy596356456/article/details/121910260 你也可以按照我的文章一步步实现
kafka 生产者
01-20
【Kafka 生产者详解】 Kafka 生产者是 Kafka 集群中负责将数据发布到主题的应用程序组件。在 Kafka 中，生产者通过创建 `ProducerRecord` 对象来构造消息，该对象包含了目标主题、消息内容以及可选的键和分区信息。...
springboot集成kafka实战项目，kafka生产者、消费者、创建topic，指定消费分区
01-04
在本项目中，我们将深入探讨如何使用Spring Boot与Kafka进行集成，实现一个实战项目，包括Kafka的生产者、消费者以及如何创建Topic，并且特别关注指定消费分区这一高级特性。Kafka是一款高吞吐量的分布式消息系统，...
vertxkafkatemplate:使用 Vert.x 编写的 Kafka 消费者和可选的 Kafka 生产者
06-01
使用 Vert.x 编写的 Kafka 消费者和可选的 Kafka 生产者 使用 vertx 开发项目真的很有趣！ 尤其是当您意识到 vertx 的有效性和全部 - 或至少 - 某些优势时！ 这个项目为你提供了一个 kafka 消费者的框架，包括通过 ...
Kafka基础-生产者发送消息
热门推荐
煉心的博客
06-20 2万+
无论你是使用Kafka作为队列，消息总线还是数据存储平台，你都会用到生产者，用于发送数据到Kafka。下文介绍如何使用Java来发送消息到Kafka。1. 发送消息的主要步骤 首先创建ProducerRecord对象，此对象除了包括需要发送的数据value之外还必须指定topic，另外也可以指定key和分区。当发送ProducerRecord的时候，生产者做的第一件事就是把key和value序列...
kafka遇到问题一：发布者发布消息抛异常org.apache.kafka.clients.producer.internals.ErrorLoggingCallback
测试极客
06-25 1万+
最近一个项目中使用到kafka作为分布式消息系统，于是网上找了些资料学习下kafka，在学习过程中遇到了如题的异常，google了下，找到了解决方法 实验环境 Tips：本机Mac系统 服务 zookeeper ：单节点 进程ID：27318 kafka服务：集群 进程ID：27329、27345、27342 消息发布者（控制台模式）：进程ID：27373 消息订阅者（...
Kafka-Callback回调接口
weixin_45154559的博客
06-20 7911
1. 什么是Callback其使用场景是什么? 在这个send方法中我们看到需要传入两个参数,而第二个参数是一个Callback Callback是一个回调接口:用户可以实现的回调接口Callback，以允许在请求完成时执行实现接口方法的代码。 2.代码示例 import org.apache.kafka.clients.producer.Callback; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.
吃透Kafka四：kafka producer源码详细分析
吃透Java
12-08 2093
一，kafka producer基本使用 kafka生产则代码如下： public static void main(String[] args) throws ExecutionException, InterruptedException { Properties conf = new Properties(); conf.setProperty(ProducerConfig.ACKS_CONFIG, "0"); conf.setProperty(Pr
如何更好地使用Kafka？
QcloudCommunity的博客
11-25 918
引言| 要确保Kafka在使用过程中的稳定性，需要从kafka在业务中的使用周期进行依次保障。主要可以分为：事先预防（通过规范的使用、开发，预防问题产生）、运行时监控（保障集群稳定，出问题能及时发现）、故障时解决（有完整的应急预案）这三阶段。事先预防即通过规范的使用、开发，预防问题产生。主要包含集群/生产端/消费端的一些最佳实践、上线前测试以及一些针对紧急情况（如消息积压等）的临时开关功能。
查询Kafka生产者是否连接到Kafka服务
最新发布
weixin_44976692的博客
06-22 5万+
java领域优质创作者🌐。
simple-kafka-producer-pool:Kafka 生产者的简单池
06-27
`simple-kafka-producer-pool` 是一个基于 Java 开发的库，用于管理 Kafka 生产者的集合，以提高效率和性能。这个库的设计目标是为应用程序提供一个简单的方法来创建和管理多个 Kafka 生产者的实例，形成一个池，...
Kafka生产者发送消息流程解析（三）
尼古拉斯赵四的博客
07-25 1365
这里写目录标题消费者发送消息流程发送消息类型序列化器分区器拦截器其他生产者参数 消费者发送消息流程 发送消息类型 同步发送 //同步发送消息 //通过send()方法发送完一个消息后返回一个Future，然后调用Future对象的get()方法等待Kafka响应 Future<RecordMetadata> future = producer.send(record); //如果Kafka正常响应,返回一个RecordMetadata记录元数据对象，该对象存储的是记录的偏移量 //如果Ka
Kafka学习---2、kafka生产者、异步和同步发送API、分区、生产经验
星光不问赶路人，岁月不负有心人
06-13 2387
Kafka学习---2、kafka生产者、异步和同步发送API、分区、生产经验
Kafka-消息发送
u010277958的博客
07-01 814
1.消息发送方式 立即发送：不关注消息是否成功到达，大部分情况下，消息会成功送达至broker。但是还是会存在消息丢失的情况。 同步发送：调用send方法发送消息后，回去该方法的Future方法，根据对象的结果查看send方法调用是否成功 异步发送：先注册一个回调函数，通过调用send方法发送消息的时候把回调函数作为参数传入，这样当生产者接收到Kafka服务器的响应时会触发执行回调函数。 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

王博1999

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

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

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

打赏作者

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

抵扣说明：

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

余额充值