Kafka--05---java客户端代码实现

已于 2023-12-12 23:16:07 修改
阅读量588 收藏
点赞数
分类专栏： MQ消息队列 文章标签： kafka java 分布式
于 2021-12-26 23:55:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48052161/article/details/122153815
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

java客户端-⽣产者的实现

依赖

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

1. ⽣产者的基本实现

  1. 设置参数-----Properties
  2. 创建⽣产消息的客户端 ----KafkaProducer
  3. 创建消息-----key：作⽤是决定了往哪个分区上发，value：具体要发送的消息内容
  4. 发送消息,得到消息发送的元数据并输出
package com.cy.kafka;

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

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

public class MySimpleProducer {
    private final static String TOPIC_NAME = "my-replicated-topic";

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.设置参数
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "172.16.253.38:9092,172.16.253.38:9093,172.16.253.38:9094");
        //把发送的key从字符串序列化为字节数组
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //把发送消息value从字符串序列化为字节数组
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());


        //2.创建⽣产消息的客户端，传⼊参数
        Producer<String, String> producer = new KafkaProducer<String, String>(props);


        //3.创建消息
        //key：作⽤是决定了往哪个分区上发，value：具体要发送的消息内容
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(TOPIC_NAME, 1,"mykeyvalue", "hellokafka");


        //4.发送消息,得到消息发送的元数据并输出
        RecordMetadata metadata = producer.send(producerRecord).get();

        System.out.println("同步⽅式发送消息结果：" + "topic-" + metadata.topic() + "|partition-" + metadata.partition() + "|offset-" + metadata.offset());
    }
}

在这里插入图片描述

发送消息到指定分区上

newProducerRecord<String, String>(TOPIC_NAME, 0,
order.getOrderId().toString(), 
JSON.toJSONString(order));

ProducerRecord

  • topic, partition. key, value
    在这里插入图片描述
未指定分区，则会通过业务key的hash运算，算出消息往哪个分区上发
new ProducerRecord<String, String>(TOPIC_NAME
, order.getOrderId().toString(), JSON.toJSONString(order));

2.⽣产者的----同步发送消息

⽣产者同步发消息，在收到kafka的ack告知发送成功之前⼀直处于阻塞状态
  • 如果⽣产者发送消息没有收到ack，⽣产者会阻塞，阻塞到3s的时间，如果还没有收到消息， 会进⾏重试。重试的次数3次。

在这里插入图片描述

在这里插入图片描述

3. ⽣产者的----异步发送消息

⽣产者发消息，发送完后不⽤等待broker给回复，直接执⾏下⾯的业务逻辑
  • broker在收到消息后异步调⽤⽣产者提供的callback回调⽅法。
package com.cy.kafka;

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

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

public class MySimpleProducer2 {
    private final static String TOPIC_NAME = "my-replicated-topic";

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.设置参数
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "172.16.253.38:9092,172.16.253.38:9093,172.16.253.38:9094");
        //把发送的key从字符串序列化为字节数组
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //把发送消息value从字符串序列化为字节数组
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());


        //2.创建⽣产消息的客户端，传⼊参数
        Producer<String, String> producer = new KafkaProducer<String, String>(props);


        //3.创建消息
        //key：作⽤是决定了往哪个分区上发，value：具体要发送的消息内容
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(TOPIC_NAME, 1,"mykeyvalue", "hellokafka");


        //4.异步发送消息
        producer.send(producerRecord, new Callback() {
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if (exception != null) {
                    System.err.println("发送消息失败：" +
                            exception.getStackTrace());
                }
                if (metadata != null) {
                    System.out.println("异步⽅式发送消息结果：" + "topic-" + metadata.topic() + "|partition-" + metadata.partition() + "|offset-" + metadata.offset());
                }
            }
        });

    }
}

在这里插入图片描述

4.⽣产者中相关配置-----ProducerConfig

在这里插入图片描述

