Redis基础
一、 概念
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。
- redis是单线程的。
-
官方文档中文：
http://www.redis.cn/
-
官方文档英文：
https://redis.io/
-
make安装
进入redis加压后的文件夹下 或有一个makefile文件
make
make install
-
配置文件
redis.config
daemonize yes 后台启动（默认不是后台启动）
二、基础命令(五大数据类型)
1、String（字符串类型）
127.0.0.1:6379> set name rentianjie # 插入数据
OK
127.0.0.1:6379> get name # 获取数据
"rentianjie"
127.0.0.1:6379> keys * # 获取所有数据
1) "name"
127.0.0.1:6379> exists name # 检查是否存在该key值
(integer) 1
127.0.0.1:6379> expire name 10 # 设置有效时间
(integer) 1
127.0.0.1:6379> ttl name # 查看过期剩余时间
(integer) -2
127.0.0.1:6379> flushdb # 清楚当前数据库
OK
127.0.0.1:6379> flushall # 清除所有数据库
OK
127.0.0.1:6379> set key1 hello
OK
127.0.0.1:6379> append key1 --rentianjie # 追加内容
(integer) 17
127.0.0.1:6379> getrange key1 0 1 # 截取内容
"he"
127.0.0.1:6379> setrange key1 1 xx # 替换内容
(integer) 17
127.0.0.1:6379> strlen key1 # 查看长度
(integer) 17
127.0.0.1:6379> incr num # 自增1
(integer) 2
127.0.0.1:6379> incrby num 20 # 增加指定数量
(integer) 22
127.0.0.1:6379> decr num 15 # 自减1
(integer) 7
127.0.0.1:6379> decrby num 15 # 自减指定数量
(integer) 7
127.0.0.1:6379> setex name 10 hello # 存储时设置过期时间
OK
127.0.0.1:6379> setnx name rentianjie # 不存在key值再设置
(integer) 1
127.0.0.1:6379> mset k1 v1 k2 v2 k3 vv3 # 批量设置
OK
127.0.0.1:6379> mget k1 k2 k3 # 批量获取
1) "v1"
2) "v2"
3) "vv3
127.0.0.1:6379> msetnx k1 v1 k4 v4 # msetnx: 原子性操作 要么都成功要么都是失败
(integer) 0"
# 对象
set user:1 {name:zhangsan,age:3} # 设置一个user:1对象，值为json字符保存一个对象
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 22 # 特殊用法 存储对象
OK
127.0.0.1:6379> mget user:1:name user:1:age # 获取对象属性
1) "zhangsan"
2) "22"
127.0.0.1:6379> getset db mongodb # 先（get）获取在（set）设置 / cas
"redis"
Strin类似的使用场景：value除了是我们的字符串还可以是数字
- 计数器
- 统计多单位数据量
- 粉丝数
- 对象缓存存储
2、List（列表）
在redis里面，可以把list完成，栈、队列、阻塞队列！
所有的命令都是以l开头的，redis不区分大小命令。
# 添加 LPUSH RPUSH
127.0.0.1:6379> lpush list one two three # 将一个值或多个值添加到列表头部(左)
(integer) 3
127.0.0.1:6379> lrange list 0 -1 # 获取list值，可以以获取区间的值.
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> rpush list righr # 将一个值或多个值添加到列表尾部(右)
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "righr"
# 移除 LPOP RPOP
127.0.0.1:6379> lpop list # 头部(左)移除
"three"
127.0.0.1:6379> rpop list # 尾部(右)移除
"righr"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
# 指定获取 LINDEX
127.0.0.1:6379> lindex list 0 # 通过下标获取某一个值
"two"
127.0.0.1:6379> lindex list 1
"one"
# 获取长度 Llen
127.0.0.1:6379> llen list # 获取list长度
(integer) 2
# 移除指定值 Lrem
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> lrem list 1 three # 移除list集合中指定个数的value值，精准匹配
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
# 修剪，截取 Ltrim
127.0.0.1:6379>
127.0.0.1:6379> lpush mylist v1 v2 v3 v4
(integer) 4
127.0.0.1:6379> ltrim mylist 1 2 # 通过下表截取指定的长度，这个list已经被改变了，只剩下被截取的元素
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "v3"
2) "v2"
#rpoplpush 移动列表的最后一个元素，将他移动到新的列表中。
127.0.0.1:6379> lrange mylist 0 -1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> rpoplpush mylist list # 将列表中的最后 一个元素。将他移动到新的列表中。
"v1"
127.0.0.1:6379> lrange mylist 0 -1 # 查看原来的列表
1) "v3"
2) "v2"
127.0.0.1:6379> lrange list 0 -1 # 查看目标列表
1) "v1"
# Lset 更新list中指定位置的值，集合不存在或者指定下标元素不存在更新则失败。
127.0.0.1:6379> lpush list reids
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "reids"
127.0.0.1:6379> lset list 0 item # 更新list中指定位置的值
OK
127.0.0.1:6379> lrange list 0 -1
1) "item"
# Linsert 将一个具体的value值插入到列中某一个元素的前面或者后面
127.0.0.1:6379> lrange list 0 -1
1) "v2"
2) "v1"
127.0.0.1:6379> linsert list before v2 hello # 将指定元素的插入到list集合中‘v2’元素的前面
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "v2"
3) "v1"
127.0.0.1:6379> linsert list after v2 hello # 将指定元素的插入到list集合中‘v2’元素的后面
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "v2"
3) "hello"
4) "v1"
127.0.0.1
小结
- 它实际是一个链表，before Node after , left ,right 都可以插入
- 如果key不存在，则创建一个新的链表
- 如果key存在，则创建新的内容
- 如果移除了所有值，空链表，也代表不存在！
- 在两边插入或改动值，效率最高！中间插入相对效率低些。
3、Set (集合)
set集合中元素是不重复的
127.0.0.1:6379> sadd myset hello rentianjie # set集合中添加多个元素
(integer) 2
127.0.0.1:6379> smembers myset # 查看指定set的所有值
1) "rentianjie"
2) "hello"
127.0.0.1:6379> sismember myset hello # 判断某一个值是不是在set集合中
(integer) 1
127.0.0.1:6379> sismember myset world
(integer) 0
# scrad 查看集合数量
127.0.0.1:6379> scard myset # 查看集合数量
(integer) 1
# srem 移除集合中的指定元素
127.0.0.1:6379> SMEMBERS myset
1) "redis"
2) "hello"
3) "v1"
127.0.0.1:6379> Srem myset hello
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "redis"
2) "v1"
# srandmember 随机获取元素
127.0.0.1:6379> SRANDMEMBER myset
"redis"
127.0.0.1:6379> SRANDMEMBER myset
"v1"
# spop 随机弹出（数码处）元素
127.0.0.1:6379> SMEMBERS myset
1) "redis"
2) "v1"
127.0.0.1:6379> SPOP myset # 随机弹出指定set集合中的元素
"v1"
127.0.0.1:6379> SMEMBERS myset
1) "redis"
# smove 将指定集合中的指定元素移动到另一个set集合中
127.0.0.1:6379> SMEMBERS myset1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> SMEMBERS myset2
1) "h3"
127.0.0.1:6379> smove myset1 myset2 v1 # 将'myset1'中的'v1'元素移动到'myset2'
(integer) 1
127.0.0.1:6379> SMEMBERS myset1
1) "v3"
2) "v2"
127.0.0.1:6379> SMEMBERS myset2
1) "h3"
2) "v1"
# 数字集合类
- 差集: SDIFF
- 交集: SINTER
- 并集: SUNION
127.0.0.1:6379> SMEMBERS key1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> SMEMBERS key2
1) "c"
2) "d"
3) "e"
127.0.0.1:6379> SDIFF key1 key2 # 差集
1) "a"
2) "b"
127.0.0.1:6379> SINTER key1 key2 # 交集
1) "c"
127.0.0.1:6379> SUNION key1 key2 # 并集
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
4、Hash （哈希）
Map集合，key-map!时候这个值是一个map集合！本质和String类型没有太大区别，还是一个简单的key-value！
127.0.0.1:6379> hset myhash field1 rentianjie # set一个具体的key-value
(integer) 1
127.0.0.1:6379> hget myhash field1 # 获取一个值
"rentianjie"
127.0.0.1:6379> hmset myhash field1 hello field2 world # set多个ky-value值
OK
127.0.0.1:6379> hmget myhash field1 field2 # 获取多个值
1) "hello"
2) "world"
127.0.0.1:6379> hgetall myhash # 获取set中所有的值 以key-value形式
1) "field1"
2) "hello"
3) "field2"
4) "world"
# hdel 删除指定key字段
127.0.0.1:6379> hdel myhash field1 # 删除指定key字段，随之value也被删除
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
# hlen 获取hash个数
127.0.0.1:6379> hlen myhash # 获取myhash中有多少键值对
(integer) 1
# hexists 判断hash中是否有指定的key值
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
127.0.0.1:6379> HEXISTS myhash field2 # 判断hash中是否有指定的key值
(integer) 1
# hkeys hvals 输出所有的key、val值
127.0.0.1:6379> hkeys myhash
1) "field2"
127.0.0.1:6379> hvals myhash
1) "world"
# hincrby 自增，hsetnx：不存在key值就替换
127.0.0.1:6379> hset myhash field1 5
(integer) 1
127.0.0.1:6379> hincrby myhash field1 1 # 指定自增
(integer) 6
127.0.0.1:6379> hincrby myhash field1 -1 # 自减
(integer) 5
127.0.0.1:6379> hsetnx myhash field1 hello # 如果不存在，则设置
(integer) 0
127.0.0.1:6379> hsetnx myhash field2 world # 如果存在，则不设置
(integer) 1
hash变更的数据user、name age，尤其是用户信息之类的，经常变更的数据！hash更适合与对象的存储，String更符合字符串的存储！
5、Zset （有序集合）
在set的基础上，增加一个值，set k1 v1 zset k1 socre1 v1
# zadd 添加一个或多个值 并指定序号
127.0.0.1:6379> zadd myset 1 one 2 two # 添加一个或多个值 '1 one' '2 two'
(integer) 2
127.0.0.1:6379> zrange myset 0 -1 # 查询zset值
1) "one"
2) "two"
# ZRANGEBYSCORE 排序， -inf：负无穷，+inf：正无穷
127.0.0.1:6379> zadd salary 2500 xiaohuang # 添加三个员工工资
(integer) 1
127.0.0.1:6379> zadd salary 5000 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 500 rentianjie
(integer) 1
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf # 显示全部用户，从小到大
1) "rentianjie"
2) "xiaohuang"
3) "zhangsan"
127.0.0.1:6379> ZREVRANGE salary 0 -1 # 从小到大排序
1) "zhangsan"
2) "xiaohuang"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores # 显示全部用户并且附带成绩
1) "rentianjie"
2) "500"
3) "xiaohuang"
4) "2500"
5) "zhangsan"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores # 显示工资小于2500员工升序排序!
1) "rentianjie"
2) "500"
3) "xiaohuang"
4) "2500"
# Zrem 移除
127.0.0.1:6379> ZRANGE salary 0 -1 # 查看所有
1) "rentianjie"
2) "xiaohuang"
3) "zhangsan"
127.0.0.1:6379> zrem salary rentianjie # 移除指定元素
(integer) 1
127.0.0.1:6379> ZRANGE salary 0 -1
1) "xiaohuang"
2) "zhangsan"
# Zcard 查询集合中的个数
127.0.0.1:6379> ZCARD salary
(integer) 2
# Zcount 查询指定区间有多少数量
127.0.0.1:6379> zadd myset 1 hello 2 world 3 rtj
(integer) 3
127.0.0.1:6379> zcount myset 1 3 # 查询指定区间有多少成员数量
(integer) 3
127.0.0.1:6379> zcount myset 1 4
(integer) 3
案例思路：
set排序，存储班级成绩表，工资表排序！
普通消息： 1, 重要消息：2，带权重进行判断！
排行榜应用实例，取Top N 测试！
三、特殊类型（三种特殊类型）
1、geospatial（地理空间）
GEOadd
# geoadd 添加地理位置
# 规则：两地无法直接添加，我们一般会下载城市数据，直接通过java程序直接添加。
# 参数 key 值（经度、纬度、名称）
# 有效经度为 -180 到 180 度。
# 有效纬度是从 -85.05112878 到 85.05112878 度。
127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
(integer) 1
127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai 113.28 23.12 guangzhou 114.05 22.52 shenzhen 120.15 30.28 hangzhou
(integer) 4
GEOpos
# 获取当前定位：指定是一个坐标值！
127.0.0.1:6379> geopos china:city beijing # 获取指定的城市的经度纬度!
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
127.0.0.1:6379> geopos china:city shanghai shenzhen
1) 1) "121.47000163793563843"
2) "31.22999903975783553"
2) 1) "114.04999762773513794"
2) "22.5200000879503861"
GEOdist
两个位置的距离
单位：
- m为米。
- km为公里。
- mi数英里。
- ft为英尺
# 两地之间的直线距离
127.0.0.1:6379> GEOdist china:city beijing shanghai km
"1067.3788"
127.0.0.1:6379> GEOdist china:city beijing shenzhen km
"1945.7881"
GEOradius
已给定的经纬度为中心，找出某一半径内的元素
# 查找给定经纬度内半径内的数据
# 参数：
# withdist：距离以与命令的半径参数指定的单位相同的单位返回
# withcoord：同时返回匹配项的经纬度坐标。
# count：显示数量
127.0.0.1:6379> GEOradius china:city 110 30 1000 km withdist
1) 1) "shenzhen"
2) "924.6408"
2) 1) "guangzhou"
2) "831.7713"
3) 1) "hangzhou"
2) "976.4868"
127.0.0.1:6379> GEOradius china:city 110 30 1000 km withdist withcoord count 2
1) 1) "guangzhou"
2) "831.7713"
3) 1) "113.27999979257583618"
2) "23.1199990030198208"
2) 1) "shenzhen"
2) "924.6408"
3) 1) "114.04999762773513794"
2) "22.5200000879503861"
GEOOradiusByMember
# 根据指定‘元素’找出周围指定范围的元素
127.0.0.1:6379> georadiusBymember china:city shanghai 400 km withdist
1) 1) "hangzhou"
2) "164.5694"
2) 1) "shanghai"
2) "0.0000"
GEOhash 命令-返回一个或多个位置元素的GeoHash表示
该命令将返回11个字符的Geohash字符串!
127.0.0.1:6379> GEOHASH china:city beijing shanghai
1) "wx4fbxxfke0"
2) "wtw3sj5zbj0"
GEO底层的实现原理其实就是Zset！我们可以使用Zset命令来操作geo！
127.0.0.1:6379> ZRANGE china:city 0 -1 # 查看地图中所有的元素
1) "shenzhen"
2) "guangzhou"
3) "hangzhou"
4) "shanghai"
5) "beijing"
127.0.0.1:6379> zrem china:city beijing
(integer) 1
127.0.0.1:6379> ZRANGE china:city 0 -1 # 移除指定元素!
1) "shenzhen"
2) "guangzhou"
3) "hangzhou"
4) "shanghai"
2、hyperloglog （数学基数）
什么是基数？
A{1,3,5,7,8,7}
B{1,3,5,7,8}
基数（不重复的元素）= 5，可以接受误差！
简介
Rides 2.8.9 版本就更新了hyperloglog数据结构！
Rides Hyperloglog 基数统计的算法！
优点：占用内存是固定的，2^64不同的元素的基数，只需占用12KB的内存！如果从内存的角度的比较Hyperloglog首选！
网页UV（一个人访问一个网站多次，但是还是算一个人！）
传统的方式，set保存用户id，然后就可以统计set中的元素数量作为标准判断！
这个方法如果保存大量的用户id，就会比较麻烦！我们的目的为了计数，而不是保存用户id;
0.81%错误率！统计UV任务，可以忽略不计！
测试使用
127.0.0.1:6379> pfadd key1 a b c d e f g h i j # 创建第一组元素
(integer) 1
127.0.0.1:6379> pfcount key1 # 统计元素基数量
(integer) 10
127.0.0.1:6379> pfadd key2 i j z x c v b n m # 创建第二组元素
(integer) 1
127.0.0.1:6379> pfcount key2 # 统计数量
(integer) 9
127.0.0.1:6379> PFMERGE key3 key1 key2 # 合并两组元素数据（不重复的） 并集
OK
127.0.0.1:6379> pfcount key3
(integer) 15
如果允许容错，那么可以使用hyperloglog！
如果不允许容错，就使用set或自己的数据类型即可！
3、Bitmaps （位图）
位存储
统计用户信息，活跃，不活跃！登录、未登录！打卡，365打卡！两个状态的，都可以使用Bitmaps！
Bitmaps 位图，数据结构！都是操作二进制位来进程记录，就只有0和1两个状态！
365天 = 365 bit 1字节 = 8bit 46个字节左右！
测试
使用bitmaps 来记录周一到周日打卡！
周一：1 周二：1 周三：0 …
127.0.0.1:6379> setbit sign 1 1 # 记录周一 打卡（最后一个参数 只有两个状态）
(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 1
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379> setbit sign 7 0
(integer) 0
127.0.0.1:6379> getbit sign 3 # 查看周三状态 0 未打卡
(integer) 0
127.0.0.1:6379> getbit sign 4 # 查看周四状态 1 打卡
(integer) 1
127.0.0.1:6379> bitcount sign # 统计sign 一周内几天状态为 1 打卡
(integer) 4
四、事务
Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行的过程中，会按照顺序执行！
一次性、顺序性、排他性！执行一些列的命令！
------ 队列 set set set 执行 ------
Redis事务没有隔离级别的概念！
所有的命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行！Exec
Redis单条命令式保存原子性的，但是事务不保证原子性！
redis的事务：
-
开启事务（multi）
-
命令入队（）
-
执行事务（exec）
锁：Redis可以实现乐观锁，watch，解锁: unwatch
正常执行事务
127.0.0.1:6379> MULTI # 开启事务
OK
# 命令入队
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec # 执行事务
1) OK
2) OK
3) "v2"
4) OK
放弃事务 discard
127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> DISCARD # 取消事务
OK
127.0.0.1:6379> get k4 # 事务队列中的命令都不会被执行！
(nil)
编译型异常（代码有问题！命令有错误！），事务中所有的命令多不会被执行！
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> getset k3
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379> set k5 v5
QUEUED
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k5
(nil)
运行时异常（1/0），如果事务队列中存在语法型错误，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常！
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incr k1 # 执行失败 运行时失败 逻辑错误！
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k3
QUEUED
127.0.0.1:6379> exec # 虽然第一条执行失败，但是依旧正常执行成功了！
1) (error) ERR value is not an integer or out of range # 失败
2) OK
3) OK
4) "v3"
监控！
悲观锁：
- 很悲观，认为什么时候都会出现问题，无论做什么都加锁！
乐观锁：
- 很乐观，认为问么时候都不会出现问题，所以不会上锁！更新数据的时候判断一下，在此期间是否有人修改过这个数据，
- 获取version
- 更新的时候比较version
Redis 监视器测试
正常执行！
127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money # 监视‘money’对象
OK
127.0.0.1:6379> MULTI # 在执行事务命令期间，如果监视对象没有发生变动，则事务执行成功！
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> INCRBY out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20
测试多线程修改值，使用watch 可以当作redis的管所操作！
27.0.0.1:6379> WATCH money # 监视 money 值
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY money 10
QUEUED
127.0.0.1:6379> INCRBY out 10
QUEUED
127.0.0.1:6379> exec # 在执行事务期间，另外一个线程修改了money的值，则事务执行失败！
(nil)
unwacth 解锁
- 事务执行失败会自动失败锁！
- 手动释放锁！unwatch
如果执行事务失败，会手动释放锁，也可以执行期间主动释放锁，在加锁！
五、Jedis
我们要使用Java 来操作Redis！
什么是Jedis, 是Redis 官方推荐的 java连接工具！使用 Java 操作Redis中间件！如果你要使用java操作redis，那么一定要对redis十分熟悉！
测试
1、导入依赖
<!-- jedis client -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
2、编译测试
- 连接数据库
- 操作命令
- 断开连接
@Test
public void JedisConnTest() {
Jedis jedis = new Jedis("127.0.0.1", 6379);
log.info(jedis.ping());
jedis.flushDB();
JSONObject jsonObject = new JSONObject();
jsonObject.put("name", "hello");
jsonObject.put("age", "14");
String json = jsonObject.toJSONString();
// 监控
// jedis.watch("user1");
Transaction multi = jedis.multi();
try {
multi.set("user1", json);
multi.set("user2", json);
int i = 1 / 0;
// 提交事务
multi.exec();
} catch (Exception e) {
multi.discard();
log.error("jedis 事务异常 e={}", e.getMessage());
} finally {
String str1 = jedis.get("user1");
String str2 = jedis.get("user2");
log.info("user1={}, user2={}", str1, str2);
jedis.close();
}
}
六、Spring Boot整合
String Boot 操作数据：spring-da’ta jpa jdbc mongodb redis
String Boot 也是和 Spring boot 齐名的项目！
说明：在spring boot 2.x之后，原来的jedis 被替代为了 lettuce !
jedis：采用的直连，多个线程操作的话，是不安全的，如果想避免不安全的，使用jedis pool 连接池！BIO
lettuce：netty，实例可以在多个线程中进行共享，不存在线程不安全问题！ 可以减少线程数量，更像NIO
源码分析：
// 表示当指定Bean在容器中只有一个，或者虽然有多个但是指定首选Bean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 默认的 RedisTemplate 没有过多的设置，redis 对象都是序列化的！
// 两个泛型都是 Object， Object的类型，我们后面使用<String, Object>
RedisTemplate<Object, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean //判断当前需要注入Spring容器中的bean的实现类是否已经含有，有的话不注入，没有就注入
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)// 由于string是最常用的，所以单独提一个bean出来！
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
// 判断当前需要注册的bean的实现类否被spring管理，如果被管理则注入，反之不注入
// @ConditionalOnBean
整合测试！
1、导入依赖
<!-- spring boot 整合的 redis -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
</dependency>
2、配置连接
spring:
redis:
host: 127.0.0.1
port: 6379
3、测试
@Test
void redisTemplateTest() {
// redisTemplate.opsForValue(); 对应字符串
// redisTemplate.opsForList(); 对应列表
// redisTemplate.opsForSet();
// redisTemplate.opsForHash();
// redisTemplate.opsForZSet();
// redisTemplate.opsForGeo();
// redisTemplate.opsForHyperLogLog();
redisTemplate.opsForValue().set("user1", "rentianjie");
System.out.println(redisTemplate.opsForValue().get("user1"));
}
自定义redisTemplate
package com.example.config;/**
* @author: 任天杰
* @date : 2021/07/21 0:18
*/
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @author 任天杰
* @date 2021-07-21 0:18
*/
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings("all") // 消除警告
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
//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 stringSerializer = new StringRedisSerializer();
// key 采用String序列化方式
template.setKeySerializer(stringSerializer);
// hash key 采用String序列化方式
template.setHashKeySerializer(stringSerializer);
// value 采用json序列化方式
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash value 采用json序列化方式
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
Redis工具类
package com.example.uilts;
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;
}
}
}
Redis 应用
一、Redis Config详解
单位
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
配置文件载入
# include /path/to/local.conf
# include /path/to/other.conf
网络
bind 127.0.0.1 # ip绑定
protected-mode yes3 # 保护模式
port 6379 # 端口
通用
daemonize yes # 是否为守护进程，默认no
pidfile /var/run/redis_6379.pid # 守护进程模式下，指定的pid文件！
# 日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing) # 测试、开发
# verbose (many rarely useful info, but not a mess like the debug level)# 相对于debug少一下日志
# notice (moderately verbose, what you want in production probably) # 生成环境 默认的
# warning (only very important / critical messages are logged) # 警告 （关键重要的信息）
loglevel notice
logfile "" # 日志文件的日志名
databases 16 # 数据库数量，默认16个
always-show-logo yes# 是否总是显示logo
快照
持久化，在规定的时间内，执行多少次操作，则会持久化到文件.rdb .aof
redis 是一个内存数据库，如果没有持久化，断电即失！
# 在 900s 内，如果至少有一个 key 进行了修改，则会被持久化到文件 .rdb .aof
save 900 1
# 在 300s 内，如果至少有10 key 进行了修改，则会被持久化到文件 .rdb .aof
save 300 10
# 在 60s 内，如果至少有10000 key 进行了修改，则会被持久化到文件 .rdb .aof
save 60 10000
stop-writes-on-bgsave-error yes # 持久化如果出错，是否还需要继续工作！
rdbcompression yes # 是否压缩rdb文件，需要消耗一些 cpu 资源！
rdbchecksum yes # 保存rdb文件的时候，进行错误的校验！
dbfilename dump.rdb # RDB文件名字
dir ./ # rdb文件目录
REPLICATION 主从复制
SECURITY 安全
可以在这里设置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" # 设置密码
OK
127.0.0.1:6379> config get requirepass
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth 123456 # 登陆密码
OK
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "123456"
限制 CLIENTS
maxclients 10000 # 客户端最大连接数
maxmemory <bytes> # redis最大内存容量
maxmemory-policy noeviction # 内存达到上限后的处理策略
noeviction: 不删除策略, 达到最大内存限制时, 如果需要更多内存, 直接返回错误信息。（默认值）
allkeys-lru: 所有key通用; 优先删除最近最少使用(less recently used ,LRU) 的 key。
volatile-lru: 只限于设置了 expire 的部分; 优先删除最近最少使用(less recently used ,LRU) 的 key。
allkeys-random: 所有key通用; 随机删除一部分 key。
volatile-random: 只限于设置了 expire 的部分; 随机删除一部分 key。
volatile-ttl: 只限于设置了 expire 的部分; 优先删除剩余时间(time to live,TTL) 短的key。
APPEND ONLY 模式 aof 配置
appendonly no # 默认是不开启模式，默认是用的是rdb方式持久化，在大部分情况下，rdb完全够用！
appendfilename "appendonly.aof" # 持久化文件的名字
# appendfsync always # 每次都会 sync（同步），消化性能
appendfsync everysec # 每秒都执行一次 sync，可能丢失1s 的数据！
# appendfsync no # 不执行 sync ，这个时候操作系统自己同步数据，速度最快！
no-appendfsync-on-rewrite no #
二、Redis 持久化
1、RDB（Redis DataBase）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2wILu0B-1628000592784)(.\imgs\1626881401(1)].jpg)
在指定的时间间隔内将内存中的数据集快照写入磁盘,也就是行话讲的Snapshot快照,它恢复时是将快照文件直接读到内存里。Redis会单独创建(fork )一个子进程来进行持久化,会先将数据写入到一个临时文件中,待持久化过程都结束了,再用这个临时文,件替换上次持久化好的文件。整个过程中,主进程是不进行任何0操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复,且对于数据恢复的完整性不是非常敏感,那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。我们默认的就是RDB ,一般情况下不需要修改这个配置!
触发机制
1、save的规则满足的情况下,会自动触发rdb规则
2、执行flushall 命令,也会触发我们的rdb规则!
3、退出redis,也会产生rdb文件!
备份就自动生成一个dump.rdb
恢复rdb文件数据
1、只需要将rdb文件放在我们redis启动目录就可以, redis启动的时候会自动检查dump.rdb恢复其中的数据!
2、查看需要存在的位置
127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin"
优点:
1、适合大规模的数据恢复!
2、对数据的完整性要不高!
缺点：
1、需要一定的时间间隔进程操作! 如果redis意外宕机了, 这个最后一次修改数据就没有的了!
2、 fork 进程的时候,会占用一定的内容空间 !
2、AOF (Append Only File)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IbCKsqTq-1628000592786)(.\imgs\1626882905(1)].jpg)
以日志的形式来记录每个写操作,将Redis执行过的所有指令记录下来(读操作不记录) ,只许追加文件但不可以改写文件, redis启动之初会读取该文件重新构建数据,换言之, redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
配置生效
默认是不开启的,我们需要手动进行配置!我们只需要将appendonly改为yes就开启了aof !
重启redis就生效了！
如果这个aof文件有错位,这时候redis是启动不起来的吗,我们需要修复这个aof文件！
redis给我们提供了一个工具redis-check-aof
redis-check-aof - fix appendonly.aof
优点和缺点
appendonly no # 默认是不开启模式，默认是用的是rdb方式持久化，在大部分情况下，rdb完全够用！
appendfilename "appendonly.aof" # 持久化文件的名字
# appendfsync always # 每次都会 sync（同步），消化性能
appendfsync everysec # 每秒都执行一次 sync，可能丢失1s 的数据！
# appendfsync no # 不执行 sync ，这个时候操作系统自己同步数据，速度最快！
no-appendfsync-on-rewrite no # 如果达到规定大小或文件是否追加，
auto-aof-rewrite-percentage 100 # 从写率
auto-aof-rewrite-min-size 64mb # 文件限制超过指定大小，重写aof文件.
优点：
1、每一次修改都会同步，文件的完成性更好！
2、每一同步一次，可能会丢失一秒的数据！
3、从不同步，效率更高！
缺点：
1、相对于数据文件来说，aof远远大于rdb，修复的效率也比rdb慢！
2、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文件就可以了,代价一是带来了持续的10,二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可,应该尽量减少AOF rewrite的频率, AOF重写的基础大小默认值64M太小了,可以设到5G以上,默认超过原大小100%大小重写可以改到适当的数值
-
如果不Enable AOF ,仅靠Master-Slave Repllcation实现高可用性也可以,能省掉一大笔10,也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时倒掉,会丢失十几分钟的数据,启动脚本也要比较两个Master/Slave中的RDB文件,载入较新的那个,微博就是这种架构。
三、Redis 发布订阅
Redis 发布订阅（pub/sub）是一种消息通信模式：发送者（pub）发送消息，订阅着（sub）接受消息。微信、微博、关注系统！
Redis 客户端可以订阅任意数量的频道。
订阅者 SUBSCRIBE
127.0.0.1:6379> SUBSCRIBE channel # 订阅channel频道
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel"
3) (integer) 1
1) "message" # 消息标识
2) "channel" # 频道（管道）名称
3) "rentianjie" # 消息内容
发布者 PUBLISH
127.0.0.1:6379> PUBLISH channel hello # 向‘channel’发送 消息 ‘hello’
(integer) 1
原理
Redis是使用C实现的,通过分析Redis源码里的pubsub.d文件,了解发布和订阅机制的底层实现,籍此加深对Redis的理解。
Redis通过PUBLISH, SUBSCRIBE和PSUBSCRIBE等命令实现发布和订阅功能。通过SUBSCRIBE命令订阅某频道后, redis-server里维护了一个字典,字典的键就是一个个channel ,而字典的值则是一个链表,链表中保存了所有订阅这个channel的客户端。SUBSCRIBE命令的关键,就是将客户端添加到给定channel的订阅链表中通过PUBLISH命令向订阅者发送消息, redis-server会使用给定的频道作为键,在它所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表,遍历这个链表,将消息发布给所有订阅者。Pub/Sub从字面上理解就是发布( Publish )与订阅( Subscribe ) ,在Redis中,你可以设定对某一个key值进行消息发布及消息订阅,当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统,比如普通的即时聊天,群聊等功能!
四、Redis 主从复制
主从复制,是指将一台Redis服务器的数据,复制到其他的Redis服务器。前者称为主节点(master/leader) ,后者称为从节点(slavel/follower) ;数据的复制是单向的,只能由主节点到从节点。Master以写为主, Slave以读为主。（至少一主二从）
默认情况下,每台Redis服务器都是主节点;且一个主节点可以有多个从节点(或没有从节点),但一个从节点只能有一个主节点。
主从复制的作用主要包括：
1、数据冗余：主从复制实现了数据的热备份，是持久化的一种数据冗余方式。
2、故障恢复：当节点出现问题时，可以有从节点提供服务，实现快速故障恢复；实际上是一种服务的冗余。
3、负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写redis数据时应用链接主节点，读redis数据时应用连接从节点），分担服务器负载；尤其是在写少读多的场景下，通过多个节点分担读负载，可以大大提高Redis服务器的并发。
4、高可用（集群）基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。
一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不可的，原因如下：
1、从结构上，单个Redis服务器发生单节点故障，并且一台服务器要处理所有的请求负载，压力较大。
2、从容量上，单个Redis服务内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存作用Redis存储内存，一般来说，单个Redis最大使用内存不应该超过20G
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HIwMOIP7-1628000592788)(D:\workspace\my-learn\doc\复习记录\imgs\08-Redis基础\image-20210722213459377.png)]
主从复制，读写分离！80%的情况下都是在进行读操作！减缓服务器的压力！架构中经常使用！一主二从！
1、环境配置
只配置从库，不用配置主库
127.0.0.1:6379> info replication # 查看库的信息
# Replication
role:master # 角色 master 主机
connected_slaves:0 # 从机数量
master_replid:84075f20ce3c0432a80259b039b4cf23be6f8305
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
复制3个配置文件，修改对应信息
1、端口
2、pid名字
3、log文件的名字
4、dump.rad 名字
2、一主二从
默认情况下，每台Redis服务器都是主机，我们一般情况下只用配置从机就好！
- 从机配置
127.0.0.1:6380> SLAVEOF 127.0.0.1 6379 # slaveof 主机ip 主机端口
OK
127.0.0.1:6380> info replication # 查询服务信息
# Replication
role:slave # 角色
master_host:127.0.0.1 # 主机的ip
master_port:6379 # 主机的端口
master_link_status:up
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_repl_offset:14
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:2cf70d0babf1441100a72383ecc4b730bf5b93a9
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:14
# 主机查询
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2 # 从机数量
slave0:ip=127.0.0.1,port=6380,state=online,offset=1834,lag=0# 从机0信息
slave1:ip=127.0.0.1,port=6381,state=online,offset=1834,lag=1# 从机1信息
master_replid:2cf70d0babf1441100a72383ecc4b730bf5b93a9
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:1834
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:1834
注：真是的主从配置在配置文件中配置，通过和客户端命令配置是暂时！
配置文件配置主从
# 主机ip 主机端口
# replicaof <masterip> <masterport>
# 主机的密码（如果主机有密码，则配置）
# masterauth <master-password>
细节
-
主机可以写数据，从机不能写只能读取数据！主机中的所有信息和数据，都会自己被从机器保存！
-
主机断开连接，从机依旧连接主机的，但是没有写操作，这个时候，主机如果又回来了，从机依旧可以直接获取主机的信息和数据！
-
从机断开连接，如果是由客户端命令命令执行的主从配置，如果从机恢复，则从机默认是自己主机。如果从机又配置主从，则可以获取到主机所有数据！
复制原理
Salve (从机) 启动成功连接到 msater 后会发送一个 sync 同步命令。
Master (主机) 接到命令，启动后台的存盘进程，同时收集所有收到的用于修改数据集的命令，在后台进程执行完毕，master将传送整个数据文件到salve，并完成一次同步。
- 全量复制：而salve 服务在接受到数据库文件数据后，将其存盘并加载到内存中。
- 增量复制：Master 继续将新的所有收集到的修改命令依次传给salve，完成同步。
但只要是重新连接master，一次完全同步（全量复制）将被自动执行！我们的数据一定在从机中看到！
层层链路
比如三台机器：79 80 81
79 是 80 的主节点，80 是 81 的 主节点，这种模式也是一种主从复制，
如果当79宕机，80这时还是一个从机，不会自动变为主机。可以手动指定配置 80当前机器为主机点如下：
SLAVEOF no one 手动配置当前机器为主节点
127.0.0.1:6381> SLAVEOF no one # 配置当前机器为主节点
OK
127.0.0.1:6381> info replication
# Replication
role:master
connected_slaves:0
master_replid:fc992ac59788287c30969172f8b536d332789dad
master_replid2:2cf70d0babf1441100a72383ecc4b730bf5b93a9
master_repl_offset:8414
second_repl_offset:8415
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1807
repl_backlog_histlen:6608
3、哨兵模式
概述
主从切换技术的方法是:当主服务器宕机后,需要手动把一台从服务器切换为主服务器,这就需要人工干预,费事费力,还会造成一段时间内服务不可用。这不是一种推荐的方式,更多时候,我们优先考虑哨兵模式。 Redis从2.8开始正式提供了Sentinel (哨兵)架构来解决这个问题。
谋朝篡位的自动版,能够后台监控主机是否故障,如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式,首先Redis提供了哨兵的命令,哨兵是一个独立的进程,作为进程,它会独立运行。其原理是哨兵通过发送命令,等待Redis服务器响应,从而监控运行的多个Redis实例。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xjdw5TC8-1628000592790)(.\imgs\08-Redis基础\image-20210722235850525.png)]
这里哨兵有两个作用：
- 通过命令发送，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
- 当哨兵监控到master宕机，会自动将salve切换程master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让他们自动切换主机。
然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可是使用多个哨兵进行监控。各个哨兵之间还会互相监控，这样就形成了多哨兵模式。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fkt5NeX3-1628000592792)(.\imgs\08-Redis基础\image-20210723000716245.png)]
假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover(选举)过程，仅仅是哨兵1主观地认为主服务器不可用，这个现象被称为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover[故障转移]操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。
配置哨兵模式
1、 配置哨兵配置文件
vim sentinel.config
# sentinel monitor 被监控的名称 host 端口 选举人
sentinel monitor myredis 127.0.0.1 6379 1
后面的数字1，代表主机挂了，salve投票看让谁接替成为主机，票数最多的，就会成为主机！
2、启动哨兵
[root@localhost bin]# redis-sentinel kconfig/sentinel.config # 启动哨兵命令 指定脚本
6184:X 22 Jul 2021 09:41:49.710 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
6184:X 22 Jul 2021 09:41:49.710 # Redis version=5.0.7, bits=64, commit=00000000, modified=0, pid=6184, just started
6184:X 22 Jul 2021 09:41:49.710 # Configuration loaded
6184:X 22 Jul 2021 09:41:49.710 * Increased maximum number of open files to 10032 (it was originally set to 1024).
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis 5.0.7 (00000000/0) 64 bit
.-`` .-```. ```\/ _.,_ ''-._
( ' , .-` | `, ) Running in sentinel mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 26379
| `-._ `._ / _.-' | PID: 6184
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | http://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
6184:X 22 Jul 2021 09:41:49.711 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
6184:X 22 Jul 2021 09:41:49.712 # Sentinel ID is 5fbb4c6e3a1dfcaeb4cb948b4608a9fcade6b0c3
6184:X 22 Jul 2021 09:41:49.712 # +monitor master myredis1 127.0.0.1 6379 quorum 1
6184:X 22 Jul 2021 09:41:49.713 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:41:49.715 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.520 # +sdown master myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.520 # +odown master myredis1 127.0.0.1 6379 #quorum 1/1
6184:X 22 Jul 2021 09:42:32.520 # +new-epoch 1
6184:X 22 Jul 2021 09:42:32.520 # +try-failover master myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.521 # +vote-for-leader 5fbb4c6e3a1dfcaeb4cb948b4608a9fcade6b0c3 1
6184:X 22 Jul 2021 09:42:32.521 # +elected-leader master myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.521 # +failover-state-select-slave master myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.592 # +selected-slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.592 * +failover-state-send-slaveof-noone slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.682 * +failover-state-wait-promotion slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.823 # +promoted-slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.823 # +failover-state-reconf-slaves master myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:32.914 * +slave-reconf-sent slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:33.833 * +slave-reconf-inprog slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:33.833 * +slave-reconf-done slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:33.887 # +failover-end master myredis1 127.0.0.1 6379
6184:X 22 Jul 2021 09:42:33.887 # +switch-master myredis1 127.0.0.1 6379 127.0.0.1 6381
6184:X 22 Jul 2021 09:42:33.887 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis1 127.0.0.1 6381
6184:X 22 Jul 2021 09:42:33.887 * +slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis1 127.0.0.1 6381
# 127.0.0.1 6381 被选举新的主机
如果Master 节点断开了，这个时候就会从主机中随机选择一个服务器！（这里有一个投票算法！）
之前的主机恢复了
6184:X 22 Jul 2021 09:47:53.133 # -sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis1 127.0.0.1 6381
6184:X 22 Jul 2021 09:48:03.054 * +convert-to-slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis1 127.0.0.1 6381
如果主机回来了，只能归并到新的主机下，当做从机，这就是哨兵模式的规则！
哨兵模式
优点：
1、哨兵集群，基于主从复制模式，所有的主从配置的优点，他全有！
2、主从自动切换，故障可以自动转移，系统的可用性就会更好！
3、哨兵模式就是主从模式的升级，手动变为自动，更加健壮！
缺点：
1、Redis 不好在线扩容的，集群容量一旦达到上限，在扩容就十分麻烦！
2、实现哨兵模式的配置其实是很麻烦的，里面有很多选择！
哨兵模式的全部配置
# Example sentinel.conf
# 哨兵sentinel实例运行的端口默认26379
port 26379
# 哨兵sentinel的工作目录
dir /tmp
# 哨兵sentine7监控的redis主节点的ip port
# master-name 可以自己命名的主节点名字只能由字母A-z、数字0-9、这三个字符".-_"组成。
# quorum配置多少个sentine1哨兵统一认为master主节点失联那么这时客观上认为主节点失联了
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 2
# 当在Redis实例中开启了requirepass foobared授权密码这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel连接主从的密码注意必须为主从设置一样的验证密码
# sentine] auth-pass <master-name> <plassword>
sentinel auth-pass mymaster MySUPER--secret-0123password
# 指定多少毫秒之后主节点没有应答哨兵sentine1此时哨兵主观上认为主节点下默认30秒
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行同步,这个数字越小,完成failover所需的时间就越长,但是如果这个数字越大,就意味着越多的slave因为replication而不可用。可以通过将这个值设为1来保证每次只有一个slave处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间failover-timeout可以用在以下这些方面:
# 1.同一个sentine7对同一个master两次failover之间的间隔时间。
# 2·当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
# 3.当想要取消一个正在进行的failover所需要的时间
# 4·当进行failover时,配置所有slaves指向新的master所需的最大时间。不过,即使过了这个超时, slaves依然会被正确配置为指向master,但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
#sentinel failover-timeout <master-name> <mil1iseconds>
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
# 配置当某一事件发生时所需要执行的脚本,可以通过脚本来通知管理员,例如当系统运行不正常时发邮件通知相关人员。
# 对于脚本的运行结果有以下规则:
# 若脚本执行后返回1,那么该脚本稍后将会被再次执行,重复次数目前默认为10
# 若脚本执行后返回2,或者比2更高的一个返回值,脚本将不会重复执行。
# 如果脚本在执行过程中由于收到系统中断信号被终止了,则同返回值为1时的行为相同
# 一个脚本的最大执行时间为60s,如果超过这个时间,脚本将会被一个SIGKILL信号终止,之后重新执行。
# 通知型脚本:当sentine1有任何警告级别的事件发生时(比如说redis实例的主观失效和客观失效等等) ,将会去调用这个脚本,这时这个脚本应该通过邮件, SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时,将传给脚本两个参数,一个是事件的类型,个是事件的描述。如果sentine . conf配置文件中配置了这个脚本路径,那么必须保证这个脚本存在于这个路径,并且是可执行的,否则sentine7无法正常启动成功。#通知脚本
# sentinel notification-script <master-name> <script-path>
sentinel notification-script mymaster /var/redis/notify.sh
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时,这个脚本将会被调用,通知相关的客户端关于master地址已经发生改变的信息
# 以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是"failover"
# <role>是"Teader"或者"observer"中的一个
# 参数from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的,能被多次调用,不是针对性的。
# sentinel c7ient-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig. shl
五、Redis 缓存穿透和雪崩
1、缓存穿透
概念
缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询，发现也什么有没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这回给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
解决方案
-
布隆过滤器
布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vatPSQMx-1628000592793)(.\imgs\08-Redis基础\image-20210723165917591.png)]
- 缓存空对象
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FVJCp6sO-1628000592795)(.\imgs\08-Redis基础\image-20210723170339749.png)]
但是这个方法存在两个问题：
1、如果控制能够呗缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这个当中可能会有很多的空值的键；
2、即使对控制设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口不一致，这对于需要保证一致性的业务会有影响。
2、缓存击穿
概念
这里需要注意的缓存穿透的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对一个点进行访问，当这个key在失效的瞬间，持久的大并发就穿破缓存，直接请求到数据库，就像在一个屏障上凿开一个洞。
当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般都是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且写回缓存，会导致数据库瞬间压力过大。
解决方案
- 设置二点数据永不过期
从缓存层面来看，没有设置过期时间，所以不会出现热点 key 过期后产生的问题。
- 加互斥锁
分布式锁：使用分布式锁，保证对于每个key同时只能有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此需要等待即可，这种方式将高并发的压力转移到了分布式锁上，因此对分布式锁的考验很大。
3、缓存雪崩
概念
缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis 宕机 ！
产生雪崩的原因之一，比如在写问的时候，马上要到双十二零点， 很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时，那么到凌晨一点种的时候，这波商品的缓存就都到期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会爆增，造成存储层也会挂掉的情况。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1Us8KbFB-1628000592796)(.\imgs\08-Redis基础\image-20210723173144082.png)]
其实集中过期，倒不是非常致命，比较致命的缓存雪崩。是缓存服务器某个节点宕机或者断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压跨。
解决方案
- redis 高可用
这个思想的含义是，既然 redis 有可能挂掉，那我就多设几台 redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。（异地多活）
- 限流降级
这个解决方案的思想是，在缓存失效后，通过枷锁或者排队来控制读数据库些缓存的线程数量。比如对某个key只允许一个线程查寻数据和写缓存，其他线程等待。
- 数据预热
数据预热的含义就是在正式部署之前，先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会在加载到缓存中。在即将发生大并发访问钱手动触发加载不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。
sentinel notification-script mymaster /var/redis/notify.sh
客户端重新配置主节点参数脚本
当一个master由于failover而发生改变时,这个脚本将会被调用,通知相关的客户端关于master地址已经发生改变的信息
以下参数将会在调用脚本时传给脚本:
目前总是"failover"
是"Teader"或者"observer"中的一个
参数from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
这个脚本应该是通用的,能被多次调用,不是针对性的。
sentinel c7ient-reconfig-script
sentinel client-reconfig-script mymaster /var/redis/reconfig. shl
## 五、Redis 缓存穿透和雪崩
### 1、缓存穿透
> 概念
缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询，发现也什么有没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这回给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
> 解决方案
- **布隆过滤器**
布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力；
[外链图片转存中...(img-vatPSQMx-1628000592793)]
- 缓存空对象
[外链图片转存中...(img-FVJCp6sO-1628000592795)]
但是这个方法存在两个问题：
1、如果控制能够呗缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这个当中可能会有很多的空值的键；
2、即使对控制设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口不一致，这对于需要保证一致性的业务会有影响。
### 2、缓存击穿
> 概念
这里需要注意的缓存穿透的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对一个点进行访问，当这个key在失效的瞬间，持久的大并发就穿破缓存，直接请求到数据库，就像在一个屏障上凿开一个洞。
当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般都是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且写回缓存，会导致数据库瞬间压力过大。
> 解决方案
- **设置二点数据永不过期**
从缓存层面来看，没有设置过期时间，所以不会出现热点 key 过期后产生的问题。
- **加互斥锁**
分布式锁：使用分布式锁，保证对于每个key同时只能有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此需要等待即可，这种方式将高并发的压力转移到了分布式锁上，因此对分布式锁的考验很大。
### 3、缓存雪崩
> 概念
缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis 宕机 ！
产生雪崩的原因之一，比如在写问的时候，马上要到双十二零点， 很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时，那么到凌晨一点种的时候，这波商品的缓存就都到期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会爆增，造成存储层也会挂掉的情况。
[外链图片转存中...(img-1Us8KbFB-1628000592796)]
其实集中过期，倒不是非常致命，比较致命的缓存雪崩。是缓存服务器某个节点宕机或者断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压跨。
> 解决方案
- **redis 高可用**
这个思想的含义是，既然 redis 有可能挂掉，那我就多设几台 redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。（异地多活）
- **限流降级**
这个解决方案的思想是，在缓存失效后，通过枷锁或者排队来控制读数据库些缓存的线程数量。比如对某个key只允许一个线程查寻数据和写缓存，其他线程等待。
- **数据预热**
数据预热的含义就是在正式部署之前，先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会在加载到缓存中。在即将发生大并发访问钱手动触发加载不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。
[参考狂神大佬](https://blog.csdn.net/qq_33369905)
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
