Redis基础与使用SpringBoot整合Redis

憨憨撸码

已于 2022-06-14 16:44:31 修改

阅读量1.3k

点赞数

文章标签： redis nosql spring boot

于 2022-03-29 23:04:31 首次发布

本文链接：https://blog.csdn.net/booguojieji/article/details/123704102

版权

Redis基础与使用SpringBoot整合Redis
Redis进阶学习之数据持久化
 Redis进阶学习之主从复制、读写分离
 Redis进阶学习之哨兵模式和分片集群
Redis主从复制集群搭建
Redis哨兵集群搭建
Redis分片集群搭建
Redis使用RedisTemplate配置和访问集群
Redis缓存策略
 Redis缓存异常场景分类

一、NoSQL

NoSQL最常见的解释是“non-relational”， “Not Only SQL”也被很多人接受。NoSQL仅仅是一个概念，泛指非关系型的数据库，区别于关系数据库，它们不保证关系数据的ACID特性。

1.NoSQL发展

单机MYSQL的年代
------->
缓存(Memcached) + MySQL+ 垂直拆分（读写分离)
------->
分库分表 + 水平拆分(表行的拆分) + MySQL 集群
MySQL最初使用MyISAM引擎: (表锁(100万条数据)) ,十分影响效率!；高并发下就会出现严重的锁问题，之后使用 Innodb引擎(行锁)，慢慢的就开始使用分库分表来解决写的压力
------->
随着互联网web2.0网站的兴起，传统的关系型数据库无法进行分析处理。MySQL等关系型数据库不够用了,数据量很多, 变化很快
用户的个人信息, 社交网络, 地理位置, 用户自己产生的数据, 用户日志等等爆发式增长!
这时候我们就需要使用NoSQL数据库。

2.NoSQL的特点

（1）易扩展

NoSQL数据库种类繁多，但是一个共同的特点都是去掉关系数据库的关系型特性。数据之间无关系，这样就非常容易扩展。无形之间，在架构的层面上带来了可扩展的能力。

（2）大数据量，高性能

NoSQL数据库都具有非常高的读写性能，尤其在大数据量下，同样表现优秀。这得益于它的无关系性，数据库的结构简单。一般MySQL使用Query Cache。NoSQL的Cache是记录级的，是一种细粒度的Cache，所以NoSQL在这个层面上来说性能就要高很多。

（3）灵活的数据模型

NoSQL无须事先为要存储的数据建立字段，随时可以存储自定义的数据格式。而在关系数据库里，增删字段是一件非常麻烦的事情。如果是非常大数据量的表，增加字段简直就是——个噩梦。这点在大数据量的Web 2.0时代尤其明显。

（4）高可用

NoSQL在不太影响性能的情况，就可以方便地实现高可用的架构。比如Cassandra、HBase模型，通过复制模型也能实现高可用。

3.NoSQL的分类

在这里插入图片描述

二、Redis

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。Redis根本是使用内存存储。

1.Redis的特性和优势

（1）支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。

（2）不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。

（3）支持数据的备份，即主从（master-slave）模式的数据备份。

（4）性能极高 – Redis读的速度是110000次/s,写的速度是81000次/s 。

（5）原子 – Redis的所有操作都是原子性的，同时Redis还支持对几个操作全并后的原子性执行。

（6）丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

2.Redis应用场景

（1）用来做缓存(ehcache/memcached)——redis的所有数据是放在内存中的（内存数据库）

（2）可以在某些特定应用场景下替代传统数据库——比如社交类的应用

（3）在一些大型系统中，巧妙地实现一些特定的功能：session共享、购物车

三、使用步骤

1. 在docker安装redis

代码如下（示例）：

// 拉取redis镜像
docker pull redis:latest
// 在6379端口启动redis容器
docker run -itd --name redis -p 6379:6379 redis
// 通过exec命令对redis的容器执行bash并使用redis-cli 访问redis容器
docker exec -it redis /bin/bash
redis-cli
可合并为：docker exec -it redis redis-cli

插入键值并通过key访问
在这里插入图片描述

2. 五大数据类型

2.1 String

String类型的value除了是字符串还可以是数字

通过get [key]获取[value]值，set [key] [value]添加键值对
通过getset在获取值的时候设置新值
例如图中getset key2 value2 ，redis中不存在key2的[key]，则会返回nil并添加key2的[key]及其[value]；
当再次访问时可以查看新赋值的[value]；
当存在key2的键，使用getset key2 value3会返回value2，之后再查询key2的[value]值时可以看到新的值为value3

在这里插入图片描述

2.2 List(列表)

List是简单的字符串列表，按照插入顺序排序。可以添加一个元素到列表的头部（左边）或者尾部（右边）
（1）添加和查看操作