props.put(ProducerConfig.ACKS_CONFIG, "1");
/*
发送失败会重试，默认重试间隔100ms，重试能保证消息发送的可靠性，但是也可能造
成消息重复发送，⽐如⽹络抖动，所以需要在
接收者那边做好消息接收的幂等性处理
*/
props.put(ProducerConfig.RETRIES_CONFIG, 3);
//重试间隔设置
props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 300);
//kafka默认会创建⼀个消息缓冲区，⽤来存放要发送的消息，缓冲区是32m
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
//kafka本地线程会去缓冲区中⼀次拉16k的数据，发送到broker
props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
//如果线程拉不到16k的数据，间隔10ms也会将已拉到的数据发到broker
props.put(ProducerConfig.LINGER_MS_CONFIG, 10);

ack的配置

在同步发送的前提下，⽣产者在获得集群返回的ack之前会⼀直阻塞。那么集群什么时候返回
ack呢？此时ack有3个配置：

  • ack = 0 kafka-cluster不需要任何的broker收到消息，就⽴即返回ack给⽣产者，最容易
    丢消息的，效率是最⾼的
  • ack=1（默认）： 多副本之间的leader已经收到消息，并把消息写⼊到本地的log中，才
    会返回ack给⽣产者，性能和安全性是最均衡的
  • ack=-1/all。⾥⾯有默认的配置min.insync.replicas=2(默认为1，推荐配置⼤于等于2)，
    此时就需要leader和⼀个follower同步完后，才会返回ack给⽣产者（此时集群中有2个
    broker已完成数据的接收），这种⽅式最安全，但性能最差。
    在这里插入图片描述
    下⾯是关于ack和重试（如果没有收到ack，就开启重试）的配置
props.put(ProducerConfig.ACKS_CONFIG, "1");
/*
发送失败会重试，默认重试间隔100ms，重试能保证消息发送的可靠性，但是也可能造
成消息重复发送，⽐如⽹络抖动，所以需要在
接收者那边做好消息接收的幂等性处理
*/
props.put(ProducerConfig.RETRIES_CONFIG, 3);
//重试间隔设置
props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 300);

5. 关于消息发送的缓冲区

在这里插入图片描述

  • kafka默认会创建⼀个消息缓冲区，⽤来存放要发送的消息，缓冲区是32m
  • kafka本地线程会去缓冲区中⼀次拉16k的数据，发送到broker
  • 如果线程拉不到16k的数据，间隔10ms也会将已拉到的数据发到broker
//kafka默认会创建⼀个消息缓冲区，⽤来存放要发送的消息，缓冲区是32m
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
//kafka本地线程会去缓冲区中⼀次拉16k的数据，发送到broker
props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
//如果线程拉不到16k的数据，间隔10ms也会将已拉到的数据发到broker
props.put(ProducerConfig.LINGER_MS_CONFIG, 10);

java客户端-消费者的实现

1.消费者的基本实现

  1. 设置参数-----Properties
  2. 创建⼀个消费者的客户端------KafkaConsumer
  3. 消费者订阅主题列表-------- consumer.subscribe()
  4. 拉取消息的⻓轮询---------- consumer.poll()
  5. 打印消息
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 MySimpleConsumer {
    private final static String TOPIC_NAME = "my-replicated-topic";
    private final static String CONSUMER_GROUP_NAME = "testGroup";

    public static void main(String[] args) {
        //设置参数-----Properties
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "172.16.253.38:9092,172.16.253.38:9093,172.16.253.38:9094");
        // 消费分组名
        props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_NAME);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());

        //1.创建⼀个消费者的客户端
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);

        //2. 消费者订阅主题列表
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        while (true) {

            // 3.poll() API 是拉取消息的⻓轮询
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
            for (ConsumerRecord<String, String> record : records) {

                //4.打印消息
                System.out.printf("收到消息：partition = %d,offset = %d, key = %s, value = %s%n", record.partition(),
                        record.offset(), record.key(), record.value());
            }
        }
    }
}

在这里插入图片描述

ConsumerRecord

  • record.partition()
  • record.offset()
  • record.key(),
  • record.value()
    在这里插入图片描述

2.⾃动提交和⼿动提交offset

在这里插入图片描述

