Redis详解——学习笔记

最新推荐文章于 2024-07-25 20:03:50 发布

豆豆子i

最新推荐文章于 2024-07-25 20:03:50 发布

阅读量310

点赞数

分类专栏： redis 文章标签： redis 学习笔记

本文链接：https://blog.csdn.net/m0_61943950/article/details/130531237

版权

redis 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

- 前言

前言

目前互联网企业架构模型

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DFeNeQ9f-1683363382207)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230422111746219.png)]$

Nosql概述

为什么使用NoSQL

用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长！NoSQL可以很好处理以上问题！

什么是NoSQL

NOSQL(Not only SQL), 不仅仅是SQL,泛指非关系型数据库

NoSQL特点

1、方便扩展(数据之间没有关系，很多扩展！)

2、大数据量高性能(Redis 一秒写8万次，读取11万，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高！)

3、数据类型是多样性的的！（不需要事先设计数据库！随去随用！如果是数据量十分大的表，很难设计了）

4、传统RDBMS(关系型数据库)和NoSQL的区别

传统的RDBMS
- 结构化组织
- 数据和关系都存在单独的表中
- 操作数据，数据定义语言
- 严格的一致性
- 基础的事务
- ......

NoSQL
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储，列存储，文档存储，图形数据库
- 最终一致性(可以过程有误差)
- CAP定理 和 BASE理论  (异地多活) 保证服务器不会宕机

NoSQL的四大分类

KV键值对：

新浪：Redis
美团：Redis + Tair
阿里、百度：Redis + memecache

文档型数据库：

MongDB(必须掌握)
- MongDB是一个基于分布式文件存储的数据库，C++编写，主要用来处理大量的文档
- MongDB是一个介于关系型数据库和非关系型数据中中间的产品。MongDB是非关系型数据库中功能最丰富，最像关系型数据库的！
ConthDB

列存储数据库

HBase
分布式文件系统

图形关系数据库

他不是存图形，放的是关系，比如：朋友圈社交网络，广告推荐！
Neo4j, InfoGrid,Infinite Graph

Redis入门

1、Redis概述

1.1、Redis是什么？

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

1.2、Redis可以干什么？

内存存储、持久化，内存中是断电即失。故持久化***(rdb、aof)
效率高，可以用于告诉缓存
发布订阅系统
地图信息分析
计时器、计数器(浏览量！ incr… decr…)

1.3、特性

多样的数据类型
持久化
集群
事务
…

2、windows下安装redis

3、Linux下安装redis

4、测试性能

redis-benckmark是一个压力测试工具！

图片来自菜鸟教程：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XyWI63bt-1683363382208)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230422160906946.png)]$

性能测试

启动redis

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SWowcVp5-1683363382209)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230422163949106.png)]$

打开连接

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3bxF62Gc-1683363382210)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230422164019314.png)]$

测试-查看分析
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6o2oshbW-1683363382212)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230422170732797.png)]$

5、基础知识

redis默认有16个数据库，默认使用的是第0[索引]个，可以使用select进行数据库的切换
查看数据库所有的key

> keys *  #查看数据库所有的key
> flushall 清空全部
> flushdb 清空当前库

redis是单线程的，是内存操作的

核心：redis是将所有的数据全部放在内存中的，所以说使用单线程去操作效率是最高的。多线程(在CPU操作会非常耗时间的操作！) 对于内存系统来说，没有上下文切换效率就是最高的。多次读写都是在一个CPU上操作的，在内存情况中，此为最佳的方案。

6、关于RedisKey的基本命令

redisKey

keys * 查看所有的key值

set name zhangsan 设置key name 为 zhangsan

EXISTS name  判断当前的key是否存在   

move 移除当前的key 

EXPIRE name 10  (s)单位是秒  设置当前过期的

ttl name   查看当前 key 的剩余时间

type 查看当前key的具体类型

五大数据类型

String

基本的命令

