kafka生产者

最新推荐文章于 2023-06-06 09:03:45 发布
最新推荐文章于 2023-06-06 09:03:45 发布
阅读量215 收藏
点赞数
分类专栏： kafka 文章标签： kafka 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/loser_you/article/details/125011162
版权

一、生产者消息发送流程

1.1 发送原理

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

image-20220504114156734

1.2 生产者参数列表

  • bootstrap.servers: 生产者连接集群所需的 broker 地址清单。例如 kafka-01:9092,kafka-02:9092，可以设置 1 个或者多个，中间用逗号隔开。注意这里并非需要所有的 broker 地址，因为生产者可以从给定的 broker 里查找到其他 broker 信息。
  • key.serializer: 指定发送消息的key的序列化类型
  • value.serializer: 指定发送消息的value的序列化类型
  • buffer.memory: RecordAccumulator 缓冲区总大小，默认 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

2.1 普通异步发送

@Test
public void sendMessage() {
    Properties properties = new Properties();
    properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    String topic = "test-topic-0";
    for (int i = 0; i < 10; i++) {
        String message = "value-" + i;
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, message);
        producer.send(producerRecord);
    }
    producer.close();
}

2.2 带回调的异步发送

@Test
public void sendMessage() {
    Properties properties = new Properties();
    properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    String topic = "test-topic-0";
    for (int i = 0; i < 10; i++) {
        String message = "value-" + i;
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, message);
        producer.send(producerRecord, (recordMetadata, exception) -> {
            if (exception != null) {
                exception.printStackTrace();
            } else {
                log.info("[kafka producer]topic={}, partition={}", recordMetadata.topic(), recordMetadata.partition());
            }

        });
    }
    producer.close();
}

2.3 同步发送消息

@Test
public void sendMessage() throws ExecutionException, InterruptedException {
    Properties properties = new Properties();
    properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    String topic = "test-topic-0";
    for (int i = 0; i < 10; i++) {
        String message = "value-" + i;
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, message);
        // 使用 .get() 同步发送信息
        producer.send(producerRecord).get();
    }
    producer.close();
}

四、生产者分区

4.1 分区的好处

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

  2. 提高并行度，生产者可以以分区为单位发送数据;消费者可以以分区为单位进行消费数据。

    image-20220508140037171

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

  1. 默认的分区器DefaultPartitioner

    签名

    public class DefaultPartitioner implements Partitioner

  2. 分区详情

    ProducerRecord类中关于发送消息的方法

    // 直接指定分区，则将数据发送到指定分区
public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value)
public ProducerRecord(String topic, Integer partition, K key, V value, Iterable<Header> headers)
public ProducerRecord(String topic, Integer partition, K key, V value)
// 没有指定分区，但是指定了key，则使用key的hashcode对topic的partition数取余，计算partition
public ProducerRecord(String topic, K key, V value)
// 没有指定partition，也没有指定key，则使用Sticky Partition（黏性分区器），会随机算则一个分区，并尽可能一直使用该分区，待该分区的batch已满或者linger.ms设置的时间到，kafka再随机选一个分区使用（和上一次的分区不同）
public ProducerRecord(String topic, V value)

    • 指定partition

      @Test
public void sendMessage() {
    Properties properties = new Properties();
    properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    String topic = "test-topic-0";
    for (int i = 0; i < 10; i++) {
        String message = "value-" + i;
        // 将数据发送到指定的partition
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, 2, "key", message);
        producer.send(producerRecord, (recordMetadata, exception) -> {
            if (exception != null) {
                exception.printStackTrace();
            } else {
                log.info("[kafka producer]topic={}, partition={}", recordMetadata.topic(), recordMetadata.partition());
            }

        });
    }
    producer.close();
}

    • 指定key

      @Test
public void sendMessage() {
    Properties properties = new Properties();
    properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    String topic = "test-topic-0";
    for (int i = 0; i < 10; i++) {
        String message = "value-" + i;
        // 不指定partition，但是指定key，使用key的hashcode对topic的partition数取余，得到partition
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, i + "", message);
        producer.send(producerRecord, (recordMetadata, exception) -> {
            if (exception != null) {
                exception.printStackTrace();
            } else {
                log.info("[kafka producer]topic={}, partition={}", recordMetadata.topic(), recordMetadata.partition());
            }
        });
    }
    producer.close();
}

  3. 自定义分区器

    package com.example.partition;

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

import java.util.Map;

