Kafka03 - Kafka生产者

最新推荐文章于 2025-09-22 21:23:33 发布
原创 最新推荐文章于 2025-09-22 21:23:33 发布 · 1.1k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#kafka #分布式

Kafka生产者

文章目录

一：生产者消息发送流程

1：发送原理

在消息发送的过程中，涉及到了两个线程——main线程和Sender线程。

在main线程中创建了一个双端队列RecordAccumulator。

  • main线程将消息发送给RecordAccumulator

  • Sender线程不断从RecordAccumulator中拉取消息发送到Kafka Broker。

在这里插入图片描述

2：生产者重要参数列表

参数名称描述
bootstrap.servers生产者连接集群所需的broker地址清单。
例如hadoop102:9092,hadoop103:9092,hadoop104:9092，可以设置1个或者多个，中间用逗号隔开。
注意这里并非需要所有的broker地址，因为生产者从给定的broker里查找到其他broker信息。
key.serializer和value.serializer指定发送消息的key和value的序列化类型。
一定要写全类名。
buffer.memoryRecordAccumulator缓冲区总大小，默认32m。
batch.size（重要）缓冲区一批数据最大值，默认16k。
适当增加该值，可以提高吞吐量，但是如果该值设置太大，会导致数据传输延迟增加。
linger.ms如果数据迟迟未达到batch.size，sender等待linger.time之后就会发送数据。
单位ms，默认值是0ms，表示没有延迟。
生产环境建议该值大小为5-100ms之间。
acks（重要）0：生产者发送过来的数据，不需要等数据落盘应答
1：生产者发送过来的数据，Leader收到数据后应答。
-1（all）：生产者发送过来的数据，Leader+和isr队列里面的所有节点收齐数据后应答。
默认值是-1，而且-1和all是等价的。
max.in.flight.requests.per.connection允许最多没有返回ack的次数，默认为5，开启幂等性要保证该值是1-5的数字。
retries（重要）当消息发送出现错误的时候，系统会重发消息。retries表示重试次数。
默认是int最大值，2147483647。
如果设置了重试，还想保证消息的有序性，需要设置MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1否则在重试此失败消息的时候，其他的消息可能发送成功了。
retry.backoff.ms（重要）两次重试之间的时间间隔，默认是100ms。
enable.idempotence是否开启幂等性，默认true，开启幂等性。
compression.type（重要）生产者发送的所有数据的压缩方式。默认是none，也就是不压缩。
支持压缩类型：none、gzip、snappy、lz4和zstd。

二：消息发送API

1：普通异步发送(默认)

// 1：创建kafka生产者配置对象
Properties properties = new Properties();
// 配置上面的核心参数可以
properties.put(key, value);
// 2：创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
// 3：发送消息（普通异步发送）
kafkaProducer.send(new ProducerRecord<>("first","kafka " + i));
// 4：关闭
kafkaProducer.close();

1：导入依赖

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

2：编写生产者配置对象

package com.example.kafkademo.util;

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

import java.util.Properties;

public class CommonUtils {
    /**
     * kafka生产者配置配置
     * @return 配置内容
     */
    public static Properties buildKafkaProperties() {
        // 1. 创建kafka生产者配置对象
        Properties properties = new Properties();
        // 2. 给kafka的配置对象添加信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");
        // key, value初始化【必须有】
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        return properties;
    }
}

2：编写不带回调函数的API代码

package com.example.kafkademo.producer;

import com.example.kafkademo.util.CommonUtils;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class MessageProducer {
    public static void main(String[] args) {
        Properties properties = CommonUtils.buildKafkaProperties();
        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        // 4. 调用send方法,发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first","kafka " + i));
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }
}

3：测试

（1）在hadoop102上开启Kafka消费者

（2）在IDEA中执行代码，观察hadoop102控制台中是否接收到消息

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

回调函数会在producer收到ack时调用，为异步调用

该方法有两个参数，分别是元数据信息（RecordMetadata）和异常信息（Exception）

如果Exception为null，说明消息发送成功，如果Exception不为null，说明消息发送失败。