127.0.0.1:6379> get view    //get key
"0"
127.0.0.1:6379> incr view   //key +1
(integer) 1
127.0.0.1:6379> get view     
"1"
127.0.0.1:6379> incr view   //key +1
(integer) 2
127.0.0.1:6379> get view
"2"
127.0.0.1:6379> GETRANGE key1 0 3     //截取字符串
"v1,z"
127.0.0.1:6379> GETRANGE key1 0 -1    //输出所有的字符串和 get key 是一样的
"v1,zhangsan"
127.0.0.1:6379> SETRANGE KEY2 1 XX  //替换指定位置开始的字符串！ 
127.0.0.1:6379> setex 设置键的过期时间
127.0.0.1:6379> setnx 如果不存在就设置过期时间
127.0.0.1:6379> setex key3 30 "hello"   //设置30秒的值就过期
    
   	mset   //同时设置多个key值
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 k4 v4     
    mget   //同时获取多个key值
127.0.0.1:6379> mget k1 k2 k3 k4   的值
    
    
# 对象
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name user:1:age 2
1) "zhangsan"
2) "2"
127.0.0.1:6379> getset db     //如果不存在 输出nil
(nil)

String 类似的使用场景：value除了我们的字符串还可以是我们的数字

计数器
统计多单位的数量
粉丝数
对象缓存存储！

List(列表)

在redis里面，我们可以把list转化为栈、队列、阻塞队列！所有的List命令都是以 L 开头的 (不区分大小写)

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j9RiJRwU-1683363382212)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230423104424217.png)]$

127.0.0.1:6379> LPUSH LIST ONE     #将一个值或者多个值插入到列表头部(放在列表左边)
(integer) 1
127.0.0.1:6379> LPUSH list two
(integer) 7
127.0.0.1:6379> LPUSH list three
(integer) 8
127.0.0.1:6379> LRANGE list 0 -1   #获取list中的所有值
1) "three"
2) "two"
3) "01"
4) "0"
5) "four"
6) "three"
7) "two"
8) "one"
127.0.0.1:6379> Rpush list right    #将一个值或者多个值，插入到列表位部(放在列表右边)
(integer) 9    
127.0.0.1:6379> lrange list 0 1     #通过区间获取具体的值
1) "three"
2) "two"
127.0.0.1:6379> 
####################################################################   移除
127.0.0.1:6379> Lpop list    #移除list最左边的元素
"01"
127.0.0.1:6379> Rpop list    #移除list最右边的元素
"right"   
127.0.0.1:6379> LRANGE list 0 -1    
1) "0"
2) "four"
3) "three"
4) "two"
5) "one"
127.0.0.1:6379> lindex list 1            //通过下标获得list中的某一个值
"four" 
####################################################################   
Llen 
127.0.0.1:6379> Llen list             #返回列表长度
(integer) 1
####################################################################
Lrem
127.0.0.1:6379> LRANGE list 0 -1  
1) "two"
2) "two"
127.0.0.1:6379> lpush list one
(integer) 3
127.0.0.1:6379> lpush list three
(integer) 4
127.0.0.1:6379> lrem list 2 one      #移除list集合中指定个数的value，精确不匹配
(integer) 1
127.0.0.1:6379> Lrange list 0 -1
1) "three"
2) "two"
3) "two"
########################################################################
trim  修建  截断操作

127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> rpush mylist "hello"
(integer) 1
127.0.0.1:6379> rpush mylist "hello1"
(integer) 2
127.0.0.1:6379> rpush mylist "hello2"
(integer) 3
127.0.0.1:6379> rpush mylist "hello3"
(integer) 4
127.0.0.1:6379> rpush mylist "hello4"
(integer) 5
127.0.0.1:6379> ltrim mylist 1 2  #通过下标截取指定的长度，这个list已经别改变，截断了只剩下截取的元素
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello1"
2) "hello2"
############################################################################################
rpoplpush        #移除列表最后一个元素，将他移动到新的列表中！
127.0.0.1:6379> rpush mylist "hello"
(integer) 3
127.0.0.1:6379> rpush mylist "hello1"
(integer) 4
127.0.0.1:6379> rpush mylist "hello2"
(integer) 5
127.0.0.1:6379> rpoplpush mylist mymotherlist
"hello2"
127.0.0.1:6379> lrange mylist 0 -1      #查看所有的列表的元素
1) "hello1"
2) "hello2"
3) "hello"
4) "hello1"
127.0.0.1:6379> lrange mymotherlist 0 -1      #查看目标列表中，确实存在该值
1) "hello2"
############################################################################################
lset  将列表中指定下标的值替换为另外一个值，更新操作
127.0.0.1:6379> EXISTS list    #判断列表是否存在
(integer) 0
127.0.0.1:6379> lpush list value1     #如果不存在列表我们去更新就会报错
(integer) 1
127.0.0.1:6379> LRANGE list 0 0
1) "value1"
127.0.0.1:6379> lset list 0 value2     #如果存在，更新当前下标的值
OK
127.0.0.1:6379> LRANGE list 0 0
1) "value2" 
127.0.0.1:6379> lset list 1 other      #如果不存在,则会报错！
(error) ERR index out of range

