Redis笔记-入门篇
Nosql概述
为什么要用Nosql
大数据时代，
大数据 一般的数据库无法进行分析处理了！
1、单机MySQL的年代
90年代，一个基本的访问量一般不会太大，单个数据库完全足够！
那个时候，更多的去使用静态网页HTML~服务更本没有太大的压力！
思考一下，这个情况下：整个网页的瓶颈是什么？
1、数据量如果太大，一个机器放不下了！
2、数据的超过300万，就要建立索引， 数据的索引（B+Tree），一个机器内存也放不下
3、访问量（读写混合），性能问题，一个服务器也承受不了~
只要开始出现以上三种情况之一，就必须要晋级！
2、Memcached（缓存） + MySQL + 垂直拆分 （读写分离）
网站80%的情况都是在读，每次都要去查询数据库的话就十分的麻烦！所以希望减轻服务器的压力，可以使用缓存来保证效率！
发展过程：优化数据结构和索引–>文件缓存（IO）–>Memcached（当时最热门的技术！）
3、分库分表 + 水平拆分 + MySQL集群
本质：数据库（读，写）
早些年MyISAM： 表锁，十分影响效率！查询表里面的一个东西，会锁整个表，高并发情况下会出现严重的锁问题
转战Innodb：行锁，
慢慢的就开始使用分库分表来解决写的压力！Mysql在那个年代推出了表分区！这个并没有被多少公司使用！
MySQL的集群，很好的满足了那个年代的需求！
4、如今的年代
2010-2020 十年之间，世界已经发生翻天覆地的变化；（定位，也是一种数据，音乐，热榜！）
MySQL等关系型数据库就不够用了！数据量很多，变化很快~！
MySQL有的使用它来存储一些比较大的文件，博客，图片！数据库很大，效率就低了！如果有一种数据库来专门处理这种数据，MySQL的压力就会小了（研究如何处理这些问题）大数据的IO压力下，表几乎无法更改！
目前一个基本的互联网项目！
为什么要用NoSQL！
用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长！
这时候用NoSQL数据库可以很好的处理以上的情况！
什么是NoSQL
NoSQL
NoSQL = Not Only SQL（不仅仅是SQL）
关系型数据库：表格，行，列
泛指非关系型数据库，随着web2.0互联网的诞生！传统的关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区！暴露出来很多难以克服的问题，NoSQL在当今大数据环境下发展的十分迅速，Redis是发展最快的，而且是当下必须要掌握的一个技术！
很多的数据类型用户的个人信息，社交网络，地理位置。这些数据类型的存储不需要一个固定的格式！不需要多余的操作就可以横向扩展的！Map
NoSQL特点
Java为什么要用接口 解耦！
1、方便扩展（数据之间没有关系，很好扩展）
2、大数据量 高性能（Redis 1s写八万次，读11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高！）
3、数据类型是多样性的！（不需要事先设计数据库！随取随用，很多人无法开始就设计一个很好的数据库）
4、传统RDBMS和NoSQL
传统的RDBMS（关系型数据库）
- 结构化组织
- SQL
- 数据和关系都存在单独的表中 row col
- 数据操作语言，数据定义语言
- 严格的一致性 数据的ACID
- 基础的事务
- .....
NoSQL
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储，列存储，文档存储，图形数据库（社交关系）
- 最终一致性， 最终！！！
- CAP定理和BASE （异地多活） 初级架构师
- 高性能，高可用，高可扩
- .....
了解：3V + 3高
大数据时代的3V：主要是描述问题的
海量 Volume
多样 Variety
实时 Velocity
大数据时代的3高：主要是对程序的要求
高并发
高可扩（随时可以水平拆分，机器不够了，可以扩展机器来解决）
高性能
真正在公司中的实践：NoSQL + RDBMS一起使用才是最强的。
阿里巴巴演进分析
这么多的数据都是在一个数据库中么？
敏捷开发、极限编程 了解
敏捷开发以用户的需求进化为核心，采用迭代、循序渐进的方法进行软件开发。在敏捷开发中，软件项目在构建初期被切分成多个子项目，各个子项目的成果都经过测试，具备可视、可集成和可运行使用的特征。换言之，就是把一个大项目分为多个相互联系，但也可独立运行的小项目，并分别完成，在此过程中软件一直处于可使用状态。
极限编程是一个轻量级的、灵巧的软件开发方法；同时它也是一个非常严谨和周密的方法。它的基础和价值观是交流、朴素、反馈和勇气；即，任何一个软件项目都可以从四个方面入手进行改善：加强交流；从简单做起；寻求反馈；勇于实事求是。
XP是一种近螺旋式的开发方法，它将复杂的开发过程分解为一个个相对比较简单的小周期；通过积极的交流、反馈以及其它一系列的方法，开发人员和客户可以非常清楚开发进度、变化、待解决的问题和潜在的困难等，并根据实际情况及时地调整开发过程。
想当一个架构师：没有什么是加一层解决不了的。 比如众多数据库 我们使用JDBC去差异化链接
# 1、商品的基本信息
名称、价格、商家信息;
关系型数据库就可以解决了! MysQL / oracle(淘宝早年就去TOE了!-王坚:推荐文章:阿里云的这群疯子:40分 钟重要!)淘宝内部的MysQL不是大家用的MysQL
# 2、商品的描述、评论(文字比较多)
文档型数据库中，MongoDB
# 3、图片
分布式文件系统 FastDFS
- 淘宝自己的 TFS
- Gooale的 GFS
- Hadoop HDFS
- 阿里云的 oss
# 4、商品的关键字(搜索)
- 搜索引擎so1r elasticsearch
- Iserach:多隆（多去了解一下这些技术大佬!)
所有牛逼的人都有一段苦逼的岁月!但是你只要像SB一样的去坚持，终将牛逼!
# 5、商品热门的波段信息
- 内存数据库
- Redis Tair Memache...
# 6、上品的交易，外部的支付接口
- 三方应用
一个简单的网页背后的技术一定不是大家所想的那么简单！
大型互联网应用的问题：
- 数据类型太多了！
- 数据源繁多，经常重构！
- 数据要改造，大面积啊改造？
解决问题：
NoSQL四大分类
KV键值对：
- 新浪： Redis
- 美团： Redis + Tair
- 阿里、百度： Redis + memcache
文档型数据库（bson格式和Json一样）：
- MongoDB（一般需要掌握）
- MongoDB是一个基于分布式文件存储的数据库， C++编写，主要用来处理大量的文档！
- MongoDB是一个介于关系型数据库和非关系型数据库中间产品，MongoDB是非关系数据库中功能最丰富，最像关系型数据库的！
- ConthDB
列存储数据库
- HBase
- 分布式文件系统
图关系数据库
- 不是存图形的，放的是关系，比如，朋友圈的社交网络，广告推荐！
- Neo4j，InfoGrid；
四者对比
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JlFVnrDt-1638932737594)(Redis.assets/image-20210106125514634.png)]
Redis入门
概述
Redis是什么？
Redis（Remote Dictionary Server )，即远程字典服务
一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。免费和开源！是当下最热门的NoSQL技术之一！也被人们称之为结构化数据库！
Redis能干嘛
1、内存存储，持久化，内存断电即失，所以说持久化很重要（rdb、aof）
2、效率高，可以用于高速缓存
3、发布订阅系统
4、地图信息分析
5、计时器、计数器（浏览量！）
6、…
特性
1、多样的数据类型
2、 持久化
3、 集群
4、 事务
…
学习中需要用到的东西
1、狂神的公众号:狂神说
2、官网: https://redis.io/
3、中文网: http://www.redis.cn/、
4、下载：通过官网下载
注意：Windows在Github上下载（停更很久）
Redis推荐都是在Linux服务器上搭建的，我们是基于Linux学习！
Windows安装
1、下载安装包：https://github.com/dmajkic/redis/releases
2、下载完毕后得到压缩包
3、解压到自己电脑上的环境目录下就可以！Redis十分的小，只有5M
4、开启Redis，双击运行服务即可
5、使用Redis客户端链接redis
Window下使用确实简单，但是Redis推荐使用Linux
Linux安装
1、下载安装包
2、解压Redis的安装包！程序放在/opt
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0WcnvPSO-1638932737598)(Redis.assets/image-20210106151726037.png)]](http://img.e-com-net.com/image/info8/550c247fa4ba440c942343421fe2ae55.png)
3、进入解压后的文件，可以看到Redis的配置文件
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rY27YY60-1638932737598)(Redis.assets/image-20210106152552164.png)]](http://img.e-com-net.com/image/info8/451060f6c8904cffb3f50ad76913b672.png)
4、基本的环境安装
yum install gcc-c++
make #安装 过长较长
make #确定 确定安装是否成功
make install#确定安装是否成功
5、redis的默认安装路径usr/local/bin
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jRvIqMQ4-1638932737599)(Redis.assets/image-20210106154254116.png)]](http://img.e-com-net.com/image/info8/9ec00c91ee294dc89858c8696bb8e497.jpg)
6、将redis配置文件，复制到当前目录下 出问题了 用原来的配置文件直接拿过来 保证安全
7、redis默认不是后台启动的 改为yes 就是后台启动了
8、启动Redis
通过自定义的配置文件启动
9、测试连接
redis-cli -h(默认是本机不用写) -p 端口
keys * 查看所有的key
10、查看redis进程是否开启！
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPiG1WQF-1638932737601)(Redis.assets/image-20210106160332913.png)]](http://img.e-com-net.com/image/info8/67283e9f751145f2a11b76cb203ea13c.png)
11、如何关闭Redis服务shotdown
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0SnN28TW-1638932737601)(Redis.assets/image-20210106160456028.png)]](http://img.e-com-net.com/image/info8/ea24a3c16b314d538e924c6fcd0fdfab.png)
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6GTfzzN1-1638932737602)(Redis.assets/image-20210106160509543.png)]](http://img.e-com-net.com/image/info8/5ade9a04b6e44d8b81f9f64f171ef0d8.png)
12、后面会使用单机多Redis启动集群测试!
测试性能
redis-benchmark是一个压力测试工具
官方自带的性能测试工具！
redis-benchmark 命令参数！
测试：
# 测试： 100个并发连接 100000请求
redis-benchmark -c 100 -n 100000
如何查看这些分析
基础的知识
Redis默认有16个数据库
默认使用的是第0个数据库
可以使用select进行切换数据库
127.0.0.1:6379> select 3 # 切换数据库
OK
127.0.0.1:637> DBSIZE # 查看DB大小
(integer) 0
清楚当前数据库内容flushdn
清楚全部数据库内容flushall
127.0.0.1:6379> keys * # 查询所以逇key
1) "key:__rand_int__"
2) "myset:__rand_int__"
3) "name"
4) "counter:__rand_int__"
5) "mylist"
127.0.0.1:6379[3]> flushdb # 清空当前库 flushall 清空所有库
OK
127.0.0.1:6379[3]> keys *
(empty list or set)
Redis是单线程的 6.0版本之后变成了多线程
明白Redis是很快的，官方表示，Redis是基于内存操作的，CPU不是Redis性能瓶颈，Redis的瓶颈是根据机器的内存和网络带宽，既然可以使用单线程来实现，就是用单线程。
Redis是C语言写的，官方提供的数据为100000+的QPS（每秒查询率），完全不比同样适用key-value的Memcache差！
Redis为什么单线程还这么快？
1、误区1：高性能的服务器一定是多线程的。
2、误区2：多线程（CPU上下文切换！消耗资源）一定比单线程效率高！
先CPU>内存>硬盘的速度有所了解
核心：redis是将所有的数据全部放在内存中的，所以说使用单线程去操作效率就是最高的。多线程（CPU上下文切换！耗时的操作！！！），对于内存系统来说，如果没有上下文切换，效率就是最高的！多次读写都是在一个CPU上的，在内存情况下，这个就是最佳的方案！
五大数据类型
官网文档
全段翻译：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-Key
exists xx # 查看xx存在不存在
EXISTS name
(integer) 1
move xx n #将xx移动到第n个数据库
127.0.0.1:6379[3]> select 0
OK
127.0.0.1:6379> keys *
1) "key:__rand_int__"
2) "myset:__rand_int__"
3) "name"
4) "counter:__rand_int__"
5) "mylist"
127.0.0.1:6379> move name 1
(integer) 1
127.0.0.1:6379> keys *
1) "key:__rand_int__"
2) "myset:__rand_int__"
3) "counter:__rand_int__"
4) "mylist"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "name"
127.0.0.1:6379> EXPIRE name 10 # 设置name销毁时间 默认s
(integer) 1
127.0.0.1:6379> ttl name #查看name 还有多少s销毁
(integer) 5
127.0.0.1:6379> ttl name
(integer) 4
127.0.0.1:6379>
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> ttl name
(integer) -2
127.0.0.1:6379> keys *
1) "key:__rand_int__"
2) "myset:__rand_int__"
3) "counter:__rand_int__"
4) "mylist"
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> type name # 查看当前key的类型
string
后续可以查看官网的命令
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uVA8dWCc-1638932737604)(Redis.assets/image-20210106183631101.png)]](http://img.e-com-net.com/image/info8/9fd8dcddabad407890d067a9d8c526e3.jpg)
String（字符串）
127.0.0.1:6379> set key1 v1
OK
127.0.0.1:6379> EXISTS key1
(integer) 1
127.0.0.1:6379> append key1 "hello" # 给key1追加"hello"
(integer) 7 # 总长度
127.0.0.1:6379> get key1
"v1hello"
127.0.0.1:6379> EXISTS key1
(integer) 1
127.0.0.1:6379> STRLEN key1 # 查看key1长度
(integer) 7
####################################################################################
127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> type views
string
127.0.0.1:6379> incr views # 自增
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> decr views # 自减
(integer) 1
127.0.0.1:6379> get views
"1"
127.0.0.1:6379> incrby views 10 # 自增 步长为10
(integer) 11
127.0.0.1:6379> incrby views 10
(integer) 21
127.0.0.1:6379> decrby views 10 # 自减 步长为10
(integer) 11
127.0.0.1:6379> get views
"11"
###################################################################################
getrange
127.0.0.1:6379> set key1 "helle,shijie"
OK
127.0.0.1:6379> get key1
"helle,shijie"
127.0.0.1:6379> getrange key1 0 3 # 截取key1 下标0-3
"hell"
127.0.0.1:6379> getrange key1 0 -1 # 截取key1 和get key1一样
"helle,shijie"
127.0.0.1:6379> set key2 abcdefg
OK
127.0.0.1:6379> get key2
"abcdefg"
127.0.0.1:6379> SETRANGE key2 1 xx # 将key2 从下标1开始替换为 xx
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"
#####################################################################################
# setex(set with expire) # 设置过期时间
# setnx(set if not exist) # 不存在再设置（在分布式锁中常常用到）
127.0.0.1:6379> setex key3 30 "hello" # 设置key3的值为hello 30s后过期
OK
127.0.0.1:6379> ttl key3
(integer) 26
127.0.0.1:6379> setnx mykey "redis" # 如果mykey不存在，创建mykey
(integer) 1
127.0.0.1:6379> keys *
1) "mykey"
2) "key3"
3) "key2"
4) "key1"
127.0.0.1:6379> ttl key3
(integer) -2
127.0.0.1:6379> setnx mykey "MongoDB" # 如果mykey存在，创建mykey失败
(integer) 0
127.0.0.1:6379> get mykey
"redis"
#####################################################################################
# mset
# mget
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 # 同时设置多个值k1 k2 k3
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"
127.0.0.1:6379> mget k1 k2 # 查询 k1 k2
1) "v1"
2) "v2"
127.0.0.1:6379> msetnx k1 vv1 k2 vv2 k4 v4 # 当k1 k2 k4 全部不存在时，才会创建 原子性操作
(integer) 0
# 对象
set user:1{name:zhangsan,ang:3} #设置一个user1 值为json字符串来保存一个对象！
# 这里的key是一个巧妙的设计： user:{id}:{filed},在redis中完全ok
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 30
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "30"
####################################################################################
getset #先get 再set
127.0.0.1:6379> getset db redis # 如果不存在返回nil，设置新的值
(nil)
127.0.0.1:6379> getset db redis
"redis"
127.0.0.1:6379> getset db shijie # 存在返回原来的值，并且设置新的值
"redis"
127.0.0.1:6379> get db
"shijie"
string类似的使用场景: value除了是我们的字符串还可以是我们的数字!
- 计数器
- 统计多单位的数量
- 粉丝数
- 对象缓存存储！
List（列表）
基本的数据类型，列表
在redis里面，我们可以把list玩成栈，队列、阻塞队列！
所有的list命令都是用l开头的
127.0.0.1:6379> lpush list one #将一个值或者多个值插入到名为list的list头部 最左边 下标为0
(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 0 -1
(error) ERR wrong number of arguments for 'lrange' command
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> lrange list 0 1 # 最后进来的下标为0
1) "three"
2) "two"
127.0.0.1:6379> rpush list four # #将一个值或者多个值插入到名为list的list尾部 最右边 下标最大
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"
####################################################################################
lpop # 左弹出
rpop # 右弹出
127.0.0.1:6379> lpop list # 移除最左边的一个元素 头部 下标0
"three"
127.0.0.1:6379> rpop list # 移除最右边的一个元素 尾部 下标最大
"four"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
####################################################################################
lindex # 获取 某个list 的第n个值
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 # 返回列表长度
(integer) 2
####################################################################################
# 移除指定的值！
# 取关 uid
lrem
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "two"
3) "one"
4) "three"
127.0.0.1:6379> lrem list 1 three # 移除list 中 1个元素 值为 three
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "two"
3) "one"
127.0.0.1:6379> lrem list 2 two # 移除list 中 2个元素 值为 two ，也可以移除一个，不清楚是那一个应该是靠近头部的被移除
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "one"
####################################################################################
trim # 在java中修剪
list # 截断
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "two"
3) "three"
4) "four"
127.0.0.1:6379> ltrim list 1 2 # 通过下标截取
OK
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "three"
####################################################################################
rpoplpush #移除列表的最后一个元素 并且给另一个表
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 "hello12"
(integer) 3
127.0.0.1:6379> RPOPLPUSH mylist myotherlist
"hello12"
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "hello1"
127.0.0.1:6379> lrange myotherlist 0 -1
1) "hello12"
####################################################################################
lset # 将列表中指定下标的值替换为另一个值 ，更新操作
127.0.0.1:6379> EXISTS list # 判断列表是否存在
(integer) 0
127.0.0.1:6379> lset list 0 item # 不存在更新会报错
(error) ERR no such key
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 item
OK
127.0.0.1:6379> lrange list 0 0
1) "item"
127.0.0.1:6379> lrange list 1 other
(error) ERR value is not an integer or out of range
####################################################################################
linsert # 将某个值插入到列表中某个元素的前面或者换后面，
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（集合）
set中的值是不能重复的
127.0.0.1:6379> sadd myset "hello" # set中添加元素
(integer) 1
127.0.0.1:6379> sadd myset "shijie"
(integer) 1
127.0.0.1:6379> sadd myset "love shijie"
(integer) 1
127.0.0.1:6379> SMEMBERS myset # 查看指定set的所有值
1) "shijie"
2) "hello"
3) "love shijie"
127.0.0.1:6379> sismember myset hello # 查看指定set集合中有没有某个元素
(integer) 1
127.0.0.1:6379> sismember myset world
(integer) 0
####################################################################################
127.0.0.1:6379> scard myset # 获取set集合中元素的个数
(integer) 3
####################################################################################
127.0.0.1:6379> smembers myset # 移除set集合汇总的所有元素
1) "shijie"
2) "love shijie"
####################################################################################
set # 无序不重复 ， 抽随机
127.0.0.1:6379> SRANDMEMBER myset # 从set集合中随机抽取一个元素
"love shijie"
127.0.0.1:6379> SRANDMEMBER myset
"shijie"
127.0.0.1:6379> SMEMBERS myset
1) "shijie"
2) "love shijie2"
3) "love shijie"
127.0.0.1:6379> SRANDMEMBER myset 2 #从set集合中随机抽取指定个数元素
1) "shijie"
2) "love shijie2"
127.0.0.1:6379> SRANDMEMBER myset 2
1) "love shijie2"
2) "love shijie"
spop # 随机移除key！
127.0.0.1:6379> spop myset
"love shijie2"
127.0.0.1:6379> spop myset
"love shijie"
127.0.0.1:6379> SMEMBERS myset
1) "shijie"
####################################################################################
smove # 将一个指定的值，移动到另外一个set集合
127.0.0.1:6379> SMEMBERS myset
1) "shijie"
2) "love shijie2"
3) "love shijie"
127.0.0.1:6379> SMEMBERS myset2
(empty list or set)
127.0.0.1:6379> smove myset myset2 "shijie" #
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "love shijie2"
2) "love shijie"
127.0.0.1:6379> SMEMBERS myset2
1) "shijie"
####################################################################################
微博，b站，共同关注！（并集）
数学集合类型
- 差集
- 交集
- 并集
127.0.0.1:6379> smembers key1
1) "a"
2) "c"
3) "b"
127.0.0.1:6379> smembers key2
1) "d"
2) "c"
3) "e"
127.0.0.1:6379> sdiff key1 key2 # key1中有相对key2中没有的 差集
1) "a"
2) "b"
127.0.0.1:6379> sinter key1 key2 # key1 key2都有的 交集
1) "c"
127.0.0.1:6379> sunion key1 key2 # key1 key2总共有多少元素 并集
1) "c"
2) "b"
3) "a"
4) "d"
5) "e"
####################################################################################
微博，A用户将所有关注的人放在一个set集合中！将它的粉丝也放在一个集合中！
共同关注，共同爱好，二度好友，推荐好友！（六度分割理论）
Hash（哈希）
Map集合， key- 也就是key-map map是一个集合！本质和string没有太大的区别，还是一个简单的集合key-value
127.0.0.1:6379> hset myhash field1 shijie # set 一个具体的key value
(integer) 1
127.0.0.1:6379> hget myhash field1
"shijie"
127.0.0.1:6379> hmset myhash field1 hello field2 world # set多个key value
OK
127.0.0.1:6379> hmget myhash field1 field2 # 获取多个字段
1) "hello"
2) "world"
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "hello"
3) "field2"
4) "world"
127.0.0.1:6379> hdel myhash field1
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
####################################################################################
hlen # 获得hash字段数量
127.0.0.1:6379> hlen myhash
(integer) 1
127.0.0.1:6379> hmset myhash field1 hello
OK
127.0.0.1:6379> hlen myhash
(integer) 2
####################################################################################
HEXISTS # 存在
127.0.0.1:6379> HEXISTS myhash field # 判断hash中指定的key是否存在
(integer) 0
127.0.0.1:6379> HEXISTS myhash field1
(integer) 1
####################################################################################
hkeys # 只获得所有的field
hvals # 只获得所有的value
127.0.0.1:6379> hkeys myhash # 只获得所有的field
1) "field2"
2) "field1"
127.0.0.1:6379> hvals myhash # 只获得所有的value
1) "world"
2) "hello"
####################################################################################
incr decr # 自增步长 没有hdecrby
127.0.0.1:6379> hset myhash field3 5
(integer) 1
127.0.0.1:6379> hincrby myhash field3 10
(integer) 15
127.0.0.1:6379> hget myhash field3
"15"
127.0.0.1:6379> hdecrby myhash field3 5
(error) ERR unknown command `hdecrby`, with args beginning with: `myhash`, `field3`, `5`,
127.0.0.1:6379> hincrby myhash field3 -5
(integer) 10
127.0.0.1:6379> hget myhash field3
"10"
####################################################################################
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "hello"
3) "field2"
4) "world"
127.0.0.1:6379> hsetnx myhash field1 hello # 如果存在不可以设置
(integer) 0
127.0.0.1:6379> hsetnx myhash field3 ! # 如果不存在则可以设置
(integer) 1
hash存变更的数据，尤其是用户信息子类的，经常变动的信息！ hash更适合存储对象
127.0.0.1:6379> hset user:1 name shijie
(integer) 1
127.0.0.1:6379> hget user:1 name
"shijie"
Zset （有序集合）
在set的基础上，增加了一个值 set k1 v1 zset k1 score1 v1
127.0.0.1:6379> zadd myset 1 one
(integer) 1
127.0.0.1:6379> zadd myset 2 two 3 three
(integer) 2
127.0.0.1:6379> zrange myset 0 -1
1) "one"
2) "two"
3) "three"
127.0.0.1:6379> zadd salary 2500 xiaohong # 添加三个用户 每个人的 薪水是多少
(integer) 1
127.0.0.1:6379> zadd salary 5000 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 500 shijie
(integer) 1
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf # 从salary中 找-inf到+inf中间的值 升序排列 withscores LIMIT offset count 从第几个开始，而count表示取几条数据。
1) "shijie"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> ZREMRANGEBYSCORE salary -inf +inf # 降序 用法同上
127.0.0.1:6379> zrem salary xiaohong # 移除某个元素
(integer) 1
127.0.0.1:6379> zrange salary 0 -1 # 获取所有的元素 升序排列
1) "shijie"
2) "zhangsan"
127.0.0.1:6379> zrevrange salary 0 -1 # 获取所有的元素 降序排列
1) "zhangsan"
2) "shijie"
127.0.0.1:6379> zcard salary # 获取有序集合中的元素的个数
(integer) 2
127.0.0.1:6379> zadd myset 1 hello 2 world 3 kuangshen # 获取指定区间的值
(integer) 3
127.0.0.1:6379> zcount myset 1 3
(integer) 3
127.0.0.1:6379> zcount myset 1 2
(integer) 2
其与的一些API，通过我们的学习吗，你们剩下的如果工作中有需要，这个时候你可以去查查看官方文档！
案例思路: set排序存储班级成绩表，工资表排序!
普通消息，1，重要消息2，带权重进行判断！
排行榜应用实现，取Top N测试！
三种特殊数据类型
geospatial 地理位置
朋友的定位，附近的人，打车距离计算？
Redis Geo在Redis3.2版本就推出了!这个功能可以推算地理位置的信息，两地之间的距离，方圆几里的人 !
可以查询一些测试数据：http://www.jsons.cn/lngcodeinfo/0706D99C19A781A3/
只有六个命令
getadd
# getadd 添加地理位置
# 规则：两级无法直接诶添加，我们一般会下载城市数据，直接公国java程序一次性导入
# 有效的经度从-180度到180度。
# 有效的纬度从-85.05112878度到85.05112878度。
# 当坐标位置超出上述指定范围时，该命令将会返回一个错误。
# 127.0.0.1:6379> geoadd china:city 39.90 116.40 beijin
(error) ERR invalid longitude, latitude pair 39.900000,116.40000o
# 参数 key 值（经度、维度、名称）
127.0.0.1:6379> geoadd china:city 116.405289 39.904987 beijing
(integer) 1
127.0.0.1:6379> geoadd china:city 121.472641 31.231707 shanghai 106.504959 29.533155 chongqing
(integer) 2
127.0.0.1:6379> geoadd china:city 114.05571 22.53291 shenzhen 120.16922 30.24255 hangzhou
(integer) 2
127.0.0.1:6379> geoadd china:city 108.9608 34.26641 xian
(integer) 1
geopos
获取当前的定位：一定是一个坐标值！
127.0.0.1:6379> GEOPOS china:city beijing # 获取指定地方的经度和纬度
1) 1) "116.40528827905654907"
2) "39.90498588819134085"
127.0.0.1:6379> GEOPOS china:city beijing chongqing
1) 1) "116.40528827905654907"
2) "39.90498588819134085"
2) 1) "106.50495976209640503"
2) "29.53315530684997015"
geodist
两个人之间的距离
单位：
- m表示单位为米。
- km表示单位为千米。
- mi表示单位为英里。
- ft标示单位为英尺。
127.0.0.1:6379> geodist china:city beijing shanghai # 查看北京到上海的直线距离
"1067597.0432"
127.0.0.1:6379> geodist china:city beijing shanghai km
"1067.5970"
georadius
我附近的人？（获得所有附近的人的地址，定位！）通过半径来查询！
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km # 以110 30为重心在china:city 中查找1000 km以内的元素
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km
1) "chongqing"
2) "xian"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist # 显示到中心距离的位置
1) 1) "chongqing"
2) "341.4052"
2) 1) "xian"
2) "484.5164"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord # 再显示经纬度
1) 1) "chongqing"
2) "341.4052"
3) 1) "106.50495976209640503"
2) "29.53315530684997015"
2) 1) "xian"
2) "484.5164"
3) 1) "108.96080106496810913"
2) "34.26640995400126855"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord count 1 # 显示指定数量
1) 1) "chongqing"
2) "341.4052"
3) 1) "106.50495976209640503"
2) "29.53315530684997015"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord count 2
1) 1) "chongqing"
2) "341.4052"
3) 1) "106.50495976209640503"
2) "29.53315530684997015"
2) 1) "xian"
2) "484.5164"
3) 1) "108.96080106496810913"
2) "34.26640995400126855"
georadiusbymember
用法同上 中心位置是geo里面的元素
127.0.0.1:6379> georadiusbymember china:city beijing 1000 km
1) "beijing"
2) "xian"
geohash 返回一个或者多个位置元素用geohash表示
该命令将返回11个字符串的Geohash字符串 如果两个字符串越近 代表 越近
127.0.0.1:6379> geohash china:city beijing # 返回或多个元素的经纬度并用hash编码
1) "wx4g0b7xru0"
127.0.0.1:6379> geohash china:city beijing chongqing
1) "wx4g0b7xru0"
2) "wm78p86e170"
GEO 底层的实现其实就是Zset！可以使用Zset命令来操作geo！
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> zrem china:city beijing
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
hyperloglog
什么是基数？
A:{1,3,5,7,8,9,7}
B{1,3,5,7,8}
基数（不重复的元素的个数） = 5， 可以接受误差
简介
Redis 2.8.9版本就更新了hyperloglog数据结构！
Redis hyperloglog 基数同级的算法！
优点：占领的内存是固定的，2^64 不同的数据，只需要费12kb的内存！如果从内存角度来比较的话hyperloglog首选！。
网页的UV（一个人访问一个网站多次，但还是算作一个人！）
传统的方式，set保存用户的id，然后就可以同级set 中的元素数量作为标准判断
这种方式如果保存大量的用户id，就会比较麻烦！目的是为了计数，而不是保存用户id；
0.81%的错误率！同级UV任务，可以忽略不计！
测试使用
127.0.0.1:6379> pfadd name a b c d e f g h i j
(integer) 1
127.0.0.1:6379> pfadd name2 i j z x c v b n m
(integer) 1
127.0.0.1:6379> pfcount name # 获取基数
(integer) 10
127.0.0.1:6379> pfcount name2
(integer) 9
127.0.0.1:6379> pfmerge name3 name name2 # 将name和name2合并成name3
OK
127.0.0.1:6379> pfcount name3
(integer) 15
如果允许容错，一定可以使用hyperloglog
如果不允许容错，就使用set或者自己的数据类型
bitmap
位存储
同级用户信息，活跃，不活跃！登录、未登录！打卡，365打卡！ 两个状态的都可以使用bitmap
Bitmap位图，数据结构！都是操作二进制来进行记录，就只有0和1两种状态！
365天 = 365bit 1字节 = 8bit 接近46个字节左右！
测试
使用bitmap来记录周一到周日的打卡！
周一：1 周二：0 周三：0 周四：1…
查看某一天是否打卡
127.0.0.1:6379> getbit sign 3
(integer) 1
统计操作，统计打卡的天数！
127.0.0.1:6379> bitcount sign # 统计这周打卡记录 可以写开始下标和结束下标
(integer) 4
事务
Redis事务本质：一组命令的集合！一个十五中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行。
一次性、顺序性、排他性！执行一系列的命令
------ 队列 set set set 执行------
Redis事务没有隔离级别的概念！
所有命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行 exec
Redis单条命令保证原子性，但是事务不保证原子性！
redis的事务：
- 开启事务（multi）
- 命令入队（…）
- 执行事务（exec）
正常执行事务。
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
放弃事务
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 # 没有k4所以获取不到
(nil)
编译性异常（代码有问题！命令有错！），事务中所有的命令都不会被执行！
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 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 k4 v4
QUEUED
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"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> get k3
"v3"
监控！ watch
悲观锁：
- 很悲观，认为什么时候都会出问题，无论做什么都会加锁
乐观锁：
- 很乐观，认为什么时候都不会出问题，所以不会上锁，更新数据的时候去判断一下，在此期间是否有人修改过这个数据。
- 获取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
测试多线程修改值监视，修改失败
127.0.0.1:6379> watch 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> get money # 另开一个链接
"80"
127.0.0.1:6379> set money 1000 # 修改了money的值
OK
127.0.0.1:6379> EXEC # 执行事务，失败
(nil)
| 客户端1 | 客户端2 | 说明 |
|---|---|---|
| redis 127.0.0.1:6379> get age “10” redis 127.0.0.1:6379> get name “zhangsan” | redis 127.0.0.1:6379> get age “10” redis 127.0.0.1:6379> get name “zhangsan” | 数据库中两客户端登录，及键初始值。 |
| redis 127.0.0.1:6379> multi OK redis 127.0.0.1:6379> incr age QUEUED redis 127.0.0.1:6379> set name lisi QUEUED | 此时，客户端1开启事务，并提交队列命令： 1.想要将当前age自增+1运算； 2.将name值改为lisi | |
| redis 127.0.0.1:6379> incr age (integer) 11 | 此时，客户端2修改了age值 | |
| redis 127.0.0.1:6379> exec 1) (integer) 12 2) OK redis 127.0.0.1:6379> get name “lisi” | 此时，客户端1执行队列命令，发现运算之后age不是理想中的11，而是12原因是被其它客户插足抢先给修改了。name值也修改了。这样可能导致数据不一致性… 为了解决这个问题引入“乐观锁”的机制： | |
| 客户端1-引入“乐观锁”机制 | 客户端2 | 说明 |
| redis 127.0.0.1:6379> get age “10” redis 127.0.0.1:6379> get name “zhangsan” | redis 127.0.0.1:6379> get age “10” redis 127.0.0.1:6379> get name “zhangsan” | 数据库中两客户端登录，及键初始值。 |
| redis 127.0.0.1:6379> watch age name OK redis 127.0.0.1:6379> multi OK redis 127.0.0.1:6379> incr age QUEUED redis 127.0.0.1:6379> set name lisi QUEUED | 此时，客户端1用watch命令监视age和name，然后开启事务，并提交队列命令 | |
| redis 127.0.0.1:6379> incr age (integer) 11 | 此时，客户端2修改了age值 | |
| redis 127.0.0.1:6379> exec (nil) redis 127.0.0.1:6379> get age “11” redis 127.0.0.1:6379> get name “zhangsan” | 此时，客户端1执行队列命令，由watch监控发现此期间age的值已经被修改过，则让事整个务回滚，不做任何动作。 watch可以同时监控多个键，在监控期间只要有一个键被其它客户端改变，则整个事务回滚。 |
Jedis
这段的代码在redis-jedis
使用JAva来操作Redis
什么是Jedis 是Redis 官方推荐的java连接开发工具!使用lava操作Redis 中间件！如果你要使用java操作redis，那么一定要对Jedis十分的熟悉!
新建一个空项目 新建一个maven子项目 在设置里面将java版本改成8（setting->javac）
测试
导包
<dependencies>
<dependency>
<groupId>redis.clientsgroupId>
<artifactId>jedisartifactId>
<version>3.2.0version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.62version>
dependency>
dependencies>
2、测试：
先设置个密码
-
连接数据库
- 连接远程失败，修改了/usr/local/bin/canconfig 里面的redis.conf
- bind 将127.0,0.1注释
- protected mode 也就是保护模式？？ mode把它改成no试试
- 连接远程失败，修改了/usr/local/bin/canconfig 里面的redis.conf
-
操作命令
-
断开连接
package com.can;
import redis.clients.jedis.Jedis;
public class TestPing {
public static void main(String[] args) {
//1、 new Jedis对象
Jedis jedis = new Jedis("8.131.237.11", 6379);
// Jedis 所有的命令就是之前学习的所有指令！ 所以之前的指令学习很重要
System.out.println(jedis.ping());
}
}
输出：
SpringBoot整合
SpringBoot操作数据:spring-data jpa jdbc mongodb redis ！
SpringData也是和SpringBoot齐名的项目!
说明︰在SpringBoot2.x之后，原来使用的jedis被替换为了lettuce？
jedis：采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全，使用jedis pool连接池！ 更像BIO模式 同步并阻塞 即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据了，更像NIO模式 同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
原码分析
@Bean
@ConditionalOnMissingBean(name = "redisTemplate") // 可以自己定义一个redisTemplate来替换这个
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 默认的 RedisTemplate 没有过多的设置，redis 对象都是需要序列化！
// 两个泛型都是 都是Object类型，后期需要强制转换
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean // 由于String是redis中最常使用的类型，所以说单独提出来了一个bean！
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
整合测试
除了web之外要勾上这个
配置连接
spring.redis.host=8.131.237.11
spring.redis.port=6379
spring.redis.password=@saneryi66!
关于对象的保存：
如果注释掉的注释的话 需要在对象类中序列化 也就是 implement Serializable
一般所有pojo都会序列化
我们来编写一个自己的RedisTemplate
@Configuration
public class RedisConfig {
// 这是我给大家写好的一个固定模板，大家在企业中，拿去就可以直接使用！
// 编写我们自己的 RedisTemplate
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
// 我们为了自己开发方便，一般直接使用 Redis.conf详解
启动的时候，就是需要通过配置文件启动！
单位
配置文件unit单位 对大小写不敏感
包含
就好比学习Spring、import，include
网络
bind 127.0.0.1 # 绑定的ip
protected yes # 保护模式
port # 端口
通用
daemonize yes # 以守护进程的方式运行，默认是no，自己改为yes
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)
# 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
快照 SNAPSHOTTING
持久化，在规定的时间，执行了多少次操作，则会持久化到文件 .rdb .aof
redis是内存数据库，如果没有持久化，那么断电及失
save 900 1
# 如果900s内 如果有1个key进行了修改，就进行持久化
save 300 10
# 如果300s内 如果有10个key进行了修改，就进行持久化
save 60 10000
# 如果60s内 如果有10000个key进行了修改，就进行持久化
#以后自己会定义这个
stop-writes-on-bgsave-error yes # 如果持久化出错，是否还需要继续工作！
rdbcompression yes # 是否压缩rdb文件，需要消耗一些cpu资源
rdbchecksum yes # 保存rdb文件的时候，进行错误的检查校验
dir ./ # rdb文件保存的目录
REPLICATION 复制，后面你的主从复制再详细讲解
安全 SECURITY
# requirepass foobared 默认没有密码 注释掉了
下面是临时性设置密码演示 永久性的在配置文件中更改并且重启 在上面有过操作
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> config get requirepass # 获取redis的密码
1) "requirepass"
2) ""
127.0.0.1:6379> config set requirepass "123456" # 设置redis的密码oK
127.0.0.1:6379> config get requirepass # 发现所有的命令都没有权限了
(error) NOAUTH Authentication required.
127.0.0.1:6379> ping
(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 # 设置能连接上redis的最大客户端的数量
maxmemory <bytes> # redis配置最大的内存容量
maxmemory-policy noeviction # 内存到达上限之后的处理策略
# 移除一些过期的 key
# 报错
# ....
# volatile-lru：只对设置了过期时间的key进行LRU（默认值）
# allkeys-lru ： 删除lru算法的key
# volatile-random：随机删除即将过期key
# allkeys-random：随机删除
# volatile-ttl ： 删除即将过期的
# noeviction ： 永不过期，返回错误
APPEND ONLY MODE aof配置
appendonly no # 默认不开启aof模式，默认是使用rdb方式持久化，在大部分情况下rdb完全够用了
appendfilename "appendonly.aof" # 持久化文件的名字
# appendfsync always # 每次修改都会 sync。消耗性能
appendfsync everysec # 每秒执行一次 sync，可能会丢失这1s的数据
# appendfsync no # 不执行sync，这个时候操作系统自己同步数据，速度最快！
Redis持久化（重点）
面试和工作持久化是重点！
Redis是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。所以Redis 提供了持久化功能！
RDB（Redis DataBase）
什么是RDB
在主从复制中，rdn就是备用的，在从机上面！
在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。
Redis会单独创建(（ fork )一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。默认的就是rdb，一般情况下不需要修改这个配置！
rdb保存的文件是 dump.rdb 都是在配置文件中快照汇总进行配置的
触发机制
1、save的规则满足的抢矿洗啊，会自动触发rdb规则
2、执行flushall命令，会触发rdb规则 flushdb不会
3、退出redis，也会产生rdb文件
备份就会自动生成一个rdb文件
如何恢复rdb文件！
1、只需要将rdb文件放在redis启动目录就可以了，redis启动的时候会自动检查dump.rdb文件 恢复里面的数据
2、查看需要存在的位置
127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin" # 如果在这个目录下存在dump.rdb的文件，启动就会自动恢复其中的数据
优点：
1、适合大规模的数据恢复！
2、对数据的完整性要求不高！
缺点：
1、需要一定的时间间隔进程操作！如果redis意外宕机了，这个最后一次修改的数据就没有了！
2、fork进程的时候，会占用一定的内存空间
AOF（Append Only File）
将我们的所有命令都记录下来，history，恢复的时候就把这个文件全部再执行一遍
是什么
以日志的形式来记录每个写操作，将Redis执行过的所有指令记录下来(读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
Aof保存的是appendonly.aof 文件
append
默认是不开启的，需要手动进行配置！将appendonly改为yes就可以开启aof
重启redis
如果aof文件有错误，这时候redis是启动不了的，需要修复这个aof
redis提供了一个工具redis-check-aof --fix + 文件名
修复完毕之后可以启动，删除了错误的数据
重写规则说明
aof默认就是文件的无限增加，文件会越来越大！
如果aof文件大于了64m，太大了！fork新的进程来讲文件进行重写！
redis就提供了一种压缩的方式，比如还是上面list数据类型100条数据，经过压缩以后就变成了一条，这就是AOF重写。
优点：
1、每一次修改都同步，文件的完整会更加好
2、每秒同步一次，可能会丢失一秒的数据
3、从不同步，效率最高的！
缺点：
1、相对数据文件来说，aof远远大于rdb，修复的数据也慢
2、aof运行效率也要比rdb慢，所以默认的配置就是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 9001这条
规则。 - 如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的IO，二是AOF rewrite 的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
- 如果不Enable AOF，仅靠Master-Slave Replcation实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave 中的RDB文件，载入较新的那个，微博就是这种架构。
Redis发布订阅
Redis 发布订阅(pub/sub)是一种消息通信模式∶发送者(pub)发送消息，订阅者(sub)接收消息。微信、微博、关注系统!
Redis客户端可以订阅任意数量的频道。
订阅/发布消息图:
第一个：消息发送者， 第二个：频道 第三个：消息订阅者!
下图展示了频道channel1，以及订阅这个频道的三个客户端―—client2、client5和client1之间的关系:
当有新消息通过PUBLISH命令发送给频道channel1时，这个消息就会被发送给订阅它的三个客户端︰
命令
这些命令被广泛用于构建即时通信应用，比如网络聊天室(chatroom)和实时广播、实时提醒等。
测试
订阅端：
127.0.0.1:6379>SUBSCRIBE kuangshenshuo # 订阅一个频道
Reading messages. . . (press Ctr1-C to quit)
1) "subscribe"
2) "kuangshenshuo"
3) (integer) 1
# 等待读取推送的信息
1) "message "
2) "kuangshenshuo"
3) "hello,kuangshen"
1) "message "
2) "kuangshenshuo"
3) "hello,redis"
发送端：
127.0.0.1:6379> PUBLISH kuangshenshuo "hello,kuangshen" # 发布者发布消息到频道！
(integer) 1
127.0.0.1:6379> PUBLISH kuangshenshuo "hello,redis"
(integer) 1
原理
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值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。
使用场景：
1、实时消息系统！
2、实时聊天系统（频道当做聊天室，将信息回显给所有人即可）
3、订阅，关注系统都是可以的！
稍微复杂的场景我们就会使用消息中间件MQ（）
Redis主从复制
概念
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master/leader)，后者称为从节点(slave/follower);数据的复制是单向的，只能由主节点到从节点。Master以写为主，Slave以读为主。
默认情况下，每台Redis服务器都是主节点;
且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。
主从复制的作用主要包括:
1、数据冗余︰主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
2、故障恢复∶当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复;实际上是一种服务的冗余。
3、负载均衡︰在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载;尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
4、高可用（集群）基石∶除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。
一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的（宕机，一般3个，1主3从），原因如下∶
1、从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大;
2、从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台Redis最大使用内存不应该超过20G。
电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是"多读少写"。
对于这种场景，使用如下这种架构：
主从复制读写分离！80%的情况下都是在进行读操作！减缓服务器压力，架构中经常使用！最低配 一主二从！
在公司中，主从复制是必用的没因为真实项目不可能单机使用。
环境配置
只配置从库，不用配置主库！
127.0.0.1:6379> info replication # 查看当前库的信息
# Replication
role:master # 角色
connected_slaves:0 # 从机数量
master_replid:3b54deef5b7b7b7f7dd8acefa23be48879b4fcff
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.rdb文件名字
修改完毕后启动三个redis服务
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k9mfdg2R-1638932737616)(Redis.assets/image-20210110170808073.png)]
一主二从
==默认情况下，每台Redis服务器都是主节点;==一般情况下只用配置从机就可以了
认老大！一主（79）二从（80,81）
127.0.0.1:6381> slaveof 127.0.0.1 6379 # 找谁当自己的老大
OK
127.0.0.1:6381> info replication
# Replication
role:slave # 当前角色是从机
master_host:127.0.0.1 # 可以看到主机的信息
master_port:6379
master_link_status:up
master_last_io_seconds_ago:7
master_sync_in_progress:0
slave_repl_offset:154
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:db50ee5b7273d4cde6a73719dfee89da477e042e
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:154
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:154
# 在主机中查看
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=14,lag=0 # 多了从机的配置
master_replid:db50ee5b7273d4cde6a73719dfee89da477e042e
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
如果能给个都配置完了，就是有两个从机的
真实的主从配置应该在配置文件中配置，这样的话是永久的，这里使用的是命令，是暂时的！
细节
主机可以写，从机负责读！主机中的所有信息和数据，都会自动被从机保存
主机写：
从机只能读内容！
测试：主机断开连接，从机一人连接到主机的，但是没有写操作了。这个时候主机回来了，从机依旧可以获取到主机写的信息！
如果使用命令行来配置的主从配置，这时候如果重启了，从机就会变为主机。只要变味了从机，立马就会从主机中获取值
复制原理
Slave 启动成功连接到 master 后会发送一个sync同步命令
Master 接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次完全同步。
全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
增量复制：Master 继续将新的所有收集到的修改命令依次传给slave，完成同步
但是只要是重新连接master，一次完全同步（全量复制）将被自动执行！ 我们的数据一定可以在从机中看到！
毛毛虫样主从复制
这时候也可以完成主从复制
如果没有老大了，这个时候能不能选择一个老大出来呢？ 手动
谋权篡位
如果主机断开连接了，可以使用slaveof no one让自己编程主机，其他的节点可以手动连接到最新这个主节点，（手动）！如果这时候原来的老大修复了，那就只能重新连接！
哨兵模式
（自动选取老大的模式）
主从切换技术的方法是︰当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel (哨兵）架构来解决这个问题。
谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。
这里的哨兵有两个作用
- 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
- 当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。
然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。
假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover[故障转移]操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。
测试
目前的状态 一主二从！不是毛毛虫式
1、配置哨兵配置文件 sentinel.conf
# sentinel monitor 被监控的名称（自己起） host port 1
# sentinel monitor
sentinel monitor myredis 127.0.0.1 6379 1
# sentinel auth-pass
sentinel auth-pass myredis @saneryi66!
# 设置连接master和slave时的密码，注意的是sentinel不能分别为master和slave设置不同的密码，因此master和slave的密码应该设置相同。
后面的这个数字1，代表主机挂了，slave投票看让谁接替成为主机，票数最高的，就会成为主机。
这个“1”表示有“1”个哨兵认为主机宕机时，该主机才被判定为宕机
2、启动哨兵
[root@xcc2199 bin]# redis-sentinel canconfig/sentinel.conf
21585:X 10 Jan 2021 20:11:39.394 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
21585:X 10 Jan 2021 20:11:39.394 # Redis version=5.0.10, bits=64, commit=00000000, modified=0, pid=21585, just started
21585:X 10 Jan 2021 20:11:39.394 # Configuration loaded
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis 5.0.10 (00000000/0) 64 bit
.-`` .-```. ```\/ _.,_ ''-._
( ' , .-` | `, ) Running in sentinel mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 26379
| `-._ `._ / _.-' | PID: 21585
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | http://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
21585:X 10 Jan 2021 20:11:39.395 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
21585:X 10 Jan 2021 20:11:39.397 # Sentinel ID is 9d41447224475375758aec63c511068e3c034596
21585:X 10 Jan 2021 20:11:39.397 # +monitor master myredis 127.0.0.1 6379 quorum 1
21585:X 10 Jan 2021 20:11:39.399 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
21585:X 10 Jan 2021 20:11:39.400 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
如果Master节点断开了，这个时候就会从从机中随机选择一个服务器作为主机！（这里面又一个投票算法）
哨兵日志
原来的主机回来了，只能当新的主机的从机，这就是哨兵模式
优点：
1、哨兵集群，基于主从复制模式，所有的主从配置优点，他全有
2、主从可以切换，鼓掌可以转移，系统的可用性就会更好
3、哨兵模式就是主从模式的升级，手动到自动，更加健壮！
缺点：
1、Redis不好在线扩容，集群容量一旦到达上线，在线扩容就十分麻烦
2、实现哨兵模式的配置其实是很麻烦的，里面有很多选择！
哨兵模式的全部配置
# Example sentinel.conf
# 哨兵sentinel实例运行的端口 默认26379
port 26379
# 哨兵sentinel的工作目录
dir /tmp
# 哨兵sentinel监控的redis主节点的 ip port
# master-name 可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了
# sentinel monitor
sentinel monitor mymaster 127.0.0.1 6379 1
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
# sentinel down-after-milliseconds
sentinel down-after-milliseconds mymaster 30000
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行同步，
# 这个数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为
# replication而不可用。可以通过将这个值设为1来保证每次只有一个slave处于不能处理命令请求的状态。
### 另一个解释
# 当sentinel领导者开始进行故障转移的时候，选出新的主节点，原来的从节点会向新的主节点发起复制操作，
# parallel-syncs就是用来限制在一次故障转移之后，每次向新的主节点同时发起复制操作节点个数。如果这个值
# 较大， 虽然一般不会阻塞主节点，但是会给网络和磁盘IO带来开销。
# sentinel parallel-syncs
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间 failover-timeout 可以用在以下这些方面：
# 1. 同一个sentinel对同一个master两次failover之间的间隔时间。
# 2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
# 3.当想要取消一个正在进行的failover所需要的时间。
# 4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依
# 然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
# 配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人
# 员。
# 对于脚本的运行结果有以下规则：
# 若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
# 若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
# 如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
# 一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
# 通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调
# 用这个脚本，
# 这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两
# 个参数，
# 一个是事件的类型，
# 一个是事件的描述。
# 如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，
# 否则sentinel无法正常启动成功。
# 通知脚本
# shell编程
# sentinel notification-script
sentinel notification-script mymaster /var/redis/notify.sh
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改
# 变的信息。
# 以下参数将会在调用脚本时传给脚本:
#
# 目前总是“failover”,
# 是“leader”或者“observer”中的一个。
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh # 一般都是由运维来配置
Redis缓存穿透和雪崩（面试高频）
并不想洗分析解决方案的底层（以后专题）
Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。
另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。
缓存穿透（查不到）
概念
缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
解决方案
布隆过滤器
布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力;
缓存空对象
当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源;
但是这种方法会存在两个问题︰
1、如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键;
2、即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。
缓存击穿（量太大，缓存过期！全部砸在了数据库）
概念
这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导使数据库瞬间压力过大。
解决方案
设置热点数据永不过期
从缓存层面来看，没有设置过期时间，所以不会出现热点 key过期后产生的问题。
加互斥锁
分布式锁∶使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。
缓存雪崩
缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis宕机！
产生雪崩的原因之一，比如在写本文的时候，马上就要到双十二零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时。那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。
其实集中过期，倒不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。
解决方案
redis高可用
这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。（异地多活!）
限流降级
这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
数据预热
数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。