【大数据学习 | kafka】kafka的偏移量管理

1. 偏移量的概念

消费者在消费数据的时候需要将消费的记录存储到一个位置，防止因为消费者程序宕机而引起断点消费数据丢失问题，下一次可以按照相应的位置从kafka中找寻数据，这个消费位置记录称之为偏移量offset。

kafka0.9以前版本将偏移量信息记录到zookeeper中

新版本中偏移量信息记录在__consumer_offsets中，这个topic是系统生成的，不仅仅帮助管理偏移量信息还能分配consumer给哪个coordinator管理，是一个非常重要的topic

它的记录方式和我们知道的记录方式一样 groupid + topic + partition ==> offset

其中存储到__consumer_offsets中的数据格式也是按照k-v进行存储的，其中k是groupid + topic + partition
value值为offset的偏移量信息。

[hexuan@hadoop106 ~]$ kafka-topics.sh --bootstrap-server hadoop106:9092 --list
__consumer_offsets
topic_a
topic_b
topic_c
topic_e
topic_f
topic_g

可以看到系统生成的topic

因为之前我们消费过很多数据，现在可以查看一下记录在这个topic中的偏移量信息

其中存在一个kafka-consumer-groups.sh 命令

# 查看消费者组信息
kafka-consumer-groups.sh --bootstrap-server hadoop106:9092 --list
# 查询具体信息
kafka-consumer-groups.sh --bootstrap-server hadoop106:9092 --describe --group my-group
# 查看活跃信息
kafka-consumer-groups.sh --bootstrap-server hadoop106:9092 --describe --group my-group --members

查看消费者组信息：

[hexuan@hadoop106 ~]$ kafka-consumer-groups.sh --bootstrap-server hadoop106:9092 --list
hainiu_group
hainiu_group2

当前使用组信息：

[hexuan@hadoop106 ~]$ kafka-consumer-groups.sh --bootstrap-server hadoop106:9092 --describe --group hainiu_group

GROUP           TOPIC           PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG             CONSUMER-ID                                                  HOST            CLIENT-ID
hainiu_group    topic_c         0          0               0               0               consumer-hainiu_group-1-41a9ebd6-99a3-4d83-b1d7-88a2a9295054 /192.168.154.1  consumer-hainiu_group-1
hainiu_group    topic_b         1          1438            1438            0               -                                                            -               -
hainiu_group    topic_b         0          1440            1440            0               -                                                            -               -
hainiu_group    topic_b         3          1417            1417            0               -                                                            -               -
hainiu_group    topic_b         4          1473            1473            0               -                                                            -               -
hainiu_group    topic_b         5          1440            1440            0               -                                                            -               -
hainiu_group    topic_b         2          1407            1407            0               -                                                            -               -
hainiu_group    topic_b         6          1391            1391            0               -

当前组消费偏移量信息：

GROUP：组名 
TOPIC：topic信息           
PARTITION：分区  
CURRENT-OFFSET：当前消费偏移量  
LOG-END-OFFSET：这个分区总共存在多少数据  
LAG：还差多少没消费             
CONSUMER-ID：随机消费者id                                                  
HOST：主机名            
CLIENT-ID：客户端id

同时我们也可以查询__consumer_offset中的原生数据：

kafka-console-consumer.sh  --bootstrap-server hadoop106:9092 \
--topic __consumer_offsets --from-beginning --formatter \
kafka.coordinator.group.GroupMetadataManager\$OffsetsMessageFormatter

使用元数据格式化方式查看偏移量信息数据

key展示的是groupid,topic,partition ,  value值展示的是当前的偏移量信息

并且在这个topic中是追加形式一致往里面写入的

2. 偏移量的自动管理

那么我们已经看到了偏移量的存储但是偏移量究竟是怎么提交的呢？

首先我们没有设置任何的偏移量提交的代码，这个是默认开启的，其中存在两个参数