####################################################################################################
linsert      #将某个具体的value插入到列表中的某个元素的前面或者后面！

127.0.0.1:6379> Rpush mylist "hello"
(integer) 1
127.0.0.1:6379> Rpush mylist "world"
(integer) 2
127.0.0.1:6379> LINSERT mylist before "world" "other"
(integer) 3
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "other"
3) "world"
127.0.0.1:6379> LINSERT mylist after world new 
(integer) 4
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "new"

小结

它实际上是一个链表，before Node after， left, right都可以插入值
如果key不存在，创建一个新的链表
如果key存在，新增内容
如果移除了所有值，空链表，也代表不存在！
在两边插入或者改动值，效率最高!中间元素，相对来说效率会低一点

消息队列（Lpush Rpop）, 栈（Lpush Lpop） !

Set(集合)

127.0.0.1:6379>sadd myset "he11o"			# set集合中添加匀速
(integer) 1
127.0.0.1:6379> sadd myset "kuangshen"
(integer) 1
127.0.0.1:6379> sadd myset "lovekuangshen"
(integer) 1
127.0.0.1:6379>SMEMBERS myset          #查看指定set的所有值
1) "he11o"
2) "1ovekuangshen "3)"kuangshen"
127.0.0.1:6379>SISMEMBER myset hello #判断某一个值是不是在set集合中! 
(integer) 1
127.0.0.1:6379>SISMEMBER myset wor1d
(integer) 0

#################################################################################
127.0.0.1:6379> scard myset  #获取set集合中的内容元素个数
(integer) 4

##################################################################################
rem  移除
127.0.0.1:6379>srem myset hello    #移除set集合中的指定元素
(integer) 1
127.0.0.1:6379> scard myset
(integer) 3
127.0.0.1:6379> SMEMBERS myset
1) "lovekuangshen2"
2) "lovekuangshen"
3) "kuangshen"

##################################################################################
set 无序不重复集合
127.0.0.1:6379> SRANDMEMBER myset       #随机抽选一个元素
"kuangshen"
127.0.0.1:6379> SRANDMEMBER myset 2     #随机抽选指定个数的元素
1) "lovekuangshen2"  
2) "lovekuangshen"

##################################################################################
127.0.0.1:6379> spop myset      #随机删除set集合中的元素
"lovekuangshen2"  

127.0.0.1:6379> SRANDMEMBER myset 2     #随机抽选指定个数的元素
1) "lovekuangshen2"  
2) "lovekuangshen"

##################################################################################
将一个指定的值，移动到另外一个set集合!
127.0.0.1:6379>sadd myset "he1lo"
(integer) 1
127.0.0.1:6379> sadd myset "wor1d"
(integer) 1
127.0.0.1:6379> sadd myset "kuangshen"
(integer) 1
127.0.0.1:6379> sadd myset2 "set2"
(integer) 1
127.0.0.1:6379> smove myset myset2 "kuangshen"     # 将一个指定的值，移动到另外一个set集合!(integer) 1
127.0.0.1:6379>SMEMBERS myset1) "wor1d"
2) "he11o"
127.0.0.1:6379>SMEMBERS myset21)"kuangshen"
2) "set2"

