Kafka 3.0 分区、Kraft模式、整合Flink、整合SpringBoot

已于 2022-09-19 16:02:08 修改
阅读量496 收藏
点赞数
分类专栏： 消息队列和缓存 文章标签： kafka java 大数据 flink
于 2022-08-19 16:15:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44350137/article/details/126418004
版权

目录

kafka分区副本调整策略

先创建一个主题
在这里插入图片描述

更改分区
在这里插入图片描述
原先分区副本有1、2、3
在这里插入图片描述

输入以下计划

{

        "version":1,
        "partitions":[
                        {
                        "topic":"three","partition":0,"replicas":[2,1]
                        },
                        {
                        "topic":"three","partition":1,"replicas":[2,1]
                        },
                        {
                        "topic":"three","partition":2,"replicas":[1,2]
                        },
                        {
                        "topic":"three","partition":3,"replicas":[1,2]
                        }


                        ]
}

执行计划

kafka-reassign-partitions.sh --bootstrap-server master:9092 --reassignment-json-file increase-replication-factor.json --execute

现分区副本 只有1、2
在这里插入图片描述

增加副本数

不能通过命令行的方式，只能执行计划

{
	"version":1,
	"partitions":
		[
			{
				"topic":"four","partition":1,"replicas":[3,1,2]
			},
			{
				"topic":"four","partition":2,"replicas":[3,1,2]
			},
			{
				"topic":"four","partition":3,"replicas":[3,1,2]
			}

		]


}

执行计划

主题文件存储位置

在这里插入图片描述
通过工具可以查看，否则是序列化后的

kafka-run-class.sh kafka.tools.DumpLogSegments --files 00000000000000000000.log

kafka消费者

两种消费方式：

pull 模式

pull 模式是kafka采用的，注意：如果kafka没有数据，那么consumer可能回陷入循环，一直返回空数据

push 模式

API方式消费


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.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class CustomConsumer {
    public static void main(String[] args) {
        //配置文件
        Properties prop = new Properties();
        //连接集群
        prop.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.10.101:9092,192.168.10.102:9092");
        //反序列化
        prop.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        prop.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //配置groupid
        prop.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //创建一个消费者
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(prop);
        //订阅主题
        List<String> topics = new ArrayList<>();
        topics.add("first");
        kafkaConsumer.subscribe(topics);
        //消费数据
        while (true){
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(Duration.ofSeconds(1));
            for (ConsumerRecord<String, String> record : poll) {
                System.out.println("key:"+record.key()+"\t"+"value:"+record.value());
                System.out.println();
            }
        }
    }
}

消费指定分区

		List<TopicPartition> topics = new ArrayList<>();
        topics.add(new TopicPartition("first",0));
        kafkaConsumer.assign(topics);

指定分区分配策略

        //指定分区策略
        prop.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, RoundRobinAssignor.class.getName());

offset设置

  		//自动提交offset
        prop.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,true);
        //设置时间间隔
        prop.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,1000);

手动提交

 		//手动提交offset
        prop.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);

			
			
        //消费数据
        while (true){
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(Duration.ofSeconds(1));
            for (ConsumerRecord<String, String> record : poll) {
                System.out.println("key:"+record.key()+"\t"+"value:"+record.value());
                System.out.println();
            }
            //手动提交offset，在拉取完数据后，异步
            kafkaConsumer.commitAsync();
            //同步提交
            kafkaConsumer.commitSync();
        }

从指定offset开始

   		  //在指定位置进行消费之前需要保证分区分配方案以及指定完毕
        Set<TopicPartition> assignment = kafkaConsumer.assignment();
        while (assignment.size()==0){
            kafkaConsumer.poll(Duration.ofSeconds(1));
            assignment = kafkaConsumer.assignment();
        }
        //指定位置进行消费
        for (TopicPartition topicPartition : assignment) {
            kafkaConsumer.seek(topicPartition,1000);
        }

按照时间开始

  //在指定位置进行消费之前需要保证分区分配方案以及指定完毕
        Set<TopicPartition> assignment = kafkaConsumer.assignment();
        while (assignment.size()==0){
            kafkaConsumer.poll(Duration.ofSeconds(1));
            assignment = kafkaConsumer.assignment();
        }

        //把时间转换成offset
        Map<TopicPartition, Long> map = new HashMap<>();
        //封装对应的集合
        for (TopicPartition topicPartition : assignment) {
            map.put(topicPartition,System.currentTimeMillis()-1*24_3600*24);
        }
        Map<TopicPartition, OffsetAndTimestamp> offsetAndTimestampMap = kafkaConsumer.offsetsForTimes(map);

        //指定位置进行消费
        for (TopicPartition topicPartition : assignment) {
            OffsetAndTimestamp timestamp = offsetAndTimestampMap.get(topicPartition);
            kafkaConsumer.seek(topicPartition,timestamp.offset());
        }

Kraft 模式

在config目录下还有一个目录kraft
在这里插入图片描述

