Kafka原生API使用Java代码-生产者-分区策略-默认分区策略&轮询分区策略

已于 2024-05-30 10:45:58 修改
阅读量766 收藏 18
点赞数 7
分类专栏： Kafka 文章标签： kafka java linq 默认分区策略 轮询分区策略 linger.ms
于 2024-05-29 20:40:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65152767/article/details/139303253
版权

文章目录

1、代码演示

1.1、pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <!-- Generated by https://start.springboot.io -->
    <!-- 优质的 spring/boot/data/security/cloud 框架中文文档尽在 => https://springdoc.cn -->
    <groupId>com.atguigu.kafka</groupId>
    <artifactId>kafka-producer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>kafka-producer</name>
    <description>kafka-producer</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

1.2、KafkaProducerPartitioningStrategy.java

1.2.1、ProducerConfig.LINGER_MS_CONFIG取 0 值得情况，不轮询

不等待，不轮询，默认分区策略

package com.atguigu.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
import java.util.UUID;
public class KafkaProducerPartitioningStrategy {

    public static void main(String[] args) {
        // 初始化Kafka生产者配置
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.74.148:9092"); // 指定Kafka broker的地址和端口
        // 确认消息写入策略，"acks"设置为all表示所有副本都确认消息接收后才会响应
        props.put("acks", "all");
        // 消息发送失败时的重试次数，设置为0表示不重试
        props.put("retries", 0);
        // 发送缓冲区等待时间，等待1秒后，发送
        //props.put(ProducerConfig.LINGER_MS_CONFIG, 1000);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定键的序列化器
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定值的序列化器
        // 分区器选择RoundRobinPartitioner，实现消息在主题分区间的轮询分配
        //props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "org.apache.kafka.clients.producer.RoundRobinPartitioner"  );
        // 创建Kafka生产者实例
        Producer<String, String> producer = new KafkaProducer<>(props);

        for (int i = 0; i < 1000; i++) {
            producer.send(new ProducerRecord<String, String>("my_topic3", "88"), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("recordMetadata.partition() = " + recordMetadata.partition());
                    }
                }
            });

        }
        producer.close();
    }
}

在这里插入图片描述

1.2.2、ProducerConfig.LINGER_MS_CONFIG取 0 值得情况，轮询

不等待，立即发送，轮询策略

package com.atguigu.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
import java.util.UUID;
public class KafkaProducerPartitioningStrategy {

    public static void main(String[] args) {
        // 初始化Kafka生产者配置
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.74.148:9092"); // 指定Kafka broker的地址和端口
        // 确认消息写入策略，"acks"设置为all表示所有副本都确认消息接收后才会响应
        props.put("acks", "all");
        // 消息发送失败时的重试次数，设置为0表示不重试
        props.put("retries", 0);
        // 发送缓冲区等待时间，设置为0表示不等待，立即发送
        props.put(ProducerConfig.LINGER_MS_CONFIG, 0);   
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定键的序列化器
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定值的序列化器
        // 分区器选择RoundRobinPartitioner，实现消息在主题分区间的轮询分配
        props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "org.apache.kafka.clients.producer.RoundRobinPartitioner"  );
        // 创建Kafka生产者实例
        Producer<String, String> producer = new KafkaProducer<>(props);

        for (int i = 0; i < 1000; i++) {
            producer.send(new ProducerRecord<String, String>("my_topic3", "88"), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("recordMetadata.partition() = " + recordMetadata.partition());
                    }
                }
            });

        }
        producer.close();
    }
}

在这里插入图片描述

1.2.3、ProducerConfig.LINGER_MS_CONFIG取 1000 值得情况，轮询

等待1秒后发送，轮询策略

package com.atguigu.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
import java.util.UUID;
public class KafkaProducerPartitioningStrategy {

