SpringBoot整合Redisson（操作五种数据类型）

D3zQ

已于 2024-10-14 20:38:41 修改

阅读量867

点赞数 8

文章标签： spring boot 后端 java

于 2024-10-14 20:36:26 首次发布

本文链接：https://blog.csdn.net/2403_86763612/article/details/142921464

版权

学会你就是大Cattle

文章目录

一、Redisson是什么？

Redisson 是一个用于 Redis 的 Java 客户端，它提供了许多高级功能和数据结构，使得在 Java 应用程序中使用 Redis 更加方便。

Redisson 项目旨在帮助开发者更高效地利用 Redis 的特性，包括但不限于：

分布式集合：如 List, Set, Map, Queue 等。
分布式对象和服务：如 RAtomicLong, RCountDownLatch, RSemaphore, RLock 等。
发布/订阅模式支持。
高效的 Redis 连接池管理。
主从复制和哨兵模式支持。
集群模式支持。
事务支持。

Redisson 可以让开发者更容易地实现分布式锁、分布式计数器、消息队列等常见需求，而无需直接操作复杂的 Redis 命令。此外，它还提供了一系列针对线程安全和并发场景优化的数据结构，这在构建高性能、可扩展的应用时非常有用。

二、使用步骤

1.引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.5</version>
</dependency>

2.加入配置文件

#在spring下粘 
redis:
    host: 127.0.0.1
    port: 6379
    password:

3.设置编码方式

防止消息乱码，通常可能是字符编码不一致。为了防止出现这种情况我们可以设置编码方式以下是：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;



@Configuration
@EnableCaching
@AutoConfigureBefore(RedisAutoConfiguration.class)
public class RedisConfig {

    @Bean
    public RedissonClient createClient(){
        Config config = new Config();
        config.setCodec(new JsonJacksonCodec());
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }

}

4.数据类型操作

字符串

//字符串操作
RBucket<String> rBucket =  redissonClient.getBucket("nameKey");
// 设置value和key的有效期
rBucket.set("大头儿子", 10, TimeUnit.SECONDS);
// 通过key获取value
System.out.println(redissonClient.getBucket("nameKey").get());
//通过key删除value
rBucket.delete();

对象

Redisson操作对象类型首先要实现序列化接口Serializable

RBucket<SysGoods> key = redissonClient.getBucket("sysGoodsKey");
SysGoods goods = new SysGoods();
goods.setGoodsName("苹果");
//设置value 和过期时间
key.set(goods,30, TimeUnit.MINUTES);
//获取value
//通过key删除value
key.delete();

集合

//获取数据
RList<Classify> clientList = redissonClient.getList("classify:");
//添加
Classify classify = new Classify();
classify.setId(1);
classify.setClassifyName("哈哈");
clientList.add(classify);
//批量添加
clientList.addAll(classifies);

//单个删除
clientList.remove(classify);
//根据索引删除 传索引 删除索引为2的数据
clientList.remove(2);
// 删除指定范围内的元素
clientList.remove(0, 2);// 删除索引 0 到 2 之间的元素（不包括 2)
//删除所有匹配的数据
clientList.removeAll();

//设置过期时间 1分钟
clientList.expire(1, TimeUnit.MINUTES);

哈希

在 Redisson 中，RMap 接口提供了对 Redis 哈希（Hash）数据结构的操作以购物车为例：

//每个用户都有自己的购物车
String cartKey = "cart:" +userId;
//获取自己的购物车信息
//泛型可以直接转
RMap<String, SysGoods> cart = redissonClient.getMap(cartKey);

//获取指定的数据 id是商品id
SysGoods goods = cart.get(id);

//添加数据
cart.put(String.valueOf(id),sysGoods);

//获取所有的值
for (Map.Entry<String, SysGoods> entry : map.entrySet()) {
     SysGoods goods = entry.getValue();
}


// 删除单个键值对
map.remove("key2");  // 删除键为 "key2" 的键值对
// 删除特定键且值匹配的键值对
map.remove("key1", "value1");  // 返回 true 如果键值对被成功移除
// 批量删除多个键值对
map.removeAll(Collections.singleton("key3"));  // 删除键为 "key3" 的键值对
map.fastRemove("key4", "key5");  // 快速删除多个键
// 根据条件删除
map.removeIf(value -> value.startsWith("value"));  // 删除所有值以 "value" 开头的键值对
// 清空整个哈希表
map.clear();  // 清空整个哈希表

Set

在 Redisson 中，RSet 接口提供了对 Redis 集合（Set）数据结构的操作。集合是一个无序且不包含重复元素的数据结构。

RSet<SysGoods> set = redissonClient.getSet("mySet");
SysGoods goods = new SysGoods();
goods.setGoodsName("香蕉");
//单个添加
set.add(goods);
//批量添加
List<SysGoods> list = new ArrayList<>();
list.add(goods);
set.addAll(list);

//删除单个
set.remove(goods);
//批量删除
set.removeAll(list);
//清空整个集合
set.clear();
//检查元素是否存在
set.contains(goods);

// 获取集合中的所有元素
List<SysGoods> goodsList = new ArrayList<>(set.readAll());

ZSet

在 Redisson 中，RScoredSortedSet 接口提供了对 Redis 有序集合（ZSet）的操作。有序集合是一个类似于集合的数据结构，但是每个元素都关联了一个分数（score），这使得集合中的元素可以按照分数进行排序。

// 获取 RScoredSortedSet 实例
RScoredSortedSet<SysGoods> zset = redissonClient.getScoredSortedSet("myZSet");
SysGoods goods = new SysGoods();
SysGoods goodsTwo = new SysGoods();
goods.setGoodsName("香蕉");
// 添加单个元素
zset.add(1.0,goods);

// 批量添加元素
Map<SysGoods, Double> map = new HashMap<>();
map.put(goods,2.0);
map.put(goodsTwo ,3.0);
zset.addAll(map);


// 删除单个元素
zset.remove(goods);
// 批量删除元素
List<SysGoods> goodsList = new ArrayList<>();
zset.removeAll(goodsList);
// 根据分数范围删除
zset.removeRangeByScore(2.0, true, 4.0, true);  // 删除分数在 [2.0, 4.0] 范围内的元素

// 检查元素是否存在
zset.contains(goods);
// 获取元素的分数
zset.getScore(goods);
// 获取有序集合中的所有元素
List<SysGoods> allList = new ArrayList<>(zset.readAll());

// 按分数范围获取元素
List<SysGoods> rangeList = new ArrayList<>(zset.valueRange(1.0, true, 3.0, true));
// 按分数范围获取元素及其分数
Map<SysGoods, Double> rangeEntries = (Map<SysGoods, Double>) zset.entryRange(1.0, true, 3.0, true);

分布式锁

Redisson 是一个用于 Redis 的 Java 客户端，它提供了许多高级功能，包括分布式锁。分布式锁是解决分布式系统中并发控制问题的一种方法

 RLock lock = redissonClient.getLock("myLock");
      try {
          // 尝试获取锁，最多等待10秒，锁持有时间60秒
          boolean isLocked = lock.tryLock(10, 60, TimeUnit.SECONDS);
          if (isLocked) {
              try {
                  // 执行业务逻辑
               
              } finally {
                  // 释放锁
                  lock.unlock();
              }
            }
     } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException();
}