基础篇-Redis快速入门

基础篇-Redis入门

一、概述

1.Redis简介

Redis 是C语言开发的一个开源高性能键值对的内存数据库，可以用来做数据库、缓存、**消息中间件**等场景，是一种NoSQL(not-only sql,非关系型数据库)的数据库

2.Redis-认识NoSQL

NoSQL

	SQL	NoSQL
数据结构	结构化	非结构化
数据关联	关联的	无关联
查询方式	SQL查询	非SQL
事务特征	ACID	BASE
储存方式	磁盘	内存
扩展性能	垂直	水平
使用场景	1.数据结构固定 2.相关业务对数据安全要求性、一致要求高	1.数据结构不稳定 2.对一致性、安全要求不高 3.对性能要求

---

3.Redis特点：

• 优秀的性能、数据是储存在内存中、读写速度非常快、可支持并发10W QPS
• 单线程但进程、是线程安全的、采取IO多路复用性
• 可作为分布式锁
• 支持五种数据类型
• 支持数据持久化到磁盘
• 可以作为消息中间件使用、支持消息发布及订阅。

---

4.容器下进入Redis控制界面

1.Docker相关命令

docker run [Options] image运行容器

docker run [Options] image

#参数说明
--name="名字"           指定容器名字
-d                     后台方式运行
-it                    使用交互方式运行,进入容器查看内容
-p                     指定容器的端口
	-p ip:主机端口:容器端口  配置主机端口映射到容器端口
	-p 主机端口:容器端口（常用）
	-p 容器端口
-P                     随机指定端口
-e					   环境设置
-v					   容器数据卷挂载

2.运行并进入容器centos

[root@localhost ~]# docker run -it centos /bin/bash
[root@ce2bbae9f151 /]# ls#查看
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr

进入容器，因为通常我们的容器都是使用后台方式来运行的，有时需要进入容器修改配置

• docker exec -it 容器id /bin/bash

# docker exec 进入容器后开启一个新的终端，可以在里面操作
docker exec -it 容器id /bin/bash

• docker attach 容器id

# docker attach 进入容器正在执行的终端
docker attach 容器id

退出容器

exit 	# 停止容器并退出（后台方式运行则仅退出）
Ctrl+P+Q  # 不停止容器退出

docker ps 查看运行的容器

# 查看当前正在运行的容器
docker ps 
     
-a   # 查看所有容器的运行记录
-n=? # 显示最近创建的n个容器
-q   # 只显示容器的id

docker start 容器id 启动容器

docker start 容器id          # 启动容器
docker restart 容器id        # 重启容器
docker stop 容器id           # 停止当前运行的容器
docker kill 容器id           # 强制停止当前容器

docker logs 容器id查看容器运行日志

docker logs -tf 容器id
docker logs --tail num 容器id  # num为要显示的日志条数

docker top 容器id查看容器中进程信息

docker top 容器id

docker inspect 容器id查看容器的元数据

docker inspect 容器id

2.Docker 启动redis

docker run -p 6379:6379 -d --name myredis \
		   -v /home/docker_volume/redis/data:/data \
           -v /home/docker_volume/redis/conf/redis.conf:/etc/redis/redis.conf \
		   redis redis-server /etc/redis/redis.conf --appendonly yes

• redis-server /etc/redis/redis.conf 以配置文件启动redis
• appendonly yes 开启redis 持久化

进入redis容器

docker exec -it myredis redis-cli

1.进入redis容器及redis控制台

### 通过 Docker 命令进入 Redis 容器内部
# redis6-1 是容器名称，也可以用容器id指定
docker exec -it redis6-1 /bin/bash
docker exec -it redis6-1 bash
 
### 进入 Redis 控制台
redis-cli
 
### 通过密码进入Redis控制台
redis-cli -h 127.0.0.1 -p 6379 -a 123456
 
### 或者也可以直接通过Docker Redis 命令进入Redis控制台 (上面两个命令的结合)
docker exec -it redis6-1 redis-cli

2.容器内命令行测试

### 添加一个变量为 key 为 name , value 为 bella 的内容
> set name bella
### 查看 key 为 name 的 value 值
> get name

3.查看指定容器的log

# 查看指定容器的日志：docker logs -f 容器id或容器名称
docker logs redis6-1
docker logs -f redis6-1

4.redisclient工具测试

