SpringBoot 3.2.0 结合Redisson接入Redis

依赖版本

  • JDK 17
  • Spring Boot 3.2.0
  • Redisson 3.25.0

工程源码：Gitee

集成Redis步骤

导入依赖

<properties><redisson.version>3.25.0</redisson.version>
</properties>
<dependencies><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.redisson</groupId><artifactId>redisson-spring-boot-starter</artifactId><version>${redisson.version}</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>
</dependencies>

编写配置文件

# application.yml
spring:# ======== Redis配置 ========redis:redisson:file: classpath:redisson.yaml

# redisson.yaml
​
# 编码。默认值: org.redisson.codec.JsonJacksonCodec
codec: !<org.redisson.codec.Kryo5Codec> {}
# 线程池数量。默认值: 当前处理核数量 * 2
threads: 16
# Netty线程池数量。默认值: 当前处理核数量 * 2
nettyThreads: 32
# 传输模式。默认值: NIO
transportMode: "NIO"
# 监控锁的看门狗超时，单位：毫秒。默认值: 30000
lockWatchdogTimeout: 30000
# 是否保持订阅发布顺序。默认值: true
keepPubSubOrder: true
​
# Redisson 单实例配置
singleServerConfig:# 节点地址。格式：redis://host:portaddress: "redis://127.0.0.1:6379"# 密码。默认值: nullpassword: null# 数据库编号。默认值: 0database: 0# 客户端名称（在Redis节点里显示的客户端名称）。默认值: nullclientName: null# 连接超时，单位：毫秒。默认值: 10000connectTimeout: 10000# 命令等待超时，单位：毫秒。默认值: 3000timeout: 3000# 命令失败重试次数。默认值: 3retryAttempts: 3# 命令重试发送时间间隔，单位：毫秒。默认值: 1500retryInterval: 1500# 最小空闲连接数。默认值: 32connectionMinimumIdleSize: 24# 连接池大小。默认值: 64connectionPoolSize: 64# 单个连接最大订阅数量。默认值: 5subscriptionsPerConnection: 5# 发布和订阅连接的最小空闲连接数。默认值: 1subscriptionConnectionMinimumIdleSize: 1# 发布和订阅连接池大小。默认值: 50subscriptionConnectionPoolSize: 50# DNS监测时间间隔，单位：毫秒。默认值: 5000dnsMonitoringInterval: 5000# 连接空闲超时，单位：毫秒。默认值: 10000idleConnectionTimeout: 10000

编写Redis操作工具

