Producer异步直接发送、异步阻塞发送、异步回调发送、自定义Partition负载均衡、事务支持、带SSL异步发送

已于 2023-04-08 14:58:30 修改
阅读量170 收藏
点赞数
分类专栏： kafka 文章标签： java kafka 分布式
于 2023-01-03 22:56:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37432174/article/details/128540448
版权 
 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
            <version>2.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>28.2-jre</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
        </dependency>
    </dependencies>
  • ACKS_CONFIG acks 消息保障（
    0:至少一次，只发不管你收没收到，最快；
    1：至多一次，broker没响应就会再发；
    all：正好一次，broker没响应会再发，producer会带上id+消息，broker会去重，并响应已收到）
  • RETRIES_CONFIG：message.send.max.retries 发送失败后，重试次数
  • BATCH_SIZE_CONFIG：batch.num.messages 批量发送最大条数
  • LINGER_MS_CONFIG：linger.ms 单次批量发送，消息追加所用时间，到达该时间则发送
  • BUFFER_MEMORY_CONFIG：buffer.memory 单次批量发送，消息追加内存大小
  • KEY_SERIALIZER_CLASS_CONFIG：key序列化
  • VALUE_SERIALIZER_CLASS_CONFIG：value序列化
  • PARTITIONER_CLASS_CONFIG:自定义Partition负载均衡

异步直接发送

    /*
        Producer异步发送演示
        ACKS_CONFIG acks 消息保障 （0:至少一次，只发不管你收没收到，最快；1：至多一次，broker没响应就会再发；all：正好一次，broker没响应会再发，producer会带上id+消息，broker会去重，并响应已收到）4
        RETRIES_CONFIG：message.send.max.retries 发送失败后，重试次数
        BATCH_SIZE_CONFIG：batch.num.messages 批量发送最大条数
        LINGER_MS_CONFIG：linger.ms 单次批量发送，消息追加所用时间，到达该时间则发送
        BUFFER_MEMORY_CONFIG：buffer.memory 单次批量发送，消息追加内存大小
        KEY_SERIALIZER_CLASS_CONFIG：key序列化
        VALUE_SERIALIZER_CLASS_CONFIG：value序列化
     */
    public static void producerSend(){
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.174.128:9092");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,"key-"+i,"value-"+i);

            producer.send(record);
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

异步阻塞发送

/*
        Producer异步阻塞发送
        ACKS_CONFIG acks 消息保障 （0:至少一次，只发不管你收没收到，最快；1：至多一次，broker没响应就会再发；all：正好一次，broker没响应会再发，producer会带上id+消息，broker会去重，并响应已收到）4
        RETRIES_CONFIG：message.send.max.retries 发送失败后，重试次数
        BATCH_SIZE_CONFIG：batch.num.messages 批量发送最大条数
        LINGER_MS_CONFIG：linger.ms 单次批量发送，消息追加所用时间，到达该时间则发送
        BUFFER_MEMORY_CONFIG：buffer.memory 单次批量发送，消息追加内存大小
        KEY_SERIALIZER_CLASS_CONFIG：key序列化
        VALUE_SERIALIZER_CLASS_CONFIG：value序列化
     */
    public static void producerSyncSend() throws ExecutionException, InterruptedException {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.174.128:9092");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            String key = "key-"+i;
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,key,"value-"+i);

            Future<RecordMetadata> send = producer.send(record);
            RecordMetadata recordMetadata = send.get();
            System.out.println(key + "partition : "+recordMetadata.partition()+" , offset : "+recordMetadata.offset());
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

在这里插入图片描述
异步发送带回调函数

 /*
        Producer异步发送带回调函数
        ACKS_CONFIG acks 消息保障 （0:至少一次，只发不管你收没收到，最快；1：至多一次，broker没响应就会再发；all：正好一次，broker没响应会再发，producer会带上id+消息，broker会去重，并响应已收到）4
        RETRIES_CONFIG：message.send.max.retries 发送失败后，重试次数
        BATCH_SIZE_CONFIG：batch.num.messages 批量发送最大条数
        LINGER_MS_CONFIG：linger.ms 单次批量发送，消息追加所用时间，到达该时间则发送
        BUFFER_MEMORY_CONFIG：buffer.memory 单次批量发送，消息追加内存大小
        KEY_SERIALIZER_CLASS_CONFIG：key序列化
        VALUE_SERIALIZER_CLASS_CONFIG：value序列化
     */
    public static void producerSendWithCallback(){
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.174.128:9092");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,"key-"+i,"value-"+i);

            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    System.out.println(
                            "partition : "+recordMetadata.partition()+" , offset : "+recordMetadata.offset());
                }
            });
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