##################################################################################
数字集合类： 交集、差集、并集
127.0.0.1:6379> sadd key1 a
(integer) 1
127.0.0.1:6379> sadd key1 b
(integer) 1
127.0.0.1:6379> sadd key1 c
(integer) 1
127.0.0.1:6379> sadd key2 c
(integer) 1
127.0.0.1:6379> sadd key1 e
(integer) 1
127.0.0.1:6379> SDIFF key1 key2
1) "e"
2) "a"
3) "b"
127.0.0.1:6379> SINTER key1 key2
1) "c"
127.0.0.1:6379> SUNION key1 key2
1) "e"
2) "a"
3) "b"
4) "c"

Hash(哈希)

Map集合，key-Map集合！

set

127.0.0.1:6379> HSET myhash field1 mk   #set 一个具体的 key-value
(integer) 1
127.0.0.1:6379> HGET myhash field1      #获取 key 对应的value
"mk"
127.0.0.1:6379> hset myhash field1 hello field2 world     #set 多个 key - value
(integer) 1
127.0.0.1:6379> HGETALL myhash           #获取全部的 数据 
1) "field1"
2) "hello"
3) "field2"
4) "world"

127.0.0.1:6379> HDEL myhash field1     # 删除hash指定的key字段！ 对应的value值也就消失了
(integer) 1
127.0.0.1:6379> HGETALL myhash
1) "field2"
2) "world"

127.0.0.1:6379> hlen myhash         #查看有几个hash 键值对
(integer) 1
127.0.0.1:6379> HEXISTS myhash field1   #判断hash中指定字段是否存在！
(integer) 0
127.0.0.1:6379> HEXISTS myhash field2
(integer) 1

#只获得所有的field (字段)     hkeys myhash

#只获得所有的value           hvals myhash

Zset(有序集合)

在set的基础上增加了一个值。set k1 v1; zset k1 score v1

127.0.0.1:6379> zadd myset 1  one     #添加一个值
(integer) 1 
127.0.0.1:6379> zadd myset 2  two     #添加多个值
(integer) 1
127.0.0.1:6379> zadd myset 33 three
(integer) 1
127.0.0.1:6379> ZRANGE myset 0 -1
1) "one"
2) "two"
3) "three"
 
 #####################################################################################
127.0.0.1:6379> zadd salary 2500 mk 
(integer) 1
127.0.0.1:6379> zadd salary 4000 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 3100 Marry
(integer) 1
127.0.0.1:6379> ZRANGE salary 0 -1      
1) "mk"
2) "Marry"
3) "zhangsan"
127.0.0.1:6379> zrangeByScore salary -inf +inf      #显示用户按照从小到大排序
1) "mk"
2) "Marry"
3) "zhangsan"
127.0.0.1:6379> zrevrange salary 0 -1      #显示用户按照从大到小排序
1) "zhangsan"
2) "Marry"
3) "mk"
127.0.0.1:6379> zrangeByScore salary -inf +inf withscores   #带值输出
1) "mk"
2) "2500"
3) "Marry"
4) "3100"
5) "zhangsan"
6) "4000"

##################################################################
127.0.0.1：6039> zrem salary xiaohong    #移除有序集合中的指定元素
(integer) 1
127.0.0.1：6039> zrange salary 0 -1
1) "mk"
2) "zhangsan"
127.0.0.1：6039> zcard salary #获取有序集合中的个数
(integer) 2

##################################################################################
127.0.0.1:6379> ZRANGE myset 0 -1
1) "hello"
2) "one"
3) "two"
4) "world"
5) "mk"
6) "three"
127.0.0.1:6379> zcount myset 1 3         #获取指定区间的成员数量
(integer) 5

应用：

set排序存储班级成绩表，工资表排序；排行榜应用实现，取Top N 测试

三种特殊数据类型

geospatial

Hypertloglog

什么是基数？

基数不重复的元素 = 5 ,可以接收误差

简介

Redis 2.8.9 版本就更新了Hyperloglog 数据结构！

Redis Hyperloglog 基数统计的算法！

传统的方式，set保存用户的id,然后就可以统计set中元素

优点：

占用的内存是固定的，2*64不同的元素的技术，只需要费12KB内存！如果要从内存来首选Hyperloglog首选