打开server.properties

在这里插入图片描述
其中process.roles 表示承担的角色,

node.id 和broke.id 类似

controller.quorum.voters 表示集群地址

在这里插入图片描述
表示对外端口

在这里插入图片描述

日志文件存储位置,其实也是数据存储位置

启动kafka
首先初始化
生成一个uuid
bin/kafka-storage.sh random-uuid

在这里插入图片描述

格式化

bin/kafka-storage.sh format -t mjWD2tpuRranR4SyjRPOXA -c /opt/soft/kafka2/config/kraft/server.properties

启动

bin/kafka-server-start.sh -daemon config/kraft/server.properties

Kafka整合Flink

生产者


import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class FlinkKafka {
    public static void main(String[] args) throws Exception {
        //获取环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);
        //准备数据源
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("hadoop");
        list.add("java");
        list.add("flink");
        DataStreamSource<String> streamSource = env.fromCollection(list);
        //创建一个kafka生产者
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.10.101:9092,192.168.102:9092");
        FlinkKafkaProducer<String> kafkaProducer = new FlinkKafkaProducer<>("first", new SimpleStringSchema(), properties);


        //添加数据源
        streamSource.addSink(kafkaProducer);

        //执行代码
        env.execute();
    }
}
消费者


import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;


import java.util.Properties;

public class FlinkKafkaConsumer1 {
    public static void main(String[] args) throws Exception {
        //获取环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //创建一个kafka消费者
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.10.101:9092,192.168.102:9092,192.168.103:9092");
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test1");
        FlinkKafkaConsumer<String> kafkaProducer = new FlinkKafkaConsumer<>("five", new SimpleStringSchema(), properties);
        //关联
        env.addSource(kafkaProducer).print();
        //执行代码
        env.execute();
    }
}

kafka整合SpringBoot

生产者

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class KafkaController {

    @Autowired
    KafkaTemplate<String,String> kafka;

    @GetMapping("/kafka")
    public String data(String msg){
        kafka.send("five",msg);
        return "ok";
    }

}


spring:
  kafka:
    bootstrap-servers: 192.168.10.101:9092,192.168.10.102:9092,192.168.10.103:9092
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      group-id: test1

消费者

import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.annotation.KafkaListeners;

@Configuration
public class KafkaConsumer {

    @KafkaListener(topics = {"five"})
    public void kafkaListener(String msg){
        System.out.println("收到kafka消息:"+msg);
    }
}

kafka调优

布丁味的博客:https://blog.csdn.net/wang5g/article/details/124777990