public class MyPartitioner implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        int message = Integer.parseInt(String.valueOf(value));
        int partition;
        if (message % 2 == 0) {
            partition = 2;
        } else {
            partition = 1;
        }
        return partition;
    }

    @Override
    public void close() {

    }

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

    }
}

    使用自定义的分区器

    @Test
public void sendMessage() {
    Properties properties = new Properties();
    properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    // 使用自定义的分区器
    properties.setProperty(ProducerConfig.PARTITIONER_CLASS_CONFIG, MyPartitioner.class.getName());
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    String topic = "test-topic-0";
    for (int i = 0; i < 10; i++) {
        String message = String.valueOf(i);
        // 不指定partition，但是指定key，使用key的hashcode对topic的partition数取余，得到partition
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, message);
        producer.send(producerRecord, (recordMetadata, exception) -> {
            if (exception != null) {
                exception.printStackTrace();
            } else {
                log.info("[kafka producer]topic={}, partition={}", recordMetadata.topic(), recordMetadata.partition());
            }
        });
    }
    producer.close();
}

五、提高生产者吞吐量

  1. batch.size：批次大小，默认16k
  2. linger.ms：等待时间，默认0ms，可以设置到5-100ms
  3. compression.type：压缩数据，
  4. RecordAccumulator：缓冲区大小，默认32m
@Test
public void sendMessage() {
    Properties properties = new Properties();
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    // batch.size：批次大小，默认16k
    properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
    // linger.ms：等待时间，默认0ms
    properties.put(ProducerConfig.LINGER_MS_CONFIG, 5);
    // buffer.memory：缓冲区大小，默认32mb
    properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
    // compression.type: 压缩数据，默认 none，可配置的值有：gzip，snappy，lz4，zstd
    properties.setProperty(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    String topic = "test-topic-0";
    for (int i = 0; i < 10; i++) {
        String message = String.valueOf(i);
        // 不指定partition，但是指定key，使用key的hashcode对topic的partition数取余，得到partition
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, i + "", message);
        producer.send(producerRecord, (recordMetadata, exception) -> {
            if (exception != null) {
                exception.printStackTrace();
            } else {
                log.info("[kafka producer]topic={}, partition={}", recordMetadata.topic(), recordMetadata.partition());
            }
        });
    }
    producer.close();
}

六、数据可靠性

ack应答原理：

  • 0：生产者发送数据后，不需要等数据落盘响应

    image-20220508144610015

  • 1：生产者发送数据后，leader收到数据后响应

    image-20220508144625333

  • -1：生产者发送数据后，leader和isr队列里面的所有节点收齐数据后响应

    image-20220508144637317

    Leader维护了一个动态的in-sync replica set(**ISR**)，意为和 Leader保持同步的Follower+Leader集合(leader:0，isr:0,1,2)。

    如果Follower长时间未向Leader发送通信请求或同步数据，则 该Follower将被踢出ISR。该时间阈值由**replica.lag.time.max.ms**参 数设定，默认30s。例如2超时，(leader:0, isr:0,1)。

    这样就不用等长期联系不上或者已经故障的节点。

    数据可靠性分析:

    如果分区副本设置为1个，或者ISR里应答的最小副本数量 ( min.insync.replicas 默认为1)设置为1，和ack=1的效果是一 样的，仍然有丢数的风险(leader:0，isr:0)。

    数据完全可靠条件 = ACK级别设置为**-1** + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2

    可靠性总结:

    • acks=0，生产者发送过来数据就不管了，可靠性差，效率高;

    • acks=1，生产者发送过来数据Leader应答，可靠性中等，效率中等;

    • acks=-1，生产者发送过来数据Leader和ISR队列里面所有Follwer应答，可靠性高，效率低;

    在生产环境中，acks=0很少使用；acks=1，一般用于传输普通日志，允许丢个别数据；acks=-1，一般用于传输和钱相关的数据， 对可靠性要求比较高的场景。

    数据重复：

    acks: -1(all):生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据后应答。

    当leader和ISR队列中的所有节点都收到数据后，但是还没有响应时，leader宕机，ack失败。此时会重新选择一个leader，生产者会重新发送数据，就会导致数据重复。

    image-20220508151420369

