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.mzph.cn/news/580270.shtml

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

相关文章

【Python】requests库在CTFWeb题中的应用

【Python】requests库在CTFWeb题中的应用

目录 ①Bugku-GET ②Bugku-POST ③实验吧-天下武功唯快不破 ④Bugku-速度要快 ⑤Bugku-秋名山车神 ⑥Bugku-cookies ①Bugku-GET import requestsresprequests.get(urlhttp://114.67.175.224:12922/,params{what:flag}) print(resp.text)//或者 //resprequests.get(urlht…
阅读更多...
【操作系统】探究文件系统奥秘：创建proc文件系统的解密与实战

【操作系统】探究文件系统奥秘：创建proc文件系统的解密与实战

​&#x1f308;个人主页&#xff1a;Sarapines Programmer&#x1f525; 系列专栏&#xff1a;Linux专栏&#xff1a;《探秘Linux | 操作系统解密》⏰诗赋清音&#xff1a;月悬苍穹泛清辉&#xff0c;梦随星河徜徉辉。情牵天际云千层&#xff0c;志立乘风意自飞。 ​ 目录 &a…
阅读更多...
亚马逊美国站ASTM F2613儿童折叠椅和凳子强制性安全标准

亚马逊美国站ASTM F2613儿童折叠椅和凳子强制性安全标准

ASTM F2613折叠椅和凳子安全标准 美国消费品安全委员会&#xff08;CPSC&#xff09;发布的ASTM F2613儿童折叠椅和凳子的强制性安全标准&#xff0c;已于2020年7月6日生效&#xff0c;并被纳入联邦法规《16 CFR 1232儿童折叠椅和凳子安全标准》。 亚马逊要求在美国站上架的儿…
阅读更多...
C语言——字符函数和字符串函数（三）【strtok，strerror，perror】

C语言——字符函数和字符串函数（三）【strtok，strerror，perror】

&#x1f4dd;前言&#xff1a; 上一篇文章C语言——字符函数和字符串函数&#xff08;二&#xff09;对字符函数和字符串函数strstr&#xff0c;strcmp和strncmp进行了一定的讲解 这篇文章主要讲解以下函数的用法: 1&#xff0c;strtok 2&#xff0c;strerror 3&#xff0c;pe…
阅读更多...
Linux下的文本编辑Vi/Vim

Linux下的文本编辑Vi/Vim

编辑文件 文本编辑器有很多&#xff0c;比如图形模式的gedit、OpenOffice 等&#xff0c;文本模式下的编辑器有vi、vim&#xff08;vi的增强 版本&#xff09;等。vi和vim是我们在Linux中最常用的编辑器。 gedit 类似于Windows下的记事本&#xff0c;很方便的去修改文本。 Op…
阅读更多...
深入了解云原生：定义与特征解析

深入了解云原生：定义与特征解析

文章目录 一、云原生概述1.1 什么是云原生1.2 云原生组成要素1.3 补充资料 二、云原生的目标2.1 云原生关键目标2.2 云原生特性 三、云原生应用 VS 传统单体应用参考资料 一、云原生概述 1.1 什么是云原生 (1)云原生定义 云原生(Cloud Native) 是一种软件架构和开发方法论&a…
阅读更多...
山西电力市场日前价格预测【2023-12-27】

山西电力市场日前价格预测【2023-12-27】

日前价格预测 预测说明&#xff1a; 如上图所示&#xff0c;预测明日&#xff08;2023-12-27&#xff09;山西电力市场全天平均日前电价为737.42元/MWh。其中&#xff0c;最高日前电价为1500.00元/MWh&#xff0c;预计出现在08:00~08:30。最低日前电价为313.03元/MWh&#xff…
阅读更多...
Qt Creator可视化交互界面exe快速入门3

Qt Creator可视化交互界面exe快速入门3

上一期介绍的通过Qt Creator的组件直接拖拽的方式完成了一个界面&#xff0c;这期介绍按钮的信号交互。 专有名称叫信号与槽 实现方法1&#xff1a; 鼠标右键选择转化为槽就会跳出这样的界面 选择第一个为单击信号。然后就会跳转到代码界面。多了on_pushButton_clicked()。 …
阅读更多...
分页合理化是什么？

分页合理化是什么？

一、前言 只要是干过后台系统的同学应该都做过分页查询吧&#xff0c;前端发送带有页码&#xff08;pageNum&#xff09;和每页显示数量&#xff08;pageSize&#xff09;的请求&#xff0c;后端根据这些参数来提取并返回相应的数据集。在SpringBoot框架中&#xff0c;经常会使…
阅读更多...
以社区为基石，IvorySQL逐步成为中国基础软件开源数据库产业重要一员

以社区为基石，IvorySQL逐步成为中国基础软件开源数据库产业重要一员

编者按&#xff1a;开源数据库技术&#xff0c;作为软件开发领域的一大趋势&#xff0c;正逐渐改变整个软件产业的面貌。在这个充满活力的领域中&#xff0c;瀚高股份的IvorySQL凭借其社区活跃度和影响力&#xff0c;已经成为中国基础软件开源数据库产业的重要一员。随着《2023…
阅读更多...
TCP:IP原理

TCP:IP原理

TCP/IP 原理 TCP/IP 协议不是 TCP 和 IP 这两个协议的合称&#xff0c;而是指因特网整个 TCP/IP 协议族。从协议分层模型方面来讲&#xff0c;TCP/IP 由四个层次组成&#xff1a;网络接口层、网络层、传输层、应用层。 网络访问层(Network Access Layer) 网络访问层(Network …
阅读更多...
宏集方案 | 物联网HMI的关键驱动力—SCADA级功能库和控件库

宏集方案 | 物联网HMI的关键驱动力—SCADA级功能库和控件库

来源&#xff1a;宏集科技 工业物联网 宏集方案 | 物联网HMI的关键驱动力—SCADA级功能库和控件库 原文链接&#xff1a;https://mp.weixin.qq.com/s/UEPtpTehdbFrw3MUCnuR2A 欢迎关注虹科&#xff0c;为您提供最新资讯&#xff01; 01 前言 在这个数字化时代&#xff0c;物…
阅读更多...
Java内存区域与内存溢出异常

Java内存区域与内存溢出异常

Java与C++之间有一堵由内存分配和垃圾收集技术所围成的高墙，墙外面的人想进去，墙里面的人却想出来。 2.1 概述 对于从事C、C++程序开发的开发人员来说，在内存管理领域，他们即是拥有最高权力的“皇帝”，又是从事最基础工作的劳动人民——即拥有每一个对象的“所有权”，又…
阅读更多...
个性化定制的知识付费小程序，为用户提供个性化的知识服务，知识付费saas租户平台

个性化定制的知识付费小程序，为用户提供个性化的知识服务，知识付费saas租户平台

明理信息科技知识付费saas租户平台 在当今数字化时代&#xff0c;知识付费已经成为一种趋势&#xff0c;越来越多的人愿意为有价值的知识付费。然而&#xff0c;公共知识付费平台虽然内容丰富&#xff0c;但难以满足个人或企业个性化的需求和品牌打造。同时&#xff0c;开发和…
阅读更多...
vscode中默认shell选择

vscode中默认shell选择

terminal.integrated.defaultProfile.linux在vs的Preference的Settings里面搜索terminal.integrated.defaultProfile.linux&#xff0c;默认的应该是null&#xff0c;将其修改为bash即可。 linux———/bin/sh、 /bin/bash、 /bin/dash的区别
阅读更多...
亚马逊云科技 re:Invent 2023 产品体验：亚马逊云科技产品应用实践 国赛选手带你看 Elasticache Serverless

亚马逊云科技 re:Invent 2023 产品体验：亚马逊云科技产品应用实践 国赛选手带你看 Elasticache Serverless

抛砖引玉 讲一下作者背景&#xff0c;曾经参加过国内世界技能大赛云计算的选拔&#xff0c;那么在竞赛中包含两类&#xff0c;一类是架构类竞赛&#xff0c;另一类就是 TroubleShooting 竞赛&#xff0c;对应的分别为亚马逊云科技 GameDay 和亚马逊云科技 Jam&#xff0c;想必…
阅读更多...
数据结构：图文详解 树与二叉树（树与二叉树的概念和性质，存储，遍历）

数据结构：图文详解 树与二叉树（树与二叉树的概念和性质，存储，遍历）

目录 一.树的概念 二.树中重要的概念 三.二叉树的概念 满二叉树 完全二叉树 四.二叉树的性质 五.二叉树的存储 六.二叉树的遍历 前序遍历 中序遍历 后序遍历 一.树的概念 树是一种非线性数据结构&#xff0c;它由节点和边组成。树的每个节点可以有零个或多个子节点…
阅读更多...
【Linux基础】5. 磁盘管理

【Linux基础】5. 磁盘管理

文章目录 【 1. 查看磁盘空间 】1.1 df 查看空间利用大小1.2 du 查看目录所占空间大小 【 2. 打包、压缩 】2.1 tar -cvf 打包2.2 gzip 压缩 【 3. 解压缩、解包 】3.1 gunzip 解压缩3.2 tar -xvf 解包 【 1. 查看磁盘空间 】 1.1 df 查看空间利用大小 作用 查看整个文件系统…
阅读更多...
5G阅信应用场景有哪些？

5G阅信应用场景有哪些？

5G阅信的应用场景非常广泛&#xff0c;以下是一些常见的应用场景&#xff1a; 1.工业自动化&#xff1a;5G阅信可以连接各种工业设备和传感器&#xff0c;实现设备之间的实时通信和控制&#xff0c;提高生产效率和自动化水平。 2.物联网和智能家居&#xff1a;5G阅信可以连接各…
阅读更多...
2014年第三届数学建模国际赛小美赛B题全地形伪装解题全过程文档及程序

2014年第三届数学建模国际赛小美赛B题全地形伪装解题全过程文档及程序

2014年第三届数学建模国际赛小美赛 B题 全地形伪装 原题再现&#xff1a; 破坏性着色在军事用途中很常见&#xff0c;用于军用车辆、士兵制服和装备。视觉是人类的主要方向感&#xff0c;伪装的主要功能是欺骗人眼。军事服装中存在大量的伪装图案&#xff0c;以适应作战服装与…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023