pro.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, true);
//开启自动提交偏移量信息
pro.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 5000);
//默认提交间隔5s

官网的设置参数为两个true和5000。

所以我们在没有开启默认提交的时候已经自动提交了

为了演示自动提交的效果我们引入一个参数

auto.offset.reset

这个参数用于控制没有偏移量存储的时候，应该从什么位置进行消费数据

（因为偏移量自动提交默认是5秒一次，如果数据在5秒内消费完毕，则会造成偏移量并没有存储的情况）

其中参数值官网中给出三个

[latest, earliest, none]

latest:从最新位置消费

earliest：最早位置消费数据

none：如果不指定消费的偏移量直接报错

一定要记得一点，如果有偏移量信息那么以上的设置是无效的.

官方文档显示给出的该参数的默认值为lastest，即从最新位置开始消费。

现在我们设置读取位置为最早位置，并且消费数据，看看可不可以记录偏移量，断点续传

思路：

首先修改组id为一个新的组，然后从最早位置消费数据，如果记录了偏移量，那么重新启动消费者会看到，没有任何数据，因为之前记录了消费数据的位置

整体代码如下：

package com.hainiu.kafka;

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.*;

public class Consumer1 {
    public static void main(String[] args) {
        Properties pro = new Properties();
        pro.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"nn1:9092");
        pro.put(ConsumerConfig.GROUP_ID_CONFIG,"new_group");
        pro.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, true);
        pro.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        pro.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 5000);

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(pro);
        List<String> topics = Arrays.asList("topic_d","topic_e");
        consumer.subscribe(topics);

        while (true){
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));
            Iterator<ConsumerRecord<String, String>> it = records.iterator();
            while(it.hasNext()){
                ConsumerRecord<String, String> record = it.next();
                System.out.println(record.topic()+"->"+record.partition()+"->"+ record.offset()+"->"+record.key()+"->"+record.value());
            }
        }
    }
}

运行完毕打印数据

这个时候我们需要在5s之内关闭应用，然后重新启动，因为提交的间隔时间是5s

再次启动

我们发现数据依旧被消费出来了，证明之前的偏移量存储没有任何效果和作用，因为间隔时间是5s

现在我们等待5s后在关闭应用

发现没有任何数据产生，因为偏移量已经提交了

3. 偏移量的手动提交

如上的案例我们发现偏移量的管理如果交给系统自己管理，我们没有办法及时的修改和管理偏移量信息，这个时候我们需要手动来提交给管理偏移量，更加及时和方便

这个时候引入两个方法

consumer.commitAsync();
consumer.commitSync();

commitAsync 异步提交方式：只提交一次，不管成功与否不会重试

commitSync 同步提交方式：同步提交方式会一直提交到成功为止

一般我们都会选择异步提交方式，他们的功能都是将拉取到的一整批数据的最大偏移量直接提交到__consumer_offsets中，但是同步方式会很浪费资源，异步方式虽然不能保证稳定性但是我们的偏移量是一直递增存储的，所以偶尔提交不成功一个两个不影响我们的使用

 pro.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
//设定自动提交为false
consumer.commitSync();
consumer.commitAsync();
//设定提交方式为手动提交

整体代码如下：

package com.hainiu.kafka.consumer;

/**
 * ClassName : consumer_offsets
 * Package : com.hainiu.kafka.consumer
 * Description
 *
 * @Author HeXua
 * @Create 2024/11/5 21:30
 * Version 1.0
 */

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.*;

public class Consumer_CommitSync {
    public static void main(String[] args) {
        Properties pro = new Properties();
        pro.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop106:9092");
        pro.put(ConsumerConfig.GROUP_ID_CONFIG,"hainiu_group2");
        pro.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        pro.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
//        pro.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 5000);

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(pro);
        List<String> topics = Arrays.asList("topic_h");
        consumer.subscribe(topics);

        while (true){
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));
            Iterator<ConsumerRecord<String, String>> it = records.iterator();
            while(it.hasNext()){
                ConsumerRecord<String, String> record = it.next();
                System.out.println(record.topic()+"->"+record.partition()+"->"+ record.offset()+"->"+record.key()+"->"+record.value());
            }
            consumer.commitAsync();
//            consumer.commitSync();
        }
    }
}