package com.example.kafkademo.producer;

import com.example.kafkademo.util.CommonUtils;
import org.apache.kafka.clients.producer.*;

import java.util.Properties;

/**
 * 异步回调
 * 消息发送失败会自动重试，不需要我们在回调函数中手动重试
 */
public class MessageProducerCallback {
    public static void main(String[] args) throws Exception {
        Properties properties = CommonUtils.buildKafkaProperties();
        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        for (int i = 0; i < 5; i++) {
            // new ProducerRecord中三个参数：要发送到的主题，消息内容，和回调方法
            kafkaProducer.send(new ProducerRecord<>("first", "hello" + i), new Callback() {
                /**
                 * 发送完成时的回调方法
                 * @param metadata 发送的元数据信息
                 * @param exception 异常说明
                 */
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println("主题：" + metadata.topic() + "->"  + "分区：" + metadata.partition());
                    } else {
                        // 出现异常打印
                        exception.printStackTrace();
                    }
                }
            });
            // 延迟一会会看到数据发往不同分区
            Thread.sleep(2L);
        }
        kafkaProducer.close();
    }
}

测试：

（1）在hadoop102上开启Kafka消费者

（2）在IDEA中执行代码，观察hadoop102控制台中是否接收到消息

主题：first->分区：0
主题：first->分区：0
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1

3：同步发送API

只需在异步发送的基础上，再调用一下get()方法即可

package com.example.kafkademo.producer;

import com.example.kafkademo.util.CommonUtils;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class MessageProducerSync {
    public static void main(String[] args) throws Exception {
        Properties properties = CommonUtils.buildKafkaProperties();
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        for (int i = 0; i < 10; i ++) {
            // 同步发送
            // 在异步发送的基础上加上get()，这样会阻塞，直到结果返回
            RecordMetadata record = kafkaProducer.send(new ProducerRecord<>("first", "kafka" + i)).get();
        }
        kafkaProducer.close();
    }
}

测试：

（1）在hadoop102上开启Kafka消费者

（2）在IDEA中执行代码，观察hadoop102控制台中是否接收到消息

三：分区Partition

1：分区的好处

便于合理使用存储资源

  • 每个Partition在一个Broker上存储，可以把海量的数据按照分区切割成一块一块数据存储在多台Broker上。
  • 合理控制分区的任务，可以实现负载均衡的效果

提高并行读

  • 生产者可以以分区为单位发送数据；消费者可以以分区为单位进行消费数据

在这里插入图片描述

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

2.1：Kafka原则
  1. 指明分区的情况下，直接将指明的值作为分区值，例如partition = 0，所有的数据都会写到这个指定的分区中
  2. 没有指定的分区的情况下，如果指定了key，将key的hash值与topic的分区数进行取余得到的分区值
例如key1的hash值=5，key2的hash值=6，topic的分区数=2，value1 = 5 % 2 == 1号分区，value2 = 6 % 2 == 0号分区
2.2：默认的分区器

(1)：将数据发往指定partition的情况下，例如，将所有数据发往分区1中

// 指定数据发送到1号分区，key为空（IDEA中ctrl + p查看参数）
kafkaProducer.send(new ProducerRecord<>("first", 1, "", "kafka" + i), new Callback() {
    /*
     * 发送完成时的回调方法
     */
    @Override
    public void onCompletion(RecordMetadata metadata, Exception exception) {
        if (exception == null) {
            // 没有异常,输出信息到控制台
            System.out.println("主题：" + metadata.topic() + "->"  + "分区：" + metadata.partition());
        } else {
            // 出现异常打印
            exception.printStackTrace();
        }
    }
});

主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1

（2）没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值。

for (int i = 0; i < 5; i++) {
    // 依次指定key值为a,b,f ，数据key的hash值与3个分区求余，分别发往1、2、0
    kafkaProducer.send(new ProducerRecord<>("first", "a","atguigu " + i), new Callback() {
        @Override
        public void onCompletion(RecordMetadata metadata, Exception e) {
            if (e == null){
                System.out.println("主题：" + metadata.topic() + "->" + "分区：" + metadata.partition());
            }else {
                e.printStackTrace();
            }
        }
    });
}
2.3：自定义分区器

