Redis基础篇

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
  1. 安装Redis依赖Redis是基于C语言编写的,因此首先需要安装Redis所需要的gcc依赖:yum install -y gcc tcl

  2. 上传安装包并解压到/usr/local/src

解压命令: tar -xzf redis-6.2.6.tar.gz

  1. 进入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的 哨兵启动脚本
  1. 启动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 redis
1.3.2 Redis客户端

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

  • 命令行客户端
  • 图形化桌面客户端
  • 编程客户端
  1. 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
  1. 图形化桌面客户端

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 0

2.Redis 常见命令

2.1 Redis数据结构介绍

Redis是一个key-value的数据库,key一般是String类型,不过value的类型多种多样:

2.2 Redis通用指令

通用指令是不分数据类型的,都可以使用的指令,常见的有:

KEYS:查看符合模板的所有key

  • DEL:删除一个指定的key
  • EXISTS:判断key是否存在
  • EXPIRE:给一个key设置有效期,有效期到期时该key会被自动删除
  • TTL:查看一个KEY的剩余有效期

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

2.3 String类型

String类型,也就是字符串类型,是Redis中最简单的存储类型。

其value是字符串,不过根据字符串的格式不同,又可以分为3类:

  1. string:普通字符串
  2. int:整数类型,可以做自增、自减操作
  3. 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
  • 参考实例

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类似的特征:

  1. 无序
  2. 元素不可重复
  3. 查找快
  4. 支持交集、并集、差集等功能
  • 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具备下列特性:

  1. 可排序
  2. 元素不重复
  3. 查询速度快

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

  • 快速入门
    1. 引入依赖
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的支持, 使用如下:

  1. 引入依赖
  2. 配置文件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
  1. 注入RedisTemplate
java 复制代码
@Resource
private RedisTemplate redisTemplate;
  1. 编写测试
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);
    }

}
相关推荐
奶糖趣多多1 小时前
Redis知识点
数据库·redis·缓存
CoderIsArt2 小时前
Redis的三种模式:主从模式,哨兵与集群模式
数据库·redis·缓存
ketil277 小时前
Redis - String 字符串
数据库·redis·缓存
王佑辉9 小时前
【redis】延迟双删策略
redis
生命几十年3万天9 小时前
redis时间优化
数据库·redis·缓存
Shenqi Lotus10 小时前
Redis-“自动分片、一定程度的高可用性”(sharding水平拆分、failover故障转移)特性(Sentinel、Cluster)
redis·sentinel·cluster·failover·sharding·自动分片·水平拆分
java知路11 小时前
springboot 基于google 缓存,实现防重复提交
spring boot·后端·缓存
_.Switch13 小时前
Serverless架构与自动化运维
运维·python·缓存·自动化·运维开发
YMY哈14 小时前
Redis常见面试题(二)
redis
元气满满的热码式14 小时前
Redis常用的五大数据类型(列表List,集合set)
数据库·redis·缓存