【Redisson】Redisson--基础入门

素颜马尾好姑娘i 2023-10-13 10:51 33阅读 0赞

Redisson系列文章：

*  [【Redisson】Redisson–基础入门][Redisson_Redisson]
 *  [【Redisson】Redisson–布隆(Bloom Filter)过滤器][Redisson_Redisson_Bloom Filter]
 *  [【Redisson】Redisson–分布式锁的使用（推荐使用）][Redisson_Redisson 1]
 *  [【分布式锁】Redisson分布式锁底层原理][Redisson]
 *  [【Redisson】Redisson–限流器][Redisson_Redisson 2]

#### 文章目录 ####

*  前言
 *  一、在SpringBoot中快速集成
 *  二、增删改查骚操作
 *   *  2.1、字符串操作
     *  2.2、对象操作
     *  2.3、哈希操作
     *  2.4、列表操作
     *  2.5、集合操作
     *  2.6、有序集合操作

## 前言 ##

什么是 Redisson？来自于官网上的描述内容如下！

> Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格客户端（In-Memory Data  
> Grid）。它不仅提供了一系列的 redis  
> 常用数据结构命令服务，还提供了许多分布式服务，例如分布式锁、分布式对象、分布式集合、分布式远程服务、分布式调度任务服务等等。

相比于 Jedis、Lettuce 等基于 redis 命令封装的客户端，Redisson 提供的功能更加高端和抽象，逼格高！

更多功能特性和开发文档说明，可用移步github进行获取，访问地址如下：

> https://github.com/redisson/redisson/wiki/目录

之前用的Redis，都是用的原生的RedisTempale或者是StringRedisTemplate，各种API非常的难易记忆，每次用的时候还得去网上查询API文档，真是麻烦。所以我在想，能不能自己提供一个Redis的便捷工具。按道理，几乎每个公司都会有一套RedisService的实现，但是在我看来还是不够完美，功能不算是强大。无意间在网上看到了Redisson，号称是Redis正确使用姿势。

Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。

## 一、在SpringBoot中快速集成 ##

Redisson是建立在Redis的基础之上的，所以需要在SpringBoot项目中引入Redis。配置Redis传送门：第二节 String典型场景。下面是快速集成Redisson的步骤。

1.  导入依赖。这里提供了阿里云镜像仓库地址，不知道为什么，我直接走中央仓库导不上Redisson的包，所以从阿里云下载的依赖包。

<dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>3.8.2</version>
            </dependency>
     
        </dependencies>
     
        <repositories>
            <repository>
                <id>public</id>
                <name>aliyun nexus</name>
                <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
                <releases>
                    <enabled>true</enabled>
                </releases>
            </repository>
        </repositories>
        <pluginRepositories>
            <pluginRepository>
                <id>public</id>
                <name>aliyun nexus</name>
                <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
                <releases>
                    <enabled>true</enabled>
                </releases>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </pluginRepository>
        </pluginRepositories>

1.  在SpringBoot中增加RedisClient配置类。我这里是单机部署的方法，集群配置方式以及更多属性的配置，可参考官方大佬文档：Redisson官方文档。配置这两步就TM结束了。下面就来操作安排一波。

package com.tyzhou.redisson;
     
    import org.redisson.Redisson;
    import org.redisson.api.RedissonClient;
    import org.redisson.config.Config;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.stereotype.Component;
     
    @Configuration
    @Component
    public class RedissonConfig {
        
        private static final Logger LOGGER = LoggerFactory.getLogger(RedissonConfig.class);
     
        /**
         * https://github.com/redisson/redisson/wiki/
         */
        @Bean
        public RedissonClient redissonClient() {
        
            Config config = new Config();
            config.useSingleServer().setAddress("yourRedisUrl:port");                                   
                                          //.setPassword("yourRedisPwd");
            RedissonClient redisson = Redisson.create(config);
            return redisson;
        }
    }

