Java代码实现kafka的消息生产与消费

最新推荐文章于 2023-07-14 08:53:04 发布
最新推荐文章于 2023-07-14 08:53:04 发布
阅读量4.4k 收藏 5
点赞数 1
分类专栏： kafka 文章标签： java kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57128596/article/details/127350722
版权

目录

生产者的同步发送消息

异步发送

生产端ack的配置

发送消息缓冲机制

 代码实现

生产者消费者实例

生产者的同步发送消息

 生产者发送消息到我们的topic分区上，需要等待我们kafka返回的ack，如果没有返回就会进入3s的阻塞，retry3次——>抛出异常（这里面我们可以将信息记录到文件日志中）

(43条消息) NIO学习_Fairy要carry的博客-CSDN博客

package com.wyh.kafka_demo.kafka;

import com.alibaba.fastjson.JSON;
import com.wyh.kafka_demo.pojo.Order;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

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


public class SimpleProducer {
    /**
     * 1.创建主题
     */
    private final static String TOPIC_NAME = "jqTopic5";

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 2.kafka的broker
         */
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "82.157.198.247:9092,82.157.198.247:9093");

        /**
         * 2.1序列化:Key+value
         */
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        /**
         * 封装到发消息的客户端中
         */
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);

        /**
         * 3.模拟发送五条消息
         */
        int maxNum = 5;

        /**
         * 3.1创建消息
         * hash(key)%partition
         * ProducerRecord:消息记录
         * key:消息标识key，帮助告诉发送到哪个分许通过hash计算
         * value：json数据，消息内容
         */
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(TOPIC_NAME, 0,"TestKey", "hello,kafka");

        /**
         * 3.2通过异步的形式发送消息
         */
        RecordMetadata recordMetadata = producer.send(producerRecord).get();
        System.out.println("同步方式得到的消息：" + "topic-" + recordMetadata.topic()
                + "|partition-" + recordMetadata.partition()
                + "|offset-" + recordMetadata.offset());

    }

}

异步发送

我们可以利用异步回调，生产者不管你消费者有没有消费发送完就往下执行自己的了；当我们拿到数据后通过回调机制异步返回（比如zk的watch机制就是这样）

(43条消息) Zookeeper_Fairy要carry的博客-CSDN博客

优点：速度较快，像银行转账业务异步就毕竟好，反馈较快

缺点：可能会出现消息丢失的情况，例如我们rabbitmq可以利用spring的retry机制解决，另外分布式事务也是需要解决的

(43条消息) RabbitMQ的高级特性（消息可靠性）_Fairy要carry的博客-CSDN博客

(43条消息) MQ-消息延迟_Fairy要carry的博客-CSDN博客_mq 延迟消息

像消息堆积我们kafka不需要考虑这方面，消息放在硬盘中

生产端ack的配置

1.两个broker上创建2个分区配上两个副本 

bin/kafka-topics.sh --bootstrap-server xxxx:9092,xxxx:9093 --create --partitions 2 --replication-factor 2 --topic jqTopic5

2.生产者配置 

bin/kafka-console-producer.sh --broker-list xxxx:9092,xxxx:9093 --topic jqTopic5

同步发送的前提，生产者在获取ack前会一直阻塞：三种ack 

ack=0：生产者只需要把消息给到broker，而不需要到partition中kafka就会把ack返回给生产者，速度较快容易丢消息

ack=1：多副本都接收到消息（leader进行同步），并且将消息传到log中kafka就返回ack

ack=all：leader和follower同步完后才会将ack返回

发送消息缓冲机制

生产者并不是直接把消息推送给kafka的——>利用了消息缓冲的机制，kafka本地线程默认会创建一个缓冲区 ，用来存放发送的数据（先放到缓冲区，当到达16k就进行发送）

