Redis 基础篇
一. Redis 快速入门
1.初识Redis
1.1 认识NoSQL
非关系型数据库:
- 键值对没有固定的要求,如: 长度等 (非结构化)
- 不会在一张表上使用外键将两张表关联在一起 (无关联的)
- 不是使用sql语句查询 (非SQL)
- 没有事务 (没有ACID的特征)
1.2 认识Redis
Redis诞生于2009年全称是Re mote Di ctionary Server，远程词典服务器，是一个基于内存的键值型NoSQL数据库。
特征：
- 键值（key-value）型，value支持多种不同数据结构，功能丰富
- 单线程，每个命令具备原子性
- 低延迟，速度快（基于内存、IO多路复用、良好的编码）。
- 支持数据持久化
- 支持主从集群、分片集群
- 支持多语言客户端
1.3 安装Redis
此处选择的Linux版本为CentOS 7
Redis的官方网站地址：https://redis.io/
1.3.1 单机安装Redis
-
安装Redis依赖Redis是基于C语言编写的，因此首先需要安装Redis所需要的gcc依赖：
yum install -y gcc tcl -
上传安装包并解压到
/usr/local/src
解压命令: tar -xzf redis-6.2.6.tar.gz
- 进入redis目录, 进行安装
shell
cd redis-6.2.6
make && make install
# 编译 安装- 默认的安装路径是在
/usr/local/bin目录下
shell
[kiddkid@myvm bin]$ ls
redis-benchmark redis-check-rdb redis-sentinel
redis-check-aof redis-cli redis-server- 该目录已经默认配置到环境变量，因此可以在任意目录下运行这些命令。其中：
- redis-cli：是redis提供的 命令行客户端
- redis-server：是redis的 服务端启动脚本
- redis-sentinel：是redis的 哨兵启动脚本
- 启动redis的启动方式有很多种，例如：
- 默认启动
- 指定配置启动
- 开机自启
-
默认启动安装完成后，在任意目录输入redis-server命令即可启动Redis：
redis-server
这种启动属于 前台启动 ，会阻塞整个会话窗口，窗口关闭或者按下CTRL + C则Redis停止。不推荐使用。 -
指定配置启动如果要让Redis以后台 方式启动，则必须修改Redis配置文件，就在我们之前解压的redis安装包下（
/usr/local/src/redis-6.2.6），名字叫redis.conf- 备份配置文件
shell
cp redis.conf redis.conf.bck- 修改redis.conf文件中的一些配置
properties
# 允许访问的地址，默认是127.0.0.1，会导致只能在本地访问。修改为0.0.0.0则可以在任意IP访问，生产环境不要设置为0.0.0.0
bind 0.0.0.0
# 守护进程，修改为yes后即可后台运行
daemonize yes
# 密码，设置后访问Redis必须输入密码
requirepass 123456- Redis的其它常见配置
properties
# 监听的端口
port 6379
# 工作目录，默认是当前目录，也就是运行redis-server时的命令，日志、持久化等文件会保存在这个目录
dir .
# 数据库数量，设置为1，代表只使用1个库，默认有16个库，编号0~15
databases 1
# 设置redis能够使用的最大内存
maxmemory 512mb
# 日志文件，默认为空，不记录日志，可以指定日志文件名
logfile "redis.log"- 启动Redis
shell
# 进入redis安装目录
cd /usr/local/src/redis-6.2.6
# 启动
redis-server redis.conf- 停止服务
shell
# 利用redis-cli来执行 shutdown 命令，即可停止 Redis 服务，
# 因为之前配置了密码，因此需要通过 -u 来指定密码
redis-cli -u 123456 shutdown- 开机自启通过配置来实现开机自启
- 新建一个系统服务文件
shell
vim /etc/systemd/system/redis.service * 内容如下
properties
[Unit]
Description=redis-server
After=network.target
[Service]
Type=forking
ExecStart=/usr/local/bin/redis-server /usr/local/src/redis-6.2.6/redis.conf
PrivateTmp=true
[Install]
WantedBy=multi-user.target- 重载系统服务
shell
systemctl daemon-reload * 我们可以用下面这组命令来操作redis
shell
# 启动
systemctl start redis
# 停止
systemctl stop redis
# 重启
systemctl restart redis
# 查看状态
systemctl status redis
# 开机自启
systemctl enable redis1.3.2 Redis客户端
安装完成Redis，我们就可以操作Redis，实现数据的CRUD了。这需要用到Redis客户端，包括：
- 命令行客户端
- 图形化桌面客户端
- 编程客户端
- Redis命令行客户端
Redis安装完成后就自带了命令行客户端：redis-cli，使用方式如下：
redis-cli [options] [commonds]
其中常见的options有：
-h 127.0.0.1：指定要连接的redis节点的IP地址，默认是127.0.0.1-p 6379：指定要连接的redis节点的端口，默认是6379-a 123456：指定redis的访问密码
其中的commonds就是Redis的操作命令，例如：
ping：与redis服务端做心跳测试，服务端正常会返回pong
不指定commond时，会进入redis-cli的交互控制台：
shell
# 方式1 : 直接输入密码
[root@myvm bin]# redis-cli -h 192.168.198.130 -p 6379 -a 123456
Warning: Using a password with '-a' or '-u' option on the command line interface may not be safe. # 提示不安全
192.168.198.130:6379> ping
PONG
192.168.198.130:6379>
# 方式2 : 通过auth命令来指定密码
[root@myvm bin]# redis-cli -h 192.168.198.130 -p 6379
192.168.198.130:6379> AUTH 123456
OK
192.168.198.130:6379> ping
PONG- 图形化桌面客户端
GitHub上的大神编写了Redis的图形化桌面客户端，地址：https://github.com/uglide/RedisDesktopManager
不过该仓库提供的是RedisDesktopManager的源码，并未提供windows安装包。
在下面这个仓库可以找到安装包：https://github.com/lework/RedisDesktopManager-Windows/releases
选择 rdm-xxxx.x.zip
- 安装
- 解压后运行安装程序即可安装 (安装在win下)
- 关闭虚拟机防火墙
192.168.198.130:6379> systemctl stop firewalld- 若不关闭将连接失败
- 建立连接
- 点击左上角的
连接到Redis服务器按钮：
- 在弹出的窗口的 连接设置 中填写Redis服务信息：
- 点击即可建立连接
- 点击左上角的
Redis默认有16个仓库，编号从0至15. 通过配置文件可以设置仓库数量，但是不超过16，并且不能自定义仓库名称。
如果是基于redis-cli连接Redis服务，可以通过select命令来选择数据库：
shell
# 选择 0号库
select 02.Redis 常见命令
2.1 Redis数据结构介绍
Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样：
- 查看不同类型的命令
- 官网https://redis.io/commands
- 使用help命令
2.2 Redis通用指令
通用指令是不分数据类型的，都可以使用的指令，常见的有：
KEYS：查看符合模板的所有key
- DEL：删除一个指定的key
- EXISTS：判断key是否存在
- EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除
- TTL：查看一个KEY的剩余有效期
通过help [command] 可以查看一个命令的具体用法，例如：
2.3 String类型
String类型，也就是字符串类型，是Redis中最简单的存储类型。
其value是字符串，不过根据字符串的格式不同，又可以分为3类：
- string：普通字符串
- int：整数类型，可以做自增、自减操作
- float：浮点类型，可以做自增、自减操作
不管是哪种格式，底层都是 字节数组 形式存储，只不过是 编码方式 不同。字符串类型的最大空间不能超过512m.
- String的常见命令有：
- SET：添加 或者 修改 已经存在的一个String类型的键值对
- GET：根据key获取String类型的 value
- MSET：批量 添加多个String类型的键值对
- MGET：根据 多个key 获取 多个String类型的value
- INCR：让一个 整型 的key自增1
- INCRBY:让一个 整型 的key自增 并 指定步长，例如：incrby num 2 让num值自增2
- INCRBYFLOAT：让一个 浮点类型 的数字 自增 并 指定步长
- SETNX：添加一个 String类型的键值对，前提是这个key不存在，否则不执行
- SETEX：添加一个 String类型的键值对，并且 指定有效期
- 参考实例
shell
# 查看所有键
192.168.198.130:6379> KEYS *
1) "age"
2) "name"
# 查看a开头的所有键
192.168.198.130:6379> KEYS a*
1) "age"
# 查看del命令的作用
192.168.198.130:6379> help del
DEL key [key ...]
summary: Delete a key
since: 1.0.0
group: generic
# 删除键
192.168.198.130:6379> del name
(integer) 1
192.168.198.130:6379> KEYS *
1) "age"
# 设置多个键值对
192.168.198.130:6379> MSET k1 v1 k2 v2 k3 v3
OK
192.168.198.130:6379> KEYS *
1) "age"
2) "k3"
3) "k1"
4) "k2"
# 删除多个键
192.168.198.130:6379> DEL k1 k2 k3 k4
(integer) 3
192.168.198.130:6379> KEYS *
1) "age"
# 查看exists的作用
192.168.198.130:6379> help exists
EXISTS key [key ...]
summary: Determine if a key exists
since: 1.0.0
group: generic
# 查看key是否存在
192.168.198.130:6379> EXISTS age
(integer) 1 # 存在
192.168.198.130:6379> EXISTS name
(integer) 0 # 不存在
192.168.198.130:6379> MSET k1 v1 k2 v2 k3 v3
OK
# 查看多个键
192.168.198.130:6379> MGET name age k1 k2 k3
1) "Jack"
2) "18"
3) "v1"
4) "v2"
5) "v3"
# int增长
192.168.198.130:6379> get age
"18"
192.168.198.130:6379> INCR age
(integer) 19
192.168.198.130:6379> get age
"19"
192.168.198.130:6379> incr age
(integer) 20
192.168.198.130:6379> get age
"20"
# 指定步长
192.168.198.130:6379> INCRBY age 2
(integer) 22
192.168.198.130:6379> INCRBY age 2
(integer) 24
# 实现步减
192.168.198.130:6379> INCRBY age -1
(integer) 25
192.168.198.130:6379> DECR age
(integer) 24
# float增长, 没有默认步长, 必须指定步长
192.168.198.130:6379> set score 10.1
OK
192.168.198.130:6379> INCRBYFLOAT score 0.5
"10.6"
192.168.198.130:6379> INCRBYFLOAT score 0.5
"11.1"
192.168.198.130:6379> INCRBYFLOAT score 0.5
"11.6"
192.168.198.130:6379> get score
"11.6"- key的结构
- Redis的key允许有多个单词形成层级结构，多个单词之间用':'隔开，格式如下：
项目名:业务名:类型:id这个格式并非固定，也可以根据自己的需求来删除或添加词条。- 例如我们的项目名称叫 heima，有user和product两种不同类型的数据，我们可以这样定义key：
- user相关的key：
heima:user:1 - product相关的key：
heima:product:1
如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储：
| KEY | VALUE |
|---|---|
| heima:user:1 | {"id":1, "name": "Jack", "age": 21} |
| heima:product:1 | {"id":1, "name": "小米11", "price": 4999} |
2.4 Hash类型
Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。
- String结构是将对象序列化为JSON字符串后存储，当需要修改对象某个字段时很不方便：
- Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD：
- Hash类型的常见命令
- HSET key field value：添加 或者 修改hash类型key的 field 的值
- HGET key field：获取一个hash类型key的 field的值
- HMSET：批量添加 多个hash类型 key的field的值
- HMGET：批量获取 多个hash类型 key的field的值
- HGETALL：获取一个hash类型的key 中的所有的 field和value
- HKEYS：获取一个hash类型的 key中的所有的 field
- HVALS：获取一个hash类型的 key中的所有的 value
- HINCRBY:让一个hash类型key的字段值 自增 并 指定步长
- HSETNX：添加一个hash类型的key的 field 值，前提是这个field不存在，否则不执行
- 参考实例
shell
192.168.198.130:6379> HSET heima:user:3 name Lucy
(integer) 1
192.168.198.130:6379> HSET heima:user:3 age 21
(integer) 1
192.168.198.130:6379> HSET heima:user:3 age 17
(integer) 0
192.168.198.130:6379> HGET heima:user:3 name
"Lucy"
192.168.198.130:6379> HGET heima:user:3 age
"17"
192.168.198.130:6379> HMSET heima:user:4 name LiLei age 20 sex man
OK
192.168.198.130:6379> HMGET heima:user:4 name age sex
1) "LiLei"
2) "20"
3) "man"
# 获取所有hash键值对 类似java entrySet()
192.168.198.130:6379> HGETALL heima:user:4
1) "name"
2) "LiLei"
3) "age"
4) "20"
5) "sex"
6) "man"
# 获取所有键 类似keySet()
192.168.198.130:6379> HKEYS heima:user:4
1) "name"
2) "age"
3) "sex"
# 获取所有值 类似valueSet()
192.168.198.130:6379> HVALS heima:user:4
1) "LiLei"
2) "20"
3) "man"
192.168.198.130:6379> HINCRBY heima:user:4 age 2
(integer) 22
....
192.168.198.130:6379> HINCRBY heima:user:4 age 2
(integer) 28
192.168.198.130:6379> HVALS heima:user:4
1) "LiLei"
2) "28"
3) "man"
192.168.198.130:6379> HINCRBY heima:user:4 age -2
(integer) 26
192.168.198.130:6379> HINCRBY heima:user:4 age -2
(integer) 24
192.168.198.130:6379> HSETNX heima:user:4 sex woman
(integer) 0 # 已存在sex, 设置失败
192.168.198.130:6379> HSETNX heima:user:3 sex woman
(integer) 1 # 设置成功
192.168.198.130:6379> HGETALL heima:user:3
1) "name"
2) "Lucy"
3) "age"
4) "17"
5) "sex"
6) "woman"
2.5 List类型
Redis中的List类型与Java中的LinkedList类似，可以看做是一个 双向链表结构 。既可以支持正向检索和也可以支持反向检索。
特征也与LinkedList类似：
- 有序
- 元素可以重复
- 插入和删除快
- 查询速度一般
常用来存储一个 有序数据，例如：朋友圈点赞列表，评论列表等。
-
List类型的常见命令
- LPUSH key element ... ：向列表左侧插入一个或多个元素
- LPOP key：移除并返回列表左侧的第一个元素，没有则返回nil
- RPUSH key element ... ：向列表右侧插入一个或多个元素
- RPOP key：移除并返回列表右侧的第一个元素
- LRANGE key star end：返回一段角标范围内的所有元素
- BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil
-
实现栈 队列 阻塞队列
- 如何利用List结构模拟一个栈?
- 入口和出口在同一边
- 如何利用List结构模拟一个队列?
- 入口和出口在不同边
- 如何利用List结构模拟一个阻塞队列?
- 入口和出口在不同边
- 出队时采用BLPOP或BRPOP
- 如何利用List结构模拟一个栈?
-
参考实例
shell
192.168.198.130:6379> LPUSH users 1 2 3
(integer) 3
192.168.198.130:6379> RPUSH users 4 5 6
(integer) 6
192.168.198.130:6379> LPOP users 1
1) "3"
192.168.198.130:6379> RPOP users 1
1) "6"
192.168.198.130:6379> LRANGE users 1 2
1) "1"
2) "4"
192.168.198.130:6379> BLPOP users 2
1) "users"
2) "2"
192.168.198.130:6379> BLPOP users2 100
-------------------------
# 另一个用户登录操作
[kiddkid@myvm ~]$ redis-cli
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> LPUSH users2 jack
(integer) 1
-------------------------
# 该用户查到数据, 返回
1) "users2"
2) "jack"
(66.56s)2.6 Set类型
Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：
- 无序
- 元素不可重复
- 查找快
- 支持交集、并集、差集等功能
- Set类型的常见命令
- SADD key member ... ：向set中添加一个或多个元素
- SREM key member ... : 移除set中的指定元素
- SCARD key： 返回set中 元素的个数
- SISMEMBER key member：判断 一个元素 是否存在于set中
- SMEMBERS：获取set中的所有元素
- SINTER key1 key2 ... ：求key1与key2的交集
- SADD key member ... ：向set中添加一个或多个元素
- SREM key member ... : 移除set中的指定元素
- SCARD key： 返回set中元素的个数
- SISMEMBER key member：判断一个元素是否存在于set中
- SMEMBERS：获取set中的所有元素
- SINTER key1 key2 ... ：求key1与key2的交集
- SDIFF key1 key2 ... ：求key1与key2的差集
- SUNION key1 key2 ...：求key1和key2的并集
- Set命令的练习
- 将下列数据用Redis的Set集合来存储：•张三的好友有：李四、王五、赵六•李四的好友有：王五、麻子、二狗利用Set的命令实现下列功能：•计算张三的好友有几人•计算张三和李四有哪些共同好友•查询哪些人是张三的好友却不是李四的好友•查询张三和李四的好友总共有哪些人•判断李四是否是张三的好友•判断张三是否是李四的好友•将李四从张三的好友列表中移除
shell
192.168.198.130:6379> SADD zs lisi wangwu zhaoliu
(integer) 3
192.168.198.130:6379> SADD ls wangwu mazi ergou
(integer) 3
192.168.198.130:6379> scard zs
(integer) 3
192.168.198.130:6379> SINTER zs ls
1) "wangwu"
192.168.198.130:6379> SUNION zs ls
1) "wangwu"
2) "zhaoliu"
3) "lisi"
4) "mazi"
5) "ergou"
192.168.198.130:6379> SISMEMBER zs lisi
(integer) 1
192.168.198.130:6379> SISMEMBER ls zhangsan
(integer) 0
192.168.198.130:6379> SREM zs lisi
(integer) 1
192.168.198.130:6379> SMEMBERS zs
1) "wangwu"
2) "zhaoliu"2.7 SortedSet类型
Redis的SortedSet是一个可排序的set集合，与Java中的 TreeSet 有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。
SortedSet具备下列特性：
- 可排序
- 元素不重复
- 查询速度快
因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。
-
SortedSet类型的常见命令
- ZADD key score member：添加一个或多个元素到sorted set ，如果已经存在则更新其score值
- ZREM key member：删除sorted set中的一个指定元素
- ZSCORE key member : 获取sorted set中的指定元素的score值
- ZRANK key member：获取sorted set 中的指定元素的排名
- ZCARD key：获取sorted set中的元素个数
- ZCOUNT key min max：统计 score值 在给定范围内的所有元素的个数
- ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值
- ZRANGE key min max：按照score排序后，获取指定排名 范围内的元素
- ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围 内的元素
- ZDIFF、ZINTER、ZUNION：求差集、交集、并集
- 注意：所有的排名默认都是升序 ，如果要降序则在命令的Z后面添加REV即可
-
SortedSet命令练习
- 此处将加REV和未加的作对比
- 将班级的下列学生得分存入Redis的SortedSet中：Jack 85, Lucy 89, Rose 82, Tom 95, Jerry 78, Amy 92, Miles 76•并实现下列功能：•删除Tom同学•获取Amy同学的分数•获取Rose同学的排名•查询80分以下有几个学生•给Amy同学加2分•查出成绩前3名的同学•查出成绩80分以下的所有同学
shell
192.168.198.130:6379> ZADD stus 85 Jack 82 Rose 95 Tom 78 Jerry 92 Amy 76 Miles 89 Lucy
(integer) 7
192.168.198.130:6379> ZREM stus Tom
(integer) 1
192.168.198.130:6379> ZRANK stus Rose
(integer) 2 # 升序后的下标
192.168.198.130:6379> ZREVRANK stus Rose
(integer) 3 # 降序后的下标
192.168.198.130:6379> ZCARD stus
(integer) 6
192.168.198.130:6379> ZCOUNT stus 0 80
(integer) 2
192.168.198.130:6379> ZINCRBY stus 2 Amy
"94"
192.168.198.130:6379> ZRANGE stus 0 2
1) "Miles"
2) "Jerry"
3) "Rose"
192.168.198.130:6379> ZREVRANGE stus 0 2
1) "Amy"
2) "Lucy"
3) "Jack"
192.168.198.130:6379> ZRANGEBYSCORE stus 0 80
1) "Miles"
2) "Jerry"3.Redis 的java客户端
在Redis官网中提供了各种语言的客户端，地址：https://redis.io/clients
SpringDataRedis 集成了Jedis和lettuce
3.1 Jedis
Jedis的官网地址： https://github.com/redis/jedis
- 快速入门
- 引入依赖
xml
<!-- jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.7.0</version>
</dependency>
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>2. 建立连接
3. 测试string
4. 释放资源
java
public class JedisTest {
private Jedis jedis;
@Before
public void setUp(){
// 1. 建立连接
// jedis = new Jedis("192.168.198.130",6379);
jedis = JedisConnectionFactory.getJedis();
// 2. 设置密码
jedis.auth("123456");
// 3. 选择库
jedis.select(0);
}
@Test
public void testString() throws Exception{
// 存入数据
String result = jedis.set("name", "虎哥");
System.out.println("result=" + result);
// 获取数据
String name = jedis.get("name");
System.out.println("name=" + name);
}
@Test
public void testHash() throws Exception{
// 插入hash数组
jedis.hset("user:1","name","Jack");
jedis.hset("user:1","age","21");
// 获取
Map<String, String> map = jedis.hgetAll("user:1");
System.out.println(map);
}
// 释放
@After
public void tearDown(){
if (jedis != null){
jedis.close();
}
}
}- Jedis连接池Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。
- JedisConnetcionFactory
java
public class JedisConnectionFactory {
private static final JedisPool jedisPool;
static {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(8);
poolConfig.setMaxIdle(8);
poolConfig.setMinIdle(0);
poolConfig.setMaxWaitMillis(1000);
jedisPool = new JedisPool(poolConfig,"192.168.198.130",6379,1000,"123456");
}
public static Jedis getJedis(){
return jedisPool.getResource();
}
}- 修改建立连接的方式
java
// 1. 建立连接
// jedis = new Jedis("192.168.198.130",6379);
jedis = JedisConnectionFactory.getJedis();3.2 SpringDataRedis
入门案例
SpringBoot已经提供了对SpringDataRedis的支持, 使用如下:
- 引入依赖
- 配置文件pool里的配置就算使用默认也必须重新写一遍才能生效
yaml
spring:
redis:
host: 192.168.198.130
port: 6379
password: 123456
lettuce:
pool:
max-active: 8
max-idle: 8
min-idle: 0
max-wait: 1000ms- 注入RedisTemplate
java
@Resource
private RedisTemplate redisTemplate;- 编写测试
java
@Test
void testString() {
// 写入一条String数据
redisTemplate.opsForValue().set("name","虎哥");
// 获取string数据
Object name = redisTemplate.opsForValue().get("name");
System.out.println(name);
}
@Test
public void testSaveUser() throws Exception{
// 写入数据
redisTemplate.opsForValue().set("user:100",new User("虎哥",21));
// 获取数据
User o = (User) redisTemplate.opsForValue().get("user:100");
System.out.println(o);
}SpringDataRedis的序列化方式
RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：
缺点：
- 可读性差
- 内存占用较大
RedisTemplate的两种序列化实践方案：
方案一：
1.自定义RedisTemplate
2.修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
方案二：
1.使用StringRedisTemplate
2.写入Redis时，手动把对象序列化为JSON
3.读取Redis时，手动把读取到的JSON反序列化为对象
- 方案一：我们可以自定义RedisTemplate的序列化方式
java
@Configuration
public class RedisConfig {
@Resource
@Bean
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory) {
// 创建RedisTemplate对象
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 设置连接工厂
template.setConnectionFactory(connectionFactory);
// 创建JSON序列化工具
GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
// 设置Key的序列化
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
// 设置Value的序列化
template.setValueSerializer(jsonRedisSerializer);
template.setHashValueSerializer(jsonRedisSerializer);
// 返回
return template;
}尽管JSON的序列化方式可以满足我们的需求，但依然存在一些问题，如图：
为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。
为了节省内存空间，我们并不会使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。
- 方案二：Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程：
java
@SpringBootTest
class RedisStringTests {
@Resource
private StringRedisTemplate stringRedisTemplate;
@Test
void testString() {
// 写入一条String数据
stringRedisTemplate.opsForValue().set("name","虎哥");
// 获取string数据
Object name = stringRedisTemplate.opsForValue().get("name");
System.out.println(name);
}
private static final ObjectMapper mapper = new ObjectMapper();
@Test
public void testSaveUser() throws Exception{
// 创建对象
User user = new User("虎哥", 21);
// 手动序列化
String json = mapper.writeValueAsString(user);
// 写入数据
stringRedisTemplate.opsForValue().set("user:200",json);
// 获取数据
String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
// 手动反序列化
User user1 = mapper.readValue(jsonUser, User.class);
System.out.println(user1);
}
@Test
public void testHash() throws Exception{
stringRedisTemplate.opsForHash().put("user:400","name","虎哥");
stringRedisTemplate.opsForHash().put("user:400","age","21");
Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
System.out.println(entries);
}
}