// 添加一个list 并从左部按顺序插入
127.0.0.1:6379> lpush list one 
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> lpush list four
(integer) 4

// 查看list 0到3的值
127.0.0.1:6379> lrange list 0 3
1) "four"
2) "three"
3) "two"
4) "one"

// 可以使用lrange list 0 -1查看全部
127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "two"
4) "one"

// 从右部插入一个值并查看list
127.0.0.1:6379> rpush list zero
(integer) 5
127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "two"
4) "one"
5) "zero"

// 查看list长度
127.0.0.1:6379> llen list
(integer) 5

// 查看下标为0的value(左边)
127.0.0.1:6379> lindex list 0
"four"

// 查看list是否存在
127.0.0.1:6379>  exists list
(integer) 1
127.0.0.1:6379>  exists list3
(integer) 0

（2） lset更新

// 根据下标更新value
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
127.0.0.1:6379> lset list 0 six
OK

（3）linsert在指定value后面插入值

127.0.0.1:6379> LRANGE list 0 -1
1) "six"
2) "five"
3) "four"
4) "three"
127.0.0.1:6379> linsert list before three two
(integer) 5
127.0.0.1:6379> LRANGE list 0 -1
1) "six"
2) "five"
3) "four"
4) "two"
5) "three"
127.0.0.1:6379> linsert list after two one
(integer) 6
127.0.0.1:6379> LRANGE list 0 -1
1) "six"
2) "five"
3) "four"
4) "two"
5) "one"
6) "three"

（4） lpop和rpop删除

// 移除头部（左边两个元素），移除尾部（右边）一个值
127.0.0.1:6379> lpop list 2
1) "four"
2) "three"
127.0.0.1:6379> rpop list
"zero"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"

（5）使用lrem删除指定value

从左到右删除几个指定的value值
lrem list [count] [value] 

127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "three"
4) "two"
5) "one"
127.0.0.1:6379> lrem list 1 three
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379> lrem list 2 two
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "one"
127.0.0.1:6379> lpush list one
(integer) 3
127.0.0.1:6379> lpush list one
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "one"
3) "three"
4) "one"
127.0.0.1:6379> lrem list 2 one
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "one"

（6） rpoplpush删除list尾部的值存到新list中

127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
5) "two"
127.0.0.1:6379> rpoplpush list list2
"two"
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
127.0.0.1:6379> LRANGE list2 0 -1
1) "two"

（7）ltrim截取

127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
5) "two"
6) "one"
// 从下标0截取到下标4
127.0.0.1:6379> ltrim list 0 4
OK
127.0.0.1:6379> LRANGE list 0 -1
1) "zero"
2) "five"
3) "four"
4) "three"
5) "two"

2.3 Set(集合)

（1）Set添加操作

127.0.0.1:6379> sadd set one
(integer) 1
127.0.0.1:6379> sadd set two
(integer) 1
127.0.0.1:6379> sadd set three
(integer) 1
// set中的值是无序 
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"
// set中的值不能重复的
127.0.0.1:6379> sadd set three
(integer) 0
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"

（2）Set 查看操作

// smembers ：查看set数据
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"
// 查看某个值是不是在Set集合中
127.0.0.1:6379> sismember set four
(integer) 0
127.0.0.1:6379> sismember set one
(integer) 1
// 查看Set集合的大小
127.0.0.1:6379> scard set
(integer) 3

（3）移除操作
// 移除set集合中的one成员
127.0.0.1:6379> srem set one
(integer) 1
127.0.0.1:6379> smembers set
1) "three"
2) "two"
// 随机在set在取值一个成员
127.0.0.1:6379> SRANDMEMBER set
"two"
127.0.0.1:6379> SRANDMEMBER set
"three"
// 随机在set集合中删除一个成员
127.0.0.1:6379> spop set
"three"
127.0.0.1:6379> smembers set
1) "two"
// smove 将set中的two成员移到set2中
127.0.0.1:6379> smembers set
1) "one"
2) "three"
3) "two"
127.0.0.1:6379> smove set set2 two
(integer) 1
127.0.0.1:6379> smembers set
1) "one"
2) "three"
127.0.0.1:6379> smembers set2
1) "two"

（4）差集、交集和并集

127.0.0.1:6379> smembers set
1) "one"
2) "three"
127.0.0.1:6379> smembers set2
1) "one"
2) "two"
// sdiff 找出set集合与set2集合不一样的成员
127.0.0.1:6379> sdiff set set2
1) "three"
// sinter 找出set集合与set2集合一样的成员
127.0.0.1:6379> sinter set set2
1) "one"
// sunion  set集合和set2集合的并集
127.0.0.1:6379> sunion set set2
1) "one"
2) "three"
3) "two"

2.4 Hash（哈希）

Map 集合，多个Key-Value组合的Map
（1）添加操作