如果没有满足16k，就等待10ms再发送消息

 代码实现

   /**
         * 2.kafka的broker
         */
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"82.157.198.247:9092,82.157.198.247:9093");

        /**
         * 2.1发送消息持久化机制参数ack
         * 生产者会等3s，然后重试3次
         */
        properties.put(ProducerConfig.ACKS_CONFIG,"1");

        /**
         * 2.12重试间隔的设置
         * 默认间隔为100ms，次数为3次
         */
        properties.put(ProducerConfig.RETRIES_CONFIG,3);
        properties.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG,300);

        /**
         * 2.2设置消息的缓冲区
         * 消息先放到缓冲区，如果到16k就发送，未满足则进行等待10ms再发送
         */
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);

        /**
         * 2.3序列化:Key+value
         */
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        /**
         * 封装到发消息的客户端中
         */
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);

生产者消费者实例

生产者代码

package com.wyh.kafka_demo.kafka;

import com.alibaba.fastjson.JSON;
import com.wyh.kafka_demo.pojo.Order;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;


public class MyProducer {
    /**
     * 1.创建主题
     */
    private final static String TOPIC_NAME="jqTopic5";

    public static void main(String[] args) throws InterruptedException {
        /**
         * 2.kafka的broker
         */
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"82.157.198.247:9092,82.157.198.247:9093");

        /**
         * 2.1发送消息持久化机制参数ack
         * 生产者会等3s，然后重试3次
         */
        properties.put(ProducerConfig.ACKS_CONFIG,"1");

        /**
         * 2.12重试间隔的设置
         * 默认间隔为100ms，次数为3次
         */
        properties.put(ProducerConfig.RETRIES_CONFIG,3);
        properties.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG,300);

        /**
         * 2.2设置消息的缓冲区
         * 消息先放到缓冲区，如果到16k就发送，未满足则进行等待10ms再发送
         */
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);

        /**
         * 2.3序列化:Key+value
         */
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        /**
         * 封装到发消息的客户端中
         */
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);

        /**
         * 3.模拟发送五条消息
         */
        int maxNum=5;
        final CountDownLatch countDownLatch = new CountDownLatch(maxNum);
        for (int i = 1; i <= 5; i++) {
            Order order = new Order((long) i, i);
            /**
             * 3.1消息记录发送给指定的分区
             * hash(key)%partition
             * ProducerRecord:消息记录
             * key:消息标识key，帮助告诉发送到哪个分许通过hash计算
             * value：json数据，消息内容
             */
            ProducerRecord<String, String> producerRecord = new ProducerRecord<>(TOPIC_NAME, order.getOrderId().toString(), JSON.toJSONString(order));

            /**
             * 3.2通过异步的形式发送消息
             */
            producer.send(producerRecord, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if(e!=null){
                        System.err.println("发送消息失败："+e.getStackTrace());
                    }
                    if(recordMetadata!=null){
                        System.out.println("异步发送的消息为："+"topic-"+recordMetadata.topic()
                                +"|partition-"+recordMetadata.partition()
                        +"|offset-"+recordMetadata.offset());
                    }
                    countDownLatch.countDown();
                }
            });
        }

        /**
         * 4.主线程等待countDownlatch
         */
        countDownLatch.await(5, TimeUnit.SECONDS);
        producer.close();
    }

}

消费者代码：

 

package com.wyh.kafka_demo.kafka;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Arrays;
import java.util.Properties;

public class MyConsumer {
    private final static String TOPIC_NAME="jqTopic5";
    private final static String CONSUMER_GROUP_NAME="testGroup";

    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"82.157.198.247:9092,82.157.198.247:9093");
        /**
         * 1.消费分组名
         */
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,CONSUMER_GROUP_NAME);
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"0");

        /**
         * 1.2设置序列化
         */
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());

        /**
         * 2.创建一个消费者的客户端
         */
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(properties);

        /**
         * 3.消费者订阅主题列表
         */
        consumer.subscribe(Arrays.asList(TOPIC_NAME));

        while(true){
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("收到的消息：partition= %d,offset= %d,key= %s,value=%s %n",record.partition(),
                        record.offset(),record.key(),record.value());
            }
        }
    }
}