七、数据去重

  1. 数据传递语义

    • 至少一次(AtLeastOnce)= ACK级别设置为-1+分区副本大于等于2+ISR里应答的最小副本数量大于等于2

    • 最多一次(AtMostOnce)= ACK级别设置为0

    • 总结:

      • At Least Once可以保证数据不丢失，但是不能保证数据不重复;

      • At Most Once可以保证数据不重复，但是不能保证数据不丢失。

    • 精确一次(Exactly Once): 对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。 Kafka 0.11版本以后，引入了一项重大特性: 幂等性和事务。

  2. 幂等性

    幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。

    精确一次(Exactly Once) = 幂等性 + 至少一次( ack=-1 + 分区副本数**>=2 + ISR最小副本数量>=2**)

    重复数据的判断标准:具有<PID, Partition, SeqNumber>相同主键的消息提交时，Broker只会持久化一条。其 中PID是Kafka每次重启都会分配一个新的；Partition 表示分区号；Sequence Number是单调自增的。

    所以幂等性只能保证的是在单分区单会话内不重复

    image-20220508151931542

    使用幂等性：开启参数 enable.idempotence 默认为 true，false 关闭

  3. kafka事务

    说明：开启事务，必须开启幂等性

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3p0w29vo-1653657359826)(https://you-blog.oss-cn-shenzhen.aliyuncs.com/2022/05/20220508152303.png)]

    @Test
public void sendMessage() {
    Properties properties = new Properties();
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    // 设置事务id
    properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0");
    properties.put(ProducerConfig.RETRIES_CONFIG, 3);
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    // 初始化事务
    producer.initTransactions();
    // 开始事务
    producer.beginTransaction();
    String topic = "test-topic-0";
    try {
        for (int i = 0; i < 10; i++) {
            String message = String.valueOf(i);
            // 不指定partition，但是指定key，使用key的hashcode对topic的partition数取余，得到partition
            ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, 1, "", message);
            producer.send(producerRecord, (recordMetadata, exception) -> {
                if (exception != null) {
                    exception.printStackTrace();
                } else {
                    log.info("[kafka producer]topic={}, partition={}", recordMetadata.topic(), recordMetadata.partition());
                }
            });
        }
        // 提交事务
        producer.commitTransaction();
    } catch (Exception e) {
        // 出现异常，终止事务
        producer.abortTransaction();
    } finally {
        // 关闭资源
        producer.close();
    }
}

八、数据有序

  1. kafka在1.x版本之前保证数据单分区有序，条件如下:

    max.in.flight.requests.per.connection=1(不需要考虑是否开启幂等性)

  2. kafka在1.x及以后版本保证数据单分区有序，条件如下:

    • 未开启幂等性

      max.in.flight.requests.per.connection需要设置为1。

    • 开启幂等性

      max.in.flight.requests.per.connection需要设置小于等于5。

      原因说明: 因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据， 故无论如何，都可以保证最近5个request的数据都是有序的。

    image-20220508153059125

