【Kafka】——Producer

最新推荐文章于 2024-02-13 07:30:00 发布
最新推荐文章于 2024-02-13 07:30:00 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： kafka bigdata 文章标签： kafka 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42000631/article/details/127088743
版权

Kfaka Producer

1. 原理

在这里插入图片描述
<1> 创建mian线程
<2> 调用send() 方法
<3> 经过拦截器interceptors ，生产中用的较少
<4> 经过序列化器 serializer ，数据量较少
<5> 经过分区器 partitioner ，判断发送到哪一个区分,
<6>数据发送到缓冲区（双端队列record accumulator），一个分区创建一个队列，都是在内存中完成，内存总大小为32M，数据 发送每一个批次大小默认为16k
batch.size: 只有数据积累到了batch.size 之后，sender 才会发送数据，默认为16k
linger.ms：如果数据迟迟未到到batch.size ，sender等待linger.ms设置的时间到了之后会发送数据，单位ms。默认是0ms。表示没有延迟。
<7> sender线程，sender从缓冲区（record accumulator）中读取，发送到kafka集群。默认每个broker节点最多缓存5个请求。
<8> selector 创建消息发送链路
<9> 收到消息进行副本同步，然后会进行应答。应答级别如下
0：生产者发送过来消息后，不需要等待数据落盘应答。
1：生产者发送过来消息后，Leader收到数据后就进行应答。
-1（all）：生产者发送过来消息后，Leader和ISR队列里面的所有节点收起数据后应答，-1和all等价
<10> 应答成功后，清理请求，清理缓冲区，应答不成功 sender进行重试，重试的次数为int的最大值。

2. 生产者重要参数列表

在这里插入图片描述

3. 异步发送

<1>普通异步发送

在这里插入图片描述

1. 新建项目

在这里插入图片描述

2. 导入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kafka</groupId>
    <artifactId>KafkaDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>3.0.0</version>
        </dependency>
    </dependencies>
</project>
3. 创建不带回调函数客户端类
package com.kafkademo.case1.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 : hechaogao
 * @createTime : 2022/9/19 17:09
 */
public class CustomProducer {

    private static final String HOST = "hadoop102:9092,hadoop103:9092,hadoop104:9092";
    private static final String TOPIC = "test_topic";

    public static void main(String[] args) {

        //1. 配置
        Properties properties = new Properties();
        //1.1 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, HOST);
        //1.2 指定对应的的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //2. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        //3. 发送数据
        for (int i = 0; i < 10; i++) {
            kafkaProducer.send(new ProducerRecord<>(TOPIC, "test message no : " + i));
        }
        //4. 关闭资源
        kafkaProducer.close();
    }
}
4. 执行结果

在这里插入图片描述

<2> 带回调函数的异步发送

1. 创建带回调函数客户端类
package com.kafkademo.case1.producer;

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

import java.util.Properties;

/**
 * @author : hechaogao
 * @createTime : 2022/9/19 21:22
 *
 * 带回调函数的异步发送消息案例
 */
public class CustomProducerCallBack {
    private static final String HOST = "hadoop102:9092,hadoop103:9092,hadoop104:9092";
    private static final String TOPIC = "test_topic";

    public static void main(String[] args) {

        //1. 配置
        Properties properties = new Properties();
        //1.1 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, HOST);
        //1.2 指定对应的的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //2. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        //3. 发送数据
        for (int i = 0; i < 10; i++) {
            kafkaProducer.send(new ProducerRecord<>(TOPIC, "test message no : " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if(e == null){
                        System.out.println("topic :  "+recordMetadata.topic()+", partition : "+recordMetadata.partition());
                    }


                }
            });
        }
        //4. 关闭资源
        kafkaProducer.close();
    }
}
2. 执行结果

在这里插入图片描述
在这里插入图片描述

4. 同步发送

在这里插入图片描述
当缓冲区（Record Accumulator）中的数据全部发送到Kafka集群之后，外部数据再写入缓冲区（Record Accumulator）。

<1> 创建同步发送客户端类

package com.kafkademo.case1.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.clients.producer.RecordMetadata;
import org.apache.kafka.common.serialization.StringSerializer;

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