管理redis的可视化客户端目前较流行的有三个：Redis Client ; Redis Desktop Manager ; Redis Studio.

5.基本的Docker命令

docker build -t friendlyname .# 使用此目录的 Dockerfile 创建镜像
docker run -p 4000:80 friendlyname  # 运行端口 4000 到 90 的“友好名称”映射
docker run -d -p 4000:80 friendlyname         # 内容相同，但在分离模式下
docker ps                                 # 查看所有正在运行的容器的列表
docker stop                      # 平稳地停止指定的容器
docker ps -a           # 查看所有容器的列表，甚至包含未运行的容器
docker kill                    # 强制关闭指定的容器
docker rm               # 从此机器中删除指定的容器
docker rm $(docker ps -a -q)           # 从此机器中删除所有容器
docker images -a                               # 显示此机器上的所有镜像
docker rmi             # 从此机器中删除指定的镜像
docker rmi $(docker images -q)             # 从此机器中删除所有镜像
docker login             # 使用您的 Docker 凭证登录此 CLI 会话
docker tag  username/repository:tag  # 标记  以上传到镜像库
docker push username/repository:tag            # 将已标记的镜像上传到镜像库
docker run username/repository:tag                   # 运行镜像库中的镜像

二、数据类型

概述：

五种数据类型的特点及使用场景

类型	简介	特征	场景
String（字符串）	二进制安全	可包含任何数据，比如jpg图片或 序列化对象	…
Hash（字典）	键值对集合、即编程语言中 的map类型	适用存储对象，并且可以像数据库中 的update一个属性一样只能修改某一 项属性值	存储、读取、修改属性
List（列表）	链表（双向链表）	增删快，提供操作某一元素的API	最新消息排行：消息对列
set（集合）	hash表实现，元素不重复	添加、删除、查找到复杂度都是 O(1).提供了求交集、并集、差集的操作	共同好友：利用唯一性.统计访问网站所有IP
sorted set（有序集合）	将set中的元素增加一个权 重参与score,元素按score有序排列	数据插入集合时，已进行天然排序	排行榜：带权重的消息队列

Redis通用命令

通用指令是部分数据类型的、都可以使用的指令、常见的有：

• KEYS：查看符合模板的所有key，不建议在生产环境设备上使用
• DEL：删除指定的key
• EXISTS：判断key是否存在
• EXPIRE：给一个key设置有效期，有效期到期时改key会被自动删除
• TTL：查看KEY的剩余有效期

通过help [command] 可以查看一个命令的具体用法

Redis-Key

简单介绍一下Redis中队Key的操作命令。希望大家可以跟着注释敲一遍，简单记一下，都是最常用的命令！
Redis的key允许有多个单词形成层级结构，多个单词之间用’：'隔开，格式如下：
项目名：业务名：类型：id
这个格式并非固定，也可以根据自己的需求来删除或添加词条。
例如我们的项目名称叫heima,有user和producti两种不同类型的数据，我们可以这样定义key:

• user相关的key: heima:user:1
• producti相关的key: heima:product:1

127.0.0.1:6379> ping  #查看当前连接是否正常，正常返回PONG
PONG
127.0.0.1:6379> clear  #清楚当前控制台（为了更好的看到下面输入的命令）
127.0.0.1:6379> keys *  #查看当前库里所有的key
1) "db"
127.0.0.1:6379> FLUSHALL  #清空所有库的内容
OK
127.0.0.1:6379> keys * 
(empty array)
127.0.0.1:6379> set name dingdada  #添加一个key为‘name’ value为‘dingdada’的数据
OK
127.0.0.1:6379> get name  #查询key为‘name’的value值
"dingdada"
127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> set name1 dingdada2
OK
127.0.0.1:6379> get name1
"dingdada2"
127.0.0.1:6379> keys *  #查看当前库里所有的key
1) "name1"
2) "name"
127.0.0.1:6379> EXISTS name  #判断当前key是否存在
(integer) 1
127.0.0.1:6379> move name 1  #移除当前库1的key为‘name‘的数据
(integer) 1
127.0.0.1:6379> keys *
1) "name1"
127.0.0.1:6379> FLUSHALL  #再次清空所有库的内容
OK

