06.Java整合Kafka

最新推荐文章于 2024-07-24 16:37:05 发布
最新推荐文章于 2024-07-24 16:37:05 发布
阅读量446 收藏 1
点赞数 2
分类专栏： 消息队列——Kafka 文章标签： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43891622/article/details/109219615
版权

五种客户端

  1. Producer负责发送消息
  2. Consumer负责消费消息
  3. Streams高效的将输入流转换到输出流
  4. Connect从一些源系统或应用程序中拉取数据到Kafka
  5. Admin负责管理和检测Topic和broker以及其他Kafka对象
    在这里插入图片描述

依赖

<!--这个依赖包括Admin,producer,consumer客户端-->
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>2.4.1</version>
</dependency>

Admin客户端操作

创建AdminClient

 Properties properties = new Properties();
 properties.setProperty(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
 AdminClient adminClient = AdminClient.create(properties);

创建Topic


ArrayList<NewTopic> newTopics = new ArrayList<>();
Short sr = 1;
//参数1：Topic名称，参数2：分区数量，参数3：副本数量
newTopics.add(new NewTopic("shanguoyu", 1, sr));
//创建Topic
CreateTopicsResult topics = adminClient.createTopics(newTopics);

查看所有Topic信息

ListTopicsResult listTopicsResult = adminClient.listTopics();
//获取所有Topic的名称返回的是Future
KafkaFuture<Set<String>> names = listTopicsResult.names();
//打印出所有Topic的名称
names.get().forEach(System.out::println);

删除Topic

DeleteTopicsResult deleteTopicsResult = adminClient.deleteTopics(Arrays.asList("shanguoyu"));

查看Topic详情

DescribeTopicsResult describeTopics = adminClient.describeTopics(Arrays.asList("shanguoyu"));
Map<String, TopicDescription> stringTopicDescriptionMap = describeTopics.all().get();
stringTopicDescriptionMap.entrySet().forEach(System.out::println);

查看Topic配置信息

ConfigResource configResource = new ConfigResource(ConfigResource.Type.TOPIC, "shanguoyu");
DescribeConfigsResult describeConfigsResult = adminClient.describeConfigs(Arrays.asList(configResource));
Map<ConfigResource, Config> configResourceConfigMap = describeConfigsResult.all().get();
configResourceConfigMap.entrySet().forEach(System.out::println);

修改Topic配置信息

ConfigResource configResource = new ConfigResource(Type.TOPIC, "shanguoyu");
Config config = new Config(Arrays.asList(new ConfigEntry("preallocate", "true")));
Map<ConfigResource, Config> configResourceConfigMap = new HashMap<>();
configResourceConfigMap.put(configResource, config);
//新API对于单节点不友好
AlterConfigsResult alterConfigsResult = adminClient.alterConfigs(configResourceConfigMap);

增加分区

Map<String, NewPartitions> stringNewPartitionsMap=new HashMap<>();
NewPartitions newPartitions = NewPartitions.increaseTo(3);
stringNewPartitionsMap.put("shanguoyu",newPartitions );
CreatePartitionsResult partitions = adminClient.createPartitions(stringNewPartitionsMap);

Producer客户端操作

异步消息无callback

//构建连接参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
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");
//创建连接
try (Producer producer = new KafkaProducer<>(properties)) {
//创建消息对象
ProducerRecord<String, String> record = new ProducerRecord<String, String>("shanguoyu", "key", "value");
//发送消息
producer.send(record);
}

异步消息有callback

 //构建连接参数
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
        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");

        //创建连接
        try (Producer producer = new KafkaProducer<>(properties)) {
            //创建消息对象
            ProducerRecord<String, String> record = new ProducerRecord<String, String>("shanguoyu", "key", "value");
            //发送消息
            producer.send(record,(metadata,exception)->{
                System.out.println(metadata.partition());
                System.out.println(metadata.offset());
                System.out.println(metadata.topic());
            });
        }

自定义分区策略

     properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "cn.shanguoyu.kafka.kafkaapi.producer.PartitionerLB");

指定压缩算法

properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "gzip");

Consumer