    public static void main(String[] args) {
        // 初始化Kafka生产者配置
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.74.148:9092"); // 指定Kafka broker的地址和端口
        // 确认消息写入策略，"acks"设置为all表示所有副本都确认消息接收后才会响应
        props.put("acks", "all");
        // 消息发送失败时的重试次数，设置为0表示不重试
        props.put("retries", 0);
        // 发送缓冲区等待时间，等待1秒后，发送
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1000);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定键的序列化器
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定值的序列化器
        // 分区器选择RoundRobinPartitioner，实现消息在主题分区间的轮询分配
        props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "org.apache.kafka.clients.producer.RoundRobinPartitioner"  );
        // 创建Kafka生产者实例
        Producer<String, String> producer = new KafkaProducer<>(props);

        for (int i = 0; i < 1000; i++) {
            producer.send(new ProducerRecord<String, String>("my_topic3", "88"), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("recordMetadata.partition() = " + recordMetadata.partition());
                    }
                }
            });

        }
        producer.close();
    }
}

在这里插入图片描述

1.2.4、ProducerConfig.LINGER_MS_CONFIG取 1000 值得情况，不轮询

等待1秒后发送，不轮询

package com.atguigu.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
import java.util.UUID;
public class KafkaProducerPartitioningStrategy {

    public static void main(String[] args) {
        // 初始化Kafka生产者配置
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.74.148:9092"); // 指定Kafka broker的地址和端口
        // 确认消息写入策略，"acks"设置为all表示所有副本都确认消息接收后才会响应
        props.put("acks", "all");
        // 消息发送失败时的重试次数，设置为0表示不重试
        props.put("retries", 0);
        // 发送缓冲区等待时间，等待1秒后，发送
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1000);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定键的序列化器
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 指定值的序列化器
        // 分区器选择RoundRobinPartitioner，实现消息在主题分区间的轮询分配
        //props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "org.apache.kafka.clients.producer.RoundRobinPartitioner"  );
        // 创建Kafka生产者实例
        Producer<String, String> producer = new KafkaProducer<>(props);

        for (int i = 0; i < 1000; i++) {
            producer.send(new ProducerRecord<String, String>("my_topic3", "88"), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("recordMetadata.partition() = " + recordMetadata.partition());
                    }
                }
            });

        }
        producer.close();
    }
}

在这里插入图片描述

2、分区策略

kafka的生产者分区策略

  1. 默认分区策略：减少重新建立分区连接的性能损耗 开发使用最多的分区方式，采用黏性分区，默认向第一次连接上的主题分区发送消息，直到消息累积到 batch.size大小（16kb）
  2. 轮询分区策略：每个分区接收一次消息（linger.ms决定生产者一次批量发送多少条消息 到一个分区中），开发中一定不会用轮询分区策略，顶多自定义，因为轮询性能太差，频繁跟不同的分区建立连接，大数据会用轮询策略

2.1、linger.ms参数的含义

在Kafka的生产者（Producer）配置中，props.put("linger.ms", 1); 这行代码是用于设置生产者的linger.ms参数的。

linger.ms参数的含义是：生产者会在发送消息之前等待更多消息被发送到同一个分区（partition）的额外时间（以毫秒为单位）。这样做的目的是为了提高吞吐量，因为将多个消息批量发送到同一个分区可以减少网络传输的开销和服务器端的I/O开销。

具体来说，当你设置了linger.ms参数（比如设置为1毫秒），Kafka生产者会尝试在发送消息之前等待1毫秒，看看是否还有其他的消息要发送到同一个分区。如果有，这些消息将会被合并成一个批次（batch）一起发送。

注意，设置linger.ms参数可能会增加消息的延迟，因为生产者会等待指定的时间以合并更多的消息。所以，这个参数需要在吞吐量和延迟之间进行权衡。

这里是一个简化的示例，展示如何在使用Java Kafka生产者时设置linger.ms参数：

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 KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        // 设置linger.ms
        props.put("linger.ms", 1);

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        // 发送消息...

        producer.close();
    }
}

在这个示例中，我们创建了一个KafkaProducer对象，并设置了包括linger.ms在内的多个配置参数。然后，你可以使用这个生产者对象来发送消息到Kafka集群。

2.2、linger milliseconds

linger.ms 的英文全称就是 “linger milliseconds”，其中 “linger” 是指延迟或等待，“milliseconds” 是毫秒的意思。