## 多加几条数据 下面测试设置key的过期时间
127.0.0.1:6379> set name dingdada
OK
127.0.0.1:6379> set name1 dingdada1
OK
127.0.0.1:6379> set name2 dingdada2
OK
127.0.0.1:6379> EXPIRE name 15  #设置key为’name‘的数据过期时间为15秒 单位seconds
(integer) 1
127.0.0.1:6379> ttl name  #查看当前key为’name‘的剩余生命周期时间
(integer) 13
127.0.0.1:6379> ttl name
(integer) 12
127.0.0.1:6379> ttl name
(integer) 11
127.0.0.1:6379> ttl name
(integer) 8
127.0.0.1:6379> ttl name
(integer) 6
127.0.0.1:6379> ttl name
(integer) 3
127.0.0.1:6379> ttl name
(integer) 2
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> ttl name
(integer) 0
127.0.0.1:6379> ttl name  #如若返回-2，证明key已过期
(integer) -2
127.0.0.1:6379> get name    #再次查询即为空
(nil)
127.0.0.1:6379> type name1
string
127.0.0.1:6379> 

1.String（字符串）

1.String（字符串）

​ ①添加、查询、追加、获取长度，判断是否存在的操作

• SET：添加或者修改已经存在的一个String的键值对
• GET：根据key 获取String

127.0.0.1:6379> set name dingdada  #插入一个key为‘name’值为‘dingdada’的数据
OK
127.0.0.1:6379> get name  #获取key为‘name’的数据
"dingdada"
127.0.0.1:6379> get key1
"hello world!"
127.0.0.1:6379> keys *  #查看当前库的所有数据
1) "name"
127.0.0.1:6379> EXISTS name  #判断key为‘name’的数据存在不存在，存在返回1
(integer) 1
127.0.0.1:6379> EXISTS name1  #不存在返回0
(integer) 0
127.0.0.1:6379> APPEND name1 dingdada1  #追加到key为‘name’的数据后拼接值为‘dingdada1’，如果key存在类似于java中字符串‘+’，不存在则新增一个，类似于Redis中的set name1 dingdada1 ，并且返回该数据的总长度
(integer) 9
127.0.0.1:6379> get name1
"dingdada1"
127.0.0.1:6379> STRLEN name1  #查看key为‘name1’的字符串长度
(integer) 9
127.0.0.1:6379> APPEND name1 ,dingdada2  #追加，key存在的话，拼接‘+’，返回总长度
(integer) 19
127.0.0.1:6379> STRLEN name1
(integer) 19
127.0.0.1:6379> get name1
"dingdada1,dingdada2"
127.0.0.1:6379> set key1 "hello world!"  #注意点：插入的数据中如果有空格的数据，请用“”双引号，否则会报错！
OK
127.0.0.1:6379> set key1 hello world!  #报错，因为在Redis中空格就是分隔符，相当于该参数已结束
(error) ERR syntax error
127.0.0.1:6379> set key1 hello,world!  #逗号是可以的
OK

②自增、自减操作

• INCR：让一个整形的key自增1
• INCRBY：让一个整型的key自增并指定步长，列如：incrby num 2 让num值自增2
• INCRBYFLOAT：让一个浮点类型的数字自增并指定步长

③截取、替换字符串操作

#截取
127.0.0.1:6379> set key1 "hello world!"
OK
127.0.0.1:6379> get key1
"hello world!"
127.0.0.1:6379> GETRANGE key1 0 4  #截取字符串，相当于java中的subString，下标从0开始，不会改变原有数据
"hello"
127.0.0.1:6379> get key1
"hello world!"
127.0.0.1:6379> GETRANGE key1 0 -1  #0至-1相当于 get key1，效果一致，获取整条数据
"hello world!"
#替换
127.0.0.1:6379> set key2 "hello,,,world!"
OK
127.0.0.1:6379> get key2
"hello,,,world!"
127.0.0.1:6379> SETRANGE key2 5 888  #此语句跟java中replace有点类似，下标也是从0开始，但是有区别：java中是指定替换字符，Redis中是从指定位置开始替换，替换的数据根据你所需替换的长度一致，返回值是替换后的长度
(integer) 14
127.0.0.1:6379> get key2
"hello888world!"
127.0.0.1:6379> SETRANGE key2 5 67  #该处只替换了两位
(integer) 14
127.0.0.1:6379> get key2
"hello678world!"

④设置过期时间、不存在设置操作

• SETEX：添加一个String类型的键值对，并指定有效期
• SETNX：添加一个String类型的键值对，前提是这个key不存在，否则不执行