如果研发人员可以根据企业需求，自己重新实现分区器

只需要定义类实现Partitioner接口，然后重写partition()方法即可

假设现在有一个需求，发送过来的数据中如果包含cuihaida，就发往0号分区，不包含cuihaida，就发往1号分区

package com.example.kafkademo.producer;

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

import java.util.Map;

/**
 * 1. 实现接口Partitioner
 * 2. 实现3个方法:partition,close,configure
 * 3. 编写partition方法,返回分区号
 */
public class MyPartitioner implements Partitioner {

    /**
     * 重写这个方法
     * @param topic 主题
     * @param key 消息的key
     * @param keyBytes 消息的key序列化后的字节数组
     * @param value 消息的值
     * @param valueBytes 消息的值序列化后的字节数组
     * @param cluster 集群元数据可以查看分区信息
     * @return 信息对应的分区
     */
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        // 获取消息
        String msgValue = value.toString();
        // 发送过来的数据中如果包含cuihaida，就发往0号分区，不包含cuihaida，就发往1号分区
        return msgValue.contains("cuihaida") ? 0 : 1;
    }

    @Override
    public void close() {

    }

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

    }
}

使用分区器的方法，在生产者的配置中添加分区器参数

package com.example.kafkademo.util;

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

import java.util.Properties;

public class CommonUtils {
    /**
     * kafka生产者配置配置
     * @return 配置内容
     */
    public static Properties buildKafkaProperties() {
        // 1. 创建kafka生产者配置对象
        Properties properties = new Properties();
        // 2. 给kafka的配置对象添加信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");
        // key, value初始化【必须有】
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        
        // =========> 添加自定义分区器 <============
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "com.example.kafkademo.producer.MyPartitioner")
        
        return properties;
    }
}

四：生产经验

1：生产者提高吞吐量

  • bitch.size：批次大小，默认是16k
  • linger.ms：等待的时间，建议修改为5 ~ 100ms
  • compression.type：压缩的类型，可以使用snappy
  • RecordAccumulator：缓冲区大小，修改为64M
// ============> 可以通过设置如下参数修改吞吐量 <============
// batch.size：批次大小，默认16K
properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
// linger.ms：等待时间，默认0
properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);
// RecordAccumulator：缓冲区大小，默认32M：buffer.memory
properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
// compression.type：压缩，默认none，可配置值gzip、snappy、lz4和zstd
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");

2：数据可靠性(消息不丢失-生产端)

ack应答原理

  • 0：生产者发送过来的数据，不需要等待数据落盘应答
  • 1：Leader应答，不用等ISR的Follower应答
  • -1：ISR的Follower也完成应答（all & 保证消息不丢失要设置成为这个）

在这里插入图片描述
acks = 1：适用于普通的日志传输，允许丢失个别的数据

acks = -1：一般用于传输和钱相关的数据，对可靠性要求比较高的场景 - all

// 设置acks
properties.put(ProducerConfig.ACKS_CONFIG, "all");
// 重试次数retries，默认是int最大值，2147483647
properties.put(ProducerConfig.RETRIES_CONFIG, 3);

3：生产者幂等（生产端去重）

没有任何手段可以保证消息一定不重复，因为只要做到不丢失，一定会造成重复问题【之前的网络延迟，然后重发，然后网络延迟的那个又来了】

幂等性原理

幂等性就是指生产者不论向Broker发送了多少次数据，Borker只会持久化一次，这样就能做到生产端的消息不重复

  • 如果精确一次 => 幂等性 + 至少一次（ack = -1 && partition.size >= 2 && ISR.size >= 2）
  • 如果判断是不是重复的数据：<PID, Partition, SeqNumber>三元组精确定位一个消息，以此判断重复数据

如何使用幂等性

开启参数enable.idempotence 默认为true，false关闭

