SpringBoot 3.2.0 结合Redisson接入Redis

已于 2024-01-01 15:02:39 修改
阅读量1k 收藏 10
点赞数 10
分类专栏： Spring Boot 文章标签： spring boot redis 后端 java spring
于 2023-12-25 02:23:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55712478/article/details/135190030
版权

依赖版本

  • 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:port
  address: "redis://127.0.0.1:6379"
  # 密码。默认值: null
  password: null
  # 数据库编号。默认值: 0
  database: 0
  # 客户端名称（在Redis节点里显示的客户端名称）。默认值: null
  clientName: null
  # 连接超时，单位：毫秒。默认值: 10000
  connectTimeout: 10000
  # 命令等待超时，单位：毫秒。默认值: 3000
  timeout: 3000
  # 命令失败重试次数。默认值: 3
  retryAttempts: 3
  # 命令重试发送时间间隔，单位：毫秒。默认值: 1500
  retryInterval: 1500
  # 最小空闲连接数。默认值: 32
  connectionMinimumIdleSize: 24
  # 连接池大小。默认值: 64
  connectionPoolSize: 64
  # 单个连接最大订阅数量。默认值: 5
  subscriptionsPerConnection: 5
  # 发布和订阅连接的最小空闲连接数。默认值: 1
  subscriptionConnectionMinimumIdleSize: 1
  # 发布和订阅连接池大小。默认值: 50
  subscriptionConnectionPoolSize: 50
  # DNS监测时间间隔，单位：毫秒。默认值: 5000
  dnsMonitoringInterval: 5000
  # 连接空闲超时，单位：毫秒。默认值: 10000
  idleConnectionTimeout: 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 {
​
    @Resource
    private 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);
    }
}

运行测试用例

在这里插入图片描述