在 Kafka 的 Producer 配置中，linger.ms 参数用于控制 Producer 在发送消息之前等待更多消息到达相同分区（partition）的时间，以便可以将这些消息一起发送，从而提高吞吐量。默认情况下，linger.ms 的值为 0，这意味着 Producer 收到消息后会立即发送，不进行任何延迟。

linger.ms 参数与 batch.size 参数一起使用时，可以实现更复杂的消息发送策略。batch.size 参数定义了单个批次（batch）中允许的最大消息字节数。当 Producer 收到消息时，它会尝试将消息添加到当前批次中。如果linger.ms 大于 0，并且当前批次中的消息数量尚未达到 batch.size 的限制，那么 Producer 会等待 linger.ms 指定的时间，看看是否还有更多的消息要发送到相同的分区。如果有，这些消息将被添加到当前批次中；如果没有，那么在当前时间到达后，Producer 将发送当前批次中的所有消息。

需要注意的是，linger.ms 参数的值应该根据具体的业务场景和性能需求进行调整。较小的值可以提高消息的实时性，但可能会降低吞吐量；较大的值可以提高吞吐量，但可能会增加消息的延迟。因此，在实际应用中需要根据实际情况进行权衡和选择。

2.3、linger.ms配置参数的理解

在Kafka中，linger.ms是一个配置参数，用于控制生产者（producer）在发送消息到broker之前的等待时间，以便将更多的消息累积到同一批次中，从而提高吞吐量。linger.ms的取值可以是任何非负整数，表示毫秒数。

以下是关于linger.ms的一些关键点：

  • 如果linger.ms设置为0，生产者会立即发送消息到broker，不会等待其他消息来累积到同一批次。
  • 如果linger.ms设置为大于0的值，生产者会等待该指定的毫秒数，或者直到达到batch.size（批次大小）的限制，然后将累积的消息作为一个批次发送到broker。
  • 增大linger.ms的值可能会提高吞吐量，因为可以累积更多的消息到同一批次中，减少网络传输的次数。但是，这也会增加消息的延迟。
  • linger.ms的取值可以根据具体的应用场景和需求进行调整。在需要低延迟的场景中，可以将linger.ms设置为较小的值；在可以容忍一定延迟的场景中，可以尝试增大linger.ms的值以提高吞吐量。

综上所述，linger.ms的取值并没有固定的几个选项，而是可以根据实际需求设置为任何非负整数。在配置Kafka生产者时，需要根据具体的业务场景和需求来选择合适的linger.ms值。