import lombok.RequiredArgsConstructor;
import org.redisson.api.RAtomicDouble;
import org.redisson.api.RAtomicLong;
import org.redisson.api.RBucket;
import org.redisson.api.RList;
import org.redisson.api.RMap;
import org.redisson.api.RScoredSortedSet;
import org.redisson.api.RSet;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
​
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
​
/*** Redis工具类*/
@Component
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class RedisService {
​private final RedissonClient redissonClient;
​// ============================= String类型操作 ============================
​/*** 将值存储到Redis中** @param key   键* @param value 值*/public <T> void setString(String key, T value) {RBucket<T> bucket = redissonClient.getBucket(key);bucket.set(value);}
​/*** 将值存储到Redis中** @param key      键* @param value    值* @param timeout  过期时间* @param timeUnit 时间单位*/public <T> void setString(String key, T value, long timeout, TimeUnit timeUnit) {RBucket<T> bucket = redissonClient.getBucket(key);bucket.set(value, timeout, timeUnit);}
​/*** 根据键获取Redis中的值** @param key 键* @return 值*/public <T> T getString(String key) {RBucket<T> bucket = redissonClient.getBucket(key);return bucket.get();}
​// ============================= Hash类型操作 ============================
​/*** 将值存储到Redis中** @param key   键* @param field hash键* @param value 值*/public <T> boolean addToHash(String key, Object field, T value) {RMap<Object, T> hash = redissonClient.getMap(key);return hash.fastPut(field, value);}
​/*** 将值存储到Redis中** @param key      键* @param field    hash键* @param value    值* @param timeout  过期时间* @param timeUnit 时间单位*/public <T> boolean addToHash(String key, Object field, T value, long timeout, ChronoUnit timeUnit) {RMap<Object, T> hash = redissonClient.getMap(key);boolean fastPut = hash.fastPut(field, value);boolean expire = hash.expire(Instant.now().plus(timeout, timeUnit));return fastPut && expire;}
​/*** 根据键和Hash键获取Redis中的值** @param key   键* @param field hash键* @return 值*/public <T> T getFromHash(String key, Object field) {RMap<Object, T> hash = redissonClient.getMap(key);return hash.get(field);}
​/*** 根据键获取Redis中的值** @param key 键* @return 值*/public <T> Map<Object, T> getFromHash(String key) {RMap<Object, T> hash = redissonClient.getMap(key);return hash.readAllMap();}
​/*** 根据键和Hash键更新Redis中的值** @param key   键* @param field hash键* @param value 值* @return 更新成功返回true，否则返回false*/public <T> boolean updateToHash(String key, Object field, T value) {RMap<Object, T> hash = redissonClient.getMap(key);return hash.fastReplace(field, value);}
​/*** 根据Key，删除Hash类型的数据** @param key      键* @param hashKeys hash键* @return 删除成功的数量*/public <T> long removeFromHash(String key, T... hashKeys) {RMap<Object, T> hash = redissonClient.getMap(key);return hash.fastRemove(hashKeys);}
​// ============================= List类型操作 ============================
​/*** 向List数据类型中添加值** @param key   键* @param value 值*/public <T> boolean addToList(String key, T value) {RList<T> list = redissonClient.getList(key);return list.add(value);}
​/*** 向List数据类型中添加值** @param key   键* @param value 值*/public <T> boolean addToList(String key, List<T> value) {RList<T> list = redissonClient.getList(key);return list.addAll(value);}
​/*** 向List数据类型中添加值** @param key      键* @param value    值* @param timeout  过期时间* @param timeUnit 时间单位*/public <T> boolean addToList(String key, T value, long timeout, ChronoUnit timeUnit) {RList<T> list = redissonClient.getList(key);list.add(value);return list.expire(Instant.now().plus(timeout, timeUnit));}
​/*** 从List数据类型中获取值** @param key   键* @param start 起始位置* @param end   结束位置* @return 值*/public <T> List<T> getFromList(String key, int start, int end) {RList<T> list = redissonClient.getList(key);return list.range(start, end);}
​/*** 获取List数据类型中的所有值** @param key 键* @return 值*/public <T> List<T> getFromList(String key) {RList<T> list = redissonClient.getList(key);return list.readAll();}
​
​/*** 移除集合左侧第一个元素** @param key 键*/public void removeListLeft(String key) {RList<Object> list = redissonClient.getList(key);list.fastRemove(0);}
​/*** 移除集合右侧第一个元素** @param key 键*/public void removeListRight(String key) {RList<Object> list = redissonClient.getList(key);list.fastRemove(list.size() - 1);}
​/*** 移除集合指定位置元素** @param key   键* @param index 索引*/public void removeFromList(String key, int index) {RList<Object> list = redissonClient.getList(key);list.fastRemove(index);}
​/*** 移除集合指定元素** @param key   键* @param value 值*/public <T> boolean removeFromList(String key, T value) {RList<T> list = redissonClient.getList(key);return list.removeIf(o -> o.equals(value));}
​// ============================= Set类型操作 ============================
​/*** 添加值到Set数据类型中** @param key   键* @param value 值*/public <T> boolean addToSet(String key, T value) {RSet<T> set = redissonClient.getSet(key);return set.add(value);}
​/*** 添加值到Set数据类型中** @param key      键* @param value    值* @param timeout  过期时间* @param timeUnit 时间单位* @return 是否成功*/public <T> boolean addToSet(String key, T value, long timeout, ChronoUnit timeUnit) {RSet<T> set = redissonClient.getSet(key);boolean add = set.add(value);boolean expire = set.expire(Instant.now().plus(timeout, timeUnit));return add && expire;}
​/*** 添加值到Set数据类型中** @param key    键* @param values 值* @return 是否成功*/public <T> boolean addToSet(String key, List<T> values) {RSet<T> set = redissonClient.getSet(key);return set.addAll(values);}
​/*** 添加值到Set数据类型中** @param key      键* @param values   值* @param timeout  过期时间* @param timeUnit 时间单位* @return 是否成功*/public <T> boolean addToSet(String key, List<T> values, long timeout, ChronoUnit timeUnit) {RSet<T> set = redissonClient.getSet(key);set.addAllCounted(values);return set.expire(Instant.now().plus(timeout, timeUnit));}
​
​/*** 获取Set的所有元素。** @param key 键* @return 所有值*/public <T> Set<T> getFromSet(String key) {RSet<T> set = redissonClient.getSet(key);return set.readAll();}
​/*** 从Set数据类型中删除值** @param key    键* @param values 值*/public <T> void removeFromSet(String key, List<T> values) {RSet<T> set = redissonClient.getSet(key);values.forEach(set::remove);}
​/*** 从Set数据类型中删除值** @param key   键* @param value 值*/public <T> boolean removeFromSet(String key, T value) {RSet<T> set = redissonClient.getSet(key);return set.remove(value);}
​// ============================= ZSet类型操作 ============================
​/*** 添加值到ZSet数据类型中** @param key   键* @param value 值* @param score 分值*/public <T> void addToZSet(String key, T value, double score) {RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);sortedSet.add(score, value);}
​/*** 在ZSet数据类型中添加值** @param key      键* @param value    值* @param score    分值* @param timeout  过期时间* @param timeUnit 时间单位*/public <T> void addToZSet(String key, T value, double score, long timeout, ChronoUnit timeUnit) {RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);sortedSet.add(score, value);sortedSet.expire(Instant.now().plus(timeout, timeUnit));}
​/*** 获取ZSet的范围元素。** @param key   键* @param start 起始位置* @param end   结束位置* @return Set类型的值*/public <T> Set<Object> getFromZSet(String key, int start, int end) {RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);return new HashSet<>(sortedSet.valueRange(start, end));}
​/*** 删除ZSet数据类型中的值** @param key    键* @param values 值*/public <T> void removeFromZSet(String key, List<T> values) {RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);sortedSet.removeAll(values);}
​/*** 删除ZSet数据类型中的值** @param key   键* @param value 值*/public <T> void removeFromZSet(String key, T value) {RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);sortedSet.remove(value);}
​// ============================= Common ============================
​/*** 判断Key是否存在** @param key 键* @return 存在返回true，否则返回false*/public boolean exists(String key) {return redissonClient.getBucket(key).isExists();}
​/*** 删除Key** @param key 键*/public boolean remove(String key) {long delete = redissonClient.getKeys().delete(key);return delete > 0;}
​/*** 设置Key的过期时间** @param key      键* @param timeout  过期时间* @param timeUnit 时间单位* @return 设置成功返回true，否则返回false*/public boolean expire(String key, long timeout, ChronoUnit timeUnit) {return redissonClient.getBucket(key).expire(Instant.now().plus(timeout, timeUnit));}
​/*** 获取Key的过期时间** @param key 键* @return 过期时间*/public Long getExpire(String key) {return redissonClient.getBucket(key).getExpireTime();}
​/*** 递增操作** @param key   键* @param delta 增加的值* @return 递增后的值，如果键不存在，则返回-1*/public long increment(String key, long delta) {RAtomicLong atomicLong = redissonClient.getAtomicLong(key);return atomicLong.addAndGet(delta);}
​/*** 递减操作** @param key   键* @param delta 减少的值* @return 递减后的值，如果键不存在，则返回-1*/public long decrement(String key, long delta) {RAtomicLong atomicLong = redissonClient.getAtomicLong(key);return atomicLong.decrementAndGet();}
​/*** 递增操作** @param key   键* @param delta 增加的值* @return 递增后的值，如果键不存在，则返回-1*/public double increment(String key, double delta) {RAtomicDouble atomicDouble = redissonClient.getAtomicDouble(key);return atomicDouble.addAndGet(delta);}
​/*** 递减操作** @param key   键* @param delta 减少的值* @return 递减后的值，如果键不存在，则返回-1*/public double decrement(String key, double delta) {RAtomicDouble atomicDouble = redissonClient.getAtomicDouble(key);return atomicDouble.decrementAndGet();}
}