#设置过期时间，跟Expire的区别是前者设置已存在的key的过期时间，而setex是在创建的时候设置过期时间
127.0.0.1:6379> setex name1 15  dingdada  #新建一个key为‘name1’，值为‘dingdada’，过期时间为15秒的字符串数据
OK
127.0.0.1:6379> ttl name1  #查看key为‘name1’的key的过期时间
(integer) 6
127.0.0.1:6379> ttl name1
(integer) 5
127.0.0.1:6379> ttl name1
(integer) 3
127.0.0.1:6379> ttl name1
(integer) 1
127.0.0.1:6379> ttl name1
(integer) 0
127.0.0.1:6379> ttl name1  #返回为-2时证明该key已过期，即不存在
(integer) -2
#不存在设置
127.0.0.1:6379> setnx name2 dingdada2  #如果key为‘name2’不存在，新增数据，返回值1证明成功
(integer) 1
127.0.0.1:6379> get name2
"dingdada2"
127.0.0.1:6379> keys *
1) "name2"
127.0.0.1:6379> setnx name2 "dingdada3"  #如果key为‘name2’的已存在，设置失败，返回值0，也就是说这个跟set的区别是：set会替换原有的值，而setnx不会，存在即不设置，确保了数据误操作~
(integer) 0
127.0.0.1:6379> get name2
"dingdada2"

⑤mset、mget操作

• MSET：批量添加多个String类型的键值对
• MGET：根据多个key获取多个String类型的value

⑥添加获取对象、getset操作

#这里其实本质上还是字符串，但是我们讲其key巧妙的设计了一下。
##mset student:1:name student 相当于类名，1 相当于id，name 相当于属性
#如果所需数据全部这样设计，那么我们在java的业务代码中，就不需要关注太多的key
#只需要找到student类，下面哪个id，需要哪个属性即可，减少了代码的繁琐，在一定程度上可以理解为这个一个类的对象！
127.0.0.1:6379> mset student:1:name dingdada student:1:age 22  #新增一个key为‘student:1:name’，value为‘dingdada ’。。等数据
OK
127.0.0.1:6379> keys *  #查看所有的key
1) "student:1:age"
2) "student:1:name"
127.0.0.1:6379> mget student:1:age student:1:name  #获取数据
1) "22"
2) "dingdada"

##getset操作
127.0.0.1:6379> getset name1 dingdada1  #先get再set，先获取key，如果没有，set值进去，返回的是get的值
(nil)
127.0.0.1:6379> get name1
"dingdada1"
127.0.0.1:6379> getset name1 dingdada2  ##先获取key，如果有，set（替换）最新的值进去，返回的是get的值
"dingdada1"
127.0.0.1:6379> get name1  #替换成功
"dingdada2"

⑦总结
String是Redis中最常用的一种数据类型，也是Redis中最简单的一种数据类型。首先，表面上它是字符串，但其实他可以灵活的表示字符串、整数、浮点数3种值。Redis会自动的识别这3种值。

2.List（列表）

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类似，只不过在没有元素时等待指定时间，而不是直接返回il

①lpush（左插入）、lrange（查询集合）、rpush（右插入）操作

②lpop（左移除）、rpop（右移除）操作

③lindex（查询指定下标元素）、llen（获取集合长度） 操作

④lrem（根据value移除指定的值）

⑥ltrim（截取元素）、rpoplpush（移除指定集合中最后一个元素到一个新的集合中）操作

⑦lset（更新）、linsert操作

⑧小结：

• 实际上是一个链表，before Node after ， left，right 都可以插入值
• 如果key 不存在，创建新的链表
• 如果key存在，新增内容
• 如果移除了所有值，空链表，也代表不存在！
• 在两边插入或者改动值，效率最高！ 中间元素，相对来说效率会低一点~
• 消息排队！消息队列 （Lpush Rpop）， 栈（ Lpush Lpop）！

思考

如何利用List结构模拟一个栈？

• 入口和出口在同一边

如何利用List结构模拟一个队列？

• 入口和出口在不同边

如何利用List结构模拟一个阻塞队列？

• 入口和出口在不同边
• 出队时采用BLPOP或BRPOP

3.Set（集合）元素唯一不重复

Set常见命令