/**
 * @author : hechaogao
 * @createTime : 2022/9/19 17:09
 *
 * 同步发送消息案例
 */
public class CustomProducerSync {

    private static final String HOST = "hadoop102:9092,hadoop103:9092,hadoop104:9092";
    private static final String TOPIC = "test_topic";

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1. 配置
        Properties properties = new Properties();
        //1.1 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, HOST);
        //1.2 指定对应的的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //2. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        //3. 发送数据
        for (int i = 0; i < 10; i++) {
           kafkaProducer.send(new ProducerRecord<>(TOPIC, "test message no : " + i)).get();
        }
        //4. 关闭资源
        kafkaProducer.close();
    }
}

<2> 执行结果

在这里插入图片描述

5. 生产者分区

<1> 优点

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

<2> 分区策略

默认的分区器 DefaultPartitioner
在这里插入图片描述

  1. 指明partition的情况下，直接将指明的值作为partitiion值
  2. 如果未指定分区但存在key，则将key的hash值与topic的partition数进行取模得到partition的值，
  3. 如果没有分区或不存在key，则Kafka采用Sticky Partition(黏性分区器），会随机选择一个分区，并尽可能一直使用该分区，待该分区的batch已满或者已完成，Kafka再随机一个分区进行使用(和上一次的分区不同)。
    例如:第一次随机选择0号分区，等0号分区当前批次满了（默认16k)或者linger.ms设置的时间到，Kafka再随机一个分区进行使用（如果还是0会继续随机)。

<3> 自定义分区

1. 定义类实现Partitioner接口
2. 重写partition()方法
package com.kafkademo.case2;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import java.util.Map;

/**
 * @author : hechaogao
 * @createTime : 2022/9/20 10:21
 */
public class MyPartition implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        int partition;
       // 获取数据
        String msgValues = value.toString();
        if(msgValues.contains("test")){
            partition = 0;
        }else{
            partition = 1;
        }
        return partition;
    }
    @Override
    public void close() {
    }
    @Override
    public void configure(Map<String, ?> configs) {
    }
}
3. 关联自定义分区器客户端
package com.kafkademo.case2;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
 * @author : hechaogao
 * @createTime : 2022/9/19 21:22
 *
 * 带回调函数的异步发送消息案例
 */
public class CustomProducerMyPartition {
    private static final String HOST = "hadoop102:9092,hadoop103:9092,hadoop104:9092";
    private static final String TOPIC = "test_topic"
    public static void main(String[] args) {
        //1. 配置
        Properties properties = new Properties();
        //1.1 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, HOST);
        //1.2 指定对应的的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //1.3 关联自定义分区器
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.kafkademo.case2.MyPartition");
        //2. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        //3. 发送数据
        for (int i = 0; i < 10; i++) {
            kafkaProducer.send(new ProducerRecord<>(TOPIC, " message no : " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if(e == null){
                        System.out.println("topic :  "+recordMetadata.topic()+", partition : "+recordMetadata.partition());
                    }
                }
            });
        }
        //4. 关闭资源
        kafkaProducer.close();
    }
}

6. 生产者提高吞吐量

<1> 方案

在这里插入图片描述

<2> 实现

package com.kafkademo.case3;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
 * @author : hechaogao
 * @createTime : 2022/9/20 10:52
 *
 * 修改参数提高生产者吞吐量案例
 */
public class CustomProducerParamenters {
    private static final String HOST = "hadoop102:9092,hadoop103:9092,hadoop104:9092";
    private static final String TOPIC = "test_topic";
    public static void main(String[] args) {
        //1. 配置
        Properties properties = new Properties();
        //1.1 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, HOST);
        //1.2 指定对应的的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());


        // 缓冲区大小  修改为 32M , 采用默认值
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);