现在先在topic中输入部分数据

然后启动消费者，当存在数据打印的时候马上关闭掉应用，在此启动会发现数据不会重新消费

topic_h->5->12->null->1
topic_h->5->13->null->2
topic_h->5->14->null->3
topic_h->5->15->null->4
topic_h->5->16->null->5
topic_h->5->17->null->6

偏移量已经提交不会重复消费数据

4. 断点消费数据

在没有偏移量的时候我们可以设定

auto.offset.reset进行数据的消费

可选参数有 latest earliest none等位置

但是如果存在偏移量以上的设定就不在好用了，我们需要根据偏移量的位置进行断点消费数据

但是有的时候我们需要指定位置消费相应的数据

这个时候我们需要使用到

consumer.seek();
//可以指定位置进行数据的检索

但是我们不能随意的指定消费者消费数据的位置，因为在启动消费者的时候，一个组中会存在多个消费者，每个人拿到的对应分区是不同的，所以我们需要知道这个消费者能够获取的分区是哪个，然后再指定相应的断点位置

这里我们就需要监控分区的方法展示出来所有订阅的分区信息

 consumer.subscribe(topics, new ConsumerRebalanceListener() {
            @Override
            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {

            }

            @Override
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {

            }
        });

为了演示效果我们使用生产者在topic_d中增加多个消息

package com.hainiu.kafka.consumer;

/**
 * ClassName : Producer2
 * Package : com.hainiu.kafka.consumer
 * Description
 *
 * @Author HeXua
 * @Create 2024/11/5 23:01
 * Version 1.0
 */
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class Producer2 {
    public static void main(String[] args) {
        Properties pro = new Properties();
        pro.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop106:9092");
        pro.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        pro.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(pro);
        for (int i = 0; i < 1000; i++) {
            ProducerRecord<String, String> record = new ProducerRecord<String, String>("topic_d", "" + i, "message"+i);
            producer.send(record);
        }
        producer.close();
    }
}

随机发送数据到不同的节点，使用随机key

然后使用断点消费数据

不设置任何的偏移量提交操作和断点位置

package com.hainiu.kafka.consumer;

/**
 * ClassName : ConsumerWithUDOffset
 * Package : com.hainiu.kafka.consumer
 * Description
 *
 * @Author HeXua
 * @Create 2024/11/5 23:03
 * Version 1.0
 */
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.*;

public class ConsumerWithUDOffset {
    public static void main(String[] args) {
        Properties pro = new Properties();
        pro.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop106:9092");
        pro.put(ConsumerConfig.GROUP_ID_CONFIG,"new1");
        pro.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
        pro.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG,6000);
        pro.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(pro);
        List<String> topics = Arrays.asList("topic_h");
        // range roundRobin sticky cooperativeSticky
        consumer.subscribe(topics, new ConsumerRebalanceListener() {
            @Override
            public void onPartitionsRevoked(Collection<TopicPartition> collection) {

            }

            @Override
            public void onPartitionsAssigned(Collection<TopicPartition> collection) {
                for (TopicPartition topicPartition : collection) {
                    consumer.seek(topicPartition,195);
                }
            }
        });

        while (true){
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));
            Iterator<ConsumerRecord<String, String>> it = records.iterator();
            while(it.hasNext()){
                ConsumerRecord<String, String> record = it.next();
                System.out.println(record.topic()+"->"+record.partition()+"->"+ record.offset()+"->"+record.key()+"->"+record.value());
            }
            consumer.commitAsync();
        }
    }
}

5. 时间断点

