Redis基础

IT机器猫

已于 2025-01-08 22:26:31 修改

阅读量891

点赞数 20

分类专栏：微服务文章标签： redis 数据库缓存

于 2025-01-08 22:22:52 首次发布

本文链接：https://blog.youkuaiyun.com/cgrs5572/article/details/145018917

版权

微服务专栏收录该内容

5 篇文章

订阅专栏

Redis相关概念

Redis（Remote Dictionary Service，即远程字典服务）是一个基于内存的key-value结构数据库。
- 它存储的value类型比较丰富，也被称为结构化的NoSql数据库。
  - NoSql（Not Only SQL），不仅仅是SQL，泛指非关系型数据库。NoSql数据库并不是要取代关系型数据库，而是关系型数据库的补充。
- Redis特点
  - 基于内存存储，读写性能高
  - 适合存储热点数据（热点商品、资讯、新闻）
  - 企业应用广泛
- Redis用途
  - 数据缓存
  - 消息队列
  - 注册中心
  - 发布订阅
关系型数据库（RDBMS）
- Mysql
- Oracle
- DB2
- SQLServer
非关系型数据库(NoSql)：
- Redis
- Mongo db
- MemCached

Redis下载与安装

Redis安装包分为windows版和Linux版：
- Windows版下载地址：https://github.com/microsoftarchive/redis/releases
- Linux版下载地址： https://download.redis.io/releases/
- 下载后得到下面安装包：

Windows版本安装

直接将Redis的windows版压缩包解压到对应目录下即可安装成功，解压后目录结构如下：

Linux版本安装

Step1： 将Redis的Linux版安装包上传到Linux的root目录下
Step2： 解压安装包到与root目录同级的usr/local目录下：tar -zxvf redis-7.0.15.tar.gz -C /usr/local
Step3： 安装Redis的依赖环境gcc：yum install gcc-c++
Step4： 进入到解压后的redis-7.0.15目录下：cd /usr/local/redis-7.0.15
Step5： 编译：make
Step6： 进入redis的src目录进行安装：make install
重点文件所在目录
- Redis服务启动脚本：/usr/local/redis-7.0.15/src/redis-server
- Redis客户端脚本：/usr/local/redis-7.0.15/src/redis-cli
- Redis配置文件：/usr/local/redis-7.0.15/redis.conf

Redis服务启动、连接与停止

注意
- 通过redis-cli.exe命令默认连接的是本地的redis服务，并且使用默认6379端口。也可以通过指定参数连接：redis-cli.exe -h ip地址 -p 端口号 -a 密码
- 默认情况下无密码
- 若要停止Redis服务则按Ctrl+C即可停止
- 若想要退出客户端则命令为：exit或quit
- Windows端的Redis无法通过配置文件来支持Redis后台运行，只有Linux端可以通过配置文件来支持Redis后台运行
- 设置Redis服务密码时只需要将配置文件中的 # requirepass foobared 配置项取消注释，默认为注释状态。foobared为密码，可以根据情况自己指定。
- Redis服务默认只能客户端本地连接，不允许客户端远程连接。若要远程连接则只需要将配置文件中的 bind 127.0.0.1 配置项注释掉。
配置文件注意事项
- Redis配置文件中#表示注释
- Redis配置文件中的配置项前面不能有空格，需要顶格写
- daemonize：用来指定redis是否要用守护线程的方式启动，设置成yes时，代表开启守护进程模式。在该模式下，redis会在后台运行
- requirepass：设置Redis的连接密码
- bind：如果指定了bind，则说明只允许来自指定网卡的Redis请求。如果没有指定，就说明可以接受来自任意一个网卡的Redis请求。
- 修改配置文件后需要重启Redis服务配置才能生效，并且启动Redis服务时需要显示的指定配置文件
  - Windows
  - Linux
```
# 进入Redis安装目录
cd /usr/local/redis-7.0.15
# 启动Redis服务，指定使用的配置文件
./src/redis-server ./redis.conf
```

Windows版本

Redis前台启动