编写测试用例

import jakarta.annotation.Resource;
import jodd.util.ThreadUtil;
import lombok.extern.slf4j.Slf4j;
import org.assertj.core.util.Lists;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
​
import java.time.LocalDateTime;
import java.util.List;
​
@Slf4j
@SpringBootTest
@DisplayName("Redis 集成测试类")
public class RedisApplicationTest {
​@Resourceprivate RedisService redisService;
​private static final String STRING_KEY = "redis:string";private static final String LIST_KEY = "redis:list";private static final String SET_KEY = "redis:set";private static final String HASH_KEY = "redis:hash";
​@Test@DisplayName("Redis String 数据类型测试")public void redisStringTest() {log.info("Redis String 数据类型测试");redisService.setString(STRING_KEY, LocalDateTime.now().toString());String redisGetStringData = redisService.getString(STRING_KEY);log.info("Redis String Get：{}", redisGetStringData);boolean remove = redisService.remove(STRING_KEY);log.info("Redis String Remove：{}", remove);redisGetStringData = redisService.getString(STRING_KEY);log.info("Redis String Get After Delete：{}", redisGetStringData);}
​@Test@DisplayName("Redis List 数据类型测试")public void redisListTest() {log.info("Redis List 数据类型测试");// 填充数据List<Integer> list = Lists.newArrayList();for (int i = 0; i < 5; i++) {list.add(LocalDateTime.now().getNano());ThreadUtil.sleep(5);}
​boolean addItemResult = redisService.addToList(LIST_KEY, LocalDateTime.now().getNano());log.info("Redis List Add item：{}", addItemResult);redisService.getFromList(LIST_KEY).forEach(s -> log.info("Redis List Get After Add Item：{}", s));
​boolean addListDataResult = redisService.addToList(LIST_KEY, list);log.info("Redis List Add List：{}", addListDataResult);redisService.getFromList(LIST_KEY).forEach(s -> log.info("Redis List Get After Add List：{}", s));
​redisService.getFromList(LIST_KEY, 0, 2).forEach(s -> log.info("Redis List Get By Index：{}", s));
​log.info("Redis List Size Before Delete：{}", redisService.getFromList(LIST_KEY).size());redisService.removeFromList(LIST_KEY, 0);log.info("Redis List Size After Delete：{}", redisService.getFromList(LIST_KEY).size());
​boolean remove = redisService.remove(LIST_KEY);log.info("Redis List Remove：{}", remove);}
​@Test@DisplayName("Redis Set 数据类型测试")public void redisSetTest() {log.info("Redis Set 数据类型测试");// 填充数据List<Integer> list = Lists.newArrayList();for (int i = 0; i < 5; i++) {list.add(LocalDateTime.now().getNano());ThreadUtil.sleep(5);}
​boolean addItemResult = redisService.addToSet(SET_KEY, LocalDateTime.now().getNano());log.info("Redis Set Add item：{}", addItemResult);redisService.getFromSet(SET_KEY).forEach(s -> log.info("Redis Set Get After Add Item：{}", s));
​boolean addListDataResult = redisService.addToSet(SET_KEY, list);log.info("Redis Set Add List：{}", addListDataResult);redisService.getFromSet(SET_KEY).forEach(s -> log.info("Redis Set Get After Add List：{}", s));
​log.info("Redis Set Size Before Delete：{}", redisService.getFromSet(SET_KEY).size());redisService.removeFromSet(SET_KEY, LocalDateTime.now().getNano());log.info("Redis Set Size After Delete：{}", redisService.getFromSet(SET_KEY).size());
​boolean remove = redisService.remove(SET_KEY);log.info("Redis Set Remove：{}", remove);}
​@Test@DisplayName("Redis Hash 数据类型测试")public void redisHashTest() {log.info("Redis Hash 数据类型测试");Integer key = LocalDateTime.now().getNano();
​boolean addItemResult = redisService.addToHash(HASH_KEY, key, LocalDateTime.now().toString());log.info("Redis Hash Add item：{}", addItemResult);redisService.getFromHash(HASH_KEY).forEach((k, v) -> log.info("Redis Hash Get After Add Item：{} - {}", k, v.toString()));
​log.info("Redis Hash Get By Key：{}", redisService.getFromHash(HASH_KEY, key).toString());
​log.info("Redis Hash Size Before Delete：{}", redisService.getFromHash(HASH_KEY).size());redisService.removeFromHash(HASH_KEY, key);log.info("Redis Hash Size After Delete：{}", redisService.getFromHash(HASH_KEY).size());
​boolean remove = redisService.remove(HASH_KEY);log.info("Redis Hash Remove：{}", remove);}
}