SADD key member..:向set中添加一个或多个元素
SREM key member..:移除set中的指定元素
SCARD key:返回set中元素的个数
SISMEMBER key member:判断一个元素是否存在于set中
SMEMBERS:获取set中的所有元素
SINTER key1key2.:求key1与key2的交集
SDIFF key1key2.:求key1与key2的差集
SUNION key1key2.:求key1和key2的并集

①sadd（添加）、smembers（查看所有元素）、sismember（判断是否存在）、scard（查看长度）、srem（移除指定元素）操作

②srandmember（抽随机）操作

③spop（随机删除元素）、smove（移动指定元素到新的集合中）操作

④sdiff（差集）、sinter（交集）、sunion（并集）操作

⑤总结：可实现共同好友、共同关注等需求。

4.Hash（哈希）

①hset（添加hash）、hget（查询）、hgetall（查询所有）、hdel（删除hash中指定的值）、hlen（获取hash的长度）、hexists（判断key是否存在）操作

• 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不存在，否则不执行

②hkeys（获取所有key）、hvals（获取所有value）、hincrby（给值加增量）、hsetnx（存在不添加）操作

③总结：比String更加适合存对象~

5.SortedSet（有序集合）

1.SortedSet类型

​ Redis的SortedSet,是一个可排序的set集合，与ava中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中
的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList)加hash表。

SortedSet具备以下属性：

• 可排序
• 元素不重复
• 查询速度快

因为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即可

---

6.扩展知识

---

6.1TPS和QPS快速入门

1、TPS：

Transactions Per Second，意思是每秒事务数。一个事务是指客户端向服务器发送请求然后服务器做出反应的过程，具体的事务定义，可以是一个接口、多个接口、一个业务流程等等。以单接口定义为事务举例，每个事务包括了如下3个过程：

• （1）向服务器发请求
• （2）服务器自己的内部处理（包含应用服务器、数据库服务器等）
• （3）服务器返回结果给客户端

如果每秒能够完成 N 次以上3个过程，TPS 就是 N。

TPS 是软件测试结果的测量单位。我们在进行服务性能压测时，接口层面最常关注的是最大 TPS 以及接口响应时间，个人理解 TPS 可以指一组逻辑相关的请求，而服务整体处理能力取决于处理能力最低模块的TPS值。

2、QPS：

Queries Per Second，意思是每秒查询率。指一台服务器每秒能够响应的查询次数，用于衡量特定的查询服务器在规定时间内所处理流量多少，主要针对专门用于查询的服务器的性能指标，比如dns，它不包含复杂的业务逻辑处理，比如数据库中的每秒执行查询sql的次数。QPS 只是一个简单查询的统计显然，不能描述增删改等操作，显然它不够全面，所以不建议用 QPS 来描述系统整体的性能；

QPS 基本类似于 TPS，但是不同的是，对于一个事务访问，会形成一个 “ T ”；但一次 " T " 中，可能产生多次对服务器的请求，服务器对这些请求，就可计入 QPS 之中。

3、区别：

（1）如果是对一个查询接口压测，且这个接口内部不会再去请求其它接口，那么 TPS = QPS，否则，TPS ≠ QPS

（2）如果是容量场景，假设 N 个接口都是查询接口，且这个接口内部不会再去请求其它接口，QPS = N * TPS

三、Redis的Java客户端

1.Redis的Java客户端：

Jedis

• 以Redis命令作为方法名称，学习成本低，简单实用。但是Jedis实例是线程不安全的，多线程环境下需要基于连接池来使用

Lettuce

• Lettuce是基于Netty实现的，支持同步、异步和响应式编程方式，并且是线程安全的。支持Redis的哨兵模式、集群模式和管道模式。

Redisson

• Redisson是一个基于Redis实现的分布式、可伸缩的Java数据结构集合。包含了诸如Map、Queue、Lock、Semaphore、AtomicLong等强大功能

---

2.Jedis

1.Jedis快速入门

1.引入依赖

 
 
     redis.clients
     jedis
     3.7.0
 
 
 
     org.junit.jupiter
     junit-jupiter
     5.7.0
     test
 

2.创建Jedis对象，建立连接

 private Jedis jedis;
    @BeforeEach
    void setUp() {
        //建立连接
        jedis= new Jedis("服务器地址", 6379);
        //设置密码
        jedis.auth("redis");
        //选择库
        jedis.select(0);
    }

