基础篇-Redis快速入门

学不废不睡觉

已于 2023-03-28 01:08:48 修改

阅读量656

点赞数 1

文章标签： redis 数据库 java nosql数据库缓存

于 2023-03-24 17:59:15 首次发布

本文链接：https://blog.csdn.net/x3291962846/article/details/129755873

版权

基础篇-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 <hash>                     # 平稳地停止指定的容器
docker ps -a           # 查看所有容器的列表，甚至包含未运行的容器
docker kill <hash>                   # 强制关闭指定的容器
docker rm <hash>              # 从此机器中删除指定的容器
docker rm $(docker ps -a -q)           # 从此机器中删除所有容器
docker images -a                               # 显示此机器上的所有镜像
docker rmi <imagename>            # 从此机器中删除指定的镜像
docker rmi $(docker images -q)             # 从此机器中删除所有镜像
docker login             # 使用您的 Docker 凭证登录此 CLI 会话
docker tag <image> username/repository:tag  # 标记 <image> 以上传到镜像库
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.引入依赖

 <!--jedis-->
 <dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>3.7.0</version>
 </dependency>
 <!--单元测试-->
 <dependency>
     <groupId>org.junit.jupiter</groupId>
     <artifactId>junit-jupiter</artifactId>
     <version>5.7.0</version>
     <scope>test</scope>
 </dependency>

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依赖

<!--redis依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--commons-pool-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

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的两种序列化实践方案：
方案一：

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

方案二：

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

学不废不睡觉

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
基础篇-Redis快速入门

五种数据类型的特点及使用场景类型简介特征场景String（字符串）二进制安全可包含任何数据，比如jpg图片或序列化对象Hash（字典）键值对集合、即编程语言中的map类型适用存储对象，并且可以像数据库中的update一个属性一样只能修改某一项属性值存储、读取、修改属性List（列表）链表（双向链表）增删快，提供操作某一元素的API最新消息排行：消息对列set（集合）hash表实现，元素不重复添加、删除、查找到复杂度都是O(1).提供了求交集、并集、差集的操作。
复制链接

扫一扫