Step1： 进入到redis目录下双击redis-server.exe即可启动成功

Redis连接

Step1： 进入到redis目录下双击redis-cli.exe即可启动成功

Redis设置密码

连接本地redis时默认无密码，若想要设置密码则需要按照以下步骤来设置

Step1： 打开Redis的配置文件redis.windows.conf，找到requirepass
Step2： 将其注释去掉，然后自定义密码后，保存退出即可
Step3： 重新启动redis-server.exe，此时启动时必须通过命令行窗口指明配置文件，否则密码不会生效
- **Step3-1：**在redis目录下按Shift+右键打开Powershell窗口
- Step3-2： 输入命令./redis-server.exe ./redis.windows.conf启动redis服务
Step4： 再次打开一个Powershell窗口来运行本地redis-cli进行测试

Redis后台启动

Windows版本下无法通过配置文件来支持Redis来后台启动，所以步骤如下

Step1： 进入到redis目录下，并在该目录下通过cmd打开命令行窗口
Step2： 安装redis服务到任务管理器：redis-server.exe --service-install redis.windows.conf --loglevel verbose
Step3： 打开任务管理器→服务，查看是否存在Redis服务

然后即可通过任务管理器来手动控制Redis服务的启动与停止，后续步骤演示命令形式开启或停止Redis服务
Step4： 启动Redis服务：redis-server --service-start

通过命令行启动成功后，任务管理器中对应的Redis服务也会自动启动，如图所示
Step5： 验证是否启动成功
Step6： 停止Redis服务：redis-server --service-stop

通过命令行停止成功后，任务管理器中对应的Redis服务也会自动停止，如图所示
Windows版本的Redis若设置为后台启动时，此时若更改了配置文件，则后台启动的Redis会自动使配置文件中的更改生效
- 比如说我设置了密码，若未配置后台启动，则前台启动时若想要密码生效则必须显示的指定配置文件；但是若配置了后台启动则不需要显示指定配置文件，此时配置文件会自动生效

Linux版本

Redis前台启动

Step1： 进入到redis目录的src目录下：cd /usr/local/redis-7.0.15/src
Step2： 执行Redis服务启动的脚本文件redis-server：./redis-server

Redis连接

为了清楚演示Redis连接，所以会复制CentOSDocker的标签，打开一个新的CentOSDocker，如图所示

在这里插入图片描述

Step1： 进入到redis目录的src目录下：cd /usr/local/redis-7.0.15/src
Step2： 执行Redis服务的客户端脚本文件redis-cli：./redis-cli

Redis后台启动

Redis服务启动成功后，默认为前台启动，若想要在后台启动则需要修改Redis的配置文件

Step1： 进入到redis目录下：cd /usr/local/redis-7.0.15
Step2： 打开并编辑redis.con文件：vim redis.conf
Step3： 进入该文件后直接摁/，后跟要查找的内容来定位到前后台启动的命令：/dae，然后回车即可
Step4： 通过/dae找到daemonize后将其由no改为yes，然后保存退出即可
Step5： 此时运行时就不能只运行redis-server了，需要在其后面加上配置文件
- Step5-1： 进入到redis目录
- Step5-2： 启动redis：src/redis-server ./redis.conf
Step6： 输入命令查看后台是否启动成功： ps -ef | grep redis

Redis设置密码

连接本地redis时默认无密码，若想要设置密码则需要按照以下步骤来设置

Step1： 进入到redis目录下：cd /usr/local/redis-7.0.15
Step2： 打开并编辑redis.con文件：vim redis.conf
Step3： 通过/requirepass foobared找到requirepass foobared
Step4： 将注释去掉，然后自定义密码并保存退出
Step5： 输入命令查看后台是否有正在运行的redis-server： ps -ef | grep redis
Step6： 杀死后台正在运行的redis-server：kill -9 进程id
Step7： 重新启动redis-server：src/redis-server ./redis.conf
Step8： 运行redis-cli进行测试
在测试中可以看出有密码时有两种连接方式
- 方式一：在启动redis-cli后利用auth 密码进行密码验证
- 方式二：在启动redis-cli时用-a 密码进行密码验证登录