0.81%的容错率Tf,merge mykey3

127.0.0.1:6379> PFadd mykey a b c d e f g   # 创建第一组 mykey
(integer) 1
127.0.0.1:6379> PFCOUNT mykey        #统计mykey 元素的基数数量
(integer) 7
127.0.0.1:6379> PFCOUNT mykey3       #统计mykey3 元素的基数数量
(integer) 0
127.0.0.1:6379> PFCOUNT mykey2 mk2 mk2
(integer) 0
127.0.0.1:6379> PFMERGE mykey3 mykey mykey2   #合并两组 mykey mykey2 ==> 并集
OK
127.0.0.1:6379> pfcount mykey3     #看并集的数量
(integer) 7

如果允许容错，那么一定可以使用 Hyperloglog !

如果不允许容错，就使用set或者自己的数据类型即可

Bitmaps

位存储

统计用户信息，活跃，不活跃！登录，未登录！打卡，365打卡！两个状态的，都可以使用Bitmaps

Bitmap位图，数据结构！都是操作二进制位来进行记录，就只有0 和 1 两个状态！

127.0.0.1:6379> PFadd mykey a b c d e f g
(integer) 1
127.0.0.1:6379> PFCOUNT mykey
(integer) 7
127.0.0.1:6379> PFCOUNT mykey3
(integer) 0
127.0.0.1:6379> PFCOUNT mykey2 mk2 mk2
(integer) 0
127.0.0.1:6379> PFMERGE mykey3 mykey mykey2
OK
127.0.0.1:6379> pfcount mykey3
(integer) 7
127.0.0.1:6379> SETBIT sign 1 0
(integer) 0
127.0.0.1:6379> SETBIT sign 2 1
(integer) 0
127.0.0.1:6379> SETBIT sign 3 0
(integer) 0
127.0.0.1:6379> SETBIT sign 4 1
(integer) 0
127.0.0.1:6379> SETBIT sign 5 0
(integer) 0
127.0.0.1:6379> SETBIT sign 5 1
(integer) 0
127.0.0.1:6379> SETBIT sign 6 0
(integer) 0
127.0.0.1:6379> GETBIT sign 3
(integer) 0
127.0.0.1:6379> GETBIT sign 6
(integer) 0 
127.0.0.1:6379> bitcount sign        #统计这周的打卡记录，就可以看到是否有全勤
(integer) 3

事务

Redis事务本质就是，一组命令的集合！一个事务中的所有的命令都会被序列化，在事务执行过程中，或按照顺序执行、顺序性、排他性！执行一系列的命令

Redis单条命令是保存原子性的，但是事务不保证原子性

所有的命令在事务中, 并没有直接被执行！只有发起执行命令的时候才会执行！

Redis没有隔离级别的概念

redis的事务：

开启事务( Multi )
命令入队()
执行事务()

127.0.0.1:6379> MULTI                  #开启事务
OK 
127.0.0.1:6379(TX)> set k1 v1
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)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec         # 执行事务
1) OK
2) OK
3) "v2"
4) OK


########################################################################
127.0.0.1:6379(TX)> DISCARD     # 取消事务

编译型异常(代码有问题！命令有错事务中所有的命令都不会执行！)

运行时异常：所有的命令都不会被执行

悲观锁：

很悲观，什么时候都会出问题，无论做什么都会加锁！

乐观锁：

所谓乐观锁，就是一个线程在修改某一个数据的时候，乐观地认为不会有其他线程进行修改，直接修改，然后再提交的时候检查一下是否有人修改过原来的数据，如果有人修改过，那我就放弃修改，返回失败，或者重试，所以，这种比较宽松的加锁机制，性能显然要好一些。
获取version (值)
更新的时候比较version (值)

WATCH 命令可以为 Redis 事务提供 check-and-set （CAS）行为。

127.0.0.1:6379> watch money                     #监视 money 
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 20
QUEUED
127.0.0.1:6379(TX)> exec             #执行之前，另外一个线程，修改了我们的值，这个时候就会导致事务执行失败
(error) EXECABORT Transaction discarded because of previous errors.