weixin_44350137
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kafka KRaft模式探索
csdn_manong1的博客
10-25 1388
Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。其核心组件包含Producer、Broker、Consumer，以及依赖的Zookeeper集群。其中Zookeeper集群是Kafka用来负责集群元数据的管理、控制器的选举等。
Kafka3.0学习—外部系统集成
yunweijie_cn的博客
05-05 1468
Kafka3.0学习—外部系统集成一、集成Flume1.Flume生产者2.Flume消费者 一、集成Flume Flume经常和Kafka一起使用，即可以作为生产者将数据发送到Kafka中，也可以作为消费者从Kafka中获取数据。 1.Flume生产者 场景： 使用Flume监控Linux某个文件夹下的文件，然后将监控到的数据发送到Kafka中。 这里最主要的就是Flume的配置： # 1 组件定义 a1.sources = r1 a1.sinks = k1 a1.channels = c1 # 2
SpringBoot集成kafka全面实战
bll1992的博客
04-02 123
https://blog.csdn.net/yuanlong122716/article/details/105160545/?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_baidulandingword-0&spm=1001.2101.3001.4242
springboot集成整合kafka-自定义分区策略、将消息发送到指定的分区partition
FAIRYTAIL的博客
11-19 8412
写在前面：各位看到此博客的小伙伴，如有不对的地方请及时通过私信我或者评论此博客的方式指出，以免误人子弟。多谢！ kafka中每个topic可定义多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？上一篇我们已经通过这种方式：@KafkaListener(topics = {"mytopic"},topicPartitions = {@TopicPartition(topic = "mytopic",partitions = {"1","3"})})实现了只消费指定分区的消息，但并没有实.
在Spring Boot微服务集成Kafka客户端(spring-kafka)操作Kafka
zhangbeizhen18的博客
06-17 4165
记录：457 场景：在Spring Boot微服务集成Kafka客户端spring-kafka-2.8.2操作Kafka。使用Spring封装的KafkaTemplate操作Kafka生产者Producer。使用Spring封装的@KafkaListener操作Kafka的消费者Consumer。
springboot整合kafka简单使用
qq_62408075的博客
08-09 219
docker-compose安装kafka，docker-compose.yml文件如下只需要替换KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://192.168.208.139:9094的ip为自己的ip即可启动 docker-compose up -d启动成功后访问浏览器ip换成自己的，时间可能会有点久才会出现如下页面添加集群信息。
SpringBoot整合kafka，代码简洁，自动分配分区和指定分区消费(亲测可用)
04-24
总结，SpringBoot整合Kafka可以简化消息中间件的使用，通过Spring提供的API和注解，我们可以轻松地实现消息的生产和消费，同时支持自定义分区策略。这使得在实际项目中处理实时数据流变得更加便捷。
springboot整合kafka相关讲解
04-14
SpringBoot整合Kafka是现代微服务架构中常见的一种技术组合，Kafka作为一个高效、可扩展的分布式消息中间件，能够处理大规模实时数据流。在Spring Boot框架中集成Kafka，可以方便地构建出高可用、高性能的数据处理...
SpringBoot Kafka 整合使用及安装教程
08-25
SpringBoot Kafka 整合使用及安装教程 SpringBoot Kafka 整合使用及安装教程是将 SpringBoot 和 Kafka 两个技术栈进行整合，实现消息队列的处理。本文将详细介绍 SpringBoot Kafka 的整合使用及安装教程，包括项目...
kafka最新版本3.1.0版本安装（使用zookeeper及使用kraft）两种安装及日常维护命令，kafka 3.0
05-11
在 Kafka 3.0 版本中引入了 KRaft 模式，这标志着 Kafka 可以不再依赖于 Zookeeper 进行集群管理。本指南将详细介绍如何在 Kafka 3.1.0 中使用 Zookeeper 和 KRaft 模式进行安装，并提供日常维护所需的命令。 **一...
springboot整合kafka，指定分区发送，批量消费，指定topic分区消费
09-26
在本文中，我们将深入探讨如何在Spring Boot 2.x应用程序中整合Apache Kafka，重点是实现指定分区发送、批量消费以及指定topic分区消费的功能。Apache Kafka是一个分布式流处理平台，广泛用于构建实时数据管道和流...
SpringBoot集成Kafka详解
最新发布
qq_20865839的博客
10-20 1万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。其路由机制为：1.若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；
springboot整合kafka案例demo
qq_35911118的博客
11-26 1269
afka是需要zk来支持.所以先下载zk 1.下载安装zookeeper 下载地址 https://zookeeper.apache.org/releases.html 选择不带source的 下载下来解压2次 进入到 D:\zookeeper\apache-zookeeper-3.6.1-bin\conf 目录下,把zoo_sample.cfg重命名成zoo.cfg 修改zoo.cfg 会在这里生成数据文件 添加ZK环境变量 ZK到此配置完成.可以启动ZK了 或者打开cmd 输入zkser
在Spring Boot微服务集成Kafka客户端(kafka-clients)操作Kafka
zhangbeizhen18的博客
06-17 4423
记录：459 场景：在Spring Boot微服务集成Kafka客户端kafka-clients-3.0.0操作Kafka。使用kafka-clients的原生KafkaProducer操作Kafka生产者Producer。使用kafka-clients的原生KafkaConsumer操作Kafka的消费者Consumer。
SpringBoot - Kafka的集成与使用详解 (消费者)
m0_37695902的博客
03-13 3345
SpringBoot - Kafka的集成与使用详解 (消费者)
SpringBoot集成Kafka的简单实现案列
wgy_BUG的博客
06-21 1308
通过zookeeper的协调机制，生产者保存相应主题的broker信息，可以随机或轮询的方式发送给broker;4.1，首先引入kafka的template就像redis一样首相要有一个template才可继续，如果是自定义配置类也可以引入配置类进行操作，kafka目前做数据分析，聚合，采集，流处理用的比较多所以明白了他的吞吐量为什么大了吗。rabbitMQ支持miror的，当主出现故障时，miror接管。他就是主题名通过主题名找到对应的主题进行消息消费，也有分组的组名。，以制片人、经纪人和消费者为中心。
SpringBoot3集成Kafka
m0_71777195的博客
08-19 244
Kafka是一个开源的分布式事件流平台，常被用于高性能数据管道、流分析、数据集成和关键任务应用，基于Zookeeper协调的处理平台，也是一种消息系统，具有更好的吞吐量、内置分区、复制和容错，这使得它成为大规模消息处理应用程序的一个很好的解决方案；
Kafka原理详解
Dragon的博客
05-30 627
目录 Kafka是什么？ 消息系统分类 Peer-to-Peer (Queue) Publish/Subscribe（Topic） 常用消息系统对比 Kafka介绍 Kafka架构简介 主题和日志 Distribution(分布) Geo-Replication(地域复制) Producers(生产者) Consumers(消费者) Consumer Group Guarantees(担保) Kafka是什么？ Kafka是Apache旗下的一款分布式流媒体平台，Kafka
springboot 集成kafka 3.0
08-20
对于Spring Boot集成Kafka 3.0，你可以按照以下步骤操作： 1. 添加Kafka依赖：在你的Spring Boot项目的`pom.xml`文件中，添加`spring-kafka`依赖。 ```xml <groupId>org.springframework.kafka <artifactId>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值