4：生产者事务

在这里插入图片描述
Kafka的事务一共有如下5个API

// 1初始化事务
void initTnsactions();

// 2开启事务
void beginTransaction() throws ProducerFencedException;

// 3在事务内提交已经消费的偏移量（主要用于消费者）
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets,
                              String consumerGroupId) throws ProducerFencedException;

// 4提交事务
void commitTransaction() throws ProducerFencedException;

// 5放弃事务（类似于回滚事务的操作）
void abortTransaction() throws ProducerFencedException;

单个Producer，使用事务保证消息的仅一次发送

package com.example.kafkademo.producer;

import com.example.kafkademo.util.CommonUtils;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class MessageProducerTransactions {
    public static void main(String[] args) {
        Properties properties = CommonUtils.buildKafkaProperties();
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0");

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        // 初始化事务
        kafkaProducer.initTransactions();
        // 开启事务
        kafkaProducer.beginTransaction();

        try {
            for (int i = 0; i < 5; i++) {
                kafkaProducer.send(new ProducerRecord<>("first", "kafka" + i));
            }
            // int i = i / 0; // 测试回滚用

            // 提交事务
            kafkaProducer.commitTransaction();
        } catch (Exception e) {
            // 如果出现异常，就进行回滚
            kafkaProducer.abortTransaction();
        }

        kafkaProducer.close();
    }
}

5：消息有序性

  1. Kafka1.x版本之前保证单分区有序性的条件如下：max.in.flight.requests.per.connection = 1
  2. Kafka1.x版本之后保证单分区有序性的条件如下：
    1. 如果没有开启幂等性(enable.idempotence = false)，则需要将max.in.flight.requests.per.connection = 1
    2. 如果开启了幂等性(默认)，需要将max.in.flight.requests.per.connection的值设置的 <= 5(开启幂等之后会缓存)