Redis远程连接

Redis若想要其他人远程连接到自己的Redis时需要开启远程连接权限配置，否则其他人无法连接

Step1： 进入到redis目录下：cd /usr/local/redis-7.0.15
Step2： 打开并编辑redis.con文件：vim redis.conf
Step3： 通过/band找到bind 127.0.0.1 -::1
- bind 127.0.0.1 -::1：代表只有本地可以连接到Redis服务
Step4： 将bind 127.0.0.1 -::1利用#注释起来，然后保存退出即可
Step5： 输入命令查看后台是否有正在运行的redis-server： ps -ef | grep redis
Step6： 杀死后台正在运行的redis-server：kill -9 进程id
Step7： 重新启动redis-server：src/redis-server ./redis.conf
Step8： 利用Windows端的Redis来进行连接测试
- Step8-1： 在redis目录下按Shift+右键打开Powershell窗口
- Step8-2： 输入命令测试是否能够远程连接Redis服务：./redis-cli.exe -h ip地址 -p端口号 -a 密码

Redis客户端图形工具

默认提供的客户端连接工具界面不太友好，同时操作也较为麻烦，所以引入一个Redis客户端图形工具。

客户端图形工具一

在这里插入图片描述

Step1： 新建连接
Step2： 连接成功后界面如下

Redis数据类型

在这里插入图片描述

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：
- 字符串(string)：普通字符串，常用
- 哈希(hash)：适合存储对象
- 列表(list)：按照插入顺序排序，可以有重复元素
- 集合(set)：无序集合，没有重复元素
- 有序集合(sorted set / zset)：集合中每个元素关联一个分数（score），根据分数升序排序，没有重复元素

Redis常用命令

字符串string操作命令

Redis 中字符串类型常用命令：

命令	解释
`SET key value`	设置指定key以及该key对应的值
`GET key`	获取指定key对应的值
`SETEX key seconds value`	设置指定key的值，并将 key 的过期时间设为 seconds 秒
`SETNX key value`	只有在 key 不存在时设置 key 的值

参数	解释
SET	设置键（key）值（value）
SETEX	设置键（key）值（value）以及键的过期时间的命令
key	键（key）的名称
value	键（key）对应的值
seconds	键（key）的过期时间，单位为秒。一旦过期时间到达，键会被自动删除

更多命令可以参考Redis中文官网

SET key value
- 若指定的键（key）不存在，则会先创建键（key），然后设置该键（key）的值为value
- 若指定的键（key）存在，则会将该键（key）的值更改为value
GET key
- 若键（key）不存在，则返回(nil)
- 若键（key）存在，则返回该键（key）对应的值（value）
SETEX key seconds value
- 若指定的键（key）不存在，则会设置键（key）值（value）以及键（key）的过期时间。一旦过期时间到达，键（key）会被自动删除
- 若指定的键（key）存在，则会更新键（key）对应的值（value），并为键（key）设置过期时间。。一旦过期时间到达，键（key）会被自动删除
SETNX key value
- 如果键（key）不存在，SETNX 会将键（key）设置为指定的 value，并返回 1
- 如果键（key）已经存在，则 SETNX 不会修改键（key）的值，直接返回 0
- SETNX是一个原子操作，可用于实现分布式锁
代码示例

哈希hash操作命令

哈希hash结构由图可知：哈希hash结构也是键值对组合，不过值中又分为字段和该字段所对应的值

Redis hash 是一个string类型的 field 和 value 的映射表，hash特别适合用于存储对象，常用命令：

命令	解释
`HSET key field value`	将哈希表 key 中的字段 field 的值设为 value
`HGET key field`	获取存储在哈希表中指定字段的值
`HDEL key field`	删除存储在哈希表中的指定字段
`HKEYS key`	获取哈希表中所有字段
`HVALS key`	获取哈希表中所有值
`HGETALL key`	获取在哈希表中指定 key 的所有字段和值

在这里插入图片描述

