getset #先get再set目录
一、 单机mysql的演进
1. nosql概述
1.1 为什么要使用nosql?
1.单机mysql的年代
2. memcached（缓存）+ MySQL + 垂直拆分
3. 分库分表 + 水平拆分 + mysql集群
技术和业务在发展的同时对人的要求也越来越高！
本质 数据库（读、写）
4. 如今最近的年代
为什么要用NoSQL?
1.2 nosql是什么？
nosql == not only sql
关系型数据库：
泛指非关系型数据库，随着web2.0互联网的诞生！传统的关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区。暴露出来很多难以克服的问题！
1.3 nosql的特点
1.4 NoSQL的四大分类
二、redis的入门
1. 概述
1.1 redis是什么？
redis（Remote Dictionary Server）,远程字典服务
是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。
1.2 redis可以干什么？
1. 内存存储、持久化，内存中是断电即失，所以说持久化很重要（rdb,aof）
2. 效率高，可以用于高速缓存
3. 发布订阅系统
4. 地图信息分析
5. 计时器、计数器（浏览量）
1.3 特性
1. 多样的数据类型
2. 持久化
3. 集群
4. 事务
......
1.4 学习中需要用到的东西
window上安装redis
redis中文网：http://www.redis.cn/
redis官方网：Redis
1.下载安装包
2. 解压安装包
3. 双击运行服务即可
默认端口为6379
4. 使用客户端连接redis服务端
linux下安装redis【我们在这里使用在linux下安装！！！官方不推荐在windows下使用redis】
1. 下载redis
2. 解压redis的安装包 程序放在 /opt下
mv 文件名 /opt
3. 解压（此时必须到达opt目录！！！）
tar -zxvf 包名
4. 进入解压后的文件
5. 基本环境安装
yum -install gcc-c++
make
make install
执行命令 make install 可以发现我们所有的都安装完成了
6. redis的默认的安装路径 /usr/local/bin
7. 将redis文件复制到当前目录下
8. redis默认不是后台启动，修改配置文件
vim redis.conf
9. 启动redis服务！
10. 测试联通
redis-cli -p 637911. 查看redis服务是不是开启
ps -ef|grep redis
12. 如何关闭redis服务
shutdown
13. 再次查看进程是不是存在
14. 后面我们会使用单机多redis启动服务
2. 测试性能
测试100个并发连接，1000个请求
redis-benchmark -h localhost -p 6379 -c 100 -n 1000
3. redis的基本知识的说明
3.1 有16个数据库，默认使用第0个
[root@wang kconfig]# redis-cli -p 6379
127.0.0.1:6379> select 0
OK
127.0.0.1:6379> select 3 #切换到第三个数据库
OK
127.0.0.1:6379[3]> dbsize #查看当前数据库的大小
(integer) 0
3.2 查看当前数据库所有的key
127.0.0.1:6379[3]> keys *
1) "name"
3.3 清除当前数据库
127.0.0.1:6379[3]> flushdb
OK
127.0.0.1:6379[3]> dbsize
(integer) 0
3.4 清除全部的数据库
127.0.0.1:6379> flushall
OK
3.5 redis是单线程的
为什么redis使用单线程还是这么快？
3.6 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）。
127.0.0.1:6379> exists name #判断当前是不是存在name这个key
(integer) 1
127.0.0.1:6379> keys *
1) "age"
2) "name"
127.0.0.1:6379> move name 2 #移除name这个key
(integer) 1
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> set name wang
OK
127.0.0.1:6379> expire name 10 #设置关键字的过期时间
(integer) 1
127.0.0.1:6379> ttl name #查看当前还有多久过期
(integer) 4
127.0.0.1:6379> ttl name
(integer) 3
127.0.0.1:6379> ttl name
(integer) 2
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> ttl name
(integer) -2
127.0.0.1:6379> type name #查看当前数据类型
none
127.0.0.1:6379> type age
string
☆3.6.1 String字符串类型的讲解☆
127.0.0.1:6379> set key1 v1
OK
127.0.0.1:6379> keys *
1) "age"
2) "key1"
127.0.0.1:6379> exists key1
(integer) 1
127.0.0.1:6379> move age 1
(integer) 1
127.0.0.1:6379> keys *
1) "key1"
127.0.0.1:6379> append key1 "yidinghuimeishi" #在已有的字符串后面进行添加
(integer) 17
127.0.0.1:6379> get key1
"v1yidinghuimeishi"
127.0.0.1:6379> strlen key1 #获得对应得关键字长度
(integer) 17
127.0.0.1:6379> set views 1
OK
127.0.0.1:6379> get views
"1"
127.0.0.1:6379> dcri views #自减1
(error) ERR unknown command 'dcri', with args beginning with: 'views'
127.0.0.1:6379> incr views #自增1
(integer) 2
127.0.0.1:6379> decr views
(integer) 1
127.0.0.1:6379> incrBy views 20 #可以设置步长指定增量
(integer) 21
127.0.0.1:6379> set key1 "hello,wang,you will be ok"
OK
127.0.0.1:6379> getrange key1 0 3 #获取指定区间内的关键字
"hell"
127.0.0.1:6379> getrange key1 0 -1
"hello,wang,you will be ok"
127.0.0.1:6379> setrange key1 23 fine #指定位置开始得字符串进行替换
(integer) 27
127.0.0.1:6379> get key1
"hello,wang,you will be fine"
127.0.0.1:6379> setex key2 30 "hello" #新创建一个对象同时设置过期时间，在前面我们还学过expire这个命令可以设置过期时间，只是在已有的基础上进行设置而已
OK
127.0.0.1:6379> ttl key3
(integer) -2
127.0.0.1:6379> ttl key2
(integer) 21
127.0.0.1:6379> setnx key3 "ok" #新建一个对象，如果有对应得key就不创建，没有就创建
(integer) 1
127.0.0.1:6379> setnx key3 "ok"
(integer) 0
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 #设置多个值
OK
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "key1"
4) "key3"
5) "k2"
127.0.0.1:6379> mget k1 k2 k3 #获得多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k4 v4 #msetnx是一个原子性的操作，要么一起成功，要么一起失败
(integer) 0
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "key1"
4) "key3"
5) "k2"
set usr:1 {name:zhangsan,age:10} #设置一个usr1对象，值为json字符串来保存一个对象
getset #先get再set
☆3.6.2 List的讲解☆
在redis里面，我们可以把list玩成栈、队列、阻塞队列
所有list命令都是用 l 开头的！！redis不区分大小写命令
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> Lrange list 0 1 #获取指定范围的值
1) "three"
2) "two"
LPOP
RPOP
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> lpop list 1 #移除列表的左边第一个元素
1) "three"
127.0.0.1:6379> rpop list 1 #移除列表的右边第一个元素
1) "one"
lindex
127.0.0.1:6379> lindex list 2
(nil)
127.0.0.1:6379> lindex list 0 #通过下标获得元素
"two"
llen
127.0.0.1:6379> llen list #返回列表的长度
(integer) 1
127.0.0.1:6379> llen list
(integer) 1
127.0.0.1:6379> lpush list one
(integer) 2
127.0.0.1:6379> lpush list haha
(integer) 3
127.0.0.1:6379> lpush list yes
(integer) 4
127.0.0.1:6379> lrem list 1 #移除list集合中指定的值
(error) ERR wrong number of arguments for 'lrem' command
127.0.0.1:6379> lrem list 1 one
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "yes"
2) "haha"
3) "two"
trim 修剪操作
127.0.0.1:6379> rPUSH mylist "hello1"
(integer) 1
127.0.0.1:6379> rPUSH mylist "hello2"
(integer) 2
127.0.0.1:6379> rPUSH mylist "hello3"
(integer) 3
127.0.0.1:6379> rPUSH mylist "hello4"
(integer) 4
127.0.0.1:6379> ltrim mylist 1 2 #截断，只要1-2这个区间里面的数据
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "hello2"
2) "hello3"
rpoplpush #移除列表的最后一个元素
127.0.0.1:6379> lrange mylist 0 -1
1) "hello2"
2) "hello3"
127.0.0.1:6379> rpoplpush mylist myotherlist #移动列表的最后一个元素到新的列表中
"hello3"
127.0.0.1:6379> lrange myotherlist 0 -1
1) "hello3"
127.0.0.1:6379> lrange mylist 0 -1
1) "hello2"
lset #设置指定位置的值为我们想要的
127.0.0.1:6379> lrange mylist 0 -1
1) "hello2"
127.0.0.1:6379> lset mylist 0 fine
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "fine"
linsert
127.0.0.1:6379> linsert mylist before "fine" ok #在指定列表的指定元素的前面或者后面添加新的元素
(integer) 2
127.0.0.1:6379> lrange mylist 0 -1
1) "ok"
2) "fine"
小结：
☆ 3.6.3 set（集合）的讲解☆
set中的值是以s开头的；set中的值是不能重复的
127.0.0.1:6379> sadd myset fine #set中添加值
(integer) 1
127.0.0.1:6379> sadd myset ok
(integer) 1
127.0.0.1:6379> smembers myset #查看指定set中的所有值
1) "ok"
2) "fine"
127.0.0.1:6379> sismember myset ok #查看一个元素是不是在指定的set中
(integer) 1127.0.0.1:6379> scard myset #获取set集合中的内容元素个数
(integer) 2
127.0.0.1:6379> srem myset yes #移除其中的指定的元素（就如我这里移除的是yes）
(integer) 1
127.0.0.1:6379> SRANDMEMBER myset #随机抽取一个元素
"fine"
127.0.0.1:6379> SRANDMEMBER myset
"ok"
127.0.0.1:6379>
127.0.0.1:6379> SRANDMEMBER myset
"fine"
127.0.0.1:6379> SRANDMEMBER myset 2
1) "ok"
2) "fine"
删除指定的key 随机删除key
127.0.0.1:6379> spop myset #随机删除
"ok"
127.0.0.1:6379> sadd myset hahaha
(integer) 1
127.0.0.1:6379> sadd myset ok
(integer) 1
127.0.0.1:6379> smove myset myotherset hahaha #将元素移动到指定set中
(integer) 1
127.0.0.1:6379> smembers myotherset
1) "hahaha"
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 key2 d
(integer) 1
127.0.0.1:6379> sadd key2 e
(integer) 1
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) "c"
3) "d"
4) "b"
5) "e"☆3.6.4 hash(哈希)的讲解☆
想象成一个map集合，本质上和String没有很大的区别
127.0.0.1:6379> hset myhash filed1 kuangshen
(integer) 1
127.0.0.1:6379> hget myhash filed1
"kuangshen"
127.0.0.1:6379> hmset myhash filed1 fine filed2 fine #设置多个key-value
OK
127.0.0.1:6379> hmget myhash filed1 filed2 #获得多个值
1) "fine"
2) "fine"
127.0.0.1:6379> hgetall myhash #获得所有的值
1) "filed1"
2) "fine"
3) "filed2"
4) "fine"
127.0.0.1:6379> hdel myhash filed1 #删除hash指定的key字段，对应的value值也就没有了
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "filed2"
2) "fine"
127.0.0.1:6379> hlen myhash #获取hash的字符长度
(integer) 1
127.0.0.1:6379> hkeys myhash #获取所有的key
1) "filed2"
127.0.0.1:6379> hvals myhash #获取所有的value
1) "fine"
127.0.0.1:6379> hincrby myhash filed1 1 #自增长1
(integer) 6
127.0.0.1:6379> hdecrby myhash filed1 1
(error) ERR unknown command 'hdecrby', with args beginning with: 'myhash' 'filed1' '1'
127.0.0.1:6379> hsetnx myhash filed3 haha #如果不存在则可以设置值，存在就不可以设置
(integer) 1
127.0.0.1:6379> hset user:1 name fine age 3
(integer) 2
127.0.0.1:6379> hget user:1 name
"fine"
hash变更的数据user name age,尤其是是用户信息之类的,经常变动的信息! hash更适合于对象的存储, String更加适合字符串存储!|
☆3.6.5 Zset（有序集合）的讲解☆
127.0.0.1:6379> zadd myset 1 one #添加
(integer) 1
127.0.0.1:6379> zadd myset 1 two
(integer) 1
127.0.0.1:6379> zrange myset 0 -1
1) "one"
2) "two"
127.0.0.1:6379> zadd salary 50000 wang
(integer) 1
127.0.0.1:6379> zadd salary 20000 wang1
(integer) 1
127.0.0.1:6379> zadd salary 200000 zahngsan
(integer) 1
127.0.0.1:6379> zrangebyscore salary -inf +inf #按照由小到大进行排序
1) "wang1"
2) "wang"
3) "zahngsan"
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores #由小到大排序并输出相应的人名
1) "wang1"
2) "20000"
3) "wang"
4) "50000"
5) "zahngsan"
6) "200000"
127.0.0.1:6379> zrem salary wang1 #移除
(integer) 1
127.0.0.1:6379> zrangebyscore salary 0 -1
(empty array)
127.0.0.1:6379> zrangebyscore salary 0 -1
(empty array)
127.0.0.1:6379> zrangebyscore salary -inf +inf
1) "wang"
2) "zahngsan"
127.0.0.1:6379> zrevrange salary 0 -1 #从高到低
1) "zahngsan"
2) "wang"
127.0.0.1:6379> zcount salary 20000 200000 #根据范围进行查看
(integer) 2
3.7 三种特殊数据类型
3.7.1 geospotial地理位置
geoadd #添加地理位置
#将指定的地理空间位置（经度、纬度、名称）添加到指定的key中。这些数据将会存储到sorted set这样的目的是为了方便使用GEORADIUS或者GEORADIUSBYMEMBER命令对数据进行半径查询等操作。
#两级无法添加，我们一般通过java程序直接导入
127.0.0.1:6379> geoadd china:city 39.90 116.40 beijing #添加城市数据
(integer) 1
127.0.0.1:6379> geoadd china:city 31.23 121.47 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 29.53 106.50 chongqing
(integer) 1
127.0.0.1:6379> geoadd china:city 22.52 114.05 shengzhen
(integer) 1
127.0.0.1:6379> geoadd china:city 30.24 120.16 hangzhou 34.26 108.96 xian
(integer) 2
geopos #获得指定的经纬度
127.0.0.1:6379> geopos china:city beijing #获取指定的城市的经纬度
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
geodist #获得直线距离
127.0.0.1:6379> geodist china:city beijing xian
"910056.5237"
georadius #获得指定位置的指定半径内的所有城市
127.0.0.1:6379> georadius china:city 110 30 1000 km
1) "chongqing"
2) "xian"
3) "shengzhen"
4) "hangzhou"
127.0.0.1:6379> georadius china:city 110 30 1000 km withdist #获得指定范围内的城市和直线距离
1) 1) "chongqing"
2) "341.9374"
2) 1) "xian"
2) "483.8340"
3) 1) "shengzhen"
2) "924.6408"
4) 1) "hangzhou"
2) "977.5143"
127.0.0.1:6379> georadius china:city 110 30 1000 km withcode
(error) ERR syntax error
127.0.0.1:6379> georadius china:city 110 30 1000 km withcoord #获得指定范围内的城市和经纬度
1) 1) "chongqing"
2) 1) "106.49999767541885376"
2) "29.52999957900659211"
2) 1) "xian"
2) 1) "108.96000176668167114"
2) "34.25999964418929977"
3) 1) "shengzhen"
2) 1) "114.04999762773513794"
2) "22.5200000879503861"
4) 1) "hangzhou"
2) 1) "120.1600000262260437"
2) "30.2400003229490224"
GEORADIUSBYMEMBER #找出在指定城市的指定范围内的城市的名字
127.0.0.1:6379> georadiusbymember china:city beijing 1000 km
1) "beijing"
2) "xian"
geohash 返回一个或多个位置元素的 Geohash 表示。
127.0.0.1:6379> geohash china:city beijing
1) "wx4fbxxfke0"
3.7.2 Hyperloglog
127.0.0.1:6379> pfadd mykey a b c d e f g h i j #创建第一组元素
(integer) 1
127.0.0.1:6379> pfcount mykey #统计第一组元素基数的数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 c c c d d d
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 2
127.0.0.1:6379> pfmerge mykey3 mykey mykey2 #合并两组到mykey3(并集)
OK
127.0.0.1:6379> pfcount mykey3
(integer) 10如果允许容错就可以使用hyperloglog
如果不允许的话就使用set或者自己创建的类型
3.8 bitmap 位图场景详情
127.0.0.1:6379> setbit sign 0 0 #设置值
(integer) 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 1
(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 1
(integer) 0
查看某一天是不是有打卡
127.0.0.1:6379> getbit sign 0
(integer) 0
127.0.0.1:6379> bitcount sign #统计这周的打开记录就可以看到是否有全勤
(integer) 6
4. redis的基本事务操作
redis事务本质：一组命令一块执行，一组命令的集合！一个事务中的所有命令都会被序列化！在事务的执行过程中会按照顺序执行！
一次性、顺序性、排他性！执行一系列的命令！
redis事务没有隔离级别的概念！
所有的命令在事务中并没有直接被执行，只有发起执行命令的时候才会开始执行！
redis的单条命令是保证原子性的，但是事务是不保证原子性的
redis的事务：
- 开启事务（multi）
- 命令入队
- 执行事务（exec）
锁：redis可以执行乐观锁
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)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> get v3
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) OK
4) (nil)
放弃事务
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)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> discard #取消事务
OK
127.0.0.1:6379> get k4
(nil)
编译型错误（代码有问题，命令有错），事务中所有命令都不会执行
127.0.0.1:6379> clear
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)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> getset
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors. #可以检查到上面就有错误
运行时异常（1/0），如果事务队列中存在语法性错误，那么在执行的过程中，其他命令是可以正常执行，错误命令抛出异常！
127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr k1 #这里有错误，因为字符串不能加一
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> get k3
QUEUED
127.0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range
2) OK
3) OK
4) "v3"
5. redis实现乐观锁
5.1 监控 watch
悲观锁：每次都会自动加锁，认为任何时候都会出问题
乐观锁：认为什么时候都不会出问题，所以不会上锁，更新数据的时候判断一下在此期间是不是有人修改这个数据,version！更新的时候比较这个version
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(TX)> decrby money 20
QUEUED
127.0.0.1:6379(TX)> incrby out 20
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20
6. jedis的实现
6.1 什么是jedis?
是redis官方推荐的java连接开发工具，使用redis操作java的中间件！如果你要使用java操作redis，那么一定要对jedis十分熟悉！
6.2 测试
1. 导入对应的依赖
<!--导入jedis的包-->
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.2.3</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
</dependencies>2. 编码测试
- 连接数据库
- 操作命令
- 断开连接
package com.wxy;
import redis.clients.jedis.Jedis;
public class TestPing {
public static void main(String[] args) {
//1. new jedis对象
Jedis jedis = new Jedis("127.0.0.1",6379);
//jedis所有的命令就是之前我们学习的所有的指令
System.out.printf(jedis.ping());
}
}
输出：pong
6.3 常用的API
就是对Spring hash set zset list的操作，前面我们都学过，在这里只要调用API就可以！
6.4 jedis实现事务
redis之jedis的事务操作_四颗石头的博客-CSDN博客_jedis 事务
7. Springboot整合redis
说明：在springboot2.x之后，原来的jedis都被替换成了lettuce
jedis：采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全，使用jedis pool连接池！更像BIO模式！
lettuce：采用netty，实例可以在多个线程下共享，不存在线程不安全的情况！可以减少线程的数量，更像NIO模式！
7.1实现一下
1. 导入依赖
<!--操作redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>2. 配置文件
#配置redis
spring.redis.host=127.0.0.1
spring.redis.port=63793. 测试一下
package com.wxy;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
@SpringBootTest
class Redis02Springboot01ApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
//获取连接对象
/*RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
connection.flushAll();
connection.flushDb();*/
redisTemplate.opsForValue().set("mykey","wang");
System.out.println(redisTemplate.opsForValue().get("mykey"));
}
}
❗ 注意❗
在企业中，我们所有的pojo类都会序列化！！
固定的模板
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;
/**
* 自定义 Redis 模板
*
* @author LiaoHang
* @date 2022-06-09 22:06
*/
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
// 定义泛型为 <String, Object> 的 RedisTemplate
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
// 设置连接工厂
template.setConnectionFactory(factory);
// 定义 Json 序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
// Json 转换工具
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;
}
}工具类
package cn.sail.redisspringboot.util;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* Redis 工具类
*
* @author LiaoHang
* @date 2022-06-09 22:15
*/
@Component
public class RedisUtil {
@Resource
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) {
// 如果返回值为 null，则返回 0L
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return Boolean.TRUE.equals(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);
}
// ===============================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 {
return redisTemplate.opsForList().remove(key, count, value);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ============================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 {
return redisTemplate.opsForSet().remove(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ================================Hash 哈希=================================
/**
* 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);
}
}8. redis.conf详解
8.1 单位
配置文件 unit单位 对大小写不敏感
8.2 包含
8.3 网络
8.4 通用
8.5 快照
8.6 安全
8.7 限制
8.8 append only模式 aof配置【49%】
9. redis的持久化之RDB
在指定的时间间隔内将内存中的数据集快照写入磁盘。
也就是 Snapshot 快照，恢复时是将快照文件直接读到内存里。
Redis会单独创建（fork）一个子进程来进行持久化。
会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。
整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能。
如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那 RDB 方式要比 AOF 方式更加的高效。
RDB 的缺点是最后一次持久化后的数据可能丢失。
9.1 复制
9.2 触发
9.3 恢复
9.4 优缺点
10. 持久化之AOF
10.1 配置
10.2 恢复
10.3 重写
10.4 优缺点
11. redis订阅发布
11.1 命令
订阅端
127.0.0.1:6379> subscribe wangwillbefine
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "wangwillbefine"
3) (integer) 1
1) "message"
2) "wangwillbefine"
3) "hahaha"
发送端
127.0.0.1:6379> publish wangwillbefine hahaha
(integer) 1
11.2 原理
-
Redis 是使用 C 实现的，通过分析 Redis 源码里的 pubsub.c 文件，可以了解发布和订阅机制的底层实现。
-
Redis 通过 publish 、subscribe 和 psubscribe 等命令实现发布和订阅功能。
-
通过 subscribe 命令订阅某频道后，redis-server 里维护了一个字典，字典的键就是一个个 channel。
-
而字典的值则是一个链表，链表中保存了所有订阅这个 channel 的客户端。
-
subscribe 命令的关键，就是将客户端添加到给定 channel 的订阅链表中。
-
通过 publish 命令向订阅者发送消息，redis-server 会使用给定的频道作为键，在它所维护的 channel 字典中查找记录了订阅这个频道的所有客户端的链表，遍历这个链表，将消息发布给所有订阅者。
-
pub / sub 从字面上理解就是发布（Publish）与订阅（Subscribe），在 Redis 中，你可以设定对某一个 key 值进行消息发布及消息订阅，当一个 key 值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。
这一功能最明显的用法
- 实时消息系统，比如普通的即时聊天，群聊等功能。
- 关注、订阅
稍微复杂的场景我们就会使用消息中间件MQ来做
12. redis主从复制
12.1 概述
主从复制，是指将一台 Redis 服务器的数据，复制到其他的 Redis 服务器
前者称为主节点（master / leader），后者称为从节点（slave / follower）。
数据的复制是单向的，只能由主节点到从节点。
Master 以写为主，Slave 以读为主。
一个主节点可以有多个从节点（或没有从节点），但一个从节点只能有一个主节点。
默认情况下，每台 Redis 服务器都是主节点。
12.2 作用
数据冗余
主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
故障恢复
当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复。这也是一种服务的冗余。
负载均衡
在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务，分担服务器负载。
尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高 Redis 服务器的并发量。
高可用
主从复制是哨兵和集群能够实施的基础，因此说主从复制是 Redis 高可用的基础。
一般来说，要将 Redis 运用于工程项目中，只使用一台 Redis 是万万不能的，原因如下：
-
结构上：单个 Redis 服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大。
-
容量上：单个 Redis 服务器内存容量有限，一般来说，单台 Redis 最大使用内存不应该超过 20G。
12.3 环境配置
1. 命令方式
指定主库（配从库不配主库）
slaveof 主库IP 主库端口
这种方式每次与主库断开后，都需要重新连接，非常不方便，不推荐。
拷贝多个 redis.conf 文件
标准的配置是一主三从，受限于内存大小，这里演示一主二从，所以拷贝 3 份配置文件演示。
[root@sail redis]# cp redis.conf redis6379.conf[root@sail redis]# cp redis.conf redis6380.conf[root@sail redis]# cp redis.conf redis6381.conf
修改配置文件
修改 redis6379.conf
daemonize yespidfile /var/run/redis_6379.pidlogfile "6379.log"dbfilename dump6379.rdb
修改 redis6380.conf
daemonize yespidfile /var/run/redis_6380.pidlogfile "6380.log"dbfilename dump6380.rdb
修改 redis6381.conf
daemonize yespidfile /var/run/redis_6381.pidlogfile "6381.log"dbfilename dump6381.rdb
启动服务
[root@sail redis]# redis-server redis6379.conf[root@sail redis]# redis-server redis6380.conf[root@sail redis]# redis-server redis6381.conf
查看启动的服务
[root@sail redis]# ps -ef|grep redisroot 8066 6267 0 21:40 pts/3 00:00:00 redis-cli -p 6380root 8388 1 0 21:46 ? 00:00:00 redis-server 127.0.0.1:6380root 8397 1 0 21:46 ? 00:00:00 redis-server 127.0.0.1:6381root 8417 6213 0 21:47 pts/0 00:00:00 grep --color=auto redisroot 11953 1 0 Mar15 ? 02:02:44 ./bin/redis-server *:6379
查看主从复制信息
info replication
默认情况下三台都是主机！！
主机断开
层层链路
谋朝篡位
改朝换代
13. 哨兵模式
13.1 概述
主从切换技术的操作是：当主机宕机后，需要手动把一台从机切换为主机。
这就需要人工干预，费事费力，还会造成一段时间内服务不可用。
这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。
Redis 从 2.8 开始正式提供了 Sentinel（哨兵） 架构来解决这个问题。
它是“谋朝篡位”的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从机转换为主机。
哨兵模式是一种特殊的模式，首先 Redis 提供了哨兵的命令，哨兵是一个独立的进程，它会独立运行。
其原理是哨兵通过发送命令，等待 Redis 服务器响应，从而监控运行的多个 Redis 实例。
这里的哨兵有两个作用：
-
通过发送命令，让 Redis 服务器返回监控其运行状态，包括主机和从机。
-
当哨兵监测到 master 宕机，会自动将 slave 切换成 master，然后通过发布订阅模式通知其他的从机，修改配置文件，让它们切换主机。
然而一个哨兵进程对 Redis 服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。
各个哨兵之间还会进行监控，这样就形成了多哨兵模式：
假设主机宕机，哨兵 1 先检测到这个结果，系统并不会马上进行 failover（故障转移） 过程，仅仅是哨兵 1 主观的认为主机不可用，这个现象称为主观下线。
当后面的哨兵也检测到主机不可用，并且数量达到一定值时，哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行 failover 操作。
切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从机实现切换主机，这个过程称为客观下线。
13.2 测试
1. 配置
受限于内存大小，这里只演示一个哨兵进程监测一个主机的情况。
在 redis 目录下新建 myconfig 目录，并创建文件 sentinel.conf
文件名必须为 sentinel.conf
[root@sail redis]# mkdir myconfig[root@sail redis]# cd myconfig/[root@sail myconfig]# vim sentinel.conf
编写配置
sentinel monitor myredis 127.0.0.1 6379 1
末尾的 1 代表选票达到多少时选举成功。
2. 启动
redis-sentinel myconfig/sentinel.conf
[root@sail redis]# redis-sentinel myconfig/sentinel.conf
16728:X 08 Jun 2022 22:23:38.464 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
16728:X 08 Jun 2022 22:23:38.464 # Redis version=6.2.6, bits=64, commit=00000000, modified=0, pid=16728, just started
16728:X 08 Jun 2022 22:23:38.464 # Configuration loaded
16728:X 08 Jun 2022 22:23:38.465 * monotonic clock: POSIX clock_gettime
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis 6.2.6 (00000000/0) 64 bit
.-`` .-```. ```\/ _.,_ ''-._
( ' , .-` | `, ) Running in sentinel mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 26379
| `-._ `._ / _.-' | PID: 16728
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | https://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
16728:X 08 Jun 2022 22:23:38.466 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
16728:X 08 Jun 2022 22:23:38.469 # Sentinel ID is a7ebdd5f7260485b8f6108169d96910b747e3c8f
16728:X 08 Jun 2022 22:23:38.469 # +monitor master myredis 127.0.0.1 6379 quorum 1
16728:X 08 Jun 2022 22:23:38.469 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 63793. 主机断开
主机断开后，哨兵进程会监测到，然后发起选举，调用选举算法，最后选举 6380 为新的主机，6381 也认定其为主机。
4. 主机恢复
之前断开的主机恢复后，哨兵进程也会检测到，但此时并不会将其再设为主机，而是设为新的主机的从机。
13.3 优缺点
1. 优点
哨兵集群模式是基于主从模式的，所有主从的优点，哨兵模式同样具有。
主从可以切换，故障可以转移，系统可用性更好。
哨兵模式是主从模式的升级，系统更健壮，可用性更高。
Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。
实现哨兵模式的配置也不简单，甚至可以说有些繁琐。
14. redis缓存穿透和雪崩
Redis 缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。
但同时，它也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。
如果对数据的一致性要求很高，那么就不能使用缓存。
另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。
14.1 缓存穿透
这里先介绍下日常使用缓存的逻辑：
查询一个数据，先到缓存中查询。
如果缓存中存在，则返回。
如果缓存中不存在，则到数据库查询。
如果数据库中存在，则返回数据，且存到缓存。
如果数据库中不存在，则返回空值。
1. 缓存穿透的概念
缓存穿透出现的情况就是数据库和缓存中都没有。
这样缓存就不能拦截，数据库中查不到值也就不能存到缓存。
这样每次这样查询都会到数据库，相当于直达了，即穿透。
这样会给数据库造成很大的压力。
2. 解决方案
14.2 缓存击穿
1. 概念
缓存击穿，是指一个 key 非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问。
当这个 key 在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
当某个 key 在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据。
由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导使数据库瞬间压力过大。
2. 解决方案
14.3 缓存雪崩
1. 概念
缓存雪崩，是指在某一个时间段，缓存集中过期失效。
产生雪崩的原因之一，比如马上就要到双十一零点，很快就会迎来一波抢购。
这波商品时间比较集中的放入了缓存，假设缓存一个小时。
那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。
而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。
于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。
其实集中过期，倒不是非常致命。
比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。
因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存。
这个时候，数据库也是可以顶住压力的，无非就是对数据库产生周期性的压力而已。
而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。
2. 解决方案
搭建集群
实现 Redis 的高可用，既然一台服务有可能挂掉，那就多增设几台服务。
这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。
在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。
比如对某个 key 只允许一个线程查询数据和写缓存，其他线程等待。
数据加热的含义就是在正式部署之前，先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。
在即将发生大并发访问前手动触发加载缓存不同的 key，设置不同的过期时间，让缓存失效的时间点尽量均匀。
❀完结撒花！❀
这一周效率不高，然后也是发生了一些事情，哎
希望大家加油哇，最后就给出我最近拍的一张好看的照片，希望大家喜欢哇
2643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