Kafka消息队列实现消息的发送和接收
江晓龙的博客
06-27 1万+
消息生产者Producer产生消息数据，发送到Kafka消息队列中，一台Kafka节点只有一个Broker，消息会存储在Kafka的Topic（主题中），不同类型的消息数据会存储在不同的Topic中，可以利用Topic实现消息的分类，消息消费者Consumer会订阅消息存储的Topic，从Topic中读取/接收消息数据，不同的消费者可以订阅不同的Topic。命令可以模拟消费者Consumer接收消息数据，将接收到的消息数据打印在终端，默认情况下消费的是Topic中最新的消息数据。
kafka生产者发送消息流程分析
ChinaCR07的博客
03-26 1872
kafka生产者发送消息流程分析
多图详解 kafka 生产者消息发送过程
Q54665642ljf的博客
10-18 3769
整个生产者客户端是由主线程和 Sender 线程协调运行的, 主线程创建消息, 然后通过 拦截器、元信息更新、序列化、分区器、缓存消息等等流程。然后 Sender 线程在初始化的时候就已经运行了,并且是一个 while 循环。Sender 线程里面主要工作是：去消息累加器里面获取有哪些 Node 是能够发送 Request 的。只要该 Node 有一个 TopicPartition 队列中有符合发送条件的 Batch。那么这个 Node 就应该是 ReadyNode。具体的筛选逻辑请看上文有具体分析。
kafka消息队列
最新发布
Wezzer的博客
09-22 1030
主题wezzer有 3 个分区，每个分区的副本因子为 1（无冗余，适合测试）。3 个分区的 Leader 分别分布在 Broker 2、Broker 0、Broker 1 上，实现了负载均衡（Kafka 会尽量将不同分区的 Leader 分散到不同 Broker，提升集群吞吐量）。所有分区的 ISR 都包含自身（因为只有 1 个副本），说明副本同步状态正常。
kafka 生产者
qq_43192537的博客
10-28 655
kafka 生产者
kafka生产者
永远别让世俗淹没生活的热情和浪漫
07-16 2094
生产者调用方法。ProducerRecord 是 Kafka 中的一个核心类，它代表了一组 Kafka 需要发送的 key/value 键值对，它由记录要发送到的主题名称（Topic Name），可选的分区号（Partition Number）以及可选的键值对构成。然后经过拦截器 -》 序列化器(kafak自己的序列化器。。经过分区器。在分区器决定向那个分区里面发送。消息追加到收集器。
精选资源
kafka2种工具 kafkatool-64bit.exe kafka-eagle-bin-1.4.6.tar.gz
01-27
1. **生产者和消费者模拟**：你可以使用它来发送消息到Kafka主题，或者从主题中消费消息，这对于测试和调试Kafka集群非常有用。 2. **主题管理**：创建、删除、修改主题配置，以及检查主题元数据，如分区信息、ISR...
精选资源
kafka安装包-2.13-3.6.2
06-16
3. **Producers**: 生产者是发布消息到Kafka的客户端，它们可以将数据发送到任意主题。 4. **Consumers**: 消费者是订阅主题并处理消息的客户端。Kafka支持两种消费模式：单消费者模式（每个分区只能有一个消费者）...
精选资源
kafka-2.12-3.6.1.tgz
12-19
创建一个简单的消息生产者，向`my-topic`发送消息： ```bash /usr/local/kafka_2.12-3.6.1/bin/kafka-console-producer.sh --broker-list localhost:9092 --topic my-topic ``` 然后在命令行中输入消息，每按一次...
kafka-2.13-3.4.0.tgz
02-10
Kafka提供了命令行工具和Web界面（Kafka Manager）来监控和管理集群状态，包括查看主题、消费者、生产者的状态，调整配置，以及进行数据清理等操作。 总结来说，Kafka以其强大的分布式能力、高吞吐量和消息持久化...
精选资源
kafka-2.12-3.9.0安装包
02-22
Kafka在架构上主要由生产者（Producer）、消费者（Consumer）、代理服务器（Broker）、主题（Topic）、分区（Partition）以及副本（Replica）等组件构成。生产者负责发送消息到Kafka集群中的代理服务器，而消费者则...
Kafka生产者
通往神秘的道路的专栏
09-24 1903
生产者就是负责向 Kafka发送消息的应用程序。在 Kafka的历史变迁中,一共有两个大版本的生产者客户端:第一个是于 Kafka开源之初使用Scaa语言编写的客户端,我们可以称之为旧生产者客户端(Old Producer)或 Scala版生产者客户端;第二个是从 Kafka 0.9.x版本开始推出的使用Java语言编写的客户端,我们可以称之为新生产者客户端(New Producer)或Java版...
Kafka-生产者
dark
10-17 366
《Kafka权威指南》学习笔记 Kafka生产者一一向Kafka写入数据 生产者概览 尽管生产者API使用起来很简单,但消息的发送过程还是有点复杂的： 我们从创建一个ProducerRecord对象开始，ProducerRecord对象需要包含目标主题和要发送的内容。我们还可以指定键或分区。 在发送ProducerRecord对象时，生产者要先把键和值对象序列化成字节数组，这样它们才能够在网...
Kafka 生产者
m0_56017821的博客
09-24 2792
kafka生产者原理 异步发送 分区 提高吞吐量 数据的可靠性 ack级别设置 数据重复问题 生产者事务 数据的有序和乱序
kafka之生产者
qq_38571892的博客
03-22 2079
生产者生产消息概述 从创建一个ProducerRecord对象开始，此对象包含目标主题和要发送的内容，还可以指定键和分区。 在发送ProducerRecord对象时，生产者首先要把键和值对象序列化成字节数组，这样才可以在网络上传输。 数据传送给分区器，如果数据指定了分区则使用此分区；如果没有指定分区，则通过ProducerRecord的键通过一定的算法来选择一个分区。这样生产者就知道将此消息往哪个主题的哪个分区发送了。 这条消息会被添加到一个记录批次里，这个批次里的所有消息会被发送到相同主题的同一分区。此时
【Kafka】生产者
愿万事胜意
02-27 1411
kafka的生产者是怎么样子的？一起来看看
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值