1）提交的内容

  • 消费者⽆论是⾃动提交还是⼿动提交，都需要把所属的消费组+消费的某个主题+消费的某个分区及消费的偏移量，这样的信息提交到集群的_consumer_offsets主题⾥⾯。

2）提交的位置
在这里插入图片描述

⾃动提交

  • 消费者poll消息下来以后就会⾃动提交offset
// 是否⾃动提交offset，默认就是true
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
// ⾃动提交offset的间隔时间
props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
  • 注意：⾃动提交可能会丢消息。因为消费者在消费前提交offset，有可能提交完后还没消费时消费者挂了。

⼿动提交

  • 需要把⾃动提交的配置改成false
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");

⼿动提交⼜分成了两种：

1）⼿动同步提交

  • 在消费完消息后调⽤同步提交的⽅法，当集群返回ack前⼀直阻塞，返回ack后表示提交 成功，执⾏之后的逻辑
        // poll() API 是拉取消息的⻓轮询
        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());
            }

            //所有的消息已消费完
            if (records.count() > 0) {//有消息
                // ⼿动同步提交offset，当前线程会阻塞直到offset提交成功
                // ⼀般使⽤同步提交，因为提交之后⼀般也没有什么逻辑代码了
                consumer.commitSync();//=======阻塞=== 提交成功
            }
        }

2）⼿动异步提交

  • 在消息消费完后提交，不需要等到集群ack，直接执⾏之后的逻辑，可以设置⼀个回调⽅
    法，供集群调⽤
        // poll() API 是拉取消息的⻓轮询
        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());
            }

            //所有的消息已消费完
            if (records.count() > 0) {
 
                // ⼿动异步提交offset，当前线程提交offset不会阻塞，可以继续处理后⾯的程序逻辑
                consumer.commitAsync(new OffsetCommitCallback() {
                    @Override
                    public void onComplete(Map<TopicPartition,
                                                OffsetAndMetadata> offsets, Exception exception) {
                        if (exception != null) {
                            System.err.println("Commit failed for " + offsets);
                            System.err.println("Commit failed exception: " + exception.getStackTrace());
                        }

                    }
                });
            }
        }

3.⻓轮询poll消息

  • 默认情况下，消费者⼀次会poll500条消息。
//⼀次poll最⼤拉取消息的条数，可以根据消费速度的快慢来设置
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 500);
  • 代码中设置了⻓轮询的时间是1000毫秒
        while (true) {

            // 3.poll() API 是拉取消息的⻓轮询
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
            for (ConsumerRecord<String, String> record : records) {

                //4.打印消息
                System.out.printf("收到消息：partition = %d,offset = %d, key = %s, value = %s%n", record.partition(),
                        record.offset(), record.key(), record.value());
            }
        }

意味着：

  • 如果⼀次poll到500条，就直接执⾏for循环
  • 如果这⼀次没有poll到500条。且时间在1秒内，那么⻓轮询继续poll，要么到500 条，要么到1s
  • 如果多次poll都没达到500条，且1秒时间到了，那么直接执⾏for循环

如果两次poll的间隔超过30s，集群会认为该消费者的消费能⼒过弱，该消费者被踢出消费组，触发rebalance机制，rebalance机制会造成性能开销。可以通过设置这个参数，让⼀次poll的消息条数少⼀点

//⼀次poll最⼤拉取消息的条数，可以根据消费速度的快慢来设置
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 500);
//如果两次poll的时间如果超出了30s的时间间隔，kafka会认为其消费能⼒过弱，将其踢
//出消费组。将分区分配给其他消费者。-rebalance
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 30 * 1000);

4.消费者的健康状态检查

消费者每隔1s向kafka集群发送⼼跳，集群发现如果有超过10s没有续约的消费者，将被踢出消费组，触发该消费组的rebalance机制，将该分区交给消费组⾥的其他消费者进⾏消费。

//consumer给broker发送⼼跳的间隔时间
props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 1000);
//kafka如果超过10秒没有收到消费者的⼼跳，则会把消费者踢出消费组，进⾏rebalance，把分区分配给其他消费者。
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10 * 1000);

