Kafka生产者（二）

于 2024-08-04 23:38:07 发布
阅读量1.1k 收藏 9
点赞数 7
分类专栏： 消息中间件 文章标签： kafka linq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java123456111/article/details/140907629
版权

1、生产者消息发送流程

1.1 发送原理

在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程。在 main 线程中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。
在这里插入图片描述
分区器是来规定每个数据发往哪个队列（缓存队列），这个队列大小默认是32M。
Sender线程拉取RecordAccumulator中的消息，需要满足一个条件。batch.size或linger.ms。

2、异步发送API

异步通信：允许用户把一个消息放入队列，但并不立即处理它，然后在需要的时候再去处理它们。
在这里插入图片描述

2.1 普通异步发送

1、需求：创建Kafka生产者，采用异步的方式发送到Kafka Broker

2、代码编写
（1）创建工程kafka
（2）导入依赖

<dependencies>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>
2.2 编写不带回调函数的API代码
package com.atguigu.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;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 沉淀、分享、成长，让自己有所收获！
 */
public class CustomProducer {

    public static void main(String[] args) {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 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);
        // 2.1 发送数据
        for (int i = 0; i < 10; i++) {
            KafkaProducer.send(new ProducerRecord<>("first", "aaa:" + i));
        }

        // 3、关闭资源
        KafkaProducer.close();

    }
}

测试：
在192.168.58.130上开启kafka消费者

root@cl-virtual-machine:/usr/local/kafka# bin/kafka-console-consumer.sh --bootstrap-server 192.168.58.130:9092  --topic first

执行IDEA代码，查看收到发送过来的消息
在这里插入图片描述

2.3 带回调函数的异步发送

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

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

import java.util.Properties;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 沉淀、分享、成长，让自己有所收获！
 */
public class CustomProducerCallback {

    public static void main(String[] args) {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 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);
        // 2.1 发送数据
        for (int i = 0; i < 10; i++) {
            KafkaProducer.send(new ProducerRecord<>("first", "aaa:" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("topic： " + recordMetadata.topic() + " partition：" + recordMetadata.partition());
                    }
                }
            });
        }

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

3、同步发送API

同步发送是外部的一批数据发送到双端（缓存）队列的数据，分区的这批数据必须得发送到broker完毕后，再才能发送下一批数据到分区。

代码：

package com.atguigu.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;
import java.util.concurrent.ExecutionException;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 同步发送
 */
public class CustomProducerSync {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 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);
        // 2.1 发送数据
        for (int i = 0; i < 10; i++) {
            KafkaProducer.send(new ProducerRecord<>("first", "aaa:" + i)).get();
        }

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

4、生产者-分区器

4.1 分区好处

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

（2）提高并行度，生产者可以以分区为单位发送数据；消费者可以以分区为单位进行消费数据，消费者可以组成一个消费者组，去并行的消费数据，提高消费能力。
在这里插入图片描述
将100T的数据分为三份，每份是33T分别存放到三台服务器上，这样可以减少服务器的存储压力。

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

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

2、案例一
将数据发送到指定的partition的情况下，例如，将所有数据发往分区 1 中。

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

import java.util.Properties;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 指定分区发送生产者数据
 */
public class CustomProducerCallbackPartition {

    public static void main(String[] args) {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 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);
        // 2.1 发送数据
        for (int i = 0; i < 5; i++) {
            //  指定数据发送到 1 号分区，key 为空
            KafkaProducer.send(new ProducerRecord<>("first",1,"", "aaa:" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("topic： " + recordMetadata.topic() + " partition：" + recordMetadata.partition());
                    }
                }
            });
        }

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

以下蓝色部分是新增的数据。
在这里插入图片描述

3、案例二
没有指明 partition 值但有 key 的情况下，将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值。

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

import java.util.Properties;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 指定分区发送生产者数据
 */
public class CustomProducerCallbackPartition {

    public static void main(String[] args) {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 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);
        // 2.1 发送数据
        for (int i = 0; i < 5; i++) {
            // 依次指定 key 值为 a,b,f ，数据 key 的 hash 值与 3 个分区求余，
            //分别发往 1、2、0
            KafkaProducer.send(new ProducerRecord<>("first","f", "aaa:" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("topic： " + recordMetadata.topic() + " partition：" + recordMetadata.partition());
                    }
                }
            });
        }

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

