java——redis随笔——基础

墨蓝 2024-02-25 01:38 50阅读 0赞

![1895087-20231005105303095-2109607495.png][]

![1895087-20231005105242259-2094534440.png][]

![1895087-20231005110032478-437843087.png][]

![1895087-20231005110047355-1903117517.png][]

![1895087-20231005110129056-1650568567.png][]

层级模式：

![1895087-20231005110202820-670867607.png][]

![1895087-20231005110238260-151195632.png][]

![1895087-20231005111737154-790479732.png][]

![1895087-20231005111813961-888994712.png][]

![1895087-20231005111829391-103420343.png][]

![1895087-20231005111900379-1325895664.png][]

![1895087-20231005112411664-318349738.png][]

![1895087-20231005112431896-1954535028.png][]

![1895087-20231005112537605-1826649012.png][]

![1895087-20231005114609232-1665789115.png][]

![1895087-20231005114645548-381178012.png][]

![1895087-20231005114955785-1674964283.png][]

![1895087-20231005115006917-261064229.png][]

redis的java客户端：

![1895087-20231005115319794-1860776677.png][]

重点：

序列化：https://www.cnblogs.com/xiaobaibailongma/p/17111314.html

序列化：https://www.cnblogs.com/xiaobaibailongma/p/17111329.html——重点

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到不同类型中

![1895087-20231005125145135-1853037753.png][]

![1895087-20231005125338562-1778611477.png][]

![1895087-20231005125322492-741579618.png][]

![1895087-20231005125306069-647476097.png][]

RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果就如上图

缺点：

*  可读性差
 *  内存占用较大

我们可以指定别的序列化不使用JDK默认序列化

pom 导入依赖

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-pool2</artifactId>
 </dependency>
 <dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-databind</artifactId>
 </dependency>
 
 
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>

设置RedisTemplate

package com.sofwin.redis;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.RedisSerializer;
 
 import javax.annotation.Resource;
 
 /**
 * @packageName: com.sofwin.redis
 * @author: winter
 * @date: 2023/4/6 19:14
 * @version: 1.0
 * @email 1660420659@qq.com
 * @description: TODO
 */
 @Configuration
 public class RedisConfig {
 
 
 @Bean
 @Resource
 public RedisTemplate<String,Object> getRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
 RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
 //设置连接工厂
 redisTemplate.setConnectionFactory(redisConnectionFactory);
 GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer =
 new GenericJackson2JsonRedisSerializer();
 //key RedisSerializer.string()返回值 --> StringRedisSerializer.UTF_8
 redisTemplate.setKeySerializer(RedisSerializer.string());
 //hash key
 redisTemplate.setHashKeySerializer(RedisSerializer.string());
 //value
 redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
 //hash value
 redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
 return redisTemplate;
 }
 }

![1895087-20231005124806501-164283417.png][]

![1895087-20231005124719723-2118185630.png][]

![1895087-20231005124652586-166742034.png][]

@Autowired
        private StringRedisTemplate stringRedisTemplate;
        //json工具
        private static  final ObjectMapper mapper = new ObjectMapper();
    
        @Test
        public void test03() throws JsonProcessingException {
            User user = new User("虎哥",33);
            //序列化为字符串
            String userString = mapper.writeValueAsString(user);
            stringRedisTemplate.opsForValue().set("strRedisUser:1",userString);
            String obj = stringRedisTemplate.opsForValue().get("strRedisUser:1");
            User user1 = mapper.readValue(obj, User.class);
            System.out.println("user1 = " + user1);
        }

![1895087-20231005124547487-1686810463.png][]

https://cyborg2077.github.io/2022/10/21/RedisBasic/ ——参考笔记

### 初识Redis ###

Redis是一种键值型的NoSQL数据库，这里有两个关键字

*  键值型
 *  NoSQL

其中`键值型`是指Redis中存储的数据都是以Key-Value键值对的形式存储，而Value的形式多种多样，可以使字符串、数值甚至Json

而NoSQL则是相对于传统关系型数据库而言，有很大差异的一种数据库

#### 认识NoSQL ####

`NoSql`可以翻译做Not Only Sql(不仅仅是SQL)，或者是No Sql(非Sql的)数据库。是相对于传统关系型数据库而言，有很大差异的一种特殊的数据库，因此也称之为`非关系型数据库`。

##### 结构化与非结构化 #####

传统关系型数据库是结构化数据，每张表在创建的时候都有严格的约束信息，如字段名、字段数据类型、字段约束等，插入的数据必须遵循这些约束

而NoSQL则对数据库格式没有约束，可以是键值型，也可以是文档型，甚至是图格式

##### 关联与非关联 #####