自动提交offset的消费方式

  //构建连接参数
        Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
        //消费组ID
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "test");
        //自动提交 建议为false
        properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        //自动提交间隔
        properties.setProperty(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
        properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //创建消费者连接
        try (Consumer<String, String> consumer = new KafkaConsumer<>(properties)) {
            //订阅主题
            consumer.subscribe(Arrays.asList("shanguoyu"));
            while (true) {
                ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(10000));
                for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                    System.out.println("topic = " + consumerRecord.topic());
                    System.out.println("partition = " + consumerRecord.partition());
                    System.out.println("offset = " + consumerRecord.offset());
                    System.out.println("key = " + consumerRecord.key());
                    System.out.println("value = " + consumerRecord.value());
                    System.out.println("===============================================");
                }
            }
        }

手动提交offset的消费方式


  Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "test");
        //不自动提交
        properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
        properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //创建消费者连接
        try (Consumer<String, String> consumer = new KafkaConsumer<>(properties)) {
            //订阅主题
            consumer.subscribe(Arrays.asList("shanguoyu"));
            while (true) {
                ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(10000));
                for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                    System.out.println("topic = " + consumerRecord.topic());
                    System.out.println("partition = " + consumerRecord.partition());
                    System.out.println("offset = " + consumerRecord.offset());
                    System.out.println("key = " + consumerRecord.key());
                    System.out.println("value = " + consumerRecord.value());
                    System.out.println("===============================================");
                }
                //手动提交offset
                consumer.commitAsync();
            }
        }

按照分区获取记录并且每个分区提交一次offset

 Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "test");
        //不自动提交
        properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
        properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //创建消费者连接
        try (Consumer<String, String> consumer = new KafkaConsumer<>(properties)) {
            //订阅主题
            consumer.subscribe(Arrays.asList("shanguoyu"));
            while (true) {
                //获取所有记录
                ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(10000));
                //获取所有分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历分区
                for (TopicPartition partition : partitions) {
                    //按照分区获取记录
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    records.forEach(record -> {
                        System.out.println("topic = " + record.topic());
                        System.out.println("partition = " + record.partition());
                        System.out.println("offset = " + record.offset());
                        System.out.println("key = " + record.key());
                        System.out.println("value = " + record.value());
                    });
                    Map<TopicPartition, OffsetAndMetadata> offsetAndMetadataMap = new HashMap<>();
                    //获取当前分区中最后一个记录的offset
                    long offset = records.get(records.size() - 1).offset();
                    offsetAndMetadataMap.put(partition, new OffsetAndMetadata(offset + 1));
                    consumer.commitSync(offsetAndMetadataMap);
                }
            }
        }

手动提交offset并订阅某个Topic下的分区

  Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "test");
        //不自动提交
        properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
        properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //创建消费者连接
        try (Consumer<String, String> consumer = new KafkaConsumer<>(properties)) {
            TopicPartition p0=new TopicPartition("shanguoyu",0 );
            TopicPartition p1=new TopicPartition("shanguoyu",1 );
            TopicPartition p2=new TopicPartition("shanguoyu",2 );
            //只订阅0分区
            consumer.assign(Arrays.asList(p0));
            while (true) {
                //获取所有记录
                ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(10000));
                //获取所有分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历分区
                for (TopicPartition partition : partitions) {
                    //按照分区获取记录
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    records.forEach(record -> {
                        System.out.println("topic = " + record.topic());
                        System.out.println("partition = " + record.partition());
                        System.out.println("offset = " + record.offset());
                        System.out.println("key = " + record.key());
                        System.out.println("value = " + record.value());
                        System.out.println("=================================");
                    });
                    Map<TopicPartition, OffsetAndMetadata> offsetAndMetadataMap = new HashMap<>();
                    //获取当前分区中最后一个记录的offset
                    long offset = records.get(records.size() - 1).offset();
                    offsetAndMetadataMap.put(partition, new OffsetAndMetadata(offset + 1));
                    consumer.commitSync(offsetAndMetadataMap);

                }
            }
        }