// 添加一个key-value
27.0.0.1:6379> hset myhash field1 value1
(integer) 1
// 添加多个key-value
127.0.0.1:6379> hmset myhash field1 value1 field2 value2
OK
// 在Redis 4.0.0，HMSET被视为已弃用。使用HSET 添加多个key-value
127.0.0.1:6379> hset myhash field3 value3 field4 value4
(integer) 2

（2）查看操作

// hget  查看myhash哈希表中field 为field1的value值
127.0.0.1:6379> hget myhash field1
"value1"
// 查看多个key
127.0.0.1:6379> hmget myhash field1 field2
1) "value1"
2) "value2"
// hgetall 查看myhash 哈希表的所有值
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "value1"
3) "field2"
4) "value2"
5) "field3"
6) "value3"
7) "field4"
8) "value4"
// 查看myhash的长度
127.0.0.1:6379> hlen myhash
(integer) 4
// 查看myhash中某个field 是否存在
127.0.0.1:6379> HEXISTS myhash field2
(integer) 1
127.0.0.1:6379> HEXISTS myhash field5
(integer) 0

（3）hdel 删除操作

127.0.0.1:6379> hdel myhash field1
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "value2"
3) "field3"
4) "value3"
5) "field4"
6) "value4"

（4）HINCRBY 对某个field 的value值增加指定长度

127.0.0.1:6379> HSET MYHASH FIELD5 5
(integer) 1
127.0.0.1:6379> HINCRBY MYHASH FIELD5 1
(integer) 6
127.0.0.1:6379> hgetall MYHASH
1) "FIELD5"
2) "6"

比较HASH中两个不同的插入HSET 和 HSETNX ：

HSET 将哈希表 key 中的域 field 的值设为 value 。如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作，返回 1 。如果域 field 已经存在于哈希表中，旧值将被覆盖，返回 0。
HSETNX 将哈希表 key 中的域 field 的值设置为 value。若域 field 已经存在，该操作无效，返回 0；如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令，返回 1。

2.5 Zset(有序集合)

（1）添加操作

127.0.0.1:6379> zadd myzset 1 one
(integer) 1
127.0.0.1:6379> zadd myzset 2 two
(integer) 1
127.0.0.1:6379> zadd myzset 3 three
(integer) 1
127.0.0.1:6379> zadd myzset 2 two1
(integer) 1// 同个位置则有添加先后
127.0.0.1:6379> zrange myzset 0 -1
1) "one"
2) "two"
3) "two1"
4) "three"

（2）查看操作

// 查看myzset所有值（默认从小到大）
127.0.0.1:6379> zrange myzset 0 -1
1) "one"
2) "two"
3) "two1"
4) "three"
// 从小到大查看myzset
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf +inf
1) "one"
2) "two"
3) "two1"
4) "three"
// 从大到小查看myzset
127.0.0.1:6379> ZREVRANGE myzset 0 -1
1) "three"
2) "two1"
3) "two"
4) "one"
// 从小到大查看myzset，带上value值
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf +inf withscores
1) "one"
2) "1"
3) "two"
4) "2"
5) "two1"
6) "2"
7) "three"
8) "3"
// 查看value值小于等于2的集合
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf 2 withscores
1) "one"
2) "1"
3) "two"
4) "2"
5) "two1"
6) "2"
// 查看myzset大小
127.0.0.1:6379> zcard myzset
(integer) 3
// 查看某区间的数据数量
127.0.0.1:6379> zcount myzset 1 2
(integer) 2

（3）删除操作

// 删除myzset中two1的数据
127.0.0.1:6379> zrem myzset two1
(integer) 1
127.0.0.1:6379> zrange myzset 0 -1
1) "one"
2) "two"
3) "three"

3. HyperLogLog

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。
什么是基数?
比如数据集 {1, 3, 5, 7, 5, 7, 8}，那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。基数估计就是在误差可接受的范围内，快速计算基数

127.0.0.1:6379> pfadd mypf a b c d
(integer) 1
127.0.0.1:6379> pfadd mypf2 a b e f
(integer) 1
127.0.0.1:6379> PFCOUNT mypf
(integer) 4
127.0.0.1:6379> PFCOUNT mypf2
(integer) 4
// 合并产生新的基数集为不重复的数
127.0.0.1:6379> PFMERGE mypf3 mypf mypf2
OK
127.0.0.1:6379> PFCOUNT mypf3
(integer) 6

4. 事务

Redis 事务可以一次执行多个命令，并且带有以下三个重要的保证：

批量操作在发送 EXEC 命令前被放入队列缓存。
收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：开始事务；命令入队；执行事务。
（1）开启、执行和取消事务

// 开启事务，将执行加入事务队列中，exec执行所有指令
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) "v1"
3) OK
4) "v2"