传统数据库的表与表之间往往存在关联，例如外键约束  
而非关系型数据库不存在关联关系，要维护关系要么靠代码中的业务逻辑，要么靠数据之间的耦合

JSON

例如此处要维护张三与两个手机订单的关系，不得不冗余的将这两个商品保存在张三的订单文档中，不够优雅，所以建议使用业务逻辑来维护关联关系

##### 查询方式 #####

传统关系型数据库会基于Sql语句做查询，语法有统一的标准

SQL

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 </code>
</pre></td> 
 <td> <pre><code>SELECT id, age FROM tb_user WHERE id = 1 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

而不同的非关系型数据库查询语法差异极大

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 </code>
</pre></td> 
 <td> <pre><code>Redis: get user:1 MongoDB: db.user.find({_id: 1}) elasticsearch: GET http://localhost:9200/users/1 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

##### 事务 #####

传统关系型数据库能满足事务的ACID原则(原子性、一致性、独立性及持久性)  
而非关系型数据库汪汪不支持事务，或者不能要个保证ACID的特性，只能实现计本的一致性

##### 总结 #####

<table> 
 <thead> 
 <tr> 
 <th>&nbsp;</th> 
 <th>SQL</th> 
 <th>NoSQL</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>数据结构</td> 
 <td>结构化(Structured)</td> 
 <td>非结构化</td> 
 </tr> 
 <tr> 
 <td>数据关联</td> 
 <td>关联的(Relational)</td> 
 <td>无关联的</td> 
 </tr> 
 <tr> 
 <td>查询方式</td> 
 <td>SQL查询</td> 
 <td>非SQL</td> 
 </tr> 
 <tr> 
 <td>事务特性</td> 
 <td>ACID</td> 
 <td>BASE</td> 
 </tr> 
 <tr> 
 <td>存储方式</td> 
 <td>磁盘</td> 
 <td>内存</td> 
 </tr> 
 <tr> 
 <td>扩展性</td> 
 <td>垂直</td> 
 <td>水平</td> 
 </tr> 
 <tr> 
 <td>使用场景</td> 
 <td>1)数据结构固定 2)对一致性、安全性要求不高</td> 
 <td>1)数据结构不固定 2)相关业务对数据安全性、一致性要求较高 3)对性能要求</td> 
 </tr> 
 </tbody> 
</table>

*  存储方式
    
     *  关系型数据库基于磁盘进行存储，会有大量的磁盘IO，对性能有一定影响
     *  非关系型数据库，他们的操作更多的是依赖于内存来操作，内存的读写速度会非常快，性能自然会好一些

*  扩展性
    
     *  关系型数据库集群模式一般是主从，主从数据一致，起到数据备份的作用，称为垂直扩展。
     *  非关系型数据库可以将数据拆分，存储在不同机器上，可以保存海量数据，解决内存大小有限的问题。称为水平扩展。
     *  关系型数据库因为表之间存在关联关系，如果做水平扩展会给数据查询带来很多麻烦

#### 认识Redis ####

Redis诞生于2009年，全称是Remote Dictionary Server远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征：

*  键值(Key-Value)型，Value支持多种不同的数据结构，功能丰富
 *  单线程，每个命令具有原子性
 *  低延迟，速度快(基于内存、IO多路复用、良好的编码)
 *  支持数据持久化
 *  支持主从集群、分片集群
 *  支持多语言客户端

作者：Antirez