## 二、增删改查骚操作 ##

创建一个比较简单的Controller。User对象以及UserMapper自己生成一下，User有两三个简单的属性，UserMapper就是对User对象对应的数据库表进行的增删改查操作。

package com.tyzhou.redisson.controller;
     
    import com.tyzhou.mail.mapper.MUserMapper;
    import com.tyzhou.mail.modol.MUser;
    import org.redisson.api.RBucket;
    import org.redisson.api.RedissonClient;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
     
    @RestController
    @RequestMapping(value = "redisson")
    public class BaseController {
        
        private static final Logger LOGGER = LoggerFactory.getLogger(BaseController.class);
     
        private static final String USER_BUCKET_KEY = "USER_BUCKET_KEY::";
        @Autowired
        private MUserMapper userMapper;
     
        @Autowired
        private RedissonClient redisson;
    }

每个Redisson对象实例都会有一个与之对应的Redis数据实例。Redisson的分布式RBucket对象是一种通用对象桶可以用来存放任类型的对象。

先来写新增和查询。先通过redisson对象通过getBucket方法，在Redis中创建一个字符串类型的对象。这个对象的引用就是下面的bucket，它可以存放任意的MUser对象实体。RBucket桶的神奇功能是：可直接存储MUser对象，省略了我们的MUser对象转为JSON字符串的过程。RBucket对象可以视为Redis中的 String类型，每个RBucket对象对应着一个值。

*  先插入数据库，操作成功后，将MUser对象通过RBucket存放到Redis中。
 *  查询的时候，通过KEY找到桶。再通过get() 方法取出缓存在Redis中的 指定的KEY的VALUE。
 *  修改就是通过KEY找到这个桶RBucket，然后重新SET一下。
 *  删除更简单了，找到这个桶，调用delete相关方法即可。

@PostMapping("/addUser")
        public Integer insert(@RequestBody MUser user) {
        
            user.setId(null);
            int res = userMapper.insertSelective(user);
            if (res > 0) {
        
                RBucket<MUser> bucket = redisson.getBucket(USER_BUCKET_KEY + user.getId());
                //塞入缓存
                bucket.set(user);
            }
            return user.getId();
        }
     
        @GetMapping("/getUser")
        public MUser insert(@RequestParam Integer userId) {
        
     
            RBucket<MUser> bucket = redisson.getBucket(USER_BUCKET_KEY + userId);
            if (bucket != null) {
        
                return bucket.get();
            }
            return null;
        }
     
          @PostMapping("/updateUser")
        public Integer update(@RequestBody MUser user) {
        
     
            int res = userMapper.updateByPrimaryKeySelective(user);
            if (res > 0) {
        
                RBucket<MUser> bucket = redisson.getBucket(USER_BUCKET_KEY + user.getId());
                //更新缓存
                bucket.set(user);
            }
            return user.getId();
        }
     
        @PostMapping("/deleteUser")
        public MUser delete(@RequestParam Long id) {
        
     
            int res = userMapper.deleteByPrimaryKey(id);
            MUser user = null;
            if (res > 0) {
        
                RBucket<MUser> bucket = redisson.getBucket(USER_BUCKET_KEY + id);
                //删除并获取
                user = bucket.getAndDelete();
            }
            return user;
        }

### 2.1、字符串操作 ###

Redisson 支持通过RBucket对象来操作字符串数据结构，通过RBucket实例可以设置value或设置value和有效期，简单样例如下！

//字符串操作
    RBucket<String> rBucket =  redissonClient.getBucket("strKey");
    // 设置value和key的有效期
    rBucket.set("张三", 30, TimeUnit.SECONDS);
    // 通过key获取value
    System.out.println(redissonClient.getBucket("strKey").get());

### 2.2、对象操作 ###

Redisson 支持将对象作为value存入redis，被存储的对象事先必须要实现序列化接口Serializable，否则会报错，简单样例如下！