列表list操作命令

Redis 列表是简单的字符串列表，按照插入顺序排序，取元素时按照后进先出的原则，即尾部元素先出

常用命令

命令	解释
`LPUSH key value1 [value2]`	将一个或多个值插入到列表头部
`LRANGE key start stop`	获取列表指定范围内的元素
`RPOP key`	移除并获取列表最后一个元素（即移除头部元素）
`LLEN key`	获取列表长度
`BRPOP key1 [key2 ] timeout`	移出并获取列表的最后一个元素（即移除头部元素），如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止

在这里插入图片描述

集合set操作命令

Redis set 是string类型的无序集合 。集合成员是唯一的，这就意味着集合中不能出现重复的数据

常用命令

命令	解释
`SADD key member1 [member2]`	向集合的键（key）中添加一个或多个成员
`SMEMBERS key`	返回集合的键（key）中的所有成员
`SCARD key`	获取集合的键（key）中的成员总数
`SINTER key1 [key2]`	返回所有给定集合的键（key）中的交集
`SUNION key1 [key2]`	返回所有给定集合的键（key）中的并集
`SDIFF key1 [key2]`	返回所有给定集合的键（key）中的差集
`SREM key member1 [member2]`	移除集合的键（key）中的一个或多个成员

SDIFF key1 [key2]------返回所有给定集合的键（key）中的差集
- 它会返回只在键key1中存在，但是在key2中不存在的元素
代码示例

有序集合sorted set操作命令

Redis sorted set 有序集合是 string 类型元素的集合，且不允许重复的成员。每个元素都会关联一个double类型的分数(score) 。redis会通过分数来为集合中的成员进行从小到大排序。有序集合的成员是唯一的，但分数却可以重复

常用命令

命令	解释
`ZADD key score1 member1 [score2 member2]`	向有序集合的键（key）中添加一个或多个成员，或者更新已存在成员的分数
`ZRANGE key start stop [WITHSCORES]`	通过索引区间返回有序集合的键（key）中指定区间内的成员。若加上`WITHSCORES`则会返回成员以及成员所对应的分数
`ZINCRBY key increment member`	对有序集合的键（key）中的指定成员的分数加上增量 increment
`ZREM key member [member ...]`	移除有序集合的键（key）中的一个或多个成员

在这里插入图片描述

通用命令

Redis中的通用命令，主要是针对key进行操作的相关命令：

命令	解释
`KEYS pattern`	查找所有符合给定模式( pattern)的 key，比如`kEYS *`：查看所有的key
`EXISTS key`	检查给定 key 是否存在
`TYPE key`	返回 key 所储存的值的类型
`EXPIRE key seconds`	设置指定key在缓存中的存活时间
`TTL key`	返回给定 key 的剩余生存时间(TTL, time to live)，以秒为单位。若返回-1，则代表该key永久存在；若返回-2，则代表该key已过期或不存在
`DEL key`	删除已存在的key
`RENAME key newkey`	给指定的key重命名为newKey
`PING`	测试连接是否正常

在这里插入图片描述

在Java中操作Redis

Redis 的 Java 客户端很多，官方推荐的有三种：
- dis
- Lettuce
- Redisson
注意：Spring 对 Redis 客户端进行了整合，提供了 Spring Data Redis，在Spring Boot项目中还提供了对应的Starter，即 spring-boot-starter-data-redis

Jedis

快速入门

Step1： 创建一个普通的Maven工程项目JedisDemo

Step2： 在该项目的pom.xml文件中导入相关坐标

jedis坐标
Junit坐标：主要用来在测试包下测试redis

<!--Junit坐标-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>
<!--Jedis坐标-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.2.0</version>
</dependency>

Step3： 在测试包下创建测试类JedisTest，并在该类下创建测试方法testOne，代码如下：

Step3-1： 创建Jedis对象获取连接：需要指定ip地址以及端口号
Step3-2： 执行具体的Redis操作

注意：

在Java中操作Redis的命令与Redis的常用命令一样，此处不在进行详细演示；