// DISCARD取消事务，加入事务中的队列都不会被执行
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> DISCARD
OK
127.0.0.1:6379> get k3
(nil)
127.0.0.1:6379> get k4
(nil)

（2）异常

127.0.0.1:6379> MULTI
OK
// 队列存在使用不存在的指令执行队列时所有指令都不会被执行（编译型异常）
127.0.0.1:6379(TX)> set k1
(error) ERR wrong number of arguments for 'set' command
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set k1 "v1"
QUEUED
127.0.0.1:6379(TX)> get k1
QUEUED
// 正确的指令，但k1不是增量，会报错，不影响队列中其它指令（运行时异常）
127.0.0.1:6379(TX)> incr k1
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) "v1"
3) (error) ERR value is not an integer or out of range

5. 悲观锁和乐观锁

悲观锁：每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁。

当有多个线程同时抢购时，会发生超发现象。
超发现象：共享数据被多个线程所修改，无法保证其执行顺序。则会导致扣除的库存大于实际库存。
解决超发现象：如果一个事务读取到数据之后，就将数据直接锁定，不允许其他线程操作，直至当前数据库事务完成才释放这条数据的锁。但是执行效率性能将大大下降。

乐观锁:
开启事务前，设置对数据的监听（watch），EXEC时，如果发生数据发生过修改，作用于改数据的事务会自动取消（DISCARD）,事务EXEC后，无论成败，监听会被移除。乐观锁很乐观，什么时候都不会上锁，更新数据的时候, 去判断下, 在此期间, 是否有人修改过数据。

乐观锁不加锁，通过CAS（Compare And Swap）操作来实现线程安全。
CAS执行流程：获取一个数据库存，处理业务，在更新库存的时候判断当前的库存和之前获取的库存是否一致，一致则扣库存执行操作，否则结束。

CAS流程会产生ABA问题：
ABA：线程1和线程2获取的库存都是A，线程1扣完库存之后，库存为B，此时线程2以B作为最新库存进行扣除，但此时线程1又取消扣库存，此时的库存又变回A，导致线程2读取的库存错误。
----->>解决此问题的方法可以加入版本号的限制，只要在操作过程中修改库存，无论业务正常，回退，还是异常，版本号只能递增，不能回退递减，每次通过比较数据的版本号来查看此数据是否被修改过。
------>>但加入版本号限制导致大量的请求失败，请求失败会重新请求直至成功，这个过程会造成大量的SQL查询。一般可以使用限制时间或者重入次数的方法。

Redis使用watch（乐观锁）监控

开启两个窗口访问redis，

// 对watch_key 进行监控（监控早于下一个事务）
127.0.0.1:6379> set watch_key 10
OK
127.0.0.1:6379> get watch_key
"10"
127.0.0.1:6379> watch key
OK
127.0.0.1:6379> multi
OK
// 更新watch_key，执行事务成功
127.0.0.1:6379(TX)> set key 11
QUEUED
127.0.0.1:6379(TX)> exec
1) OK

// 对watch_key 进行监控，上一个事务已为watch_key进行监控，不能再对watch_key进行更新
127.0.0.1:6379> get watch_key
"10"
127.0.0.1:6379> watch key
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key 12
QUEUED
// 执行事务失败
127.0.0.1:6379(TX)> exec
(nil)

6. Lettuce Redis

Lettuce Redis是Java 客户端的开发包

6.1 Redis和SpringBoot的整合

在SpringBoot2.x之前，使用Jedis作为Java连接开发工具，Jedis采用的直连，实例是非线程安全的，常常通过JedisPool连接池去管理实例（ BIO 模式）
在SpringBoot2.x之后使用 lettuce，采用 netty（NIO模式）, 实例可以在多个线程中进行共享, 不存在线程不安全的情况，可以减少线程连接池数量。

6.1.1依赖导入

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

6.1.2 配置redis

spring:
  redis:
   host: 127.0.0.1
   port: 6379
   password: 123456
   database: 0

6.1.3 RedisTemplate

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )  // 可以自己定义一个 redisTemplate 来替换这个默认的 
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 默认的RedisTemplate 没有过多的设置, redis对象都是需要序列化的
        // 两个泛型都是Object, Object类型, 我们后使用需要强制转换<string,Object>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean // 由于string 是redis中最常使用的类型,  所以说单独提出来了一个bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个 StringRedisTemplate。我们开发工程中使用其他类型时需要进行一个类型的转换，所以我们可以自定义一个Redis泛型的模板。

6.1.4 自定义RedisTemplate

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
   	 //  一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(factory);
        // // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String序列号
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

6.1.5 Redis工具类

@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

6.1.6 测试

redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForZSet();//操作zset
...

@SpringBootTest
class RedisTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("key","value");
        System.out.println(redisTemplate.opsForValue().get("key"));

    }

}