运行测试用例

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

echart地图的小demo12.27

echart地图的小demo12.27

图形&#xff1a; DataV.GeoAtlas地理小工具系列 点击以上链接进入--》 再点击箭头---》复制坐标到文件&#xff1a; 取名为 china.json中 &#xff08;文件名自定义&#xff09; <template><div class"map" ref"chartMap">地图</div>…
阅读更多...
案例232:基于微信小程序的学生实习与就业管理系统设计与实现

案例232:基于微信小程序的学生实习与就业管理系统设计与实现

文末获取源码 开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 数据库&#xff1a;mysql 5.7 开发软件&#xff1a;eclipse/myeclipse/idea Maven包&#xff1a;Maven3.5.4 小程序框架&#xff1a;uniapp 小程序开发软件&#xff1a;HBuilder …
阅读更多...
java旅游攻略管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

java旅游攻略管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

一、源码特点 java Web旅游攻略管理系统是一套完善的java web信息管理系统&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为 TOMCAT7.0,Myeclipse8.5开发&#xff0c;数据库为Mysql…
阅读更多...
ASUS华硕ROG幻16笔记本电脑2023款GU604VI VZ VY原装出厂Windows11系统22H2

ASUS华硕ROG幻16笔记本电脑2023款GU604VI VZ VY原装出厂Windows11系统22H2