此处仅以字符串string操作命令进行演示
Step3-3： 关闭连接

import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.Set;

public class JedisTest {
    @Test
    public void testOne() {
        // 1 获取Redis连接(指定ip地址及端口号)
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.auth("123456");
        // 2 执行具体的操作
        // 2.1 字符串string操作部分相关命令
        jedis.set("username","xiaoming");
        String value = jedis.get("username");
        System.out.println(value);
        //jedis.del("username");
        System.out.println("---------------------------------------");

        // 2.2 哈希hash操作部分相关命令
        jedis.hset("myhash","addr","bj");
        String hValue = jedis.hget("myhash", "addr");
        System.out.println(hValue);
        
        // 2.3 通用操作相关命令
        Set<String> keys = jedis.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }

        // 3 关闭连接
        jedis.close();
    }
}

Spring Data Redis

Spring Data Redis 是 Spring 的一部分，提供了在 Spring 应用中通过简单的配置就可以访问 Redis 服务，对 Redis 底层开发包进行了高度封装。在 Spring 项目中，可以使用Spring Data Redis来简化 Redis 操作。
网址：https://spring.io/projects/spring-data-redis

使用SpringData Redis时需要在pom.xml文件中导入坐标

若为普通maven项目，则导入如下坐标

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>3.4.1</version>
</dependency>

若为SpringBoot项目，则导入如下坐标

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Spring Data Redis对Redis 底层开发包进行了高度封装------Spring Data Redis中提供了一个高度封装的类：RedisTemplate

该类针对Jedis客户端中的大量api进行了归类封装,并将同一类型操作封装为operation接口，operation接口共有5类：

operation接口	解释
`ValueOperations`	简单K-V操作（String类型数据操作的接口）
`SetOperations`	set类型数据操作
`ZSetOperations`	zset类型数据操作
`HashOperations`	针对hash类型的数据操作
`ListOperations`	针对list类型的数据操作

可通过RedisTemplate接口中的opsForXXX方法来获取到以上五种分类接口对应的对象，如下代码所示：

package at.guigu;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.*;

@SpringBootTest
class SpringDataRedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testGetByOps() {
        //string类型的数据操作对象
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //set类型的数据操作对象
        SetOperations setOperations = redisTemplate.opsForSet();
        //zset类型的数据操作对象
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        //hash类型的数据操作对象
        HashOperations hashOperations = redisTemplate.opsForHash();
        //list类型的数据操作对象
        ListOperations listOperations = redisTemplate.opsForList();
    }
}

环境准备

本项目已上传至Gitee，可自行下载

Step1： 创建一个SpringBoot项目SpringDatademo，具体过程可详见SpringBoot快速入门部分内容，此处只进行不同部分的演示

由于本项目只是为了演示在Java中操作Redis，所以并未在创建项目时导入web以及sql相关坐标，只是一个最基础的SpringBoot项目