在这里插入图片描述
异步发送带回调函数和Partition负载均衡

/*
        Producer异步发送带回调函数和Partition负载均衡
        ACKS_CONFIG acks 消息保障 （0:至少一次，只发不管你收没收到，最快；1：至多一次，broker没响应就会再发；all：正好一次，broker没响应会再发，producer会带上id+消息，broker会去重，并响应已收到）4
        RETRIES_CONFIG：message.send.max.retries 发送失败后，重试次数
        BATCH_SIZE_CONFIG：batch.num.messages 批量发送最大条数
        LINGER_MS_CONFIG：linger.ms 单次批量发送，消息追加所用时间，到达该时间则发送
        BUFFER_MEMORY_CONFIG：buffer.memory 单次批量发送，消息追加内存大小
        KEY_SERIALIZER_CLASS_CONFIG：key序列化
        VALUE_SERIALIZER_CLASS_CONFIG：value序列化
        PARTITIONER_CLASS_CONFIG:自定义Partition负载均衡
     */
    public static void producerSendWithCallbackAndPartition(){
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.174.128:9092");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        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.imooc.jiangzh.kafka.producer.SamplePartition");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,"key-"+i,"value-"+i);

            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    System.out.println(
                            "partition : "+recordMetadata.partition()+" , offset : "+recordMetadata.offset());
                }
            });
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }

事务支持

 /*
         Producer 事务支持
      */
    public static void producerWithTransactional() throws ExecutionException, InterruptedException {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.174.128:9092");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        // 事务支持配置
        properties.put(ProducerConfig.RETRIES_CONFIG, "2");
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "zsl-trans-id");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);
        producer.initTransactions();

        producer.beginTransaction();
        try{
            // 消息对象 - ProducerRecoder
            for(int i=0;i<10;i++){
                String key = "key-"+i;
                ProducerRecord<String,String> record =
                        new ProducerRecord<>(TOPIC_NAME,key,"value-"+i);
//
//                if(i == 8){
//                    throw new Exception();
//                }

                producer.send(record);
//                RecordMetadata recordMetadata = send.get();
//                System.out.println(key + " , partition : "+recordMetadata.partition()+" , offset : "+recordMetadata.offset());
            }
            // 提交事务
            producer.commitTransaction();
        }catch (Exception e){
            e.printStackTrace();
            // 回滚事务
            producer.abortTransaction();
        }finally {
            producer.close();
        }
    }

带SSL异步发送

   /*
        Producer异步发送演示 并携带SSL
     */
    public static void producerSendWithSSL(){
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.174.128:8989");
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        properties.put(ProducerConfig.RETRIES_CONFIG,"0");
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        properties.put(ProducerConfig.LINGER_MS_CONFIG,"1");
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");

        properties.put("security.protocol","SSL");
        properties.put("ssl.endpoint.identification.algorithm","");
        properties.put("ssl.truststore.location","client.truststore.jks");
        properties.put("ssl.truststore.password","zsl");

        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");

        // Producer的主对象
        Producer<String,String> producer = new KafkaProducer<>(properties);

        // 消息对象 - ProducerRecoder
        for(int i=0;i<10;i++){
            ProducerRecord<String,String> record =
                    new ProducerRecord<>(TOPIC_NAME,"key-"+i,"value-"+i);

            producer.send(record);
        }

        // 所有的通道打开都需要关闭
        producer.close();
    }