        // 批次大小   默认为16k , 采用默认值
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);

        // linger.ms  默认为0ms 改为 1ms
        properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);

        //压缩 压缩方式 采用snappy
        properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");


        //2. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        //3. 发送数据
        for (int i = 0; i < 10; i++) {
            kafkaProducer.send(new ProducerRecord<>(TOPIC, "test message no : " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if(e == null){
                        System.out.println("topic :  "+recordMetadata.topic()+", partition : "+recordMetadata.partition());
                    }


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

7. 数据可靠性

<1>ACK应答级别

1. acks = 0

生产者发送过来消息后，不需要等待数据落盘应答。
在这里插入图片描述

2. acks =1

生产者发送过来消息后，Leader收到数据后就进行应答。
在这里插入图片描述

3. acks = -1（all）

生产者发送过来消息后，Leader和ISR队列里面的所有节点收起数据后应答，-1和all等价
在这里插入图片描述

<2> acks = -1（all）存在的问题

1. Follower 故障

Leader 收到数据，所有Follower都开始同步数据，但是有个一Follower因为某种故障，迟迟不能和Leader进行同步数据，则消息不能进行应答，那么这个问题咋那么解决？
ISR ：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超时。I
SR为0，1
这样就不用等长期联系不上或者已经出故障的节点。
如果分区副本设置为l个，或者ISR里应答的最小副本数量( min.insync.replicas 默认为1）设置为1，和ack=1的效果是一样的，仍然有丢数的风险（leader: 0， isr:0)。

2. Leader故障

当Leader 接收到数据，并进行Follower 数据同步之后，在消息应答之前 Leader发生故障，此时此时未进行消息应答，集群会重新选举产证Leader，上一条消息会重复发送给Ledaer ，然后重复发送到Follower ，这样就行接收到两份数据，导致消息重复。

<3> 完全可靠的条件

ACK级别设置为 -1 + 分区副本大于等于2 + ISR里应答的最小副本数大于等于2

<4>总结

  1. acks=0，生产者发送过来数据就不管了，可靠性差，效率高;
  2. acks=1，生产者发送过来数据Leader应答，可靠性中等，效率中等;
  3. acks=-1，生产者发送过来数据Leader和ISR队列里面所有Follwer应答，可靠性高，效率低。
  4. 在生产环境中，acks=0很少使用;acks=1，一般用于传输普通日志，允许丢个别数据; acks=-1，一般用于传输和钱相关的数据，对可靠性要求比较高的场景。

8. 数据重复

<1> 数据传递语义

  1. 至少一次（At Least Once）
    至少一次 = ACK级别设置为 -1 + 分区副本大于等于2 + ISR里应答的最小副本数大于等于2
    可以保证数据不丢失，但是不能保证数据不重复
  2. 最多一次（At Nost Once）
    最多一次 = ACK级别设置为 0
    可以保证数据不重复，但是不能保证数据不丢失
  3. 精确一次（Exactly Once）
    精确一次 = 幂等性+至少一次（ACK级别设置为 -1 + 分区副本大于等于2 + ISR里应答的最小副本数大于等于2）
    对应一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不能丢失
    Kafka 0.11版本以后，引入了一项重大特性：幂等性和事务

<2> 幂等性

  1. 概念
    幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。
    只能保证的是在单分区，单会话内不重复。（启动一次 一次会话）
  2. 重复数据判断标准
    具有<PID,partition,SeqNumber> 相同主键的消息提交时，Broker只会持久化一条，其中PID 是Kafka每次启动都会分配的一个新的。Partition表示分区号，Sequence Number 是单调递增的。
  3. 幂等性使用
    开启参数：enable.idempotence 。默认是true ，false 关闭

<3> 生产者事务

在这里插入图片描述

  1. 开启事务，前提必须开启幂等性
  2. 案例
package com.kafkademo.case4;

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 : hechaogao
 * @createTime : 2022/9/19 17:09
 * <p>
 * Kafka 生产者事务案例
 */
public class CustomProducerTransactions {
    private static final String HOST = "hadoop102:9092,hadoop103:9092,hadoop104:9092";
    private static final String TOPIC = "test_topic";
    public static void main(String[] args) {
        //1. 配置
        Properties properties = new Properties();
        //1.1 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, HOST);
        //1.2 指定对应的的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 指定 唯一的 Transaction id
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_01");
        //2. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        //3.1 初始化事务
        kafkaProducer.initTransactions();
        //3.2 开启事务
        kafkaProducer.beginTransaction();
        //4. 发送数据
        try {

            for (int i = 0; i < 10; i++) {
                kafkaProducer.send(new ProducerRecord<>(TOPIC, "test message no : " + i));
            }
            //int i = 1 / 0;
            //3.3 提交事务
            kafkaProducer.commitTransaction();
        } catch (Exception e) {
            //3.4 放弃事务
            kafkaProducer.abortTransaction();
        } finally {
            //5. 关闭资源
            kafkaProducer.close();
        }
    }
}

9. 数据单分区有序

<1> kafka1.x版本之前

max.in.flight.requests.per.connection需要设置为1（不需要考虑是否开启幂等性）。

<2> kafka1.x版本之后

（1）未开启幂等性 max.in.flight.requests.per.connection需要设置为1。
（2）开启幂等性 max.in.flight.requests.per.connection需要设置小于等于5。
原因说明：因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据， 故无论如何，都可以保证最近5个request的数据都是有序的
在这里插入图片描述

那时的样子_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kafka Producer原理与代码实例讲解
AI大模型应用之禅
06-05 427
Kafka Producer 原理与代码实例讲解 1. 背景介绍 Apache Kafka 是一个分布式流处理平台,被广泛应用于日志收集、消息系统、数据管道等场景。作为 Kafka 的核心组件之一,Producer 负责向 Kafka 集群发送消息。本文将深入探讨 Kafk
kafka-producer-consumer
03-14
总结来说，"Kafka-producer-consumer"项目涉及了Kafka的核心概念——生产者和消费者的交互。通过Python编程，我们可以方便地创建Kafka客户端，实现数据的发布和订阅。理解这些基础知识对于任何希望在大数据处理和...
KafkaProducer详解
热门推荐
weixin_39034379的博客
08-09 1万+
1.Producer简介 Kafka Producer 就是负责向Kafka 服务端,写入数据的程序。 Kafka 支持多种Producer库，主流的编程语言都覆盖到了。但是除了Java其他的语言都是由非Apach Kafka社区的人进行维护的。有其他语言的客户端需求，可以去这个网址去下载相应的信息。 kafakclients链接 2.构造Producer 2.1简单构造 1.构建配置文件 首先第一步是进行用户鉴权的操作（如果Kafka集群需要的话） 然后需要配置的三个主要参数 broker的地址 k
Kafka基础介绍之Producer
m0_64354070的博客
11-23 3136
简介 我们知道要想使用Kafka，其实最开始就是要创建一个Producer来往其中写消息，可以称之为消息源头吧，没有Producer来写，也就谈不上后面的consumer读了。 写消息粗听起来很简单，但是我们仔细思考一下这里就有很多问题需要确认。比如你的应用可以接受某些消息没有成功写进去吗？或者能够接受有重复的消息被写入吗？亦或是你的应用对写入的速度和延时有要求吗？ 各种应用显然对我上面提到的问题有不同的答案，比如说一个log系统，丢一条或者少一条数据并不重要，延时一个几十秒甚至几分钟也不是什么大的问
kafka基础入门（2）：kafka生产者（producer）
WHY的博客
02-01 1602
本文介绍了kafka生产者的相关内容，包括其数据发送的原理、相关API的操作、数据可靠性以及一些生产经验
11. kafka重试机制解读
GoodIdea
12-24 2869
前面对kafka的学习中已经了解到KafkaProducer通过设定参数retries，如果发送消息到broker时抛出异常，且是允许重试的异常，那么就会最大重试retries参数指定的次数。 本片文章主要分析几个问题：  - 哪些异常可以重试  - 如何实现重试 接下来通过分析一一解开这些问题的答案。 1.哪些异常可以重试 org.apache.kafka.clients.producer...
RecordAccumulator分析
happy19870612's blog
06-02 2247
它主要作用就是相当于一个队列，相当于一个缓冲区，用于储蓄record到MemoryRecords，然后被发送到服务器 一 核心字段 int batchSize: 批量大小 CompressionType compression: 压缩类型 long lingerMs: 延迟时间 long retryBackoffMs: 重试时间 BufferPool free: ByteBuffer缓
Kafka重点解释——为什么真快
08-27
Kafka 提供了一个参数——producer.type 来控制是不是主动 flush，如果 Kafka 写入到 mmap 之后就立即 flush 然后再返回 Producer 叫同步（sync）；写入mmap 之后立即返回 Producer 不调用 flush 叫异步（async）。 ...
YunaiV#Blog#2018_01_11_Kafka 解惑之 Old Producer（3）—— Async Analysi
07-25
摘要:原创出处「朱小厮」欢迎转载，保留摘要，谢
关于Kafka学习视频对照文档.zip
02-06
Kafka的核心是Producer（生产者）、Broker（代理服务器）和Consumer（消费者）。生产者负责将数据发布到特定的主题（Topic），每个主题可以分为多个分区（Partition），保证了数据的有序性和可扩展性。Broker作为...
kafka安装包、消息队列
12-28
在这个压缩包中，你将找到Kafka的一个特定版本——kafka_2.11-2.1.0，这是针对Scala 2.11编译的Kafka 2.1.0版本。 **Kafka的核心概念和特点：** 1. **主题（Topics）**：Kafka中的数据是以主题的形式存储的，主题...
Kafka 生产者（Producer）详解
qianyulin
01-08 6616
Producer : 消息生产者，就是向Kafka broker 发消息的客户端。 下面将从producer的分区策略，数据可靠性保证、Exactly Once、Producer API 来进行介绍。 1、分区策略 1）分区原因 方便在集群中扩展（相当于负载） ：每个Partition 可以通过调整以适应它所在的机...
Kafka 之 - Producer
Ellen的博客
01-12 1301
why Kafka 支持多个生产者，分布式系统中往往有多个微服务向一个kafka集群发送消息； 支持多个消费者从一个Kafka集群中消费消息，可以通过消费者组实现多个消费者同时协作消费消息。 允许消费者非实时读取消息 partition 同一个partition中的消息顺序消费 不同partition中的消息消费顺序不保证 ISR controller Kafka集群中第一个启动的broker会通过在zookeeper中创建临时节点/controller 来试图让自己成为controller，其他节点会在该
【Kafka】生产者Producer详解
qq_43745578的博客
01-23 2069
详细讲解kafka的生产者
kafka生产者
huangzhigao886的博客
07-03 593
kafka的三种发送策略： 发送即忘（fire and forget）: 同步(sync)： 异步(async)： 在同一分区，消息的发送是有序的，callback的调用顺序也是有序的 kafka.close()方法会等待所有发送请求完成再关闭producer kafkaProducer常见异常分为可重试异常与不可重试异常 可重试异常： NetworkException:网络异常 LeaderNotAviableException:没有可用的leader,等到leader重新选举完，可恢复异常 NotEn
Kafka 之生产者（Producer）
最新发布
流华追梦的专栏
02-13 1291
Kafka生产者是一个应用程序，它负责向 Kafka 主题发送消息。这些消息可以用于多种目的，如记录用户活动、收集物联网设备数据、保存日志消息或缓存即将写入数据库的数据。
Kafka producer
github_38730134的博客
02-10 550
Kafka producer producer概览 Kafka producer客户端负责向Kafka写入数据的应用程序。Kafka提供了多个语言版本的producer客户端。Kafka封装了一套二进制通信协议，对于producer而言，用户可以直接使用任意语言按照该协议的格式进行编程，实现消息的发送。 producer之间是相互独立的，producer首要功能就是向某个topic的某个分区发送消息，由分区器确定往topic的哪个分区发送消息，Kafka producer提供了一个默认的分区器，每条待发送消
【Kafka源码分析】一、生产者Producer
wanger61的博客
07-28 1266
本文旨在对Kafka的源码进行分析，第一部分主要分析Kafka生产者的工作流程
Kafka之Producer生产者
cainiao1412的博客
05-05 3571
Producer概览 Producer SDK Producer就是负责向Kafka集群中写入消息数据的应用程序，自 Kafka 0.9 版本提供了Java版本的Producer SDK供用户使用， Kafka官方支持的语言SDK较少，更多都是由第三方社区维护的SDK，如果需要使用对应语言的SDK，需要额外下载， 第三方库信息地址：docs.confluent.io/platform/cu… Producer 通信协议 Kafka自己内部封装了一套二进制通信协议，用户可使用任意语言按照该协议进行
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值