kafka没有给大家提供直接根据时间找到断点位置的方法，我们需要根据时间找到偏移量，然后根据偏移量进行数据消费

consumer.offsetsForTimes();
//通过这个方法找到对应时间的偏移量位置
consumer.seek();
//然后在通过这个方法根据断点进行消费数据

整体代码如下

package com.hainiu.kafka;

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.*;

public class Consumer1 {
    public static void main(String[] args) {
        Properties pro = new Properties();
        pro.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"nn1:9092");
        pro.put(ConsumerConfig.GROUP_ID_CONFIG,"new_group221");
        pro.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        pro.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(pro);
        List<String> topics = Arrays.asList("topic_e");
        consumer.subscribe(topics, new ConsumerRebalanceListener() {
            @Override
            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
                // no op
            }

            @Override
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                HashMap<TopicPartition, Long> map = new HashMap<>();
                for (TopicPartition partition : partitions) {
                    map.put(partition,1675076400000L);
                    //将时间和分区绑定在一起，然后合并在一起放入到检索方法中
                }
                Map<TopicPartition, OffsetAndTimestamp> offsets = consumer.offsetsForTimes(map);
                //根据时间获取时间对应的偏移量位置
                for (Map.Entry<TopicPartition, OffsetAndTimestamp> en : offsets.entrySet()) {
                    System.out.println(en.getKey()+"-->"+en.getValue());
                    if(en.getValue() != null){
                        consumer.seek(en.getKey(),en.getValue().offset());
                        //获取每个分区的偏移量的位置，使用seek进行找寻数据
                    }
                }

            }
        });

        while (true){
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));
            Iterator<ConsumerRecord<String, String>> it = records.iterator();
            while(it.hasNext()){
                ConsumerRecord<String, String> record = it.next();
                System.out.println(record.topic()+"->"+record.partition()+"->"+ record.offset()+"->"+record.key()+"->"+record.value());
            }
//            consumer.commitAsync();
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/909646.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

迪杰斯特拉算法

迪杰斯特拉算法

迪杰斯特拉算法 LeetCode 743. 网络延迟时间 https://blog.csdn.net/xiaoxi_hahaha/article/details/110257368 import sysdef dijkstra(graph, source):"""dijkstra算法:param graph: 邻接矩阵:param source: 出发点&#xff0c;源点:return:""&…
阅读更多...
[Unity Demo]从零开始制作空洞骑士Hollow Knight第十八集补充：制作空洞骑士独有的EventSystem和InputModule

[Unity Demo]从零开始制作空洞骑士Hollow Knight第十八集补充：制作空洞骑士独有的EventSystem和InputModule

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、制作空洞骑士独有的EventSystem和InputModule总结 前言 hello大家好久没见&#xff0c;之所以隔了这么久才更新并不是因为我又放弃了这个项目&#xff0c;而…
阅读更多...
K8S群集调度二

K8S群集调度二

一、污点(Taint) 和 容忍(Tolerations) 1.1、污点(Taint) 设置在node上是对pod的一种作用 节点的亲和性&#xff0c;是Pod的一种属性&#xff08;偏好或硬性要求&#xff09;&#xff0c;它使Pod被吸引到一类特定的节点 而Taint 则相反&#xff0c;它使节点能够排斥一类特…
阅读更多...
MySQL45讲 第十六讲 “order by”是怎么工作的？

MySQL45讲 第十六讲 “order by”是怎么工作的？

文章目录 MySQL45讲 第十六讲 “order by”是怎么工作的&#xff1f;一、引言二、全字段排序&#xff08;一&#xff09;索引创建与执行情况分析&#xff08;二&#xff09;执行流程&#xff08;三&#xff09;查看是否使用临时文件 三、rowid 排序&#xff08;一&#xff09;参…
阅读更多...
HTML 基础标签——结构化标签＜html＞、＜head＞、＜body＞

HTML 基础标签——结构化标签＜html＞、＜head＞、＜body＞