偷偷学习被我发现
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
flume连接kafka_kafka 分区和副本以及kafaka 执行流程，以及消息的高可用
weixin_39635314的博客
11-30 276
1、Kafka概览Apache下的项目Kafka(卡夫卡)是一个分布式流处理平台，它的流行是因为卡夫卡系统的设计和操作简单，能充分利用磁盘的顺序读写特性。kafka每秒钟能有百万条消息的吞吐量，因此很适合实时的数据流处理。例如kafka在线日志收集系统可作为flume的实时消息sink端，再通过kafka的消费者将消息实时写入hbase数据库中。卡夫卡以topic分类对记录进行存储，每个...
rocketMQ producer的异步发送
leewe7的博客
05-27 594
1.异步发送的回调函数 producer.send(msg,new SendCallback(){ @Override public void onSuccess(SendResult sendResult){ } @Override public void onException(Throwable e){ } }); 2.消息发送成功 sendMessageAsync sendResult = MQClientAPIImpl.this.processSendResponse(b
Kafka Producer 异步发送消息居然也会阻塞？
后端进阶
09-13 2438
Kafka 一直以来都以高吞吐量的特性而家喻户晓，就在上周，在一个性能监控项目中，需要使用到 Kafka 传输海量消息，在这过程中遇到了一个 Kafka Producer 异步发送消息会被阻塞的问题，导致生产端发送耗时很大。 是的，你没听错，Kafka Producer 异步发送消息也会发生阻塞现象，那究竟是怎么回事呢？ 在新版的 Kafka Producer 中，设计了一个消息缓冲池，客户端发送的消息都会被存储到缓冲池中，同时 Producer 启动后还会开启一个 Sender 线程，不断地从缓冲池获取消
Kafka：Producer异步发送与回调
kaven
02-12 3117
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 http://maven.apache.or
kafka之Producer同步与异步消息发送及事务幂等性案例应用实战
weixin_34191845的博客
11-11 1286
本套系列博客从真实商业环境抽取案例进行总结和分享，并给出Spark商业应用实战指导，请持续关注本套博客。版权声明：本套Spark商业应用实战归作者（秦凯新）所有，禁止转载，欢迎学习。 秦凯新的技术社区-大数据商业实战系列全集目录 kafka 商业环境实战-kafka生产环境规划 kafka 商业环境实战-kafka生产者和消费者吞吐量测试 kafka 商业环境实战-kafka生产者Pro...
Kafka Producer异步发送的流程
lzf的博客
01-13 9569
Producer API入门 ProducerRecord 说明 异步发送流程 2.1 用户线程调用send将record压缩到BufferPool中 2.2 发送调度 Producer设计说明Producer Configuration1. Producer API入门：KafkaProducer是一个发送record到Kafka Cluster的客户端API。这个类线程安全的。在...
Kafka负载均衡、Kafka自定义Partition、Kafk文件存储机制
u014033218的专栏
08-22 1025
1、Kafka整体结构图 Kafka名词解释和工作方式 Producer ：消息生产者，就是向kafka broker发消息的客户端。  Consumer ：消息消费者，向kafka broker取消息的客户端  Topic ：咋们可以理解为一个队列。  Consumer Group （CG）：这是kafka用来实现一个topic消息的广播（发给所有的consumer
Kafka源码解析之Producer发送数据流程(三)
百看不如一RUN
07-26 2112
1. Kakfa生产者examples public class Producer extends Thread { private final KafkaProducer<Integer, String> producer; private final String topic; private final Boolean isAsync; /** * 构造方法,初始化生产者对象 * @param topic * @param i
【Python百宝箱】Python异步通信：构建高效实时系统
记录我的学习历程
12-22 632
本文将详细介绍多个Python库，包括ZeroMQ、Redis Pub/Sub、asyncio、Trio、Celery、RabbitMQ、Apache Kafka、Flink、websockets和fastapi。每个库都将被单独探讨，介绍其核心概念、使用场景、高性能特点以及实际示例。通过学习这些库，读者将能够更好地理解如何构建强大、灵活且高效的异步通信系统。
ActiveMQ的使用代码样例（异步邮件发送）.rar
07-28
在本示例中，我们将深入探讨如何使用ActiveMQ实现异步邮件发送，这通常涉及到生产者（Producer）和消费者（Consumer）的角色。 1. **ActiveMQ的基本概念**： - **生产者（Producer）**：负责创建和发送消息到队列...
RocketMq事务消息发送代码流程详解
08-18
RocketMq事务消息发送代码流程详解是指在RocketMq中实现事务消息发送的整个过程，包括预请求消息、执行本地事务、发送消息给Broker、消息回查等步骤。通过这个流程，我们可以实现分布式事务的可靠消息传递。
ActiveMQ的使用代码样例（异步邮件发送）.zip
11-06
本示例将探讨如何使用ActiveMQ实现异步邮件发送，这有助于提高应用性能，因为邮件发送通常是一个耗时的操作。 首先，我们来看"edu-demo-mqproducer"这个文件，它代表生产者部分，即负责发送消息到ActiveMQ的消息...
kafka-python批量发送数据的实例
09-19
为了确保数据均匀分布到各个分区（Partition），我们需要知道主题的分区数量，这通过变量`PARTNUM`表示。 ```python def send_data_2_kafka(datas): # 连接到Kafka服务器 client = KafkaClient(hosts=KAFKABROKER...
Python 中由 yield 实现异步操作
09-16
### Python 中由 yield 实现异步操作 #### yield 在 Python 中的作用 `yield` 是 Python 中的一个强大特性，主要用于创建生成器（generator）。生成器是一种特殊的迭代器，它允许我们像列表那样迭代值，但并不需要...
JAVA进阶补充
2301_80150315的博客
08-15 750
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 537
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 889
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 555
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot集成kafka，并在生产者异步发送消息且配置ack，并设置回调函数
05-11
首先，需要在pom.xml文件中添加kafka的依赖： ```xml <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.4.10.RELEASE</version> </dependency> ``` 接着，在application.properties文件中配置kafka的相关信息： ```properties #kafka配置 spring.kafka.bootstrap-servers=localhost:9092 spring.kafka.producer.acks=all spring.kafka.producer.retries=3 spring.kafka.producer.batch-size=16384 spring.kafka.producer.buffer-memory=33554432 ``` 其中，`bootstrap-servers`表示kafka的地址和端口，`acks`表示消息确认模式，`retries`表示消息发送失败后的重试次数，`batch-size`表示每次批量发送消息的大小，`buffer-memory`表示消息缓存区的大小。 接下来，在配置类中创建KafkaTemplate和生产者回调函数： ```java @Configuration public class KafkaConfig { @Value("${spring.kafka.bootstrap-servers}") private String servers; @Bean public KafkaTemplate<String, String> kafkaTemplate() { return new KafkaTemplate<>(producerFactory()); } @Bean public ProducerFactory<String, String> producerFactory() { return new DefaultKafkaProducerFactory<>(producerConfigs()); } @Bean public Map<String, Object> producerConfigs() { Map<String, Object> props = new HashMap<>(); props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, servers); props.put(ProducerConfig.RETRIES_CONFIG, 0); props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); props.put(ProducerConfig.LINGER_MS_CONFIG, 1); props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432); props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class); props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class); props.put(ProducerConfig.ACKS_CONFIG, "all"); return props; } @Bean public KafkaProducerListener<String, String> kafkaProducerListener() { return new KafkaProducerListener<>(); } } class KafkaProducerListener<K, V> implements ProducerListener<K, V> { @Override public void onSuccess(ProducerRecord<K, V> producerRecord, RecordMetadata recordMetadata) { System.out.println("消息发送成功：" + producerRecord.toString()); } @Override public void onError(ProducerRecord<K, V> producerRecord, Exception exception) { System.out.println("消息发送失败：" + producerRecord.toString() + ", " + exception.getMessage()); } } ``` 在上面的代码中，我们创建了一个`KafkaTemplate`，并通过`DefaultKafkaProducerFactory`将其与`ProducerConfig`绑定。然后，我们实现了一个生产者回调函数`KafkaProducerListener`，其中`onSuccess`方法在消息发送成功后被调用，`onError`方法在消息发送失败后被调用。 最后，在消息发送时，我们可以通过`KafkaTemplate`的`send`方法异步发送消息，并传入回调函数： ```java @Service public class KafkaProducerService { @Autowired private KafkaTemplate<String, String> kafkaTemplate; public void sendMessage(String topic, String message) { ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(topic, message); future.addCallback(new ListenableFutureCallback<SendResult<String, String>>() { @Override public void onSuccess(SendResult<String, String> result) { System.out.println("发送消息成功：" + result.toString()); } @Override public void onFailure(Throwable ex) { System.out.println("发送消息失败：" + ex.getMessage()); } }); } } ``` 如上所示，我们通过`kafkaTemplate.send`方法异步发送消息，并在`ListenableFuture`的回调函数中处理发送结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偷偷学习被我发现

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值