在这里插入图片描述

4.3 自定义分区器

1、例如我们实现一个分区器实现，发送过来的数据中如果包含 atguigu，就发往 0 号分区，不包含 atguigu，就发往 1 号分区。

2、实现步骤
（1）定义类实现Partitioner 接口。
（2）重写 partition()方法。

package com.atguigu.kafka.config;

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

import java.util.Map;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 自定义分区器
 */
public class MyPartition implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] bytes, Object value, byte[] bytes1, Cluster cluster) {
        // 获取数据 atguigu hello
        String msgValues = value.toString();
        int partition;
        if (msgValues.contains("atguigu")) {
            partition = 0;
        } else {
            partition = 1;
        }
        return partition;
    }

    @Override
    public void close() {

    }

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

    }
}

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

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

import java.util.Properties;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 指定分区发送生产者数据
 */
public class CustomProducerCallbackPartition {

    public static void main(String[] args) {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 1.2 指定对应的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.atguigu.kafka.config.MyPartition");

        // 2.创建kafka生产者对象
        KafkaProducer<String, String> KafkaProducer = new KafkaProducer<>(properties);
        // 2.1 发送数据
        for (int i = 0; i < 5; i++) {
            // 包含atguigu 发往0号分区，否则发往1号分区
            KafkaProducer.send(new ProducerRecord<>("first","hello" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("topic： " + recordMetadata.topic() + " partition：" + recordMetadata.partition());
                    }
                }
            });
        }

        // 3、关闭资源
        KafkaProducer.close();
    }
}
4.4 生产者如何提高吞吐量

在这里插入图片描述

package com.atguigu.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;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： 提高生产者吞吐量的相关参数配置
 */
public class CustomProducerParameters {

    public static void main(String[] args) {

        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 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.BUFFER_MEMORY_CONFIG,33554432);
        // 1.4 批次大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        // 1.5 linger.ms   1ms
        properties.put(ProducerConfig.LINGER_MS_CONFIG,1);
        // 1.6 压缩
        properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");

        // 2.创建kafka生产者对象
        KafkaProducer<String, String> KafkaProducer = new KafkaProducer<>(properties);
        // 2.1 发送数据
        for (int i = 0; i < 5; i++) {
            KafkaProducer.send(new ProducerRecord<>("first", "aaa:" + i));
        }

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

测试，消费者收到发送过来的数据
在这里插入图片描述

4.5 生产者-数据的可靠性

ACK应答级别
（1）acks= 0
在这里插入图片描述
（2）acks= 1
在这里插入图片描述
（3）acks= -1

在这里插入图片描述
Follower会主动向Leader拉取数据。

思考：Leader收到数据，所有Follower都开始同步数据，但有一个Follower因为某种故障，迟迟不能与Leader进行同步，那这个问题怎么解决？

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

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

数据重复性分析：
acks： -1（all）：生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据后应答。
在这里插入图片描述
当Leader向生产者发送ack应答时，刚好Leader挂了，由于生产者没有收到ACK应答，会认为没有消费到，所以Hello这条数据不会被清除。当其他的Follower升级为Leader时，由于之前这个Follower已经将Hello这条数据同步过来了，现在升级后，生产者还会将Hello这条数据再发送一遍，就会导致接收到两份Hello数据，导致数据重复。

代码：

package com.atguigu.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;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright：设置ack应答机制、生产者重试次数
 */
public class CustomProducerAcks {

    public static void main(String[] args) {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 1.2 指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        // ACKS
        properties.put(ProducerConfig.ACKS_CONFIG, "1");
        // 重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);

        // 2.创建kafka生产者对象
        KafkaProducer<String, String> KafkaProducer = new KafkaProducer<>(properties);
        // 2.1 发送数据
        for (int i = 0; i < 10; i++) {
            KafkaProducer.send(new ProducerRecord<>("first", "bbb:" + i));
        }

        // 3、关闭资源
        KafkaProducer.close();
    }
}
4.6 生产经验 - 数据去重

1、数据传递语义

  • 至少一次（At Least Once）= ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2；