Fairy要carry
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
kafka源码-消费者
weixin_45328923的博客
03-19 39
kafka消费者
Kafka利用Java实现数据的生产和消费实例教程
08-28
主要给大家介绍了关于Kafka利用Java实现数据的生产和消费的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。
Java实现Kafka生产者消费者代码实例
08-19
主要介绍了Java实现Kafka生产者消费者代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
kafka消息的生产和消费(java)
qq_43460095的博客
08-08 2460
KafkaProducer还提供了一个带超时时间的重载方法，如果使用这个重载方法，则只会等待指定的超时时间，如果超过了这个时间，即使还有消息未发送完成，也会强行退出。kafka消费消息是一个不断轮询的过程，在上面的代码中可以看出，消费者消费消息就是重复的调用。就是发后即忘，他只管发送消息，至于有没有发送成功不关心，这就有消息丢失的可能。有四个重载方法，可以以集合的方式或者正则表达式的方式来订阅主题。方法返回的则是所订阅的主题（分区）上的一组消息。不会只发送单条消息。在发送完所有的消息后，调用。...
Kafka06：【案例】Java操作Kafka：Java代码实现生产者代码、Java代码实现消费者代码、消费者代码扩展、Consumer消费offset查询
weixin_40612128的博客
03-13 4587
前面我们使用基于console的生产者和消费者对topic实现了数据的生产和消费，，这个基于控制台的生产者和消费者主要是让我们做测试用的。 在实际工作中，我们有时候需要将生产者和消费者功能集成到我们已有的系统中，此时就需要写代码实现生产者和消费者的逻辑了。 在这我们使用java代码来实现生产者和消费者的功能。 一、Java代码实现生产者代码 1、创建maven项目 先创建maven项目，db_kafka 2、添加依赖 添加kafka的maven依赖。 <dependency> <
kafka生产者和消费者的javaAPI的示例代码
08-27
主要介绍了kafka生产者和消费者的javaAPI的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【Kafka】Java实现数据的生产和消费
微信公众号: 后端码匠
01-05 4685
Kafka 是由Linkedin公司开发的，它是一个分布式的，支持多分区、多副本，基于 Zookeeper 的分布式消息流平台，它同时也是一款开源的。
java消费kafka代码
weixin_42605397的博客
02-10 238
下面是一个简单的 Java 代码，用于从 Apache Kafka 中消费数据： import org.apache.kafka.clients.consumer.ConsumerConfig; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.Cons...
kafka安装及java消费kafka
qq_47386653的博客
11-04 1648
kafka安装及java消费kafka
Kafka-java代码向kafka中输入和消费数据
weixin_48370579的博客
07-25 4023
Kafka-java 1. 在写代码前需要导入依赖 <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kafka</artifactId> <version...
Java整合Kafka实现生产及消费
二蛋的博客
12-02 3814
Java整合Kafka。生产者参数配置、消费参数配置、生产自定义分区策略、生产到指定分区、设置offset 根据时间戳获取 offset 指定从头开始消费 指定从某offset开始消费
kafka-java-demo 基于java的kafka生产消费者示例
11-24
kafka-java-demo 基于java的kafka生产消费者示例。 mvn
Java中与Kafka进行交互
最新发布
10-20
创建一个Properties对象，设置Kafka消费者的配置。这些配置包括Kafka服务器地址、主题名称、组ID等。 创建一个KafkaConsumer对象，并使用上一步中创建的Properties对象初始化它。 使用KafkaConsumer对象订阅主题并...
java消费kafka的数据
程序员s的博客
03-18 5442
<!--kafka依赖--> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> <dependency>...
使用Java代码实现实时消费kafka的消息
热门推荐
liuygvip的博客
11-03 1万+
首先maven构建开发项目，配置pom.xml文件   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">   4.0.0   om.cctsoft   kafkaTest   0.0.1-SNAPSHOT   ja
java代码消费kafka数据，并打成jar包，上传至服务器运行
dddddssssa的博客
11-12 881
java代码消费kafka数据，并打成jar包，上传至服务器运行 —>>> 消费者代码： package kafka.test; import java.util.Collections; import java.util.Properties; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; import
【项目实战】Java 开发 Kafka 消费者
激流丶的博客
07-14 6125
🔔 Kafka 消费者是使用 Apache Kafka 消息队列系统的应用程序，它们用于从 Kafka 主题（topics）中读取消息。消费者订阅一个或多个主题，并从这些主题中拉取消息以进行处理。消费者可以以不同的方式配置，例如，可以指定消息的偏移量（offset）以从特定位置开始消费消息，还可以指定消费者组（consumer group）以实现消息的分组消费。消费者是 Kafka 中的重要组成部分，用于实现可靠的消息传递和数据处理。
（转）Kafka 消费者 Java 实现
PacosonSWJTU的博客
11-09 7290
转自： Kafka 消费者 Java 实现 - 简书应用程序使用 KafkaConsumer向 Kafka 订阅 Topic 接收消息，首先理解 Kafka 中消费者（consumer）和消费者组（consumer group...https://www.jianshu.com/p/1f9e18e926f6据原文作者，以下内容总结自 《kafka权威指南》； 应用程序使用 KafkaConsumer向 Kafka 订阅 Topic 接收消息，首先理解 Kafka 中消费者（consumer）和消费者组（
java生产消费kafka消息
u010479989的博客
09-09 2688
通过java生产消费kafka消息
java实现消费kafka消息
08-16
要使用Java实现消费Kafka消息，你可以按照以下步骤进行操作： 1. 添加Kafka依赖：在你的项目中添加Kafka客户端的依赖。你可以在`pom.xml`文件中添加以下依赖： ```xml <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>2.8.0</version> </dependency> ``` 2. 创建Kafka消费者配置：创建一个`Properties`对象来配置Kafka消费者的属性，例如Kafka集群的地址、消费者组ID等。 ```java import java.util.Properties; public class KafkaConsumerConfig { public static Properties getConsumerProperties() { Properties props = new Properties(); props.put("bootstrap.servers", "<kafka服务器地址>"); props.put("group.id", "<消费者组ID>"); // 其他配置属性... return props; } } ``` 3. 创建消息消费者：使用上述配置创建一个Kafka消费者实例，并指定要订阅的主题。 ```java import org.apache.kafka.clients.consumer.Consumer; import org.apache.kafka.clients.consumer.ConsumerRecords; import org.apache.kafka.clients.consumer.KafkaConsumer; import java.time.Duration; import java.util.Collections; public class KafkaMessageConsumer { public static void main(String[] args) { // 获取消费者配置 Properties props = KafkaConsumerConfig.getConsumerProperties(); // 创建Kafka消费者实例 Consumer<String, String> consumer = new KafkaConsumer<>(props); // 订阅主题 consumer.subscribe(Collections.singletonList("<topic名称>")); // 消费消息 while (true) { ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100)); // 处理接收到的消息 records.forEach(record -> { System.out.println("Received message: " + record.value()); // 在这里编写具体的业务逻辑 }); } } } ``` 在上述代码中，我们创建了一个Kafka消费者实例，并订阅了指定的主题。然后，我们使用一个无限循环来持续地消费消息。每次调用`poll`方法从Kafka服务器拉取一批消息，然后遍历这些消息并进行处理。 注意：这只是一个简单的示例来展示如何使用Java消费Kafka消息。在实际的应用中，你可能需要考虑到更多的配置和异常处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Fairy要carry

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

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

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

打赏作者

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

抵扣说明：

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

余额充值