小丁学Java
关注
专栏目录
博客
史上最快在IDEA中创建类，只需要 ctrl + 鼠标左键双击 就可以调出创建类的窗口（全网首创）
08-02 1351
需要首先鼠标右键一次，点击新建，再点击 Java类，过于麻烦。我们只需要自定义设置创建类的快捷键即可。
博客
要在 Git Bash 中使用 `tree` 命令，下载并手动安装 `tree`。
10-08 465
要在 Git Bash 中使用 `tree` 命令，下载并手动安装 `tree`。
博客
微信小程序启动不起来，报错凡是以~/包名/*.js路径的文件，都找不到，试过网上一切方法，最终居然这么解决的，【避坑】命运的齿轮开始转动
10-08 450
从这里不难发现，我的微信开发者工具是2022年8月30日10点48分装的软件，这个时候我刚好是大学微信小程序实训课，哪个时候我还在上大学，而现在是2024年10月8日8点54分，所以时间相差很大，从这里推测是我的开发者工具太旧，项目经理又和我说过这个项目是23年做完的，所以不难推测微信开发者工具太旧，所以是更新版本还是降低版本是有依据的。
博客
wxml语法-声明和绑定数据
10-06 1036
小程序页面中使用的数据均需要在Page（）方法的data对象中进行的data对象中进行声明定义在将数据声明好以后，在WXML使用将变量包起来，从而将数据绑定。
博客
微信小程序-npm支持-如何使用npm包
10-05 463
微信小程序-npm支持-如何使用npm包。
博客
阿里云域名解析和备案
10-02 578
阿里云域名解析和备案
博客
阿里云域名注册购买和备案
10-01 547
阿里云域名注册购买和备案
博客
阿里云域名HTTP+SSL证书流程（http到https的一个过程）
09-30 654
如何在nginx服务器上安装ssl证书，以及配置443端口的ssl？
博客
查看Nginx在linux中的配置文件的安装目录
09-30 221
查看Nginx在linux中的配置文件的安装目录。
博客
串行化执行、并行化执行
09-29 588
可以将多个任务编排为并行和串行化执行。也可以处理编排的多个任务的异常，也可以返回兜底数据。
博客
安装python
09-28 387
download python：https://www.python.org/downloads/
博客
Harbor使用
09-27 442
镜像上传到Harbor中。
博客
docker -私有镜像仓库 - harbor安装
09-27 1492
镜像仓库作用：存储镜像，可以通过镜像仓库实现镜像的共享镜像仓库的使用流程：镜像仓库分类：1、公有镜像仓库：可以理解成云仓库、公有仓库，是由某个组织、公司维护的仓库，对互联网开放，所有人共享。如官方的仓库docker hub。2、私有镜像仓库：不对外开放。一般情况下只在公司内网中使用，用于加快镜像拉取速度、维护公司资产。私有镜像仓库种类：Registry是Docker自带的镜像仓库，部署运行非常简洁，非常适合在测试时使用。Harbor。
博客
docker compose 容器编排
09-27 872
1、Docker Compose是一个工具，用于定义和运行多容器应用程序的工具；2、Docker Compose通过yml文件定义多容器的docker应用；3、Docker Compose通过一条命令根据yml文件的定义去创建或管理多容器；如下图所示：Docker Compose 是用来做Docker 的多容器控制，有了 Docker Compose 你可以把所有繁复的 Docker 操作全都一条命令，自动化的完成。
博客
docker - maven 插件自动构建镜像（构建镜像：ebuy-docker:v2.0）
09-26 584
上面手动构建镜像的过程比较繁琐，使用Maven的docker插件可以实现镜像的自动化部署。1、开启docker服务端的远程访问2、在pom.xml文件中添加Maven的docker插件3、在工程的根目录下创建dockerfile文件4、使用maven的打包命令进行打包5、创建容器并访问。
博客
点击IDEA中的maven插件中的生命周期的命令发现没有效果，没有任何反应，解决办法在下面
09-26 225
点击上述命令发现没有任何反应，run运行界面也不会有任何输出。是因为我们的maven配置有问题，检查maven配置。
博客
dockerfile部署springboot项目（构建镜像：ebuy-docker:v1.0）
09-26 794
需求：将提供的Spring Boot项目使用容器化进行部署分析：1、Spring Boot项目中使用到了Mysql数据库，先使用docker部署mysql2、Spring Boot项目使用docker容器进行部署：可以基于上一步java环境的dockerfile创建springboot项目的容器。实现步骤：1、使用docker部署mysql2、使用dockerfile构建Spring Boot镜像3、创建容器进行测试。
博客
使用dockerfile来构建一个包含Jdk17的centos7镜像（构建镜像：centos7-jdk17）
09-25 1144
前面我们所使用的镜像都是别人构建好的，但是别人构建好的镜像不一定能满足我们的需求(**例如：**部署springboot项目需要java环境)，使用dockerfile构建自定义镜像就可以解决这个问题。dockerfile就是一个文本文件，在这个文本文件中可以使用docker所提供的一些指令来配置构建镜像的细节，后期可以使用这个dockerfile文件来构建自己的镜像。dockerfile文件内容一般分为4部分：基础镜像信息(必选)维护者信息(可选)镜像操作指令(可选)
博客
docker - 迁移和备份
09-25 638
对某一个容器修改完毕以后，我们可以把最新的容器部署到其他的环境中。
博客
docker-图形化工具-portainer的使用
09-25 470
上述对容器和镜像的管理都是基于docker客户端的命令来完成，不太方便。为了方便的对docker中的一些对象(镜像、容器、数据卷…)来进行管理，可以使用Portainer来完成。Portainer是一个可视化的容器镜像的图形管理工具，利用Portainer可以轻松构建，管理和维护docker环境。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值