<span>Redis笔记</span>
Nosql概述
1、单机MySQL的年代！
1、 数据量如果太大，一个机器就放不下了！
2、数据的索引（B + Tree） 超过300万就一定要建立索引
3、访问量（读写混合），一个服务器承受不了~
2、Memcached（缓存）+ MySQL + 垂直拆分（读写分离）
网站80%都是读操作，每次都要去查询数据库的话就十分麻烦！希望减轻服务器的压力，可以使用缓存来保证效率！
发展过程：优化数据结构和索引 ---> 文件缓存（IO） ---> Memecached（当时最热门的技术！）
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<String,Object> 使用键值对来控制！
NoSQL特点
解耦！
1、方便扩展（数据之间没有关系，很好扩展！）
2、大数据量高性能（Redis 一秒写8万次，读取11万，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高！）
3、数据类型是多样型的！（不需要事先设计数据库！随取随用！）
4、传动的 RDMS 和 NoSQL
传统的 RDMS
- 结构化组织
- SQL
- 数据和关系都存在单独的表中
- 数据定义语言
- 严格的一致性
- 基础的事务
- ...
NoSQL
- 不仅仅是数据
- 没由固定的查询语言
- 键值对存储，列存储，文档存储，图形数据库（社交关系）
- 最终一致性
- CAP定理和BASE
- 高性能，高可用，高可扩
- ...
NoSQL的四大分类
KV键值对
- 新浪：Redis
- 美团：Redis + Tair
- 阿里、百度：Redis + memcache
文档型数据库（bson格式 和 json一样）
- MongoDB（一般必须要掌握）
- MongoDB是一个基于分布式存储的数据库， C++编写，主要用来处理大量的文档！
- MongoDB是一个介于关系型数据库和非关系型数据中中间的产品！MongoDB是非关系型数据库***能最丰富，最像关系型数据库的！
- ConthDB
列存储数据库
- HBase
- 分布式文件系统
图形关系数据库
Redis入门
概述
Redis是什么？
- Redis（<mark>Re</mark>mote <mark>Di</mark>ctionary <mark>S</mark>erver），即远程字典服务！
- 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
- Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了 master-slave（主从）同步。
- 免费和开源！是当下最热门的NoSQL技术之一！也被称之为结构化数据库！
Redis能干嘛？
1、内存存储、持久化，内存中是断电即失，所以说持久化很重要（RDB、AOF）
2、效率高，可以用于高速缓存
3、发布订阅系统
4、地图信息分析
5、计时器、计数器（浏览量！）
6、.....
Linux环境中安装
1、官网下载redis-5.0.5.tar.gz压缩包
2、安装gcc和gc-c++
- yum install gcc
- yum install gc-c++
3、将redis-5.0.5.tar.gz上传到/opt文件夹下
4、运行 tar -zxvf redis-5.0.5.tar.gz 进行解压
5、解压之后，进入解压之后的文件夹redis-5.0.5，运行make，进行编译
6、运行make install 进行编译安装
7、安装之后，安装目录为 /usr/local/bin
- benchmark：性能测试工具，可以在自己电脑上运行，看电脑性能如何
- check-aof：修复有问题的AOF文件
- check-dump：修复有问题的dump.rdb文件
- sentilnel：Redis集群使用
redis-server：Redis服务器启动命令redis-cli：客户端，操作入口
8、前台启动
- 在 /usr/local/bin 文件夹下可以直接运行
redis-server进行启动 端口号：<mark>6379</mark>
9、后台启动（推荐）
-
备份redis.conf
-
拷贝一份 redi.conf 到其他目录
-
cp /opt/redis-5.0.5/redis.conf /myredis
-
-
后台启动设置
daemonize no改成yes- 修改69行 ，将bind 127.0.0.1注释掉
- 修改88行，protected-mode
yes改为no - 修改redis.conf（136行） 文件将里面的 daemonize no 改成 yes，让服务在后台启动
-
Redis 启动
-
redis-server /myredis/redis.conf ps -ef|grep redis-server
-
-
用客户端访问：redis-cli -p 6379
-
测试验证：ping
-
Redis关闭
- 单实例关闭redis服务器：
- redis-cli shutdown
- redis-cli shutdown
- 也可以进入客户端关闭服务器
- shutdown
- shutdown
- 多实例关闭，指定端口关闭：redis-cli -p 6379 shutdown
- 单实例关闭redis服务器：
测试性能
redis-benchmark 是一个压力测试工具！
官方自带的性能测试工具！
redis性能测试工具参数：
# 测试 ：100个并发连接 100000 请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000
查看分析
基础的知识
Redis默认有16个数据库
默认使用的是第0个
可以使用select 进行切换数据库
127.0.0.1:6379> select 3 # 切换数据库
OK
127.0.0.1:6379[3]> dbsize # 查看DB大小！
(integer) 0
127.0.0.1:6379[3]>
127.0.0.1:6379[3]> keys * #查看数据库所有的 key
1) "name"
127.0.0.1:6379[3]>
清空当前数据库 flushdb
127.0.0.1:6379[3]> flushdb
OK
127.0.0.1:6379[3]> keys *
(empty list or set)
127.0.0.1:6379[3]>
清除所有数据库的内容 flushall
127.0.0.1:6379> set name kingtl
OK
127.0.0.1:6379> get name
"kingtl"
127.0.0.1:6379> select 3
OK
127.0.0.1:6379[3]> keys *
(empty list or set)
127.0.0.1:6379[3]> flushall
OK
127.0.0.1:6379[3]> keys *
(empty list or set)
127.0.0.1:6379[3]> select 0
OK
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379>
Redis 是单线程的！
- Redis是很快的，官方表示，Redis是基于内存操作，CPU不是Redis性能瓶颈，Redis的瓶颈是根据及其的内存和网络带宽。既然可以使用单线程来实现，所以就使用单线程了！
- Redis是C语言写的，官方提供的数据为 100000+ 的QPS，这个不比同样是使用key-value的Memecache差！
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
127.0.0.1:6379> keys * # 查看所有的 key
1) "age"
2) "name"
127.0.0.1:6379> exists name # 判断当前 key 是否存在
(integer) 1
127.0.0.1:6379> move name 1 # 移动当前key 到指定的库
(integer) 1
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "name"
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> clear
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> set name kingtl
OK
127.0.0.1:6379> clear
127.0.0.1:6379> expire name 10 # 设置key 的过期时间，单位是：秒
(integer) 1
127.0.0.1:6379> keys *
1) "age"
2) "name"
127.0.0.1:6379> ttl name # 查看当前key 的剩余时间
(integer) 3
127.0.0.1:6379> ttl name
(integer) 0
127.0.0.1:6379> ttl name
(integer) -2
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> type name # 查看当前 key的类型
string
127.0.0.1:6379> type age
string
String（字符串）
##############################################################################################
127.0.0.1:6379> exists key1 # 判断某个key 是否存在
(integer) 1
127.0.0.1:6379> append key1 "hello" # 追加字符串，如果当前key不存在，就相当于setKey
(integer) 7
127.0.0.1:6379> get key1 #获得值
"v1hello"
127.0.0.1:6379> append key1 world
(integer) 12
127.0.0.1:6379> get key1
"v1helloworld"
127.0.0.1:6379> strlen key1 #获得字符串的长度！
(integer) 12
127.0.0.1:6379> append key1 ,kingtl
(integer) 19
127.0.0.1:6379> get key1
"v1helloworld,kingtl"
127.0.0.1:6379> append k2 zhansan
(integer) 7
127.0.0.1:6379> keys *
1) "age"
2) "name"
3) "key1"
4) "k2"
127.0.0.1:6379>
##############################################################################################
# i++
#步长： i+=
127.0.0.1:6379> set views 0 # 初始浏览量0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> incr views #自增1 浏览量变为1
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> decr views #自减1 浏览量减1
(integer) 1
127.0.0.1:6379> decr views
(integer) 0
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> incrby views 10 #可以设置步长，指定增量
(integer) 10
127.0.0.1:6379> decrby views 5 #可以设置步长，指定减量
(integer) 5
127.0.0.1:6379>
##############################################################################################
字符串范围 range
127.0.0.1:6379> set key1 hello,kingtl #设置 key1 的值
OK
127.0.0.1:6379> get key1
"hello,kingtl"
127.0.0.1:6379>
127.0.0.1:6379> getrange key1 0 3 # 截取字符串 [0,3]
"hell"
127.0.0.1:6379> getrange key1 0 -1 # 获取全部的字符串 和 get key是一样的
"hello,kingtl"
127.0.0.1:6379>
# 替换！
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 #替换指定位置开始的字符串！
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"
127.0.0.1:6379>
##############################################################################################
#setex (set with expire) #设置过期时间
#setnx (set if not exist) # 不存在再设置（在分布式锁中是常常使用的）
127.0.0.1:6379> setex key3 30 hello # 设置 key3 的值为 hello，30秒后过期
OK
127.0.0.1:6379> ttl key3
(integer) 26
127.0.0.1:6379> setnx mykey reids # 如果mykey 不存在，创建mykey
(integer) 1
127.0.0.1:6379> keys *
1) "mykey"
2) "key2"
3) "key1"
127.0.0.1:6379> ttl key3
(integer) -2
127.0.0.1:6379> setnx mykey mongodb #如果mykey 存在，创建失败！
(integer) 0
127.0.0.1:6379> get mykey
"reids"
127.0.0.1:6379>
##############################################################################################
#mset
#mget
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 #同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k1"
3) "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> get k4
(nil)
127.0.0.1:6379>
# 对象
set user:1 {name:zhangsan,age:3} #设置一个user:1 对象值为json字符串来保存一个对象。
# 这里的key是一个巧妙的设计： user:{id}:{filed}，如此设计在redis中是完全OK的
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "2"
##############################################################################################
getset # 先get然后再set
127.0.0.1:6379> getset db redis #如果不存在，返回nil
(nil)
127.0.0.1:6379> get db
"redis"
127.0.0.1:6379> getset db mongodb # 如果存在值，获取原来的值，并设置新的值
"redis"
127.0.0.1:6379> get db
"mongodb"
127.0.0.1:6379>
数据结构是相同的！
String类似的使用场景：value除了是字符串还可以是数字！
- 计数器
- 统计多单位的数量 uid:{id}:follow 0
- 粉丝数
- 对象缓存存储！
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 # 获取list中的值
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> lrange list 0 1 # 通过区间获取具体的值
1) "three"
2) "two"
127.0.0.1:6379> rpush list right # 将一个值或者多个值，插入到列表尾部 （右）
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
127.0.0.1:6379>
##############################################################################################
#lpop
#rpop
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
127.0.0.1:6379> lpop list # 移除list的第一个元素
"three"
127.0.0.1:6379> rpop list # 移除list的最后一个元素
"right"
##############################################################################################
# lindex
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> lindex list 0 # 通过下标获得list 中某一个值
"two"
127.0.0.1:6379> lindex list 1
"one"
127.0.0.1:6379>
##############################################################################################
#llen
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> llen list #返回列表的长度
(integer) 3
##############################################################################################
移除指定的值！
#lrem
127.0.0.1:6379> lpush list three
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379> lrem list 1 one #移除list集合中指定个数的value，精确匹配
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "three"
3) "two"
127.0.0.1:6379> lrem list 2 three
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "two"
127.0.0.1:6379>
##############################################################################################
#trim 修剪。
127.0.0.1:6379> rpush mylist hello
(integer) 1
127.0.0.1:6379> rpush mylist hello1
(integer) 2
127.0.0.1:6379> rpush mylist hello2
(integer) 3
127.0.0.1:6379> rpush mylist hello3
(integer) 4
127.0.0.1:6379> ltrim mylist 1 2 # 通过下标截取指定的长度，这个list已经被改变了，截取了只剩下截取的元素！
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "hello1"
2) "hello2"
##############################################################################################
#rpoplpush #移除列表的最后一个元素，并且移动到新的列表中
127.0.0.1:6379> rpush mylist hello
(integer) 1
127.0.0.1:6379> rpush mylist hello1
(integer) 2
127.0.0.1:6379> rpush mylist hello2
(integer) 3
127.0.0.1:6379> rpoplpush mylist myotherlist #移除列表的最后一个元素，并且移动到新的列表中
"hello2"
127.0.0.1:6379> lrange mylist 0 -1 #查看原来的列表
1) "hello"
2) "hello1"
127.0.0.1:6379> lrange myotherlist 0 -1 #查看目标列表中的值
1) "hello2"
127.0.0.1:6379>
##############################################################################################
# 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> lset list 1 other #如果不存在，就会报错
(error) ERR index out of range
127.0.0.1:6379>
##############################################################################################
#linsert 将某个具体的value插入到列表中某个元素的前面或者后面
127.0.0.1:6379> rpush mylist hello
(integer) 1
127.0.0.1:6379> rpush mylist world
(integer) 2
127.0.0.1:6379> linsert mylist before world other
(integer) 3
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
127.0.0.1:6379> linsert mylist after "world" new
(integer) 4
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "new"
127.0.0.1:6379>
##############################################################################################
小结：
- 实际上是一个链表，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 kingtl
(integer) 1
127.0.0.1:6379> sadd myset lovekingtl
(integer) 1
127.0.0.1:6379> smembers myset # 查看指定set的所有值
1) "kingtl"
2) "lovekingtl"
3) "hello"
127.0.0.1:6379>
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
##############################################################################################
#rem
127.0.0.1:6379> srem myset hello #移除set集合中的指定元素
(integer) 1
127.0.0.1:6379> scard myset
(integer) 2
127.0.0.1:6379> smembers myset
1) "kingtl"
2) "lovekingtl"
127.0.0.1:6379>
##############################################################################################
#set 无需不重复集合。抽随机
127.0.0.1:6379> SMEMBERS myset
1) "loverkingtl2"
2) "kingtl"
3) "lovekingtl"
127.0.0.1:6379> SRANDMEMBER myset #随机抽选出一个元素
"kingtl"
127.0.0.1:6379> SRANDMEMBER myset
"lovekingtl"
127.0.0.1:6379> SRANDMEMBER myset
"lovekingtl"
127.0.0.1:6379> SRANDMEMBER myset
"kingtl"
127.0.0.1:6379> SRANDMEMBER myset
"loverkingtl2"
127.0.0.1:6379> SRANDMEMBER myset 2 #随机抽选出指定个数的元素
1) "loverkingtl2"
2) "kingtl"
127.0.0.1:6379>
##############################################################################################
#删除指定的key，随机删除一个Key！
127.0.0.1:6379> SMEMBERS myset
1) "loverkingtl2"
2) "kingtl"
3) "lovekingtl"
127.0.0.1:6379> spop myset #随机删除一些set集合中的元素！
"kingtl"
127.0.0.1:6379> spop myset
"lovekingtl"
127.0.0.1:6379> smembers myset
1) "loverkingtl2"
127.0.0.1:6379>
##############################################################################################
#将一个指定的值，移动到另外一个set集合！
127.0.0.1:6379> sadd myset hello
(integer) 1
127.0.0.1:6379> sadd myset world
(integer) 1
127.0.0.1:6379> sadd myset kingtl
(integer) 1
127.0.0.1:6379> sadd myset2 set2
(integer) 1
127.0.0.1:6379> smove myset myset2 kingtl #将一个指定的值，移动到另外一个set集合！
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "world"
2) "hello"
127.0.0.1:6379> SMEMBERS myset2
1) "kingtl"
2) "set2"
127.0.0.1:6379>
##############################################################################################
微博，B站，共同关注! (交集)
数字集合类：
- 差集
- 交集
- 并集
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) "e"
2) "b"
3) "c"
4) "a"
5) "d"
##############################################################################################
微博，A用户将所有关注的人放到一个set集合中！将他的粉丝也放在一个集合中，
共同关注，共同爱好，二度好友，推荐好友（六度分割理论）
Hash（哈希）
Map集合，key-map！这个值时一个map集合！本质和String类型没有太大区别，还是一个简单的 key-value ！
set myhash field kingtl
##############################################################################################
127.0.0.1:6379> hset myhash field1 kingtl #set一个具体 key-value
(integer) 1
127.0.0.1:6379> hget myhash field1 #获取一个字段值
"kingtl"
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 #删除hash指定的key字段！对应的value值也就消失了！
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
127.0.0.1:6379>
##############################################################################################
#hlen
127.0.0.1:6379> hmset myhash field1 hello field2 world
OK
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
3) "field1"
4) "hello"
127.0.0.1:6379> hlen myhash #获取hash表的字段数量
(integer) 2
127.0.0.1:6379>
##############################################################################################
127.0.0.1:6379> HEXISTS myhash field1 #判断hash中指定字段是否存在！
(integer) 1
127.0.0.1:6379> HEXISTS myhash field3
(integer) 0
##############################################################################################
#只获得所有的 field
#只获得所有的 值
127.0.0.1:6379> HKEYS myhash #只获得所有的 field
1) "field2"
2) "field1"
127.0.0.1:6379> HVALS myhash #只获得所有的 值
1) "world"
2) "hello"
##############################################################################################
# incr
# decr
127.0.0.1:6379> hset myhash field3 5 #指定一个初始值
(integer) 1
127.0.0.1:6379> HINCRBY myhash field3 1 #指定增鲁昂
(integer) 6
127.0.0.1:6379> HINCRBY myhash field3 -1
(integer) 5
127.0.0.1:6379> hsetnx myhash field4 hello #如果不存在 ，则可以设置
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 world #如果存在，则不能设置
(integer) 0
##############################################################################################
hash变更的数据 user name age ，尤其是用户信息之类的，进场变动的信息！hash更适合于对象的存储！String更加适合字符串存储！
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>
##############################################################################################
排序如何实现
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 kingtl
(integer) 1
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf # 显示全部用户 从小到大排序
1) "kingtl"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> ZREVRANGE salary 0 -1 # 显示全部用户 从大到小排序
1) "zhangsan"
2) "kingtl"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores # 显示全部的用户并且附带成绩
1) "kingtl"
2) "500"
3) "xiaohong"
4) "2500"
5) "zhangsan"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores #显示工资小于2500员工的 升序排列
1) "kingtl"
2) "500"
3) "xiaohong"
4) "2500"
127.0.0.1:6379>
##############################################################################################
移除rem中的元素
127.0.0.1:6379> ZRANGE salary 0 -1
1) "kingtl"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> zrem salary xiaohong # 移除有序集合中的指定元素
(integer) 1
127.0.0.1:6379> ZRANGE salart 0 -1
(empty list or set)
127.0.0.1:6379> ZRANGE salary 0 -1
1) "kingtl"
2) "zhangsan"
127.0.0.1:6379> ZCARD salary # 获取有序集合中的个数
(integer) 2
##############################################################################################
127.0.0.1:6379> ZADD myset 1 hello
(integer) 1
127.0.0.1:6379> ZADD myset 2 world 3 kingtl
(integer) 2
127.0.0.1:6379> zcount myset 1 3 #获取指定区间的成员数量
(integer) 3
127.0.0.1:6379> zcount myset 1 2
(integer) 2
##############################################################################################
案例思路： set 排序
- 存储班级成绩表，工资表排序！
- 普通消息 1， 重要消息 2 ，带权重进行判断！
- 排行榜应用实现，去Top N测试！
三种特殊数据类型
geospatial 地理位置
朋友的定位，附近的人，打车距离计算？
Redis的Geo 在Redis3.2版本就推出了！ 这个功能可以推算地理位置的信息，两地之间的距离，方圆几里的人
可以查询一些测试数据：http://www.jsons.cn/lngcode/
getadd
#getadd 添加地理位置
# 规则：两级无法添加，我们一般会下载城市数据，直接通过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
(integer) 1
127.0.0.1:6379> GEOADD china:city 106.50 29.53 chongqing
(integer) 1
127.0.0.1:6379> GEOADD china:city 114.05 22.52 shenzhen
(integer) 1
127.0.0.1:6379> GEOADD china:city 120.16 30.24 hangzhou 108.96 34.26 xian
(integer) 2
getpos
获得当前定位： 一定是一个坐标值！
127.0.0.1:6379> GEOPOS china:city beijing chongqing 获取指定的城市的经度和纬度
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
2) 1) "106.49999767541885376"
2) "29.52999957900659211"
127.0.0.1:6379>
geodist
两个人之间的距离
单位：
- m 表示单位 米
- km 表示单位 千米
- mi 表示单位 英里
- ft 表示单位 英尺
127.0.0.1:6379> GEODIST china:city beijing shanghai
"1067378.7564"
127.0.0.1:6379> GEODIST china:city beijing shanghai km #查看北京到上海的直线距离
"1067.3788"
127.0.0.1:6379> GEODIST china:city beijing chongqing
"1464070.8051"
127.0.0.1:6379> GEODIST china:city beijing chongqing km #查看北京到重庆的直线距离
"1464.0708"
georadius 以给定的经纬度为中心，找出某一半径内的元素
附近的人？（获得所有附近的人的地址，定位！） 通过半径来查询！
获得指定数量的人！200
所有的数据都应该录入： china:city，才会让结果更加清晰
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km #以100 30 这个经纬度为中心，寻找方圆1000KM内的城市
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
127.0.0.1:6379> GEORADIUS china:city 110 30 1500 km
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
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.9374"
2) 1) "xian"
2) "483.8340"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withcoord #显示他人的定位信息
1) 1) "chongqing"
2) 1) "106.49999767541885376"
2) "29.52999957900659211"
2) 1) "xian"
2) 1) "108.96000176668167114"
2) "34.25999964418929977"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord count 1 # 筛选出指定的结果！
1) 1) "chongqing"
2) "341.9374"
3) 1) "106.49999767541885376"
2) "29.52999957900659211"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord count 2
1) 1) "chongqing"
2) "341.9374"
3) 1) "106.49999767541885376"
2) "29.52999957900659211"
2) 1) "xian"
2) "483.8340"
3) 1) "108.96000176668167114"
2) "34.25999964418929977"
georadiusbymember
#找出位于指定元素周围的其他元素！
127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km
1) "beijing"
2) "xian"
127.0.0.1:6379> GEORADIUSBYMEMBER china:city shanghai 4000 km
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> GEORADIUSBYMEMBER china:city shanghai 400 km
1) "hangzhou"
2) "shanghai"
geohash 返回一个或多个位置元素的geohash 表示
该命令将返回11个字符的geohash字符串
#将二维的经纬度 转换为 一维的字符串，如果两个字符串越接近，那么则距离越近
127.0.0.1:6379> GEOHASH china:city beijing chongqing
1) "wx4fbxxfke0"
2) "wm5xzrybty0"
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 sHyperloglog 基数统计的算法！
<mark>优点：</mark>占用的内存是固定的，2^64 不同的元素的技术，只需要耗费 12KB内存！ 如果从内存角度来看的话，Hyperloglog 首选！
- 网页的 UV（一个人访问一个网站多次，但是还是算作一个人！）
传统的方式：set保存用户的id，然后就可以统计set中元素数量作为标准判断！（这个方式如果保存大量的用户id，就会比较麻烦！目的是为了计数，而不是保存用户id）
0.81% 错误率！ 统计UI任务，可以忽略不记的！
测试使用
127.0.0.1:6379> PFADD mykey a b c d e f g h i j # 创建第一组元素 mykey
(integer) 1
127.0.0.1:6379> PFCOUNT mykey # 统计 mykey 中元素的基数数量
(integer) 10
127.0.0.1:6379> PFADD mykey2 i j z x c v b # 创建第二组元素 mykey2
(integer) 1
127.0.0.1:6379> PFCOUNT mykey2
(integer) 7
127.0.0.1:6379> PFMERGE mykey3 mykey mykey2 # 合并两组 mykey mykey2 => mykey3 并集
OK
127.0.0.1:6379> PFCOUNT mycount
(integer) 0
127.0.0.1:6379> PFCOUNT mykey3 #看并集的数量
(integer) 13
如果允许容错，那么一定可以使用 Hyperloglog ！
如果不允许容错，就使用 set 或者 自己的数据类型即可！
Bitmap
位存储
统计用户信息，活跃，不活跃！ 登录、未登录！ 打卡，365打卡！ 两个状态的，都可以使用 Bitmap！
Bitmap 位图，数据结构！都是操作二进制位来进行记录，就只有0 和 1两个状态！
365 天 = 365 bit 1字节 = 8 bit
使用bitmap 来记录 周一到周日的 打开！
周天：0 周一： 1 周二：2 .....
查看某一天是否打卡：
127.0.0.1:6379> GETBIT sign 3
(integer) 1
127.0.0.1:6379> GETBIT sign 6
(integer) 0
统计操作：打卡的天数
127.0.0.1:6379> bitcount sign #统计这周的打卡记录，就可以看到是否有全勤
(integer) 4
事务
事务
原子性：要么同时成功，要么同时失败！
<mark>Redis单条命令是保证原子性，但是事务不保证原子性！</mark>
<mark>Redis事务没有隔离级别的概念！</mark>
所有的命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行！ Exec
<mark>Redis 事务本质：</mark>一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行！
一次性、顺序性、排他性！执行一系列的命令！
Redis的事务：
- 开启事务（multiI ）
- 命令入队（）
- 执行事务（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 key4 # 事务队列中的命令 都不会被执行
(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
- 更新的时候比较 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 的乐观锁操作！
127.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 # 执行之前，另外一个线程修改了值，这个时候就会导致事务失败
(nil)
如果修改失败，获取最新的值就好：
127.0.0.1:6379> UNWATCH # 如果发现事务执行失败，就先解锁
OK
127.0.0.1:6379> WATCH money # 获取最新的值，再次监视，相当于mysql里面的 select version
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 # 比对监视的值是否发生了变化，如果没有变化，那么久可以执行成功！如果变化了，就执行失败
1) (integer) 990
2) (integer) 30
Jedis
使用Java来操作Redis
什么是Jedis？
- 官方推荐的java连接开发工具！使用java操作Redis的中间件！如果要使用java操作Redis，那么一定要对Jedis十分熟悉！
测试
1、 导入对应的依赖
<!-- 导入jedis的包-->
<dependencies>
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.3.0</version>
</dependency>
<!-- fastjson-->
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.73</version>
</dependency>
</dependencies>
2、编码测试
- 连接数据库
- 操作命令
- 断开连接
package com.kingtl;
import redis.clients.jedis.Jedis;
public class TestPing {
public static void main(String[] args) {
//1、new Jedis() 对象即可
Jedis jedis = new Jedis("47.107.250.181",6379);
// Jedis 所有方法就是 Redis里面的命令
System.out.println(jedis.ping());
}
}
输出：
常用的API
String
List
Set
Hash
Zset
所有的API，都是redis里面的命令
事务
package com.kingtl;
import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
public class TestTX {
public static void main(String[] args) {
Jedis jedis = new Jedis("47.107.250.181",6379);
jedis.flushDB();
JSONObject jsonObject = new JSONObject();
jsonObject.put("hello","world");
jsonObject.put("name","kingtl");
//开启事务
Transaction multi = jedis.multi();
String result = jsonObject.toJSONString();
//jedis.watch(result);
try {
multi.set("user1",result);
multi.set("user2",result);
int i = 1/0; //代码会抛出异常，执行失败！
multi.exec(); //执行事务
} catch (Exception e) {
multi.discard(); // 放弃事务
e.printStackTrace();
} finally {
System.out.println(jedis.get("user1"));
System.out.println(jedis.get("user2"));
jedis.close(); //关闭连接
}
}
}
SpringBoot整合
SpringBoot操作数据：
SpringData 也是和 SpringBoot齐名的项目！
说明：在SpringBoot2.x之后，原来使用 Jedis 被替换成了 lettuce
Jedis：采用的是直连，多个线程操作的话，是不安全的，如果要想避免不安全，使用 redis pool 连接池！ 更像 BIO 模式
lettuce：采用netty，实例可以在多个线程进行共享，不存在线程不安全的情况！减少线程数量！ 更像 NIO模式
源码分析：
@Bean
@ConditionalOnMissingBean(
name = {"redisTemplate"}
) //可以自己定义一个redisTemplate来替换这个默认的！
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
// 默认的RedisTemplate 没有过多的设置， redis 对象都是需要序列化的！
//两个泛型都是 Object , Object 的类型，我们后面使用需要强制转换！<String,Object>
RedisTemplate<Object, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean //由于 String 是 redis中最常用的类型，所以单独提出来了 一个 Bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
整合测试
1、 导入依赖
<!-- 操作redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、配置连接
#配置redis
spring.redis.host=47.107.250.181
spring.redis.port=6379
3、测试
@SpringBootTest
class Redis02SpringbootApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
//redisTemplate 操作不同的数据类型，api和redis指令是一样的
// opsForValue 操作字符串 类似String
//opsForList 操作List 类似 List
//opsForSet 操作set
//opsForHash
//opsForGeo
//opsForZSet
//opsForHyperLogLog
//除了基本的操作。常用的方法可以直接通过redisTemplate操作。比如事务、基本的CRUD
//获取redis的连接对象
//RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//connection.flushDb();
//connection.flushAll();
redisTemplate.opsForValue().set("mykey","kingtl");
System.out.println(redisTemplate.opsForValue().get("mykey"));
}
}
编写一个 自己的RedisTempalte
package com.kingtl.redis02springboot.config;
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;
import java.net.UnknownHostException;
@Configuration
public class RedisConfig {
//写好的固定模板
//自己定义了 一个 RedisTemplate
@Bean
@SuppressWarnings("all")
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException{
//为了开发方便，一般直接使用 <String, Object>
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
//序列化配置
Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
objectJackson2JsonRedisSerializer.setObjectMapper(om);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
//hash的key 也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
//value序列化方式采用jackson
template.setValueSerializer(objectJackson2JsonRedisSerializer);
template.afterPropertiesSet();
//hash的value序列化方式采用jackson
template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
Redis.conf详解
启动的时候，就通过配置文件来启动！
单位
1、配置文件 unit单位 对大小写不敏感！
包含
网络
bind 127.0.0.1 #绑定的ip
protected-mode no #保护模式
port 6379 #端口设置
通用 GENERAL
daemonize yes #以守护进程的方式运行，默认是 no
pidfile /var/run/redis_6379.pid #如果以后台方式运行，需要指定一个 pid 文件！
#日志
# 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是内存数据库，如果没有持久化，那么数据断电即失
#如果900秒内，如果至少有 1 个key 进行了修改，就进行持久化操作
save 900 1
#如果300秒内，如果至少有 10 个key 进行了修改，就进行持久化操作
save 300 10
#如果60秒内，如果至少有 10000 个key 进行了修改，就进行持久化操作
save 60 10000
stop-writes-on-bgsave-error yes #持久化如果出错，是否还需要继续工作！
rdbcompression yes # 是否压缩 rdb 文件，需要消耗一些 cpu 资源！
rdbchecksum yes # 保存 rdb 文件的时候，进行错误的检查校验!
dir ./ # rdb 文件保存的目录
REPLICATION 复制
- 主从复制
SECURITY 安全
可以在这里设置 redis 的密码，默认是没有密码！
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 # 内存达到上限之后的处理策略
maxmemory-policy 六种方式
1、volatile-lru：只对设置了过期时间的key进行LRU（默认值）
2、allkeys-lru ： 删除lru算法的key
3、volatile-random：随机删除即将过期key
4、allkeys-random：随机删除
5、volatile-ttl ： 删除即将过期的
6、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
在主从复制中， rdb 就是备用的！从机上面！
在指定的时间内将内存中的数据集快照写入磁盘，也就是行话将的 Snapshot快照，它恢复时是将快照文件 直接读到内存里。
Redis会单独创建（fork） 一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那么RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。默认的就是RDB，一般情况下不需要修改这个配置！
在生产环境会将这个文件进行备份！
<mark>RDB保存的文件是 dump.rdb</mark> 都是在配置文件快照中进行配置！
测试 60秒内 修改5次 key 就触发 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) "/root" #如果在这个目录下 存在 dump.rdb 文件，启动就会自动恢复其中的数据
几乎默认的配置就够用了
优点：
1、 适合大规模的数据恢复！
2、对数据完整性不高！
缺点：
1、 需要一定的时间间隔进行操作！如果redis意外宕机了，最后一次修改的数据就没有了！
2、fork进程的时候，会占用一定的内容空间！
AOF（Append Only File）
将执行的所有命令都记录下来，恢复的时候，就把这个文件再执行一遍！
是什么？
以日志的形式来记录每个写操作，将Redis执行过的所有指令记录下来（读操作不记录），只许住家文件不可以改写文件，Redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。
<mark>AOF保存的是 appendonly.aof 文件</mark>
append
默认时候不开启的。需要手动进行配置！只需要将 appendonly 改为 yes 就开启了 aof !
重启，redis 就生效了！
如果aof 文件有错误，那么 redis 是启动不了的。需要修复这个 aof 文件！redis 提供了一个工具 redis-check-aof --fix
如果文件正常，重启就可以恢复了！
重写规则说明
aof 默认就是文件的无限追加，文件会越来越大！
如果aof 文件大于 64m，就会fork一个新的进程来将我们的文件进行重写！
优点和缺点
appendonly no # 默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分情况下，rdb完全够用了！
appendfilename "appendonly.aof" # 持久化的文件的名字
# appendfsync always # 每次修改都会 sync ，消耗性能
appendfsync everysec # 每秒执行一次 sync，可能会丢失这1S的数据！
# appendfsync no # 不执行 sync，这个时候，操作系统自己同步数据，速度是最快！
优点：
1、每一次修改都同步，文件完整性会更好！
2、每秒同步一次，可能会丢失一秒的数据！
3、从不同步，效率最高
缺点：
1、 相对数据文件来说，aof远远大于 rdb，修复的速度也比 rdb 慢！
2、aof 运行效率 也要比 rdb慢，所以redis默认的配置就是 rdb 持久化！
扩展：
1、RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储
2、AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
3、<mark>只做缓存，如果你只希望你的数据在服务器运行的时候存在，也可以不使用任何持久化</mark>
4、同时开启两种持久化方式
- 在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
- RDB的数据不实时，同时使用两者服务器重启也只会找AOF文件，那要不要只使用AOF呢？作者建议不要，因为RDB更适合用于备份数据库（AOF在不断地变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。、
5、性能建议
- 因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，值保留 save 900 1 这条规则。
- 如果Enable AOF，好处是在最恶劣的情况下也只会丢失不超过两秒数据，启动脚本较简单值load自己的AOF文件就可以了，代价以是带来了持续的IO，二是AOF rewrite 的最后将 rewrite 过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
- 如果不Enable AOF，仅靠Master-Slave Repllcation 实现高可用性也可以，能声调一大笔IO，也几点少了 rewrite 时带来的系统波动。代价是 如果 Master/Slave 同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个 Master/Slave 中的RDB文件，载入较新的那个，微博就是这种架构。
Redis发布订阅
Redis发布订阅（pub/sub）是一种<mark>消息通信模式</mark>：发送者（pub）发送消息，订阅者（sub）接收消息。微博、微信、关注系统！
Redis客户端可以订阅任意数量的频道。
订阅/发布消息图：
第一个：消息发送者
第二个：频道
第三个：消息订阅者！
命令
这些命令被广泛用于构建即使通信应用，比如网络聊天室（chatroom）和实时广播、实时提醒等。
测试
订阅端：
127.0.0.1:6379> SUBSCRIBE kingtl # 订阅一个频道 kingtl
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "kingtl"
3) (integer) 1
#等待读取推送的信息
1) "message" # 消息
2) "kingtl" # 哪个频道的消息
3) "hello,kingtl" # 消息的具体内容
1) "message"
2) "kingtl"
3) "hello,redis"
发送端：
127.0.0.1:6379> PUBLISH kingtl "hello,kingtl" # 发布者 发布消息到频道！
(integer) 1
127.0.0.1:6379> PUBLISH kingtl "hello,redis" # 发布者 发布消息到频道！
(integer) 1
原理
-
Redis是使用C 实现的，通过分析 Redis 源码里的 pubsub.c 文件，了解发布和订阅机制的底层实现，借此加深对 Redis 的理解。
-
Redis 通过 PUBLISH 、SUBSCRIBE 和 PSUBSCRIBE 等命令实现发布和订阅功能。
-
通过
SUBSCRIBE命令订阅某频道后，redis-server 里维护了一个字典，字典的键就是一个个 频道！而字典的值则是一个链表，链表中保存了所有订阅这个 channel 的客户端。SUBSCRIBE 命令的关键，就是讲客户端添加到给定 channel 的订阅链表中。 -
通过
PuBLISH命令想订阅者发送消息，redis-server 会使用给定的频道作为键，在它所维护的 channel 字典中查找记录了订阅这个频道的所有客户端的链表，遍历这个链表，将消息发布给所有订阅者。 -
Pub/Sub 从字面上理解就是 发布（Publish） 与订阅（Subscribe） ，在Redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值进行了消息发布后，所有订阅它的客户端都会受到相应的消息。这一功能最明显的用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。
使用场景
1、实时消息系统！
2、实时聊天！（频道当做聊天室，将信息回显给所有人！）
3、订阅、关注系统都是可以的！
稍微复杂的场景，就会使用 消息中间件。
Redis主从复制
概念
主从复制：是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点（master/leader），后者称为从节点（slave/follower）；<mark>数据的复制是单项的，只能由主节点到从节点</mark>。Master以写为主，Slave 以读为主。
<mark>默认情况下，每台Redis服务器都是主节点；</mark>
且一个主节点可以有多个从节点（或者没有从节点），但一个从节点只能有一个主节点。
主从复制的作用：
1、数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
2、故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余。
3、复杂均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
4、高可用（集群）基石：出了上述作用以外，主从复制还是 <mark>哨兵</mark> 和 <mark>集群</mark> 能够实施的基础，因此说主从复制是Redis高可用的基础。
一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的（宕机，一主二从），原因如下：
1、从 结构 上，单个Redis服务器会发生 <mark>单点故障</mark>，并且一台服务器需要处理所有的请求负载，压力较大；
2、从 容量 上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为 256G，也不能将所有内存用作 Redis 存储内存，一般来说，<mark>单台Redis最大使用内存不应该超过20G。</mark>
电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是“多读少写”。
对于这种场景，我们可以使用如下架构：
主从复制！ 读写分离！80%的情况下都是在进行读操作！减缓服务器压力！架构中经常使用！ 一主二从！
只要在公司中，主从复制就是必须要使用的，因为在真实的项目中不可能单机使用 Redis ！
环境配置
只配置从库，不用配置主库
127.0.0.1:6379> info replication # 查看当前库的信息
# Replication
role:master # 角色 master
connected_slaves:0 # 没有从机
master_replid:55bc3bb13244688151e477aecf5c7f3e2b56fac3
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 名字
修改完毕之后，启动3个redis服务器，可以通过进程信息查看！
一主二从
<mark>默认情况下，每台Redis服务器都是主节点；</mark> 一般情况下只用配置从机就好了！
# 在从机中配置
127.0.0.1:6380> SLAVEOF 127.0.0.1 6379 # slaveof host ip 认主机
OK
127.0.0.1:6380> info replication
# Replication
role:slave # 当前角色 从机
master_host:127.0.0.1 # 主机的信息
master_port:6379
master_link_status:up
master_last_io_seconds_ago:3
master_sync_in_progress:0
slave_repl_offset:14
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:ebf8b7253354b8f2267d5de86bd0e945b29a9776
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:6380>
# 在主机中查看
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1 # 多了从机的配置
slave0:ip=127.0.0.1,port=6380,state=online,offset=56,lag=0 # 多了从机的配置
master_replid:ebf8b7253354b8f2267d5de86bd0e945b29a9776
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:56
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:56
127.0.0.1:6379>
如果两个从机都配置完了，在主机查看就是有两个从机的
注意
真实的从主配置应该在配置文件中配置，这样的话是永久的。 这里使用的命令配置，是临时的。
细节
主机可以写，从机不能写 只能读！主机中的所有信息和数据，都会自动被从机保存！
主机写：
从机只能读取内容：
测试：主机断开连接，从机依旧连接到主机的，但是没有写操作，这个时候，主机如果恢复了，从机依旧可以直接获取到主机写的信息！
如果是使用命令行，来配置的主从，这个时候如果重启了，就会变回主机！只要变为从机，立马就会从主机中获取值！
复制原理
Slave 启动成功连接到 master 后会发送一个 Sync同步 命令
Master 接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，<mark>master将传送整个数据文件到slave，并完成一次完全同步。</mark>
<mark>全量复制</mark>：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
<mark>增量复制</mark>：Master 继续将新的所有收集到的修改命令依次传给slave，完成同步。
但是只要是重新连接master，一次完全同步（全量复制）将被自动执行。主机中的数据一定可以在从机中看到。
层层链路
上一个 M 连接下一个 S ！也可以完成主从复制！
如果主机宕机了，从机中选择出一个作为主机！手动！哨兵模式没出来之前！
如果主机断开了连接， 我们可以使用 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:5de4bf9d435aee276d1dda6fe23efc5bd032f5a8
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
哨兵模式
（自动选举主机的模式）
概述
主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了 Sentinel（哨兵）架构来解决这个问题。
谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数<mark>自动将从库转换为主库。</mark>
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是 哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。
这里的哨兵有两个作用
- 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
- 当哨兵检测到 master 宕机，会自动将 slave 切换为 master ，然后通过 发布订阅模式 通知其他的从服务器，修改配置文件，让他们切换主机。
然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。
假设主服务器宕机，哨兵1线检测到这个结果，系统并不会马上进行 failover 过程，仅仅是哨兵1主管的认为主服务器不可用，这个现象称为 主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行 failover [故障转移]操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为 客观下线。
测试
1、配置哨兵配置文件
# sentinel monitor 被监控的名称 host port 1 数字1，代表主机挂了，让slave投票，票数最多最多的就会称为主机
sentinel monitor myredis 127.0.0.1 6379 1
2、启动哨兵
[root@KingTL myredis]# redis-sentinel /myredis/sentinel.conf
22933:X 03 Aug 2020 18:36:47.800 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
22933:X 03 Aug 2020 18:36:47.800 # Redis version=5.0.5, bits=64, commit=00000000, modified=0, pid=22933, just started
22933:X 03 Aug 2020 18:36:47.800 # Configuration loaded
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis 5.0.5 (00000000/0) 64 bit
.-`` .-```. ```\/ _.,_ ''-._
( ' , .-` | `, ) Running in sentinel mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 26379
| `-._ `._ / _.-' | PID: 22933
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | http://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
22933:X 03 Aug 2020 18:36:47.802 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
22933:X 03 Aug 2020 18:36:47.815 # Sentinel ID is 86c0d61e90caf14717b0f476b6237412b2dafa3b
22933:X 03 Aug 2020 18:36:47.815 # +monitor master myredis 127.0.0.1 6379 quorum 1
22933:X 03 Aug 2020 18:36:47.817 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
22933:X 03 Aug 2020 18:36:47.819 * +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
prot 26379
# 哨兵 Sentinel 的工作目录
div /tmp
# 哨兵 sentinel 监控的redis主节点的 ip port
# master-name 可以自己命名的主节点名字，只能有字母A-Z、数字0-9、这三个字符“.-_”组成。
# quorum 配置多少个 sentinel 哨兵统一认为 master 主节点失联，那么这时客观上认为主节点失联了
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 2
# 当在Redis实例中开启了 requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵 Sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
#指定多少毫秒之后 主节点没有应答哨兵 sentinel 此时 哨兵主管上认为主节点下线 默认30秒
sentinel down-after-millisecondes mymaster 30000
# 这个配置项指定了在发生 failover 主备切换时最多可以有多少个 slaver 同时对新的 master 进行同步，这个数字越小，完成 failover 所需的时间就越长，但是这个数字越大，就以为着越多的 slave 因为replication而不可用。可以通过设置这个值为 1 来保证每次只有一个 slave 处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间 failover-timeout 可以用在一下这些方面：
#1、同一个 sentinel 对同一个 master 两次 failover 之间的间隔时间
#2、当一个 slave 从一个错误的 master 那里同步数据开始计算时间。知道 slave 被纠正为想正确的 mater 那里同步数据时。
#3、当想要取消一个正在进行的 failover 所需要的时间。
#4、当进行 failover 时，配置所有 slaves 执行新的 master 所需要的最大时间。不过，即使过了这个超时，slaves 依然会被正确配置为指向master，但是就不按 parallel-syncs 所配置的规则来了
# 默认三分钟
# sentinel faulover-timeout <master-name> <millisenconds>
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTTION
# 配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
# 对于脚本的运行结果有以下规则：
# 若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
# 若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
# 如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
# 一个脚本的最大执行时间为60S，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
#通知型脚本：当 sentinel 有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，这时这个脚本额应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果 sentinel.conf 配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则 Sentinel 无法正常启动成功。
# 通知脚本
# 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> 是 “leader” 或者 “observer” 中的一个。
# 参数 from-ip ，from-port，to-ip，to-port 是用来和旧的 master 和新的 master（即旧的slave）通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
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，设置不同的过期时间，让缓存失效的时间点尽量均匀。
滴滴公司福利 687人发布