Redis官网：[https://redis.io/][https_redis.io]

#### 安装Redis ####

关于Redis的安装，我在之前的这篇文章做过详细的说明，这里就不赘述了

[![6335135c16f2c2beb100182d.jpg][]][6335135c16f2c2beb100182d.jpg]

Redis入门

https://cyborg2077.github.io/2022/10/17/ReggieRedis/

#### Redis桌面客户端 ####

安装完成Redis，我们就可以操作Redis，实现数据的CRUD了。这需要用到Redis客户端，包括：

*  命令行客户端
 *  图形化桌面客户端
 *  编程客户端

##### Redis命令行客户端 #####

Redis安装完成后就自带了命令行客户端：redis-cli，使用方式如下：

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 </code>
</pre></td> 
 <td> <pre><code>redis-cli [options] [commonds] </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

其中常见的options有：

*  `-h 127.0.0.1`：指定要连接的redis节点的IP地址，默认是127.0.0.1
 *  `-p 6379`：指定要连接的redis节点的端口，默认是6379
 *  `-a 123321`：指定redis的访问密码

其中的commonds就是Redis的操作命令，例如：

*  `ping`：与redis服务端做心跳测试，服务端正常会返回\`pong

##### 图形化桌面客户端 #####

安装包：[https://github.com/lework/RedisDesktopManager-Windows/releases][https_github.com_lework_RedisDesktopManager-Windows_releases]

Redis默认有16个仓库，编号从0至15. 通过配置文件可以设置仓库数量，但是不超过16，并且不能自定义仓库名称。

如果是基于redis-cli连接Redis服务，可以通过select命令来选择数据库：

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>## 选择0号数据库 select 0 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

### Redis常用命令 ###

Redis是典型的key-value数据库，key一般是字符串，而value包含很多不同的数据类型

[![63527eb616f2c2beb12beb85.jpg][]][63527eb616f2c2beb12beb85.jpg]

#### Redis通用命令 ####

常用的通用命令有以下几个

<table> 
 <thead> 
 <tr> 
 <th>命令</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>KEYs pattern</td> 
 <td>查找所有符合给定模式(pattern)的key</td> 
 </tr> 
 <tr> 
 <td>EXISTs key</td> 
 <td>检查给定key是否存在</td> 
 </tr> 
 <tr> 
 <td>TYPE key</td> 
 <td>返回key所储存的值的类型</td> 
 </tr> 
 <tr> 
 <td>TTL key</td> 
 <td>返回给定key的剩余生存时间(TTL, time to live)，以秒为单位</td> 
 </tr> 
 <tr> 
 <td>DEL key</td> 
 <td>该命令用于在key存在是删除key</td> 
 </tr> 
 </tbody> 
</table>

*  `KEYS`：查看符合模板的所有key
    
     *  不建议在生产环境设备上使用，因为Redis是单线程的，执行查询的时候会阻塞其他命令，当数据量很大的时候，使用KEYS进行模糊查询，效率很差
 *  `DEL`：删除一个指定的key
    
     *  也可以删除多个key，`DEL name age`，会将name和age都删掉
 *  `EXISTS`：判断key是否存在
    
     *  `EXISTS name`，如果存在返回1，不存在返回0
 *  `EXPIRE`：给一个key设置有效期，有效期到期时该key会被自动删除
    
     *  `EXPIRE name 20`，给name设置20秒有效期，到期自动删除
 *  `TTL`：查看一个key的剩余有效期(Time-To-Live)
    
     *  `TTL name`，查看name的剩余有效期，如果未设置有效期，则返回-1

#### String类型 ####

String类型，也就是字符串类型，是Redis中最简单的存储类型  
其value是字符串，不过根据字符串的格式不同，又可以分为3类

*  `string`：普通字符串
 *  `int`：整数类型，可以做自增、自减操作
 *  `float`：浮点类型，可以做自增、自减操作  
    不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同，字符串类型的最大空间不能超过512M

##### String的常用命令 #####

String的常用命令有

<table> 
 <thead> 
 <tr> 
 <th>命令</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>SET</td> 
 <td>添加或者修改一个已经存在的String类型的键值对</td> 
 </tr> 
 <tr> 
 <td>GET</td> 
 <td>根据key获取String类型的value</td> 
 </tr> 
 <tr> 
 <td>MEST</td> 
 <td>批量添加多个String类型的键值对</td> 
 </tr> 
 <tr> 
 <td>MGET</td> 
 <td>根据多个key获取多个String类型的value</td> 
 </tr> 
 <tr> 
 <td>INCR</td> 
 <td>让一个整形的key自增1</td> 
 </tr> 
 <tr> 
 <td>INCRBY</td> 
 <td>让一个整形的key自增并指定步长值，例如：incrby num 2，让num值自增2</td> 
 </tr> 
 <tr> 
 <td>INCRBYFLOAT</td> 
 <td>让一个浮点类型的数字自增并指定步长值</td> 
 </tr> 
 <tr> 
 <td>SETNX</td> 
 <td>添加一个String类型的键值对，前提是这个key不存在，否则不执行，可以理解为真正的<code>新</code>增</td> 
 </tr> 
 <tr> 
 <td>SETEX</td> 
 <td>添加一个String类型的键值对，并指定有效期</td> 
 </tr> 
 </tbody> 
</table>

##### Key结构 #####

* Redis没有类似MySQL中Table的概念，那么我们该如何区分不同类型的Key呢？
 * 例如：需要存储用户、商品信息到Redis，有一个用户的id是1，有一个商品的id恰好也是1，如果此时使用id作为key，那么就回冲突，该怎么办？
 * 我们可以通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范
 
 * Redis的key允许有多个单词形成层级结构，多个单词之间用`:`隔开，格式如下
 
 PLAINTEXT
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 </code>
 </pre></td> 
 <td> <pre><code>项目名:业务名:类型:id </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 这个格式也并非是固定的，可以根据自己的需求来删除/添加词条，这样我们就可以把不同数据类型的数据区分开了，从而避免了key的冲突问题
 * 例如我们的项目名叫reggie，有user和dish两种不同类型的数据，我们可以这样定义key
 
 * user相关的key：`reggie:user:1`
 * dish相关的key：`reggie:dish:1`
 * 如果value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储

<table> 
 <thead> 
 <tr> 
 <th>KEY</th> 
 <th>VALUE</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>reggie:user:1</td> 
 <td>{“id”:1, “name”: “Jack”, “age”: 21}</td> 
 </tr> 
 <tr> 
 <td>reggie:dish:1</td> 
 <td>{“id”:1, “name”: “鲟鱼火锅”, “price”: 4999}</td> 
 </tr> 
 </tbody> 
</table>

*  并且在Redis的桌面客户端中，也会以相同前缀作为层次结构，让数据看起来层次分明，关系清晰

#### Hash类型 ####

*  Hash类型，也叫散列，其中value是一个无序字典，类似于Java中的HashMap结构
 *  String结构是将对象序列化为JSON字符串后存储，当我们要修改对象的某个属性值的时候很不方便

*  Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD

<table> 
 <tbody> 
 <tr> 
 <td>KEY</td> 
 <td colspan="2">VALUE</td> 
 </tr> 
 <tr> 
 <td>field</td> 
 <td>value</td> 
 </tr> 
 <tr> 
 <td>reggie:user:1</td> 
 <td>name</td> 
 <td>Jack</td> 
 </tr> 
 <tr> 
 <td>age&nbsp;</td> 
 <td>21</td> 
 </tr> 
 <tr> 
 <td> reggie:user:2</td> 
 <td>name&nbsp;</td> 
 <td>Rose</td> 
 </tr> 
 <tr> 
 <td>age&nbsp;</td> 
 <td>18</td> 
 </tr> 
 </tbody> 
</table>

*  Hash的常用命令有

<table> 
 <thead> 
 <tr> 
 <th>命令</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>HSET key field value</td> 
 <td>添加或者修改hash类型key的field的值</td> 
 </tr> 
 <tr> 
 <td>HGET key field</td> 
 <td>获取一个hash类型key的field的值</td> 
 </tr> 
 <tr> 
 <td>HMSET</td> 
 <td>批量添加多个hash类型key的field的值</td> 
 </tr> 
 <tr> 
 <td>HMGET</td> 
 <td>批量获取多个hash类型key的field的值</td> 
 </tr> 
 <tr> 
 <td>HGETALL</td> 
 <td>获取一个hash类型的key中的所有的field和value</td> 
 </tr> 
 <tr> 
 <td>HKEYS</td> 
 <td>获取一个hash类型的key中的所有的field</td> 
 </tr> 
 <tr> 
 <td>HINCRBY</td> 
 <td>让一个hash类型key的字段值自增并指定步长</td> 
 </tr> 
 <tr> 
 <td>HSETNX</td> 
 <td>添加一个hash类型的key的field值，前提是这个field不存在，否则不执行</td> 
 </tr> 
 </tbody> 
</table>

#### List类型 ####

*  Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。
 *  特征也与LinkedList类似：
    
     *  有序
     *  元素可以重复
     *  插入和删除快
     *  查询速度一般
 *  常用来存储一个有序数据，例如：朋友圈点赞列表，评论列表等。
 *  List的常见命令有：

<table> 
 <thead> 
 <tr> 
 <th>命令</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>LPUSH key element …</td> 
 <td>向列表左侧插入一个或多个元素</td> 
 </tr> 
 <tr> 
 <td>LPOP key</td> 
 <td>移除并返回列表左侧的第一个元素，没有则返回nil</td> 
 </tr> 
 <tr> 
 <td>RPUSH key element …</td> 
 <td>向列表右侧插入一个或多个元素</td> 
 </tr> 
 <tr> 
 <td>RPOP key</td> 
 <td>移除并返回列表右侧的第一个元素</td> 
 </tr> 
 <tr> 
 <td>LRANGE key star end</td> 
 <td>返回一段角标范围内的所有元素</td> 
 </tr> 
 <tr> 
 <td>BLPOP和BRPOP</td> 
 <td>与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil</td> 
 </tr> 
 </tbody> 
</table>

#### Set类型 ####

*  Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：
    
     *  无序
     *  元素不可重复
     *  查找快
     *  支持交集、并集、差集等功能
 *  Set的常见命令有：

<table> 
 <thead> 
 <tr> 
 <th>命令</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>SADD key member …</td> 
 <td>向set中添加一个或多个元素</td> 
 </tr> 
 <tr> 
 <td>SREM key member …</td> 
 <td>移除set中的指定元素</td> 
 </tr> 
 <tr> 
 <td>SCARD key</td> 
 <td>返回set中元素的个数</td> 
 </tr> 
 <tr> 
 <td>SISMEMBER key member</td> 
 <td>判断一个元素是否存在于set中</td> 
 </tr> 
 <tr> 
 <td>SMEMBERS</td> 
 <td>获取set中的所有元素</td> 
 </tr> 
 <tr> 
 <td>SINTER key1 key2 …</td> 
 <td>求key1与key2的交集</td> 
 </tr> 
 <tr> 
 <td>SUNION key1 key2 …</td> 
 <td>求key1与key2的并集</td> 
 </tr> 
 <tr> 
 <td>SDIFF key1 key2 …</td> 
 <td>求key1与key2的差集</td> 
 </tr> 
 </tbody> 
</table>

练习题：

1.  将下列数据用Redis的Set集合来存储：

*  张三的好友有：李四、王五、赵六

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; sadd zhangsan lisi wangwu zhaoliu (integer) 3 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  李四的好友有：王五、麻子、二狗

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; sadd lisi wangwu mazi ergou (integer) 3 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

1.  利用Set的命令实现下列功能：

*  计算张三的好友有几人

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; scard zhangsan (integer) 3 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  计算张三和李四有哪些共同好友

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; sinter zhangsan lisi 1) "wangwu" </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  查询哪些人是张三的好友却不是李四的好友

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; sdiff zhangsan lisi 1) "zhaoliu" 2) "lisi" </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  查询张三和李四的好友总共有哪些人

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; sunion zhangsan lisi 1) "wangwu" 2) "zhaoliu" 3) "ergou" 4) "lisi" 5) "mazi" </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  判断李四是否是张三的好友

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; sismember zhangsan lisi (integer) 1 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  判断张三是否是李四的好友

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; sismember lisi zhangsan (integer) 0 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  将李四从张三的好友列表中移除

BASH

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; srem zhangsan lisi (integer) 1 </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

#### SortedSet类型 ####

*  Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表(SkipList)加 hash表。
 *  SortedSet具备下列特性：
    
     *  可排序
     *  元素不重复
     *  查询速度快
 *  因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。
 *  SortedSet的常见命令有：

<table> 
 <thead> 
 <tr> 
 <th>命令</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>ZADD key score member</td> 
 <td>添加一个或多个元素到sorted set ，如果已经存在则更新其score值</td> 
 </tr> 
 <tr> 
 <td>ZREM key member</td> 
 <td>删除sorted set中的一个指定元素</td> 
 </tr> 
 <tr> 
 <td>ZSCORE key member</td> 
 <td>获取sorted set中的指定元素的score值</td> 
 </tr> 
 <tr> 
 <td>ZRANK key member</td> 
 <td>获取sorted set 中的指定元素的排名</td> 
 </tr> 
 <tr> 
 <td>ZCARD key</td> 
 <td>获取sorted set中的元素个数</td> 
 </tr> 
 <tr> 
 <td>ZCOUNT key min max</td> 
 <td>统计score值在给定范围内的所有元素的个数</td> 
 </tr> 
 <tr> 
 <td>ZINCRBY key increment member</td> 
 <td>让sorted set中的指定元素自增，步长为指定的increment值</td> 
 </tr> 
 <tr> 
 <td>ZRANGE key min max</td> 
 <td>按照score排序后，获取指定排名范围内的元素</td> 
 </tr> 
 <tr> 
 <td>ZRANGEBYSCORE key min max</td> 
 <td>按照score排序后，获取指定score范围内的元素</td> 
 </tr> 
 <tr> 
 <td>ZDIFF、ZINTER、ZUNION</td> 
 <td>求差集、交集、并集</td> 
 </tr> 
 </tbody> 
</table>

注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可，例如：

*  `升序`获取sorted set 中的指定元素的排名：ZRANK key member
 *  `降序`获取sorted set 中的指定元素的排名：ZREVRANK key memeber

* 练习题：
 
 * 将班级的下列学生得分存入Redis的SortedSet中：
 * Jack 85, Lucy 89, Rose 82, Tom 95, Jerry 78, Amy 92, Miles 76
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zadd stu 85 Jack 89 Lucy 82 Rose 95 Tom 78 Jerry 92 Amy 76 Miles (integer) 7 </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 并实现下列功能：
 
 * 删除Tom同学
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zrem stu Tom (integer) 1 </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 获取Amy同学的分数
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zscore stu Amy "92" </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 获取Rose同学的排名
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zrank stu Rose (integer) 2 </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 查询80分以下有几个学生
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zcount stu 0 80 (integer) 2 </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 给Amy同学加2分
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zincrby stu 2 Amy "94" </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 查出成绩前3名的同学
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zrange stu 0 2 1) "Miles" 2) "Jerry" 3) "Rose" </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 * 查出成绩80分以下的所有同学
 
 BASH
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 </code>
 </pre></td> 
 <td> <pre><code>127.0.0.1:6379&gt; zrangebyscore stu 0 80 1) "Miles" 2) "Jerry" </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>

### Redis的Java客户端 ###

*  目前主流的Redis的Java客户端有三种
    
     *  Jedis和Lettuce：这两个主要是提供了Redis命令对应的API，方便我们操作Redis，而SpringDataRedis又对这两种做了抽象和封装，因此我们后期会直接以SpringDataRedis来学习。
     *  Redisson：是在Redis基础上实现了分布式的可伸缩的java数据结构，例如Map、Queue等，而且支持跨进程的同步机制：Lock、Semaphore等待，比较适合用来实现特殊的功能需求。

#### Jedis客户端 ####

##### 快速入门 #####

* 使用Jedis的步骤
 
 1. 导入Jedis的maven坐标
 
 XML
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 8 9 10 11 12 13 </code>
 </pre></td> 
 <td> <pre><code>&lt;!--jedis--&gt; &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;version&gt;3.7.0&lt;/version&gt; &lt;/dependency&gt; &lt;!--单元测试--&gt; &lt;dependency&gt; &lt;groupId&gt;org.junit.jupiter&lt;/groupId&gt; &lt;artifactId&gt;junit-jupiter&lt;/artifactId&gt; &lt;version&gt;5.7.0&lt;/version&gt; &lt;scope&gt;test&lt;/scope&gt; &lt;/dependency&gt; </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 1. 建立连接 
 新建一个单元测试类
 
 JAVA
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 8 9 10 11 </code>
 </pre></td> 
 <td> <pre><code>private Jedis jedis; @BeforeEach void setUp() { //1. 建立连接 jedis = new Jedis("101.42.225.160", 6379); //2. 设置密码 jedis.auth("root"); //3. 选择库 jedis.select(0); } </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 1. 测试
 
 JAVA
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 </code>
 </pre></td> 
 <td> <pre><code>@Test void testString(){ jedis.set("name","Kyle"); String name = jedis.get("name"); System.out.println("name = " + name); } @Test void testHash(){ jedis.hset("reggie:user:1","name","Jack"); jedis.hset("reggie:user:2","name","Rose"); jedis.hset("reggie:user:1","age","21"); jedis.hset("reggie:user:2","age","18"); Map&lt;String, String&gt; map = jedis.hgetAll("reggie:user:1"); System.out.println(map); } </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>
 
 1. 释放资源
 
 JAVA
 
 <table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 </code>
 </pre></td> 
 <td> <pre><code>@AfterEach void tearDown(){ if (jedis != null){ jedis.close(); } } </code>
 </pre></td> 
 </tr> 
 </tbody> 
 </table>

##### 连接池 #####

*  `Jedis`本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。
 *  新建一个`com.blog.util`，用于存放我们编写的工具类
 *  但后面我们使用`SpringDataRedis`的时候，可以直接在`yml`配置文件里配置这些内容

JAVA

*  之后我们的测试类就可以修改为如下

JAVA

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 </code>
</pre></td> 
 <td> <pre><code>@SpringBootTest class RedisTestApplicationTests { private Jedis jedis = JedisConnectionFactory.getJedis(); @Test void testString(){ jedis.set("name","Kyle"); String name = jedis.get("name"); System.out.println("name = " + name); } @Test void testHash(){ jedis.hset("reggie:user:1","name","Jack"); jedis.hset("reggie:user:2","name","Rose"); jedis.hset("reggie:user:3","name","Kyle"); jedis.hset("reggie:user:1","age","21"); jedis.hset("reggie:user:2","age","18"); jedis.hset("reggie:user:3","age","18"); Map&lt;String, String&gt; map = jedis.hgetAll("reggie:user:1"); System.out.println(map); } @AfterEach void tearDown(){ if (jedis != null){ jedis.close(); } } } </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

#### SpringDataRedis客户端 ####

*  SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis
 *  官网地址：[https://spring.io/projects/spring-data-redis][https_spring.io_projects_spring-data-redis]
    
     *  提供了对不同Redis客户端的整合(Lettuce和Jedis)
     *  提供了RedisTemplate统一API来操作Redis
     *  支持Redis的发布订阅模型
     *  支持Redis哨兵和Redis集群
     *  支持基于Lettuce的响应式编程
     *  支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
     *  支持基于Redis的JDKCollection实现
 *  SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：

<table> 
 <thead> 
 <tr> 
 <th>API</th> 
 <th>返回值类型</th> 
 <th>说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>redisTemplate.opsForValue()</td> 
 <td>ValueOperations</td> 
 <td>操作String类型数据</td> 
 </tr> 
 <tr> 
 <td>redisTemplate.opsForHash()</td> 
 <td>HashOperations</td> 
 <td>操作Hash类型数据</td> 
 </tr> 
 <tr> 
 <td>redisTemplate.opsForList()</td> 
 <td>ListOperations</td> 
 <td>操作List类型数据</td> 
 </tr> 
 <tr> 
 <td>redisTemplate.opsForSet()</td> 
 <td>SetOperations</td> 
 <td>操作Set类型数据</td> 
 </tr> 
 <tr> 
 <td>redisTemplate.opsForzSet()</td> 
 <td>ZSetOperations</td> 
 <td>操作SortedSet类型数据</td> 
 </tr> 
 <tr> 
 <td>redisTemplate</td> 
 <td>&nbsp;</td> 
 <td>通用的命令</td> 
 </tr> 
 </tbody> 
</table>

##### 快速入门 #####

SpringBoot已经提供了对SpringDataRedis的支持，使用起来非常简单

1.  导入依赖，

XML

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 </code>
</pre></td> 
 <td> <pre><code>&lt;!--redis依赖--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt; &lt;!--common-pool--&gt; &lt;dependency&gt; &lt;groupId&gt;org.apache.commons&lt;/groupId&gt; &lt;artifactId&gt;commons-pool2&lt;/artifactId&gt; &lt;/dependency&gt; &lt;!--Jackson依赖--&gt; &lt;dependency&gt; &lt;groupId&gt;com.fasterxml.jackson.core&lt;/groupId&gt; &lt;artifactId&gt;jackson-databind&lt;/artifactId&gt; &lt;/dependency&gt; &lt;!--lombok--&gt; &lt;dependency&gt; &lt;groupId&gt;org.projectlombok&lt;/groupId&gt; &lt;artifactId&gt;lombok&lt;/artifactId&gt; &lt;optional&gt;true&lt;/optional&gt; &lt;/dependency&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-test&lt;/artifactId&gt; &lt;scope&gt;test&lt;/scope&gt; &lt;/dependency&gt; </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

1.  配置Redis

YML

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 8 9 10 11 </code>
</pre></td> 
 <td> <pre><code>spring: redis: host: 101.42.225.160 port: 6379 password: root lettuce: pool: max-active: 8 max-idle: 8 min-idle: 0 max-wait: 100ms </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

1.  注入RedisTemplate  
    因为有了SpringBoot的自动装配，我们可以拿来就用

JAVA

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 </code>
</pre></td> 
 <td> <pre><code>@Autowired private RedisTemplate redisTemplate; </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

1.  编写测试方法

JAVA

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 </code>
</pre></td> 
 <td> <pre><code>@Test void stringTest(){ redisTemplate.opsForValue().set("username","David"); String username = (String) redisTemplate.opsForValue().get("username"); System.out.println(username); } </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

##### 自定义序列化 #####

*  RedisTemplate可以接收任意Object作为值写入Redis
 *  只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的

> \\xAC\\xED\\x00\\x05t\\x00\\x06\\xE5\\xBC\\xA0\\xE4\\xB8\\x89

*  缺点：
    
     *  可读性差
     *  内存占用较大
 *  我们可以自定义RedisTemplate的序列化方式，代码如下  
    在`com.blog.config`包下编写对应的配置类

JAVA

*  我们编写一个User类，并尝试将其创建的对象存入Redis，看看是什么效果

JAVA

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 </code>
</pre></td> 
 <td> <pre><code>@Data @AllArgsConstructor @NoArgsConstructor public class User { private String name; private Integer age; } </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  测试方法

JAVA

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 </code>
</pre></td> 
 <td> <pre><code>@Test void stringTest(){ redisTemplate.opsForValue().set("userdata",new User("张三",18)); } </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  这里采用了JSON序列化来代替默认的JDK序列化方式。最终结果如下：

JSON

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 </code>
</pre></td> 
 <td> <pre><code>{
 "@class": "com.blog.entity.User", "name": "张三", "age": 18 } </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  整体可读性有了很大提升，并且能将Java对象自动的序列化为JSON字符串，并且查询时能自动把JSON反序列化为Java对象。不过，其中记录了序列化时对应的class名称，目的是为了查询时实现自动反序列化。这会带来额外的内存开销。
 *  所以肯定会有更好的方法

##### StringRedisTemplate #####

*  为了节省内存空间，我们可以不使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。
 *  因为存入和读取时的序列化及反序列化都是我们自己实现的，SpringDataRedis就不会将class信息写入Redis了
 *  这种用法比较普遍，因此SpringDataRedis就提供了RedisTemplate的子类：StringRedisTemplate，它的key和value的序列化方式默认就是String方式。源码如下

JAVA

<table> 
 <tbody> 
 <tr> 
 <td> <pre><code>1 2 3 4 5 6 7 </code>
</pre></td> 
 <td> <pre><code>public class StringRedisTemplate extends RedisTemplate&lt;String, String&gt; { public StringRedisTemplate() { this.setKeySerializer(RedisSerializer.string()); this.setValueSerializer(RedisSerializer.string()); this.setHashKeySerializer(RedisSerializer.string()); this.setHashValueSerializer(RedisSerializer.string()); } </code>
</pre></td> 
 </tr> 
 </tbody> 
</table>

*  省去了我们自定义RedisTemplate的序列化方式的步骤(可以将之前配置的RedisConfig删除掉)，而是直接使用：

JAVA

*  存入Redis中是这样的

JSON

[1895087-20231005105303095-2109607495.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/1820fa94bd9e4b30a63e7ad95be10c05.png
[1895087-20231005105242259-2094534440.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/ca46d01c8fdd4b89b164946e73aaf39e.png
[1895087-20231005110032478-437843087.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/20a8073987914281b9a0d35e17bcfa3f.png
[1895087-20231005110047355-1903117517.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/9673715933d64c3d818b68b652c7ce77.png
[1895087-20231005110129056-1650568567.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/3b775a35ac3b48d7967181fe1daebe2c.png
[1895087-20231005110202820-670867607.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/d9437877b1d94e958c3d18e892021fa1.png
[1895087-20231005110238260-151195632.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/a7f61b9f78734e3294e370bc28a5cb57.png
[1895087-20231005111737154-790479732.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/d0f69297b52349af953c122c1d498ea1.png
[1895087-20231005111813961-888994712.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/05879208436c49c6ba5dd5f54b25b3ad.png
[1895087-20231005111829391-103420343.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/cace66fbb3ab4ae6b1a98cd9511e0a1a.png
[1895087-20231005111900379-1325895664.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/696669fd2cdf48e1a23fcd2f8a8b87fc.png
[1895087-20231005112411664-318349738.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/d41ad6b425c44a28b56936e9c7a4cd29.png
[1895087-20231005112431896-1954535028.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/427f5fe99e0a48b2b7b20868cf343dda.png
[1895087-20231005112537605-1826649012.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/4f0905a5d6a74f279e2e0ac1c434d916.png
[1895087-20231005114609232-1665789115.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/7841da80ff534e95b9248cdda6055495.png
[1895087-20231005114645548-381178012.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/20ab7219338a4c67aa5ed66224926484.png
[1895087-20231005114955785-1674964283.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/5f8136c899c7426787c95d41b8f947ed.png
[1895087-20231005115006917-261064229.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/9cd11f83bc4f4ea482cf2730fb3e9165.png
[1895087-20231005115319794-1860776677.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/b1c3973d9b7141eb816139ec8f7c3deb.png
[1895087-20231005125145135-1853037753.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/afb28e85962a4118b8c85327fd2d26a3.png
[1895087-20231005125338562-1778611477.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/6e6391b1b60b42669bd7cef91a8c6c88.png
[1895087-20231005125322492-741579618.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/0ec9aa2d307a466a81d5f8f3d374dedf.png
[1895087-20231005125306069-647476097.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/5dced0eef17e4a808317e4bfd6ce6009.png
[1895087-20231005124806501-164283417.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/017cda5917354e96b30e5902dfd69b1e.png
[1895087-20231005124719723-2118185630.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/4ee0f2b565e241f293cc2328ed33ae89.png
[1895087-20231005124652586-166742034.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/f1dffe0218da4737850586b2d739fe8f.png
[1895087-20231005124547487-1686810463.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/74bf9a9e0ca942cc8fc63627d2472514.png
[https_redis.io]: https://redis.io/
[6335135c16f2c2beb100182d.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/f1541e85a62640b6b9c4d7454122f773.png
[https_github.com_lework_RedisDesktopManager-Windows_releases]: https://github.com/lework/RedisDesktopManager-Windows/releases
[63527eb616f2c2beb12beb85.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/5800018e05884c80a9ed7adbe87b4067.png
[https_spring.io_projects_spring-data-redis]: https://spring.io/projects/spring-data-redis