5.指定分区和偏移量

  • 指定分区消费
consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME, 0)));
  • 从头消费
consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME, 0)));
consumer.seekToBeginning(Arrays.asList(new TopicPartition(TOPIC_NAME,0)));
  • 指定offset消费
consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME, 0)));
consumer.seek(new TopicPartition(TOPIC_NAME, 0), 10);

在这里插入图片描述

在这里插入图片描述

6. 指定时间消费

  • 根据时间，去所有的partition中确定该时间对应的offset，然后去所有的partition中找到该
    offset之后的消息开始消费。

在这里插入图片描述

7.新消费组的消费offset规则

新消费组中的消费者在启动以后，默认会从当前分区的最后⼀条消息的offset+1开始消费（消费新消息）。

可以通过以下的设置，让新的消费者第⼀次从头开始消费。之后开始消费新消息（最后消费的位置的偏移量+1）

  • Latest:默认的，消费新消息
  • earliest：第⼀次从头开始消费。之后开始消费新消息（最后消费的位置的偏移量+1）
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
知行合一。。。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kafka使用Java客户端进行访问的示例代码
08-29
本篇文章主要介绍了Kafka使用Java客户端进行访问的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java客户端实现Kafka的生产者消费者模式
lcgoing的博客
12-04 611
kafka的设计中依赖了zookeeper，zookeeper是为了解决分布式一致性问题的工具，用作去中心化的集群模式。 网上概念说的很多了，很全也很好，话不多说，直接上代码。 一.导入依赖 之前看maven库里有两种依赖kafka-clients和kafka_2.11，经过一番查询才知道，kafka-clients比kafka_2.11依赖的jar少，对于消费者没有低版本api与低版本ap...
最全Java对接kafka简单示例_java 连接kafka，又到一年金三银四
最新发布
2401_84023482的博客
05-13 1646
架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？有思考过这个问题吗？// 创建Kafka生产者。// 设置Kafka配置。// 设置Kafka配置。
kafka java_Kafka JAVA客户端代码示例
weixin_30349167的博客
02-12 146
介绍http://kafka.apache.orgkafka是一种高吞吐量的分布式发布订阅消息系统kafka是linkedin用于日志处理的分布式消息队列，linkedin的日志数据容量大，但对可靠性要求不高，其日志数据主要包括用户行为(登录、浏览、点击、分享、喜欢)以及系统运行日志(CPU、内存、磁盘、网络、系统及进程状态)当前很多的消息队列服务提供可靠交付保证，并默认是即时消费(不适合离线)。...
kafka Kafka JAVA客户端代码示例
An342647823的专栏
12-16 1692
转载：http://my.oschina.net/cloudcoder/blog/299215 感谢！ 介绍      http://kafka.apache.org      kafka是一种高吞吐量的分布式发布订阅消息系统      kafka是linkedin用于日志处理的分布式消息队列，linkedin的日志数据容量大，但对可靠性要求不高，其日志数据主要包括用户行为（登录
kafka java代码_kafka的Java客户端示例代码(kafka_2.11-0.8.2.2)
weixin_36397509的博客
02-16 249
packagecn.ljh.kafka.kafka_helloworld;importkafka.api.FetchRequest;importkafka.api.FetchRequestBuilder;importkafka.api.PartitionOffsetRequestInfo;importkafka.cluster.BrokerEndPoint;importkafka.common.E...
kafka-manager
01-08
Kafka-Manager是针对Apache Kafka设计的一款Web客户端工具，主要用于简化Kafka集群的管理和监控。在本文中，我们将深入探讨Kafka-Manager的功能、使用方法以及它如何提升Kafka操作的效率。 首先，Kafka是一种分布式...
kafka-streams-scala：Kafka Streams Java API周围的Thin Scala包装器
02-05
Kafka Streams 提供了一个客户端库，可以直接在应用中运行，无需独立的流处理集群。通过 `kafka-streams-scala`，Scala 开发者可以利用其简洁、强大的语法特性来构建复杂的流处理管道。 首先，我们来看 `kafka-...
kafka-java-demo 基于java的kafka生产消费者示例
11-24
在Maven的pom.xml文件中，你需要添加Kafka的Java客户端依赖，以便项目可以编译和运行Kafka相关的代码。 【Kafka的其他特性】 除了基本的生产和消费功能，Kafka还支持一些高级特性，如幂等性生产者、事务性消费者、...
csv-kafka-json:一个简单的Java程序以JSON格式将CSV文件发送到Kafka主题
05-26
3. Kafka Java Producer API：Apache Kafka提供的Java客户端库，用于编写Kafka生产者，将消息发送到主题。 4. Maven或Gradle：作为构建工具，帮助管理项目的依赖关系和构建流程。 在运行程序时，用户可能需要修改...
kafka-java-app
02-23
项目没有提供具体的详细信息，但我们可以假设它涉及设计、实现和维护一个Java客户端，该客户端能够与Kafka集群交互，例如发布、订阅消息，或者执行更复杂的数据处理任务。 【标签】"Java" 明确指出该项目是用Java...
Kafka JAVA客户端代码示例--高级应用
weixin_34128501的博客
05-13 131
什么时间使用高级应用？ 针对一个消息读取多次 在一个process中，仅仅处理一个topic中的一组partitions 使用事务，确保每个消息只被处理一次 使用高级应用（调用较底层函数）的缺点？ SimpleConsumer需要做很多额外的工作（在以groups方式进行消息处理时不需要） 在应用程序中跟踪上次消息处理的offset 确定...
Kafka 使用java实现，快速入门
Qynwang的博客
05-10 8253
【代码】Kafka 集成 SpringBoot， 快速入门。
Java代码操作Kafka
凉茶铺的博客
12-04 2045
介绍了使用JavaAPI以及SpringBoot方式操作kafka
通过Java操作Kafka
weixin_45565886的博客
11-11 4529
通过Java操作Kafka
Java编程操作Kafka
qq_63431773的博客
01-06 575
接下来，我们将编写Java程序，将1-100的数字消息写入到Kafka中。导入Maven Kafka POM依赖创建KafkaProducerTest类。可以参考以下方式来编写第一个Kafka示例程序1.创建用于连接Kafka的Properties配置2.创建一个生产者对象KafkaProducer3.调用send发送1-100消息到指定Topic test，并获取返回值Future，该对象封装了返回值4.再调用一个Future.get()方法等待响应5.关闭生产者。
Kafka入门(5) -- Java编程操作Kafka
erainm
09-15 1260
1. 同步生产消息到Kafka中 1.1 需求 接下来，我们将编写Java程序，将1-100的数字消息写入到Kafka中。 1.2 开发步骤 导入Maven Kafka POM依赖 使用以下方式来编写第一个Kafka示例程序 参考以下文档：参考文档 创建用于连接Kafka的Properties配置 创建一个生产者对象 发送消息到指定 Topic 关闭生产者 参考代码： /** * 生产者程序：将1-100的数字消息写入到Kafka中 */ public class _1ProducerTest
Kafka-java代码向kafka中输入和消费数据
weixin_48370579的博客
07-25 4125
Kafka-java 1. 在写代码前需要导入依赖 <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kafka</artifactId> <version...
kafka java代码编写
xiao__miao的博客
06-09 944
上篇，我介绍了如何搭建kafka，但在如何使用kafka上，还没做过去但介绍，大多人都是写改main方法去发送和接受，但我们实际业务肯定不是这样但。我们公司是以一种方式，类似一直启动main然后接受消息的。这里我也还没去具体了解，之后我会再看看，了解之后可能会再写一篇文章出来。 kafka启动之后，需要创建topic和partitions，java代码只能帮你传递消息和接受消息，这创建topic
kafka-java统计kafka消息转发量
11-12
为了统计Kafka消息的转发量，可以使用Kafka的Java客户端API来编写一个消费者应用程序。以下是实现此目的的步骤： 1.创建一个Kafka消费者对象，指定要消费的主题和Kafka集群的地址。 2.在消费者对象上调用subscribe...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值