Jedis

Jedis是Redis官方推荐的java连接开发工具！使用Java操作Redis中间件！

测试

导入依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.7.3</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.57</version>
    </dependency>
</dependencies>

连接数据库

        Jedis jedis = new Jedis("127.0.0.1",6379);
        System.out.println(jedis.ping());

//输出 PONG

操作命令

断开连接

SpringBoot整合

SpringBoot操作数据：spring-data jpa jdbc mongodb redis!

jedis：采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用Jedis pool 连接池！更像BIO模式

lettuce: 采用netty,实例可以再多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据，更像NIO模式

整合测试

导入依赖

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

配置连接

spring.data.redis.host=127.0.0.1
spring.data.redis.port=6379

测试！

RedisTemplate

编写自己的RedisTemplate

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //连接工厂
        template.setConnectionFactory(factory);
        //Json序列化配置
        //1、使用Json去解析任意的对象
//        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(Object.class);
        Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //通过ObjectMapper 进行转义
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key 采用String 的序列化方式
        template.setKeySerializer(stringRedisSerializer);

        //hash的key也采用String 的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);

        //value序列化方式采用jackson
        template.setValueSerializer(objectJackson2JsonRedisSerializer);
        //hash的value序列化方式采用jackson
        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
}

重点去理解redis的思想和每一种数据结构的用处和作用场景

RedisUtil

package com.mk.redisUtil;

/**
 * @author 豆豆子
 * @version 1.0
 */
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间(秒)
     */
    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((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }


    // ============================String=============================

    /**
     * 普通缓存获取
     * @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)
     */
    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)
     */
    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
     */
    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 对应多个键值
     */
    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)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


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


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

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     */
    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 键
     */
    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代表所有值
     */
    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 键
     */
    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倒数第二个元素，依次类推
     */
    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 值
     */
    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  时间(秒)
     */
    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;
        }

    }

}

redisConfig详解

快照

持久化，在规定时间内，执行了多少从操作，则会持久化到文件.rdb .aof redis 是内存数据库，如果没有持久化，那么数据断电即失！

SECUITY 安全

可以在这里设置redis的密码，默认是没有密码的！

127.0.0.1:6379> ping
PONG
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) ""
127.0.0.1:6379> config set requirepass "123456"   #设置redis的密码
OK
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "123456"

限制CLIENTS

maxclients  10000   # 设置最大能连接上redis 的 最大客户端的数量
maxmemory <bytes>   # redis 配置最大的内存容量
maxmemort-policy noviction  #内存到达上限之后的处理策略
	1、volatile-7ru:只对设置了过期时间的key进行LRU（默认值)
	2、a77keys-1ru :删除1ru算法的key
	3、volatile-random:随机删除即将过期key
	4、a7lkeys-random:随机删除
	5、volatile-tt1 :删除即将过期的
	6、noeviction :永不过期，返回错误

APPEND ONLY 模式 aof配置

appendon1y no #默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下，rdb完全够用!
appendfilename "appendon1y.aof"#持久化的文件的名字

#appendfsync always   #每次修改都会sync。消耗性能
appendfsync everysec  #每秒执行一次sync，可能会丢失这1s的数据!
# appendfsync no      #不执行sync，这个时候操作系统自己同步数据，速度最快！

Redis持久化

Redis是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。所以Reids提供了持久化功能！

RDB(Redis DataBase)

RDB方式实现持久化，使用save 命令可以将当前的redis中的数据存储到磁盘上，存储dump.rdb

当redis服务启动时，会自动读取rdb文件，将已经存储的备份文件进行恢复
save指令是指示redis立即将数据存储到磁盘上进行备份，但如果存储的数据量过大，而且同时又
有其他客户端也要访问redis时就会造成堵塞状态，影响性能(不建议使用),redis提供了后台执行命
令bgsave来解决这个问题
save和 bgsave两个命令都会调用rdbSave函数将当前Redis中的数据存入到rdb文件中，但两者调
用的方式不同