手动指定Consumer Offset位置及手动提交

 Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.17.99:9092");
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "test");
        //不自动提交
        properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
        properties.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        //创建消费者连接
        try (Consumer<String, String> consumer = new KafkaConsumer<>(properties)) {
            TopicPartition p0=new TopicPartition("shanguoyu",0 );
            TopicPartition p1=new TopicPartition("shanguoyu",1 );
            TopicPartition p2=new TopicPartition("shanguoyu",2 );
            //只订阅0分区
            consumer.assign(Arrays.asList(p0));
            //指定分区的偏移量
            consumer.seek(p0, 0);
            while (true) {
                //获取所有记录
                ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(10000));
                //获取所有分区
                Set<TopicPartition> partitions = consumerRecords.partitions();
                //遍历分区
                for (TopicPartition partition : partitions) {
                    //按照分区获取记录
                    List<ConsumerRecord<String, String>> records = consumerRecords.records(partition);
                    records.forEach(record -> {
                        System.out.println("topic = " + record.topic());
                        System.out.println("partition = " + record.partition());
                        System.out.println("offset = " + record.offset());
                        System.out.println("key = " + record.key());
                        System.out.println("value = " + record.value());
                        System.out.println("=================================");
                    });
                    Map<TopicPartition, OffsetAndMetadata> offsetAndMetadataMap = new HashMap<>();
                    //获取当前分区中最后一个记录的offset
                    long offset = records.get(records.size() - 1).offset();
                    offsetAndMetadataMap.put(partition, new OffsetAndMetadata(offset + 1));
                    consumer.commitSync(offsetAndMetadataMap);
                }
            }
        }