coder_xiaoyou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kafka 生产者
01-20
kafka 生产者 创建一个包含目标主题和内容的 ProducerRecord 对象，可指定键或分区，发送前要把对象序列化成字符数组。 数据被传给分区器，如果指定了分区就直接把指定的分区返回。如果没有指定分区，分区器就根据 ...
kafka | 生产者压缩算法面面观
sinat_27143551的博客
09-16 299
今天我要和你分享的内容是：生产者压缩算法面面观。说起压缩（compression），我相信你一定不会感到陌生。它秉承了用时间去换空间的经典 trade-off 思想，具体...
kafka启动、状态监控、日常操作
chenyubei的博客
04-27 5607
kafka启动、状态监控、日常操作
kafka常见操作
King config
07-06 7257
kafka查看数据
Kafka的常用命令
北辰
05-31 5151
Kafka的常用命令
org.apache.kafka.common.errors.ProducerFencedException: Producer attempted an operation with an old
weixin_59295776的博客
06-06 743
1.flink 1.12.0以下版本都有的漏洞。需将版本升级到1.14以上版本。
Java实现Kafka生产者消费者代码实例
08-19
主要介绍了Java实现Kafka生产者消费者代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
kafka生产者源码
09-25
kafka生产者流程图，源码分析，（png）
kafka-producer:kafka生产者
04-30
kafka-producerkafkaProducerspringBoot-1.5jdk1.8kafka-0.10.0.0swagger2接口身份口令认证
kafka生产者-实例参数配置.md
07-24
kafka生产者参数配置使用于各种编程语言重要参数已标明kafka生产者参数配置使用于各种编程语言重要参数已标明
kafka一些常用命令，以及如何查看消息被谁消费了
热门推荐
u010953880的专栏
03-10 1万+
环境说明： 我们的kafka版本是：查看kafka版本，进入kafka容器：find / -name \*kafka_\* | head -1 | grep -o '\kafka[^\n]*' kafka_2.11-2.2.1 前面为scala版本，后面为kafka版本。 样例说明：2.11为scala版本，2.2.1为kafka版本。 我的kafka容器名是kafka； 注意： 不同kafka版本的命令有些不一样，有的还用z...
kafka 事务_Kafka的有且仅有一次语义与事务消息
weixin_29159711的博客
11-25 578
架构师(JiaGouX)我们都是架构师！架构未来，你来不来？作者：Dengshenyu原文：www.dengshenyu.com/kafka-exactly-once-transaction-interface/最近看到Kafka官方wiki上有一篇关于有且仅有一次语义与事务消息的文档(见这里)，里面说的非常详细。对于有且仅有一次语义与事务消息是什么东西，大家可以看我的上一篇博客，或者看...
kafka-如何压缩消息
码者人生的技术博客
06-17 1928
kafka是如何压缩消息的？要弄清楚这个问题，就要从kafka的消息格式说起。kafka的消息层次分为两层：消息集合(message set)以及消息(message)。一个消息集合包含若干条日志项(recorditem)，而日志项才是真正封装消息的地方。kafka底层的消息日志由一系列消息集合日志项组成。kafka通常不会直接操作具体的一条条消息，它总是在消息集合这个层面上进行写入操作。 在kafka中，压缩可能会发生在两个地方：生产者端和broker端。 生产者程序中配置compression.t.
kafka生产者Producer参数设置及参数调优建议-kafka 商业环境实战
weixin_34138255的博客
10-28 2500
kafka商业环境实战系列 本套系列博客从真实商业环境抽取案例进行总结和分享，并给出kafka商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。版权声明：本套kafka调优系列版权归作者(秦凯新)所有，禁止转载，欢迎学习。 作者：秦凯新 地址：于深圳 kafka 商业环境实战-kafka生产环境规划 kafka 商业环境实战-kafka生产者和消费者吞吐量测试 kafka 商...
Kafka生产者相关配置
zhangkai1992的专栏
10-30 2438
kafka基础配置
Kafka消息的压缩机制
sherlockyb的博客
05-10 4463
大纲Kafka支持的消息压缩类型什么是 Kafka 的消息压缩消息压缩类型何时需要压缩如何开启压缩在 Broker 端开启压缩compression.type 属性broker 和 topic 两个级别broker 级别topic 级别在 Producer 端压缩compression.type 属性开启压缩的方式压缩和解压的位置何处会压缩producer 端broker 端何处会解压consumer 端broker 端压缩和解压原理CompressionTypeCompressionCodecCompre
Kafka producer的事务和幂等性
小灰狼与大白兔的博客
02-06 7401
背景：kafka 客户端之producer API发送消息以及简单源码分析 从Kafka 0.11开始，KafkaProducer又支持两种模式：幂等生产者和事务生产者。幂等生产者加强了Kafka的交付语义，从至少一次交付到精确一次交付。特别是生产者的重试将不再引入重复。事务性生产者允许应用程序原子地将消息发送到多个分区（和主题）。 幂等性 Kafka在 0.11 版本引入了一项重大特性，幂等性。所谓的幂等性就是指 Producer 不论向 Server 发送多少次重复数据，Server 端都只会持久化一条
kafka生产端的调优: 提高数据吞吐量
健康平安的活着的专栏
04-07 1750
一 生产端提高吞吐量 直接先上答案，可以从这4个方面进行入手 1.batch.size：批次大小，默认16k 2.linger.ms：等待时间，修改为5-100ms 一次拉一个， 来了就走 3.compression.type：压缩snappy 4 RecordAccumulator：缓冲区大小，修改为64m 二 代码添加 1.代码添加配置 package com.ljf.spring.boot.demo.producer; import com.ljf.spring.bo.
Kafka参数调优(一)-生产者Producer
Java部落格
02-18 4814
Producer参数 一、request.required.acks Kafka producer的ack有3中机制，初始化producer时的producerconfig可以通过配置request.required.acks不同的值来实现。 0：这意味着生产者producer不等待来自broker同步完成的确认继续发送下一条（批）消息。此选项提供最低的延迟但最弱的耐久性保证（当服务器发生故障...
kafka生产者消费者
最新发布
12-01
以下是Kafka生产者和消费者的介绍和演示： 1. Kafka生产者 Kafka生产者将消息发布到主题中。以下是一个简单的Python示例，演示如何使用Kafka生产者API将消息发布到主题中： ```python from kafka import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值