华硕玩家国度幻16笔记本原厂W11系统&#xff0c;适用型号&#xff1a;GU604VI、GU604VZ、GU604VY 链接&#xff1a;https://pan.baidu.com/s/166x6FNUFEpA3Qbzeory3Hg?pwdlwau 提取码&#xff1a;lwau 系统自带所有驱动、出厂主题壁纸、Office办公软件、MyASUS华硕电脑管…
阅读更多...
『JavaScript』全面解析JavaScript中的防抖与节流技术及其应用场景

『JavaScript』全面解析JavaScript中的防抖与节流技术及其应用场景

&#x1f4e3;读完这篇文章里你能收获到 理解防抖&#xff08;Debouncing&#xff09;和节流&#xff08;Throttling&#xff09;的概念&#xff1a;了解这两种性能优化技术如何帮助我们更有效地处理频繁触发的事件掌握防抖与节流的实现方法&#xff1a;学习如何在JavaScript中…
阅读更多...
C# 常用数据类型及取值范围

C# 常用数据类型及取值范围

1.常见数据类型和取值范围 序号数据类型占字节数取值范围1byte10 到 2552sbyte1-128 到 1273short 2-32,768 到 32,7674ushort20 到 65,5355int4-2,147,483,648 到 2,147,483,6476uint40 到 4,294,967,2957float41.5 x 10−45 至 3.4 x 10388double85.0 10−324 到 1.…
阅读更多...
走进电子技术之光敏电阻、电位器、开关

走进电子技术之光敏电阻、电位器、开关

同学们大家好&#xff0c;今天我们继续学习杨欣的《电子设计从零开始》&#xff0c;这本书从基本原理出发&#xff0c;知识点遍及无线电通讯、仪器设计、三极管电路、集成电路、传感器、数字电路基础、单片机及应用实例&#xff0c;可以说是全面系统地介绍了电子设计所需的知识…
阅读更多...
关于Java并发、JVM面试题

关于Java并发、JVM面试题

前言 之前为了准备面试&#xff0c;收集整理了一些面试题。 本篇文章更新时间2023年12月27日。 最新的内容可以看我的原文&#xff1a;https://www.yuque.com/wfzx/ninzck/cbf0cxkrr6s1kniv 并发 进程与线程的区别 线程属于进程&#xff0c;进程可以拥有多个线程。进程独享…
阅读更多...
BAQ压缩MATLAB仿真

BAQ压缩MATLAB仿真

本专栏目录： ​​​​​​​全球SAR卫星大盘点与回波数据处理专栏目录-CSDN博客 我们按照上一期文章的BAQ原理编写MATLAB代码，进行baq压缩与解压缩的全流程验证，并分析BAQ压缩对信号指标造成的影响。 生成3个点目标回波数据，加入高斯噪声，对回波进行BAQ压缩和解BAQ压缩，…
阅读更多...
Android集成OpenSSL实现加解密-集成

Android集成OpenSSL实现加解密-集成

导入so 将编译生成的 OpenSSL 动态库文件&#xff08;.so 文件&#xff09;复制到你的 Android 项目的 libs 目录中 导入头文件 将编译生成的include文件夹导入到项目中 build.gradle添加配置 defaultConfig {……testInstrumentationRunner "androidx.test.runner…
阅读更多...
【10】ES6：Promise 对象

【10】ES6：Promise 对象