public class Student implements Serializable {
        
    
        private Long id;
    
        private String name;
    
        private Integer age;
    
       //set、get...
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    //Student对象
    Student student = new Student();
    student.setId(1L);
    student.setName("张三");
    student.setAge(18);
    
    //对象操作
    RBucket<Student> rBucket =  redissonClient.getBucket("objKey");
    // 设置value和key的有效期
    rBucket.set(student, 30, TimeUnit.SECONDS);
    // 通过key获取value
    System.out.println(redissonClient.getBucket("objKey").get());

### 2.3、哈希操作 ###

Redisson 支持通过RMap对象来操作哈希数据结构，简单样例如下！

//哈希操作
    RMap<String, String> rMap = redissonClient.getMap("mapkey");
    // 设置map中key-value
    rMap.put("id", "123");
    rMap.put("name", "赵四");
    rMap.put("age", "50");
    
    //设置过期时间
    rMap.expire(30, TimeUnit.SECONDS);
    // 通过key获取value
    System.out.println(redissonClient.getMap("mapkey").get("name"));

### 2.4、列表操作 ###

Redisson 支持通过RList对象来操作列表数据结构，简单样例如下！

//字符串操作
    RList<Student> rList = redissonClient.getList("listkey");
    
    Student student1 = new Student();
    student1.setId(1L);
    student1.setName("张三");
    student1.setAge(18);
    rList.add(student1);
    
    Student student2 = new Student();
    student2.setId(2L);
    student2.setName("李四");
    student2.setAge(19);
    rList.add(student2);
    
    //设置过期时间
    rList.expire(30, TimeUnit.SECONDS);
    // 通过key获取value
    System.out.println(redissonClient.getList("listkey"));

### 2.5、集合操作 ###

Redisson 支持通过RSet对象来操作集合数据结构，简单样例如下！

//字符串操作
    RSet<Student> rSet = redissonClient.getSet("setkey");
    
    Student student1 = new Student();
    student1.setId(1L);
    student1.setName("张三");
    student1.setAge(18);
    rSet.add(student1);
    
    Student student2 = new Student();
    student2.setId(2L);
    student2.setName("李四");
    student2.setAge(19);
    rSet.add(student2);
    
    //设置过期时间
    rSet.expire(30, TimeUnit.SECONDS);
    // 通过key获取value
    System.out.println(redissonClient.getSet("setkey"));

### 2.6、有序集合操作 ###

Redisson 支持通过RSortedSet对象来操作有序集合数据结构，在使用对象来存储之前，实体对象必须先实现Comparable接口，并重写比较逻辑，否则会报错，简单样例如下！

public class Student implements Serializable, Comparable<Student> {
        
    
        private Long id;
    
        private String name;
    
        private Integer age;
    
        //get、set.....
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Student obj) {
        
            return this.getId().compareTo(obj.getId());
        }
    }
    
    //有序集合操作
    RSortedSet<Student> sortSetkey = redissonClient.getSortedSet("sortSetkey");
    
    Student student1 = new Student();
    student1.setId(1L);
    student1.setName("张三");
    student1.setAge(18);
    sortSetkey.add(student1);
    
    Student student2 = new Student();
    student2.setId(2L);
    student2.setName("李四");
    student2.setAge(19);
    sortSetkey.add(student2);
    
    // 通过key获取value
    System.out.println(redissonClient.getSortedSet("sortSetkey"));

[Redisson_Redisson]: https://writer.blog.csdn.net/article/details/131525498
[Redisson_Redisson_Bloom Filter]: https://writer.blog.csdn.net/article/details/130690257
[Redisson_Redisson 1]: https://writer.blog.csdn.net/article/details/130613740
[Redisson]: https://writer.blog.csdn.net/article/details/130793760
[Redisson_Redisson 2]: https://writer.blog.csdn.net/article/details/131530310