注意：若在创建SpringBoot项目时未选中图中所示内容，则需要在创建完SpringBoot项目后手动在pom.xml文件中添加SpringData坐标依赖
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
```

Step2： 在pom.xml文件中添加坐标依赖及相关插件，完整pom.xml文件如下：

单元测试相关坐标：Junit
解决Mockito警告插件：maven-surefire-plugin

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.4.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.heima</groupId>
    <artifactId>SpringDatademo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringDatademo</name>
    <description>SpringDatademo</description>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>21</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.2</version>
                <configuration>
                    <argLine>-javaagent:"${settings.localRepository}/org/mockito/mockito-core/5.14.2/mockito-core-5.14.2.jar"</argLine>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Step3： 将SpringBoot的配置文件application.properties的后缀名改为application.yml，并在该配置文件中进行Redis相关配置，配置文件相关代码如下：

spring:
  application:
    name: SpringDatademo
  data:
    # Redis相关配置
    redis:
      host: localhost # ip地址
      port: 6379 # 端口号
      database: 0 # 操作的是Redis的哪个数据库，此处代表操作0号数据库
      password: 123456 # Redis连接密码
      jedis:
        # Redis连接池配置
        pool:
          max-active: 8 # 最大连接数
          max-wait: 1ms # 连接池最大阻塞等待时间
          max-idle: 4 # 连接池中的最大空闲连接
          min-idle: 0 # 连接池中的最小空闲连接

spring.redis.database：指定使用Redis的哪个数据库，Redis服务启动后默认有16个数据库，编号分别是从0到15。

可以通过修改Redis配置文件来指定数据库的数量。

Step4： 创建与三级架构包同级的config包，并在该包下创建Redis的配置类RedisConfig，代码如下：

Step4-1： 在该类下创建redisTemplate方法，并利用@Bean注解来对该类返回的RedisTemplate<K, V>进行依赖注入到Spring容器中

package at.guigu.config;

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.StringRedisSerializer;

/**
 * Redis配置类
 */
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        // 1 创建Redis模板对象
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

        // 2 设置Redis的key和value的序列化器
        //默认的Key序列化器为：JdkSerializationRedisSerializer  
        // 2.1 设置Redis的key的序列化器（必有）
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 2.2 设置Redis的value的序列化器（可选）
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        // 3 设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        return redisTemplate;
    }
}

注意：

该Redis的配置类RedisConfig不是必须的 ，因为 Spring Boot 框架会自动装配 RedisTemplate 对象，所以在无特殊需求时，可直接通过@Autowired注解来依赖注入RedisTemplate 对象即可

但是默认的key序列化器为JdkSerializationRedisSerializer，导致我们存到Redis中后的数据和原始数据有差别，从而导致我们无法获取到数据，所以创建了Redis的配置类RedisConfig来进行默认key的序列化器配置

一般不需要设置Redis的value的序列化器，因为在Java操作Redis时会自动将其反序列化，除非你要在redis.cli.exe中进行连接并操作redis。此处将Redis的value的序列化器也设置是为了清楚如何修改value的序列化器

Step5： 在测试包下创建测试类SpringDataRedisTest，初始代码如下：

package at.guigu;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class SpringDataRedisTest {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
    }
}

操作字符串类型数据

/**
 * 操作String类型数据
*/
@Test
public void testString(){
    //存值（等同于SET key value）
    redisTemplate.opsForValue().set("city123","beijing");

    //取值（等同于GET key）
    String value = (String) redisTemplate.opsForValue().get("city123");
    System.out.println(value);

    //存值，同时设置过期时间以及过期时间的单位（等同于SETEX key seconds value）
    redisTemplate.opsForValue().set("key1","value1",10l, TimeUnit.SECONDS);

    //存值，如果存在则不执行任何操作（等同于SETNX key value）
    Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("city1234", "nanjing");
    System.out.println(aBoolean);
}

操作哈希类型数据

/**
 * 操作Hash类型数据
*/
@Test
public void testHash(){
    HashOperations hashOperations = redisTemplate.opsForHash();

    //存值（等同于HSET key field value）
    hashOperations.put("002","name","xiaoming");
    hashOperations.put("002","age","20");
    hashOperations.put("002","address","bj");

    //取值（等同于HGET key field）
    String age = (String) hashOperations.get("002", "age");
    System.out.println(age);

    //获得hash结构中的所有字段（等同于HKEYS key）
    Set keys = hashOperations.keys("002");
    for (Object key : keys) {
        System.out.println(key);
    }

    //获得hash结构中的所有值（等同于HVALS key）
    List values = hashOperations.values("002");
    for (Object value : values) {
        System.out.println(value);
    }
    // 删除值(等同于HDEL key field）
    hashOperations.delete("002","age");
}

操作列表类型数据

/**
 * 操作List类型的数据
*/
@Test
public void testList(){
    ListOperations listOperations = redisTemplate.opsForList();

    // 存值---存单个值(等同于LPUSH key value1)
    listOperations.leftPush("mylist","a");
    // 存值---存多个值(等同于LPUSH key value1 [value2])
    listOperations.leftPushAll("mylist","b","c","d");

    // 取值（等同于LRANGE key start stop）
    List<String> mylist = listOperations.range("mylist", 0, -1);
    for (String value : mylist) {
        System.out.println(value);
    }

    // 获得列表长度(等同于LLEN key)
    Long size = listOperations.size("mylist");
    int lSize = size.intValue();
    for (int i = 0; i < lSize; i++) {
        //出队列(等同于RPOP key)
        String element = (String) listOperations.rightPop("mylist");
        // 出队列（等同于BRPOP key1 [key2] timeout）
        // listOperations.rightPop("mylist", 10l, TimeUnit.SECONDS);
        System.out.println(element);
    }
}

操作集合类型数据

/**
 * 操作Set类型的数据
*/
@Test
public void testSet(){
    SetOperations setOperations = redisTemplate.opsForSet();

        // 存值(等同于SADD key member1 [member2])
        setOperations.add("myset","a","b","c","d");
        setOperations.add("myset2","a","b","x","y");

        // 取值(等同于SMEMBERS key)
        Set<String> myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }
        // 获取集合的键中的成员数（等同于SCARD key）
        Long size = setOperations.size("myset");

        // 删除成员(等同于SREM key member1 [member2])
        setOperations.remove("myset","a","b");

        // 取值(等同于SMEMBERS key)
        myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }

        // 返回所有给定集合的键（key）中的交集(等同于SINTER key1 [key2])
        Set intersect = setOperations.intersect("myset", "myset2");
        // 返回所有给定集合的键（key）中的并集(等同于UNION key1 [key2])
        Set union = setOperations.union("myset", "myset2");
        // 返回所有给定集合的键（key）中的差集(等同于SDIFF key1 [key2])
        Set difference = setOperations.difference("myset", "myset2");

}

操作有序集合类型数据

/**
 * 操作ZSet类型的数据
*/
@Test
public void testZset(){
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        // 存值（等同于ZADD key score1 member1 [score2 member2]）
        zSetOperations.add("myZset","a",10.0);
        zSetOperations.add("myZset","b",11.0);
        zSetOperations.add("myZset","c",12.0);
        zSetOperations.add("myZset","a",13.0);

        // 取值（等同于ZRANGE key start stop）
        Set<String> myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }

        // 修改分数（等同于ZINCRBY key increment member）
        zSetOperations.incrementScore("myZset","b",20.0);

        // 取值（等同于ZRANGE key start stop）
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
        

        //删除成员（等同于ZREM key member [member ...]）
        zSetOperations.remove("myZset","a","b");

        // 取值（等同于ZRANGE key start stop）
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
        // 取值（等同于ZRANGE key start stop [WITHSCORES]）
        zSetOperations.rangeWithScores("myZset", 0, -1);
}

通用操作

/**
 * 通用操作，针对不同的数据类型都可以操作
*/
@Test
public void testCommon(){
    // 获取Redis中所有的key（等同于KEYS pattern）
        Set<String> keys = redisTemplate.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }

        // 判断某个key是否存在（等同于EXISTS key）
        Boolean itcast = redisTemplate.hasKey("itcast");
        System.out.println(itcast);

        // 删除指定key（等同于DEL key）
        redisTemplate.delete("myZset");

        // 获取指定key对应的value的数据类型（等同于TYPE key）
        DataType dataType = redisTemplate.type("myset");
        System.out.println(dataType.name());

        // 设置指定key在缓存中的存活时间(等同于EXPIRE key seconds)
        Boolean myZset = redisTemplate.expire("myZset", 10, TimeUnit.SECONDS);

        // 返回给定 key 的剩余生存时间（等同于TTL key）
        Long expireKey = redisTemplate.getExpire("myZset");

        // 给指定的key重命名(等同于RENAME key newkey)
        // 不推荐，因为该方法不论newKey是否存在都会将oldKey改为newKey
        redisTemplate.rename("myZset","myset");
        // 推荐，因为该方法只会在newKey不存在的情况下将oldKey改为newKey
        Boolean b = redisTemplate.renameIfAbsent("myZset", "myset");
}