文章目录 1. <html> 标签2. <head> 标签3. <body> 标签4. <div> 标签5. <span> 标签小结 在 HTML 文档中&#xff0c;使用特定的结构标签可以有效地组织和管理网页内容。这些标签不仅有助于浏览器正确解析和渲染页面&#xff0c;还能提高网页的可…
阅读更多...
【原创】java+ssm+mysql电费管理系统设计与实现

【原创】java+ssm+mysql电费管理系统设计与实现

个人主页&#xff1a;程序猿小小杨 个人简介&#xff1a;从事开发多年&#xff0c;Java、Php、Python、前端开发均有涉猎 博客内容&#xff1a;Java项目实战、项目演示、技术分享 文末有作者名片&#xff0c;希望和大家一起共同进步&#xff0c;你只管努力&#xff0c;剩下的交…
阅读更多...
浅谈QT中Tab键的切换逻辑

浅谈QT中Tab键的切换逻辑

浅谈QT中Tab键的切换逻辑 无意中发现在输入界面中按下Tab键时&#xff0c;没有按照预想的顺序切换焦点事件&#xff0c;如下图所示 这个现象还是很有趣&#xff0c;仔细观察了下&#xff0c;默认的切换顺序是按照控件拖入顺序&#xff0c;那么知道了这个问题想要解决起来就很简…
阅读更多...
Linux系统编程学习 NO.10——进程的概念（1）

Linux系统编程学习 NO.10——进程的概念（1）

前言 本篇文章主要了解进程的概念。 #j 冯诺依曼体系结构 什么是冯诺依曼体系结构&#xff1f; 冯诺伊曼体系结构是计算机体系结构的一种经典范式&#xff0c;由计算机科学家约翰冯诺伊曼&#xff08;John von Neumann&#xff09;提出。该体系结构在计算机设计中起到了重要…
阅读更多...
如何查看局域网内的浏览记录？总结五种方法，按步操作！一学就会！「管理小白须知」

如何查看局域网内的浏览记录？总结五种方法，按步操作！一学就会！「管理小白须知」

如何查看局域网内的浏览记录&#xff1f; 你是否也曾为如何有效监控局域网内的浏览记录而苦恼&#xff1f; 监控局域网内电脑的浏览记录是确保员工工作效率、维护网络安全以及规范上网行为的重要手段。 别担心&#xff0c;今天我们就来聊聊这个话题&#xff0c;为你揭秘五种简…
阅读更多...
室内场景建筑构成和常见物品识别图像分割系统：完整教学

室内场景建筑构成和常见物品识别图像分割系统：完整教学

室内场景建筑构成和常见物品识别图像分割系统源码&#xff06;数据集分享 [yolov8-seg-p6&#xff06;yolov8-seg-fasternet等50全套改进创新点发刊_一键训练教程_Web前端展示] 1.研究背景与意义 项目参考ILSVRC ImageNet Large Scale Visual Recognition Challenge 项目来…
阅读更多...
前端vue3若依框架pnpm run dev启动报错

前端vue3若依框架pnpm run dev启动报错

今天前端vue3若依框架pnpm run dev启动报错信息&#xff1a; > ruoyi3.8.8 dev D:\AYunShe\2024-11-6【无锡出门证】\wuxi-exit-permit-web > vite error when starting dev server: Error: listen EACCES: permission denied 0.0.0.0:80 at Server.setupListenHand…
阅读更多...
nacos — 动态路由

nacos — 动态路由

Nacos 是一个阿里巴巴开源的服务注册中心&#xff0c;广泛用于微服务架构中。它除了支持服务注册和配置管理外&#xff0c;还可以配合网关实现动态路由。动态路由能够根据配置的实时更新动态调整路由规则&#xff0c;避免应用重启&#xff0c;实现路由的灵活管理。 网关的路由…
阅读更多...
排序 （插入/选择排序）

排序 （插入/选择排序）