一、同步和异步 1、JS 是单线程语言 JavaScript 是一门单线程的语言&#xff0c;因此同一个时间只能做一件事情&#xff0c;这意味着所有任务都需要排队&#xff0c;前一个任务执行完&#xff0c;才会执行下一个任务。但是&#xff0c;如果前一个任务的执行时间很长&#xff…
阅读更多...
设计模式（4）--对象行为(6)--备忘录

设计模式（4）--对象行为(6)--备忘录

1. 意图 在不破坏封装的前提下&#xff0c;捕获一个对象的内部状态&#xff0c;并在该对象之外保存这个状态。 这样以后可以将该对象恢复到原先保存的状态。 2. 三种角色 原发器(Originator)、备忘录(Memento)、负责人(Caretaker) 3. 优点 3.1 保持了封装边界。屏蔽了原发器的…
阅读更多...
Tiny Object Detection

Tiny Object Detection

文章目录 RFLA: Gaussian Receptive Field based Label Assignment for Tiny Object Detection&#xff08;ECCV2022&#xff09;Dynamic Coarse-to-Fine Learning for Oriented Tiny Object Detection&#xff08;CVPR2023&#xff09;TOD-CMLNN&#xff08;2023&#xff09; …
阅读更多...
错误代码-9907磁盘空间不足怎么办？几个步骤轻松搞定~

错误代码-9907磁盘空间不足怎么办？几个步骤轻松搞定~

错误代码-9907表示磁盘空间不足。这意味着您的设备上的磁盘空间不足以完成当前的下载或存储任务。我们可以用这些方法解决这个问题。 一、对大文件进行压缩 可以使用压缩软件将一些文件进行压缩&#xff0c;以减少它们占用的磁盘空间。下面以嗨格式压缩大师作为操作示例。 1、…
阅读更多...
k8s的网络类型

k8s的网络类型

部署 CNI 网络组件 部署 flannel K8S 中 Pod 网络通信&#xff1a; ●Pod 内容器与容器之间的通信 在同一个 Pod 内的容器&#xff08;Pod 内的容器是不会跨宿主机的&#xff09;共享同一个网络命名空间&#xff0c; 相当于它们在同一台机器上一样&#xff0c;可以用 localho…
阅读更多...
k8s 网络

k8s 网络

还没有部署网络。 k8s的网络类型&#xff1a; k8s中的通信模式&#xff1a; 1&#xff0c;pod内部之间容器和容器之间的通信。 在同一个pod中的容器共享资源和网络&#xff0c;使用同一个网络命名空间。可以直接通信的。 2&#xff0c;同一个node节点之内不同pod之间的通信。…
阅读更多...
docker学习（十九、network使用示例bridge）

docker学习（十九、network使用示例bridge）

文章目录 一、容器网络分配情况1.启动容器2.查看容器的network3.容器网络分配 二、bridge1.bridge详细介绍2.实践bridge两两匹配3.创建network&#xff0c;默认bridge network相关内容&#xff1a; docker学习&#xff08;十八、network介绍&#xff09; docker学习&#xff08…
阅读更多...
听GPT 讲Rust源代码--src/tools(28)

听GPT 讲Rust源代码--src/tools(28)

File: rust/src/tools/clippy/clippy_lints/src/operators/identity_op.rs 文件路径 rust/src/tools/clippy/clippy_lints/src/operators/identity_op.rs 中的作用是定义了 IdentityOp 类型的 Clippy lint 规则&#xff0c;用于检查代码中是否存在不必要的恒等操作符&#xff0…
阅读更多...
RabbitMq知识概述

RabbitMq知识概述

本文来说下RabbitMq相关的知识与概念 文章目录 概述AMQP协议Exchange 消息如何保证100&#xff05;投递什么是生产端的可靠性投递可靠性投递保障方案 消息幂等性高并发的情况下如何避免消息重复消费confirm 确认消息、Return返回消息如何实现confirm确认消息return消息机制 消费…
阅读更多...
C#高级 01.Net多线程

C#高级 01.Net多线程

一.基本概念 1.什么是线程&#xff1f; 线程是操作系统中能独立运行的最小单位&#xff0c;也是程序中能并发执行的一段指令序列线程是进程的一部分&#xff0c;一个进程可以包含多个线程&#xff0c;这些线程共享进程资源进程有线程入口&#xff0c;也可以创建更多的线程 2.…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023