3.使用Jedis，方法名与Redis命令一致

 @Test
    void testString() {
        //插入数据，方法名称就是redis命令。
        String result = jedis.set("name", "槿年");
        System.out.println("result ="+result);
        //获取数据
        String name = jedis.get("name");
        System.out.println("name = "+name);
    }

4.释放资源

@AfterEach
    void tearDown() {
        if (jedis!=null){
            //释放资源
            jedis.close();
        }
    }

---

2.Jedis链接池

Jedis连接池

• Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的直连方式

private static final JedisPool jedisPool;
    
    static {
        //配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大连接数
        poolConfig.setMaxTotal(8);
        //最大空闲连接
        poolConfig.setMaxIdle(8);
        //最小空闲连接
        poolConfig.setMinIdle(0);
        //设置最长等待时长，ms
        poolConfig.setMaxWaitMillis(1000);
        //创建连接池对象
        jedisPool= new JedisPool(poolConfig,
                "服务器地址", 6379,1000,"redis密码");
    }
    //获取Jedis对象
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }

3.SpringDataRedis

1.SpringDataRedis概述

springDataRedis简述：

​ SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址

• 提供了对不同Redis客户端的整合(Lettuce和edis)
• 提供了RedisTemplate统一APl来操作Redis
• 支持Redis的发布订阅模型
• 支持Redis哨兵和Redis集群
• 支持基于Lettuce的响应式编程
• 支持基于DK、JSON、字符串、Spring对象的数据序列化及反序列化
• 支持基于Redis的DKCollection实现

2.SpringDataRedis快速入门

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

API	返回值类型	说明
redisTemplate.opsForValue()	ValueOperations	操作string类型数据
redisTemplate.opsForHash()	HashOperations	操作Hash类型数据
redisTemplate.opsForList()	ListOperations	操作L1st类型数据
redisTemplate.opsForSet()	SetOperations	操作Set类型数据
redisTemplate.opsForzSet()	ZSetOperations	操作SortedSet:类型数据
redisTemplate		通用的命令

SpringDataRedis的使用步骤：
1.引入spring-boot-starter-data-redis依赖

    org.springframework.boot
    spring-boot-starter-data-redis



    org.apache.commons
    commons-pool2

2.在application.yml配置Redis信息

spring:
  redis:
    #服务器地址
    host: 175.178.120.64
    #端口号
    port: 6379
    #密码
    password: redisa
    lettuce:
      pool:
        max-active: 8  #最大连接数
        max-idle: 8 #最大空闲连接
        min-idle: 0 #最小空闲连接
        max-wait: 100ms #等待时长

3.注入RedisTemplate

@Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name","槿言.");
        //获取String数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name="+name);
    }

3.RedisSerializer

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6sYYU4Xl-1679651587896)(C:\Users\Y-chor\Pictures\Snipaste_2023-03-24_16-16-41.jpg)]

缺点：

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

1.1SpringDataRedis的序列化方式
我们可以自定义RedisTemplate的序列化方式，代码如下：

 @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;
    }

2.StringRedisTemplate
为了节省内存空间，我们并不会使用SON序列化器来处理value,而是统一使用String序列化器，要求只能存储String
类型的key和value。当需要存储ava对象时，手动完成对象的序列化和反序列化。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HaVeuW3Q-1679651587898)(C:\Users\Y-chor\Pictures\Snipaste_2023-03-24_17-10-53.jpg)]

Spring默认提供了一个StringRedisTemplate:类，它的key和value的序列化方式默认就是String方式。省去了我们自定
义RedisTemplatel的过程：

private  static final ObjectMapper mapper=new ObjectMapper();
    @Test
    void testSaveUser() throws JsonProcessingException {
        //创建对象
        User user = new User("槿言", 18);
        //手动序列化
        String json= mapper.writeValueAsString(user);
        //写入数据
        stringRedisTemplate.opsForValue().set("user:100",json);
        //获取数据
        String jsonUser = stringRedisTemplate.opsForValue().get("user:100");
        //手动反序列化
        User value = mapper.readValue(jsonUser, User.class);
        System.out.println("value="+value);
    }

3.RedisTemplate的两种序列化实践方案：
方案一：

1. 自定义RedisTemplate
2. 修改RedisTemplate的序列化器为GenericJackson2 JsonRedisSerializer

方案二：

1. 使用StringRedisTemplate
2. 写入Redis时，手动把对象序列化为SON
3. 读取Redis时，手动把读取到的SON反序列化为对象