asadsfasfasdfas
关注
专栏目录
kafka：java集成 kafka(springboot集成、客户端集成)
积水成多，水到渠成
03-13 5567
对于java的kafka集成，一般选用springboot集成kafka，但可能由于对接方kafka老旧、kafka不安全等问题导致kafak版本与spring版本不兼容，这个时候就得自己根据kafka客户端api集成了。
java集成kafka实战
Forrest Gump的博客
06-14 1373
java集成kafka
安装配置Kafka，并使用Java集成Kafka
最新发布
m0_73799407的博客
07-24 1819
Kafka 是Java 语言编写的，因此需要在安装 Kafka 之前先安装 Java 运行环境。Kafka 支持 Java 8 及以上版本。可以通过以下命令检查 Java 运行环境的版本Kafka 的运⾏环境依赖于 ZooKeeper，Kafka 使用 ZooKeeper 进行分布式协调，因此在安装 Kafka 之前，需要先安装 ZooKeeper。
Kafka学习----Java整合Kafka_生产者
https://juejin.cn/user/4248168663101239/posts
07-03 385
Java整合Kafka_生产者一. 消息发送流程二. Java整合Kafka_生产者①. 导入依赖②. 开启Kafka集群③. 异步发送消息，不带回调函数的生产者④. 异步发送消息，带回调函数的生产者⑤. 同步发送消息_生产者⑥. 自定义分区⑦. 生产者使用自定义分区⑧. 总结分区的三种规则测试 一. 消息发送流程 Kafka 的 Producer 发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程，以及一个线程共享变量—RecordAccumu
kafka实战
weixin_30614109的博客
11-08 5661
1. kafka介绍 1.1. 主要功能 根据官网的介绍，ApacheKafka®是一个分布式流媒体平台，它主要有3种功能： 　　1：It lets you publish and subscribe to streams of records.发布和订阅消息流，这个功能类似于消息队列，这也是kafka归类为消息队列框架的原因 　　2：It lets ...
普通java项目集成kafka
weixin_46254728的博客
03-02 2790
前言 现在假设一种需求，我方业务系统要与某服务平台通过kafka交互，异步获取服务，而系统架构可能老旧，不是spring cloud桶，不是spring boot，只是java普通项目或者 java web项目，那么没有boot来干苦力，集成kafka所有需要的功能都需要自己封装 ...
java集成kafka依赖包怎么导入_SpringBoot Kafka 整合集成 示例教程
weixin_34213766的博客
02-27 1379
1、使用IDEA新建工程，创建工程 springboot-kafka-producer工程pom.xml文件添加如下依赖：org.springframework.kafkaspring-kafkacom.google.code.gsongson2.8.5org.projectlomboklombok1.16.22provided2、创建kafka配置类，KafkaProducerConfigpac...
在java代码中使用kafka(springboot整合kafka)
jerry764的博客
09-06 8690
java代码maven项目实现kafka的连接及生产者、消费者的创建，以及消息的发布和订阅
Springboot2.x集成kafka2.2.0
Jack 架构师之路
05-15 7230
【引言】 kafka近几年更新非常快，也可以看出kafka在企业中是用的频率越来越高，在springboot中集成kafka还是比较简单的，但是应该注意使用的版本和kafka中基本配置，这个地方需要信心，防止进入坑中。 【基本环境】 springboot版本2.1.4 kafka版本2.2.0 jdk 1.8 【代码编写】 1、基本引用pom ...
Java实现Spark整合Kafka和Hbase实战案例
m0_46383004的博客
03-22 1012
** Java实现SparkCore整合Kafka和Hbase实战案例 Kafka作为当下最主流的具有消峰和缓存功能的分布式消息队列，被广泛应用于大数据领域，而目前比较主流的流计算消费方式主要包括Strom，SparkStreaming，以及Flink。 下面就关于Spark整合kafka做简要介绍。 在spark1.3版本后，SparkStreaming可以使用kafkaUtils工具类里的Ka...
【Java】SpringBoot快速整合Kafka
m0_64210833的博客
12-25 5455
Kafka是一个开源的流式平台，用于构建实时数据流应用程序和实时数据管道。Kafka旨在处理大规模的数据流，具有高吞吐量、可扩展性、持久性和容错性的特点。
Spring纯Java配置集成kafka代码实例
08-25
主要介绍了Spring纯Java配置集成kafka代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java——spring boot集成kafka——kafka介绍以及概念理解
小白龙白龙马的博客
03-04 130
首先，让我们来看一下基础的消息(Message)相关术语： 名称解释 Broker 消息中间件处理节点，⼀个Kafka节点就是⼀个broker，⼀个或者多个Broker可以组成⼀个Kafka集群 Topic Kafka根据topic对消息进⾏归类，发布到Kafka集群的每条消息都需要指定⼀个topic Producer 消息⽣产者，向Broker发送消息的客户端 ...
消息队列——kafka——java集成与操作
LSY_CSDN_的博客
12-14 2007
目录 一、java集成kafka: 1、所需环境： 2、引入jar包： 3、创建基础Properties： （1）单机kafka的基础Properties： （2）集群kafka的基础Properties： 4、创建生产者公共参数Properties： 5、创建消费者公共参数Properties： 二、Java操作kafka： 1、创建topic： 2、查看所有topic： ...
Kafka入门(5) -- Java编程操作Kafka
erainm
09-15 1315
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
qq_58137891的博客
11-21 1155
【代码】【Kafka】Java整合Kafka。
java 集成kafka（支持单条消费和批量消费）
Java_Destiny的博客
04-23 5294
1、下载安装zk，kafka...（大把教程，不在这里过多阐述）8、测试类分别测试单条消费以及批量消费。7、消费者配置类（配置批量消费）5、生产者发消息的工具类。
java中整合kafka_springboot整合kafka，收发javaBean
weixin_42554162的博客
02-27 685
上午不想上班，把周六整的kafka贴出来。看网上搜不出来几篇好用的，供大家参考参考。 哇哈哈…spring和kafka整合 并没有什么starter项目。 使用的是spring-kafka。如果是在spring-cloud里使用kafka的话，可以使用spring-cloud-stream。这里我用的是springboot+dubbo，而且项目都是单个的，就直接使用spring-kafka了。由于...
java整合kafka connect
12-01
Java整合Kafka Connect的步骤如下： 1.首先，在Java项目中添加Kafka Connect的依赖，例如Maven项目可以在pom.xml文件中添加以下依赖： xml <groupId>org.apache.kafka <artifactId>connect-runtime <version>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值