入秋的大橘
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Spring Boot 3】【Redis】集成Redisson
又言又语
01-22 1073
除Lettuce和Jedis外，Redisson也是一个较为流行的Redis客户端，本文介绍开发Spring Boot应用集成Redisson实现对Redis常见数据类型的基本操作。本文只介绍了Redisson对Redis基本数据类型的操作，但Redisson有别于Lettuce和Jedis的地方在于，Redisson并非一个纯粹的Redis客户端，还提供了很多高级的分布式服务，如分布式环境下的读写锁、公平锁、ID生成器、限流器等功能，在后续文章中会逐步介绍。
springboot3整合redis
最新发布
2301_78646673的博客
04-27 514
可以看到，我们选择自定义redis的实现之后。使用起来就方便了很多，如果是比较简单的项目，那么使用StringRedisTemplate就可以解决相应的业务问题，但是在复杂的项目中，建议还是自定义一个RedisTemplate的实现类，使用自己的实现类会更方便一些，也更利于项目的扩展。（注意使用的时候，要注入相应的泛型，不然会提示找不到相应的依赖）在spring boot3版本之前，如果不注入泛型也可以，但是在3.0版本之后，如果不指定相应的泛型，那么在启动的时候就会报错，显示找不到相应的类型。
【Redis | 第三篇】Springboot整合Redis
踢桃的成长之路
02-28 1030
Redsi系列第三篇主要介绍了Springboot快速整合Redis，以及常用的数据类型操作，对实战非常有大的帮助
SpringBoot Redisson 集成详解
深圳市多克创新科技有限公司
10-03 4597
Redisson 集成SpringBoot 详解
springboot整合redisson实战（一）整合 redisson-spring-boot-starter
s_156的博客
05-24 1万+
SpringBoot整合Redisson有个比较好用的starter包就是redisson-spring-boot-starter，这也是官方比较推荐的配置方式。
redisson版本与springboot版本依赖关系
Mr_lqh325的博客
08-29 9303
关于Redisson与Springboot版本依赖关系的说明
Springboot + redis操作多种实现（以及Jedis,Redisson,Lettuce的区别比较）
热门推荐
诗和远方，任重道远
10-16 1万+
Springboot + redis 操作多种实现一、Jedis,Redisson,Lettuce三者的区别二、Jedis三、RedisTemplate3.1、使用配置3.2、使用示例3.3、扩展3.3.1、spring-boot-starter-data-redis的依赖包3.3.2、stringRedisTemplate API（部分展示）3.3.3 StringRedisTemplate默认...
Redis管理工具redisplus-3.2.0-win-x86_64
07-01
RedisPlus是为Redis可视化管理开发的一款开源免费的桌面客户端软件，支持Windows 、Linux、Mac三大系统平台，RedisPlus提供更加高效、方便、快捷的使用体验，有着更加现代化的用户界面风格。该软件支持单机、集群...
redis-3.2.0.zip
10-10
redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。
redis-linux-3.2.0.rar redis-linux-3.2.0.rar
10-20
redis 3.2 linnuxredis 3.2 linnuxredis 3.2 linnuxredis 3.2 linnuxredis 3.2 linnuxredis 3.2 linnuxredis 3.2 linnux
spring boot 利用redisson实现redis的分布式锁（二）
05-01
NULL 博文链接：https://liaoke0123.iteye.com/blog/2375556
Redis 3.2.0 源码
04-14
Redis 3.2.0 源码 想学习的小伙伴，可以下载。
redis-3.2.0.gem
12-01
redis 集群搭建需要安装的 ruby 脚本，通过 RubyGems 安装会出现找到不脚本，或脚本版本不匹配的问题，因此提供现成的版本
Spring Boot3整合Redis
蒾酒的博客
02-07 6712
⛰️个人主页: 蒾酒🔥系列专栏：《spring boot实战》目录前置条件1.导依赖2.配置连接信息以及连接池参数3.配置序列化方式4.编写测试已经初始化好一个spring boot项目且版本为3X，项目可正常启动。作者版本为3.2.2初始化教程：新版idea(2023)创建spring boot3项目-CSDN博客https://blog.csdn.net/qq_62262918/article/details/135785412?spm=1001.2014.3001.5501pom.xml:
SpringBoot3.1.0集成redisson分布式锁框架基本使用
qq_45001053的博客
06-21 1779
redisson分布锁的框架原理，是使用了redisTemplate.opsForValue().setIfAbsent(key,value)加锁，底层是redis SETNX命令，具体的框架底层原理请参考链接。
SpringBoot3.0.3集成Redisson3.20.0
pandalive的博客
03-02 1738
使用Redisson可以方便地实现分布式锁、分布式限流、分布式任务调度和分布式缓存等功能，能够提高分布式应用程序的性能和可靠性。Redisson提供了分布式缓存的实现，可以帮助我们实现分布式缓存的读写、过期时间等功能。在分布式系统中，可能需要对任务进行分布式调度，Redisson提供了分布式任务调度的实现，可以帮助我们实现任务的定时执行、延迟执行等功能。
SpringBoot集成redis（3）|（Redisson方式实现分布式锁）
Oaklkm的博客
10-09 1903
本章节主要介绍SpringBoot项目集成Redis的一些相关知识，主要介绍的是基于Springboot的Redisson方式，实现在分布式场景下锁机制。以上就是SpringBoot集成redisson实现分布式锁的代码，改方式实现可普通单机情况下的所有问题，广泛使用于分布式高并发场景下，存在的问题主要是特殊情况下，主机宕机造成锁异常问题，后面将介绍开源Redisson解决该问题的方式。
Spring Boot 整合Redisson实现限流
嘉禾嘉宁papa
03-08 6420
Spring Boot 整合Redisson实现限流，通过AOP使用RRateLimiter实现限流，trySetRate、tryAcquire方法使用，完成单用户和多用户限流
springboot3.2.0snaphots
09-03
很抱歉，我无法回答关于"springboot3.2.0snaphots"的问题。因为在提供的引用内容中没有提到这个版本的信息。请您提供更多关于这个版本的信息，我将尽力帮助您解答。<span class="em">1</span><span class="em">2</span> #### 引用[.reference_title] - *1* [springboot](https://blog.csdn.net/m0_74839717/article/details/128186214)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [ECharts v3.2.0](https://download.csdn.net/download/weixin_38725625/13457201)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值