save直接调用rdbSave,会阻塞Redis主进程，直到保存完成为止。在主进程阻塞期间，服务器不能处理客户端的任何请求。
bgsave则调用fork函数生成一个子进程，子进程负责调用rdbSave，并在保存完成之后向主进程发送信号，通知保存已完成。Redis服务器在bgsave执行期间仍然可以继续处理客户端的请求。

在配置文件里配置rdb的路径和文件名

#指定持久化文件存储路径 dir E:/Redis/Redis-x64-3.2.100/config/data

#指定持久化文件文件名 dbfilename dump-6380.rdb

手动保存过于繁琐，Redis里面提供了一种"自动保存快照"的方式，当达到存储Redis要求时，Redis就会自动调用bgsave指令，自动保存当前数据，我们需要在配置文件里配置自动保存的时间及数据变化量(不配置不会自动保存)

#该配置表示开启Redis的自动备份功能
#配置rdb快照方式自动保存时间及数据变化量
#每隔900s内有一个数据发送改变则自动保存
save 900 1 
#每隔300s内有10个数据发送改变则自动保存
save 300 10
#每隔60s内有10000个数据发送改变则自动保存
save 60 10000

根据使用场景进行设置，频率过高和过低都会使性能受到影响
调用 debug reload 指令重启服务器时会自动保存数据
服务器关闭时(shutdown指令)会自动保存数据

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kvdOO4ei-1683363382214)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230504155123945.png)]$

RDB触发机制

save的规则满足的情况下，会自动出发rdb规则
执行了flushall 命令，会触发rdb规则
退出redis,也会产生rdb文件

优点：

适合大规模的数据恢复
对数据的完整性要求不高!
RDB恢复数据的速度要比AOF快

缺点：

RDB方式基于快照思想，每次读写全部数据，当数据量巨大时效率低、IO读写性能低下
fork进程时会占用一定的内存空间！！
RDB方式无法实时备份数据，数据丢失的可能性大

AOF

Append-only.rdb

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0fxUeJSr-1683363382214)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230505171337169.png)]$

将我们的所有的命令都记录下来，history，恢复的时候就把这个文件全部执行一遍

aof保存的是appendonly.aof文件

默认不开启的，需要手动进行配置，我们只需要将appendonly 改为yes 就开启了 aof

重启redis 生效，如果这个文件有错位，这时候需要修复这个aof文件，redis提供了一个工具redis-check-aof --fix

优点：

每一次修改都同步，文件的完整性会更好！
每秒同步一次，可能会丢失一秒的数据
从不同步，效率最高

缺点：

相对于数据文件来说，aof 远远大于rdb，修复的速度也远远比rdb 慢！
aof运行效率也要比rdb 慢，所以我们redis 默认的配置就是rdb持久化

扩展：

1、RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储
2、AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis 协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
3、只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化
4、同时开启两种持久化方式

在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢﹖作者建议不要，因为RDB更适合用于备份数据库(AOF在不断变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。

5、性能建议

因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留save 900 1这条规则。
如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的lO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
如果不Enable AOF，仅靠Master-Slave Repllcation 实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave 中的RDB文件，载入较新的那个，微博就是这种架构。

Redis 订阅发布

Redis 订阅发布是一个(sub/pub) 一种消息通信模式：发送者(pub) 发送消息，订阅者(sub) 接收消息。

Redis 客户端可以订阅任意数量的频道。

订阅发布消息图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MsRHXBmq-1683363382215)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230505173700369.png)]$

命令

这些命令被广泛用于构建即时通信和消息订阅，比如网络聊天室(chatroom)和实时广播、实时通信、实时提醒等。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gAI4nF2G-1683363382216)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230505174046965.png)]$

订阅端：

127.0.0.1:6379> SUBSCRIBE MK       #订阅一个频道   mk
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "MK"
3) (integer) 1
1) "message"
2) "MK"
3) "GJHJHJ"
1) "message"
2) "MK"
3) "MK001"

发送端：

127.0.0.1:6379> PUBLISH MK GJHJHJ   # 发布者发布消息到频道
(integer) 1
127.0.0.1:6379> PUBLISH MK MK001    #发布者发布消息到频道
(integer) 1
127.0.0.1:6379>

原理