  • 最多一次（At Most Once）= ACK级别设置为0

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

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

4.7 幂等性

1、幂等性原理
幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。
精确一次（Exactly Once） = 幂等性 + 至少一次（ ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2） 。

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

在这里插入图片描述
2、如何使用幂等性
开启参数 enable.idempotence 默认为 true，false 关闭。

4.8 生产者事务

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

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

// 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;

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

package com.atguigu.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;

/**
 * @description:
 * @author：cl
 * @date: 2024/8/4
 * @Copyright： Kafka事务
 */
public class CustomProducerTransactions {

    public static void main(String[] args) {
        // 1、配置
        Properties properties = new Properties();
        // 1.1 连接集群 bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.58.130:9092");
        // 1.2 指定对应的key和value的序列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        // 设置事务id(必须)，事务id任意起名
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction_id_0");


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

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

        try {
            // 2.1 发送数据
            for (int i = 0; i < 10; i++) {
                KafkaProducer.send(new ProducerRecord<>("first", "aaa:" + i));
            }
            int i = 10/0;
            // 提交事务
            KafkaProducer.commitTransaction();
        } catch (Exception e) {
            // 终止事务
            KafkaProducer.abortTransaction();
        } finally {
            // 3、关闭资源
            KafkaProducer.close();
        }
    }
}
程序员老石
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kafka使用--IDEA创建生产者和消费者(Java版本)
小财迷嘻嘻的博客
12-07 1162
目录1、项目依赖2、生产者2.1 创建生产者2.2 测试3、消费者3.1 消费者和消费者群组3.2 分区再均衡3.3 创建消费者 1、项目依赖 本项目采用 Maven 构建，想要调用 Kafka 生产者 API，需要导入 kafka-clients 依赖，如下： <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId>
Kafka基础-生产者发送消息
煉心的博客
06-20 2万+
无论你是使用Kafka作为队列，消息总线还是数据存储平台，你都会用到生产者，用于发送数据到Kafka。下文介绍如何使用Java来发送消息到Kafka。1. 发送消息的主要步骤 首先创建ProducerRecord对象，此对象除了包括需要发送的数据value之外还必须指定topic，另外也可以指定key和分区。当发送ProducerRecord的时候，生产者做的第一件事就是把key和value序列...
Kafka生产者分区
热门推荐
01-15 4万+
生产环境中，我们往往需要更加自由的分区需求，我们可以自定义分区器。需求：在上面的根据key分区案例中，我们发现与我们知道的hash分区结果不同。那么我们就实现一个。3．实现步骤：① 定义类，实现Partitioner接口② 重写partition()方法代码实现：/*** 1. 实现接口Partitioner* 2. 实现3个方法:partition,close,configure* 3. 编写partition方法,返回分区号/*** 分区方法。
kafka入门(五)：kafka生产者发送消息
一生编程，快乐编程
12-17 1207
创建生产者实例和构建消息之后，就可以开始发送消息了。发送消息主要有三种模式：发后即忘、同步、异步。
kafka源码_Kafka生产者源码分析
weixin_39699163的博客
11-27 71
从一个Demo入手我们Kafka源码的doc文档拿下来一个Demo,这个Demo用于向服务端发送消息，从这个例子我们可以知道发送消息是通过生产者的KafkaProducer来完成的，这一篇文章将先完成KafkaProducer的分析.Properties 初始化过程先看看KafkaProducer的初始化方法，可以看出KafkaProducer是通过一些键值对的配置来实例化的。跟进去，下面这一段是...
Kafka01-Kafka生产者发送消息方式(发送即忘、同步、异步）
最新发布
m0_63833709的博客
06-26 896
接着，它演示了三种发送方式：发送即忘、同步发送和异步发送。在异步发送的例子中，我们注册了一个回调函数来处理消息发送成功或失败的情况。： 异步发送结合了发送即忘和同步发送的特点。生产者在发送消息后不会立即等待服务器的确认，而是继续发送下一条消息。： 这种方式是最简单的发送模式，生产者发送消息后不会等待任何确认，直接继续发送下一条消息。： 在同步发送模式下，生产者在发送消息后会等待服务器的确认。在 Kafka 生产者中，确实存在一些关键参数和概念，它们对消息的发送方式和性能有着重要的影响。
Java实现Kafka生产者消费者代码实例
08-19
Kafka生产者的代码实现一般包括创建Kafka生产者实例、构造消息并发送到指定主题等步骤。根据给定的代码片段，以下为生产者的关键知识点： 1. 创建KafkaProducer实例前需要配置生产者属性，包括Kafka集群的地址...
kafka客户端生产者消费者kafka可视化工具（可生产和消费消息）
06-22
Kafka生产者的主要作用是将应用程序产生的数据发送到Kafka集群的主题中。这个过程是异步的，允许应用程序在发送消息后继续执行其他任务。生产者还具有重试和错误处理机制，以确保消息在传输过程中不会丢失。 Kafka...
springboot整合kafka实现生产者和消费者
06-01
在本文中，我们将深入探讨如何使用Spring Boot整合Apache Kafka，以构建一个生产者和消费者的示例。Apache Kafka是一个分布式流处理平台，常被用于构建实时数据管道和流应用。Spring Boot简化了Java开发，提供了开箱...
springboot集成kafka实战项目，kafka生产者、消费者、创建topic，指定消费分区
01-04
在本项目中，我们将深入探讨如何使用Spring Boot与Kafka进行集成，实现一个实战项目，包括Kafka的生产者、消费者以及如何创建Topic，并且特别关注指定消费分区这一高级特性。Kafka是一款高吞吐量的分布式消息系统，...
kafka生产者源码
09-25
kafka生产者流程图，源码分析，（png）
kafka 生产者
01-20
【Kafka 生产者详解】 Kafka 生产者是 Kafka 集群中负责将数据发布到主题的应用程序组件。在 Kafka 中，生产者通过创建 `ProducerRecord` 对象来构造消息，该对象包含了目标主题、消息内容以及可选的键和分区信息。...
kafka java生产者_java kafka 生产者和消费者的代码实例
weixin_39781452的博客
02-17 248
生产者import com.google.common.collect.Lists;import org.apache.kafka.clients.producer.KafkaProducer;import org.apache.kafka.clients.producer.ProducerRecord;import org.junit.Test;import java.util.List;imp...
kafka-生产者发送消息&消费者消费消息
小丁的博客
05-28 553
kafka-生产者发送消息&消费者消费消息。
kafka生产者代码
u013758802的博客
06-26 1145
1、maven包 2、生产者代码
【kafka系列】kafka之生产者发送消息实践
增量星球
03-07 7001
一、准备工作 进入实战之前先熟悉一下topic的相关命令，使用终端命令查询创建一个新topic，用于后期实战； 特别注意：以下命令全部依据kafka文件目录中操作； 如果尚未安装kafka，请移步《centos7系统安装kafka》 查看操作主题命令参数 命令：./bin/kafka-topics.sh 日常工作中常用的命令如下表： 参数 描述 –bootstrap-server <String: server toconnect to> 连接的 Kafka Broker 主
分布式 - 消息队列Kafka：Kafka生产者发送消息的方式
你今天真好看呀
08-09 3219
具体来说，当生产者成功发送消息时，回调函数会被传递一个RecordMetadata对象，该对象包含了发送消息的相关信息，如消息所在的分区、消息在分区中的偏移量等。回调函数会在 producer 收到 ack 时调用，该方法有两个参数，分别是元数据信息（RecordMetadata）和异常信息（Exception），如果 Exception 为 null，说明消息发送成功，如果 Exception 不为 null，说明消息发送失败。发送即忘记，生产者发送消息后不会等待服务器的响应，直接发送下一条消息。
Kafka系列 - 02 Kafka生产者|发送消息|分区策略|提高吞吐量|数据可靠性|数据去重|数据有序
你今天真好看呀
11-20 990
例如我们实现一个分区器实现，发送过来的数据中如果包含 atguigu，就发往 0 号分区，不包含 atguigu，就发往 1 号分区。/**** @param topic 主题* @param key 消息的key* @param keyBytes 消息的key序列化之后的字节数组* @param value 消息的value* @param valueBytes 消息的value序列化之后的字节数组* @param cluster 集群元数据可以查看分区消息* @return。
Kafka生产者配置详解：关键参数设置
"kafka生产者参数配置用于在各种编程语言中设置Kafka生产者的关键选项，包括必填和非必填参数，确保消息正确发送到Kafka集群。" 在Kafka中，生产者是负责将数据发布到主题的组件。为了正确地配置Kafka生产者，了解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值