目录 一 . 排序概念及运用 1.1 排序的概念 1.2 排序的应用 1.3 常见的排序算法 二 . 插入排序 2.1 直接插入排序 2.1 复杂度分析 2.3 希尔排序 2.4 希尔排序时间复杂度分析 三 . 选择排序 3.1 直接选择排序 3.2 堆排序 一 . 排序概念及运用 1.1 排序的概念 排序 : 所…
阅读更多...
Unity网络开发基础（part5.网络协议）

Unity网络开发基础（part5.网络协议）

目录 前言 网络协议概述 OSI模型 OSI模型的规则 第一部分 物理层 数据链路层 网络层 传输层 第二部分 ​编辑 应用层 表示层 会话层 每层的职能 TCP/IP协议 TCP/IP协议的规则 TCP/IP协议每层的职能 TCP/IP协议中的重要协议 TCP协议 三次握手 四次挥手 U…
阅读更多...
框架学习01-Spring

框架学习01-Spring

一、Spring框架概述 Spring是一个开源的轻量级Java开发框架&#xff0c;它的主要目的是为了简化企业级应用程序的开发。它提供了一系列的功能&#xff0c;包括控制反转&#xff08;IOC&#xff09;、注入&#xff08;DI&#xff09;、面向切面编程&#xff08;AOP&#xff09;…
阅读更多...
Late Chunking×Milvus：如何提高RAG准确率

Late Chunking×Milvus：如何提高RAG准确率

01. 背景 在RAG应用开发中&#xff0c;第一步就是对于文档进行chunking&#xff08;分块&#xff09;&#xff0c;高效的文档分块&#xff0c;可以有效的提高后续的召回内容的准确性。而对于如何高效的分块是个讨论的热点&#xff0c;有诸如固定大小分块&#xff0c;随机大小分…
阅读更多...
【深度学习】InstantIR：图片高清化修复

【深度学习】InstantIR：图片高清化修复

InstantIR——借助即时生成参考的盲图像修复新方法 作者：Jen-Yuan Huang 等 近年来，随着深度学习和计算机视觉技术的飞速发展，图像修复技术取得了令人瞩目的进步。然而，对于未知或复杂退化的图像进行修复，仍然是一个充满挑战的任务。针对这一难题，研究者们提出了 Insta…
阅读更多...
qt获取本机IP和定位

qt获取本机IP和定位

前言&#xff1a; 在写一个天气预报模块时&#xff0c;需要一个定位功能&#xff0c;在网上翻来翻去才找着&#xff0c;放在这里留着回顾下&#xff0c;也帮下有需要的人 正文&#xff1a; 一开始我想着直接调用百度地图的API来定位&#xff0c; 然后我就想先获取本机IP的方…
阅读更多...
(C++回溯算法)微信小程序“开局托儿所”游戏

(C++回溯算法)微信小程序“开局托儿所”游戏

问题描述 给定一个矩阵 A ( a i j ) m n \bm A(a_{ij})_{m\times n} A(aij​)mn​&#xff0c;其中 a i j ∈ { 1 , 2 , ⋯ , 9 } a_{ij}\in\{1,2,\cdots,9\} aij​∈{1,2,⋯,9}&#xff0c;且满足 ∑ i 1 m ∑ j 1 n a i j \sum\limits_{i1}^m\sum\limits_{j1}^na_{ij} i…
阅读更多...
数字隔离器与光隔离器有何不同？---腾恩科技

数字隔离器与光隔离器有何不同？---腾恩科技

在电子隔离中&#xff0c;两种常用的解决方案是数字隔离器和光学隔离器。两者都旨在电气隔离电路的各个部分&#xff0c;以保护敏感元件免受高压干扰&#xff0c;但它们通过不同的技术实现这一目标。本文探讨了这些隔离器之间的差异&#xff0c;重点介绍了它们的工作原理、优势…
阅读更多...
最新文章

Copyright @ 2022~2023