Redis是使用C实现的，通过分析Redis源码里的pubsub.c文件，了解发布和订阅机制的底层实现，籍此加深对Redis的理解。Redis通过PUBLISH 、SUBSCRIBE和PSUBSCRIBE等命令实现发布和订阅功能。
通过SUBSCRIBE命令订阅某频道后，redis-server里维护了一个字典，字典的键就是一个个channel
，而字典的值则是一个链表，链表中保存了所有订阅这个channel 的客户端。SUBSCRIBE命令的关键，就是将客户端添加到给定 channel的订阅链表中。通过PUBLISH命令向订阅者发送消息，redis-server会使用给定的频道作为键，在它所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表，遍历这个链表，将消息发布给所有订阅者。Pub/Sub从字面上理解就是发布( Publish )与订阅(Subscribe )，在Redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。

Pub/Sub从字面上理解就是发布(publish) 与订阅 (subcribe) ,在redis中，可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅他的客户端都会收到相应的消息。

使用场景：

进行通信，例如：

实时消息系统！
事实聊天(频道当作聊天室，将信息回显给所有人！)
订阅，关注系统

主从复制

主从复制的作用主要包括：

1、数据冗余: 主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
2、故障恢复∶当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复;实际上是一种服务的冗余。
3、负载均衡︰在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载;尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
4、高可用（集群）基石:除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。

环境配置

只配置从库，不用配置主库！

复制三个配置文件，然后修改对应的信息

端口
pid名字
log名字
dump.rdb名字

一主二从

默认情况下，每台redis服务器都是主节点：一般情况下只配置从机就行

真实的主从配置应该在文件中配置

复制原理：

Slave启动成功连接到 master后会发送一个sync同步命令
Master接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次完全同步。
全量复制:而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。增量复制:Master继续将新的所有收集到的修改命令依次传给slave，完成同步但是只要是重新连接master ，T次完全同步（全量复制)将被自动执行，我们的数据一定会被重新复制

哨兵模式

(自主选取主机的过程)

概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台服务器切换为主服务器，这就需要人工干预，费力费时，还会造成一段时间服务不可用。这不是一种推荐的方式，更多时候，我们会考虑优先使用哨兵模式。Redis从2.8开始正式提供Sentinel(哨兵模式)来解决这个问题。

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover[故障转移]操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Li9DwxN-1683363382216)(C:\Users\HUAWEI\AppData\Roaming\Typora\typora-user-images\image-20230506151818159.png)]$

哨兵的两个作用：

通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

一个哨兵进程对Redis 服务器进行监控，可能会出现问题，为此我们可以使用多个哨兵进行监控。

优点︰

哨兵集群，基于主从复制模式，所有的主从配置优点，它全有
主从可以切换，故障可以转移，系统的可用性就会更好
哨兵模式就是主从模式的升级，手动到自动，更加健壮!

缺点︰

Redis 不好啊在线扩容的，集群容量一旦到达上限，在线扩容就十分麻烦!
实现哨兵模式的配置其实是很麻烦的，里面有很多选择!

Redis缓存穿透、击穿和雪崩

Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。
另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案

缓存穿透(查不到)

概念

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中（秒杀!)，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。

解决方案：

过滤器

布隆过滤器是一种数据结构，对所有可能查询的参数以hash的形式存储，在控制层先进行校验，不符合则丢弃，从而避免对底层存储系统的查询压力。

[外链图片转存中...(img-lzcp4Lbf-1683363382217)]

缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源﹔

但是这种方法会存在两个问题:
1、如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键;
2、即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

缓存击穿（量太大，缓存过期）

概述

这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导使数据库瞬间压力过大。

解决方案

设置热点永不过期

从缓存层面来看，没有设置过期时间，所以不会出现热点key过期后产生的问题

加互斥锁

分布式锁∶使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。

[外链图片转存中...(img-oPLZScD0-1683363382217)]

缓存雪崩

概念

缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis宕机

产生雪崩的原因之一，比如在写本文的时候，马上就要到双十二零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时。那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。

[外链图片转存中...(img-Iapi2nnr-1683363382218)]

其实集中过期，倒不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。