Redis学习

NoSql概述

NoSQL=Not Only Sql（不仅仅是SQL）
泛指非关系型数据库。
传统的关系型数据库很难对付web2.0互联网的诞生。
很多数据类型如用户的信息，社交网络、地理位置等等。这些数据类型的存储不一定需要一个固定的格式。可以使用 Map 使用键值来控制。

NoSQL特点

1. 方便扩展（数据之间没有关系，很好扩展）
2. 大数据量、高性能（Redis一秒可以写8万次，读取11万，NoSQL的缓存记录级的，是一种细粒度的缓存，性能会比较高）
3. 数据类型是多样型的。（不需要事先设计数据库！随去随用，如果数据量十分大的表，很多人就无法设计了）
4. 传统关系型数据库和NoSQL的区别

关系型数据库	NoSQL
结构化组织	不仅仅是数据
数据和关系都存在单独的表中	没有固定的查询语言
数据操作语言、数据定义语言	键值对存储，列存储、文档存储、图形数据库
严格的一致性	最终一致性
基础的事务	CAP定理和BASE（异地多活）
	高性能、高可用、高可扩

大数据时代的3V+3高

3V	3高
Volume（海量）	高并发
Variety（多样）	高可扩
Velocity（实时）	高性能

NoSQL的四大分类

KV键值对：

• 新浪 ：Redis
  

• 美团 ：Redis+Tair
  

• 阿里、百度 : Redis+memecache
  

文档型数据库（bson格式）：

• MongoDB (一般必须掌握）
  

  • MongoDB是一个局域分布式文件存储的数据库，C++编写，主要用来处理大量的文档！
    

  • MongoDB是非关系型数据库中是一个介于关系型数据库和非关系型数据库中中间的产品
    

  • MongoDB是非关系型数据库中功能最丰富的，最像关系型数据库的的
    

• ConthDb

列存储数据库

• Hbase
  

• 分布式文件系统
  

图关系型数据库

• 他不是用来存图形的，放的是关系，比如：朋友圈、广告推荐

Redis 入门

Redis是什么？？

Redis（Remote Dictionary Server）：远程字典服务

是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API
redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步

Redis能干什么？

• 内存（内存中是断电即失的，所以持久化也很重要（RDB、AOF））存储、持久化
• 效率高、可以用于高速缓存
• 发布订阅系统
• 地图信息分析
• 计时器、计数器（浏览量）
• 。。。。。

特性

• 支持多种数据类型
• 持久化
• 集群
• 事务
• 。。。。

Windows安装

1. 下载安装包：https://github.com/MicrosoftArchive/redis/releases
2. 下载完毕得到安装包，将安装包解压即可
3. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SwpdeOw7-1616726776338)(en-resource://database/743:1)]
4. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZVTDcV9e-1616726776341)(en-resource://database/744:1)]
5. 使用Redis客户端连接Redis，双击redis-cli.exe [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VNEfNDrt-1616726776343)(en-resource://database/745:1)]
   Windos 下使用简单，但是Redis推荐使用Linux环境开发使用

Linux安装

1、下载 中文官网
2、解压 tar -zxvf redis-6.0.6.tar.gz
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZlcRqeoC-1616726776347)(en-resource://database/825:1)]
3、进入解压后的文件，可以看到redis的配置文件
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q8YN2A8D-1616726776350)(en-resource://database/827:1)]
4、基本的环境安装 C++

[root@lqLinux redis-6.0.6]# yum install gcc-c++
make  #输入make命令

[root@lqLinux redis-6.0.6]#  make install # 确认

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bk0XFwaM-1616726776352)(en-resource://database/829:1)]
5、redis的默认安装路径： /usr/local/bin
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ftb6UoJh-1616726776356)(en-resource://database/831:1)]
6、将redis配置文件复制到当前文件下

[root@lqLinux bin]# mkdir redisconf
[root@lqLinux bin]# cp /opt/java/redis-6.0.6/redis.conf redisconf
[root@lqLinux bin]# ls
chardetect  cloud-init-per    easy_install-3.8  jsonpointer      redis-check-aof  redisconf
cloud-id    easy_install      jsondiff          jsonschema       redis-check-rdb  redis-sentinel
cloud-init  easy_install-3.6  jsonpatch         redis-benchmark  redis-cli        redis-server

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2FT8sqJn-1616726776361)(en-resource://database/833:1)]
使用这个配置文件
7、redis默认不是后台启动的，修改配置文件 将no修改为yes
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wTclpUjp-1616726776365)(en-resource://database/835:1)]
8、启动redis服务
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hSDj4Qui-1616726776367)(en-resource://database/837:1)]
9、使用redis-cli做连接使用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jlgnc025-1616726776368)(en-resource://database/839:1)]
10、查看redis的进程是否开启
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3rsPTZFo-1616726776370)(en-resource://database/841:1)]
11、关闭redis服务
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-niObwabX-1616726776371)(en-resource://database/843:1)]

性能测试

redis-benchmark是一个压力测试工具
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QIIoHaeJ-1616726776373)(en-resource://database/845:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YL8JRW9L-1616726776374)(en-resource://database/847:1)]

基础知识

redis默认有16个数据库
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8MQ4kVYF-1616726776376)(en-resource://database/849:1)]
默认使用给的是第0个数据库
可以使用select 切换数据库 有 0-15号数据库
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FR38Zd6A-1616726776377)(en-resource://database/859:1)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jsHhqEoM-1616726776378)(en-resource://database/851:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wfTaHM6t-1616726776379)(en-resource://database/853:1)]

清空数据库和获取所有的key

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fs7Dz0GF-1616726776381)(en-resource://database/857:1)]
flushall ：清空全部的数据库的内容 0-15号数据库全部清空

Redis的高并发和快速原因

• Redis是基于内存的，内存的读取速度非常快；

• Redis是单线程的，省去了很多（CPU）上下文切换线程的时间

• Redis使用多路复用技术，可以处理并发的连接。

  官方答案

因为Redis是局域内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是及其内存的大小或者网络宽带。既然单线程容易实现，而且CPU不会成为瓶颈，就顺理成章的采用单线程的方案。

原因详解

1）不需要各种锁的性能消耗

Redis的数据结构并不全是简单的Key-Value，还有list，hash等复杂的结构，这些结构有可能会进行很细粒度的操作，比如在很长的列表后面添加一个元素，在hash当中添加或者删除一个对象。这些操作可能就需要加非常多的锁，导致的结果是同步开销大大增加。
总之，在单线程的情况下，就不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出
现死锁而导致的性能消耗。

2）单线程多进程集群方案

单线程的威力实际上非常强大，每核心效率也非常高，多线程自然是可以比单线程有更高的性能上限，但是在今天的计算环境中，即使是单机多线程的上限也往往不能满足需要了，需要进一步摸索的是多服务器集群化的方案，这些方案中多线程的技术照样是用不上的。

3）CPU消耗

采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU。
但是如果CPU成为Redis瓶颈，或者不想让服务器其他CUP核闲置，那怎么办？
可以考虑多起几个Redis进程，Redis是key-value数据库，不是关系数据库，数据之间没有约束。只要客户端分清哪些key放在哪个Redis进程上就可以了。

五大数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oQQxH8dF-1616726776382)(en-resource://database/861:1)]

Redis-key

127.0.0.1:6379> set name lqlq  #设置name
OK
127.0.0.1:6379> set age 1 #设置age
OK
127.0.0.1:6379> key * 
(error) ERR unknown command `key`, with args beginning with: `*`, 
127.0.0.1:6379> keys * # 获取当前数据库的所有key
1) "age"
2) "name"
127.0.0.1:6379> get name # 获取name
"lqlq"
127.0.0.1:6379> get age 
"1"
127.0.0.1:6379> Exists name  #判断name是否存在
(integer) 1
127.0.0.1:6379> clear 
127.0.0.1:6379> move name 1  # 将name移动到数据库1
(integer) 1
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> select 1 #切换到数据库1
OK
127.0.0.1:6379[1]> get name
"teset"
127.0.0.1:6379[1]> type name  # 查看name的类型
string
127.0.0.1:6379[1]> expire name 5  # 设置name的过期时间
(integer) 1
127.0.0.1:6379[1]> ttl name  # 查看name的剩余过期时间  -2 代表已经过期
(integer) -2
127.0.0.1:6379[1]> get name  # name失效，查取不到
(nil)

http://www.redis.cn/commands.html

String

127.0.0.1:6379[1]> set k1 vq # 设置k1
OK
127.0.0.1:6379[1]> append k1 "hello" # 将hello追加到k1 ，如果k1 不存在，则新建k1
(integer) 7
127.0.0.1:6379[1]> append k1 "world" 
(integer) 12
127.0.0.1:6379[1]> get k1 
"vqhelloworld"
127.0.0.1:6379[1]> strlen k1  # 获取字符串的长度
(integer) 12
#############################################
127.0.0.1:6379[1]> set views 0 #设置数值views   为0
OK
127.0.0.1:6379[1]> get views
"0"
127.0.0.1:6379[1]> incr views # 自增1 
(integer) 1 
127.0.0.1:6379[1]> incr views # 自增1 
(integer) 2
127.0.0.1:6379[1]> get views
"2"
127.0.0.1:6379[1]> decr views # 自减 1
(integer) 1
127.0.0.1:6379[1]> decr views
(integer) 0
127.0.0.1:6379[1]> incrby views 10 # 自增10 
(integer) 10
127.0.0.1:6379[1]> decrby views 9 # 自减 9
(integer) 1
127.0.0.1:6379[1]> incrby views 5
(integer) 6
#############################################
##截取
127.0.0.1:6379[1]> set k1 "hello world"
OK
127.0.0.1:6379[1]> getrange k1 0 0  #截取字符串  从0 到0 获取的值为h
"h"
127.0.0.1:6379[1]> getrange k1 0 4 #截取字符串  从0 到4   获取的值为hello  [0,4]
"hello"
127.0.0.1:6379[1]> getrange k1 0 -1 #截取字符串 获取全部的字符串
"hello world"
#############################################
##替换
127.0.0.1:6379[1]> set k2 abcdefg
OK
127.0.0.1:6379[1]> setrange k2 2 h2 # 将指定位置的字符串替换为h2 
(integer) 7
127.0.0.1:6379[1]> get k2
"abh2efg"
#############################################
## setex (set with expire)  #设置过期时间 
## setnx（set if not exist） # 不存在再设置（在分布式锁中会经常使用）
127.0.0.1:6379[1]> setex k3 30 "hello" # 设置30秒后过期
OK
127.0.0.1:6379[1]> ttl k3  # 查看还要多少秒过期
(integer) 26
127.0.0.1:6379[1]> setnx k4 "world"  # set k4 
(integer) 1
127.0.0.1:6379[1]> setnx k4 "hello" # k4 已经存在，无法在进行设置
(integer) 0
127.0.0.1:6379[1]> get k4
"world"
#############################################
## 批处理 
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 k4 v4  #同时设置多个值
OK
127.0.0.1:6379> keys *  
1) "k3"
2) "k1"
3) "k4"
4) "k2"
127.0.0.1:6379> mget k1 k2 k3  #同时获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k5 v5   # 因为k1 已经存在，所以k5设置失败。**原子性** 要么一起成功，要目一起失败
(integer) 0 # 设置失败

#############################################
##对象
127.0.0.1:6379> set user:1 {name:lqlq,age:10}  #设置一个user：1 对象，值为json字符串
OK
127.0.0.1:6379> get user
(nil)
127.0.0.1:6379> get user:1
"{name:lqlq,age:10}"


127.0.0.1:6379> mset user:2:name zhangsan user:2:age 24 #设置user2的各个属性
OK
127.0.0.1:6379> get user:2 #这样无法获取值
(nil)
127.0.0.1:6379> get user:2:name #可以获取name的值
"zhangsan"
127.0.0.1:6379> mget user:2:name user:2:age #批处理获取值
1) "zhangsan"
2) "24"
#############################################
## getset 先get再set  
127.0.0.1:6379> getset k1 redis # 先get，如果不存在则返回nil  再设置值
(nil)
127.0.0.1:6379> get k1 
"redis"
127.0.0.1:6379> getset k1 lqlq  # 如果存在值，则返回原来的值，并设置新的值
"redis"
127.0.0.1:6379> get k1
"lqlq"

List

所有的list操作都是以L开头的

127.0.0.1:6379> lpush list1 1 #向一个集合插入一个或多个数据  （从左侧开始插入） 类似队列
(integer) 1
127.0.0.1:6379> lpush list1 2 3   # 插入多个数据
(integer) 3
127.0.0.1:6379> lrange list1 0 -1 # 获取list中的所有数据
1) "3"
2) "2"
3) "1"
127.0.0.1:6379> lrange list1 0 1 #查看list中的0和1  index的数据  ，是从后往前的
1) "3"
2) "2"
127.0.0.1:6379> rpush list1 8  #将一个或者多个值放到list的右边  
(integer) 5
127.0.0.1:6379> lrange list1 0 -1
1) "3"
2) "2"
3) "1"
4) "8"
5) "8"

#############################################
POP 移除命令
127.0.0.1:6379> lrange list1 0 -1 # 移除list的第一个值
1) "3"
2) "2"
3) "1"
4) "8"
5) "8"
127.0.0.1:6379> lpop list1 
"3"
127.0.0.1:6379> rpop list1# # 移除list的最后一个值
"8"
#############################################
INDEX  通过下标获取值
127.0.0.1:6379> lrange list1 0 -1
1) "2"
2) "1"
3) "8"
127.0.0.1:6379> lindex list1 0  #通过下标获取值
"2"
#############################################
获取集合长度
127.0.0.1:6379> llen list1 # 返回集合的长度
(integer) 3 
#############################################
LREM 移除
127.0.0.1:6379> lrem list 1 one   # 移除集合中的1个one
(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 #移除集合中的2个three
(integer) 2
127.0.0.1:6379> lrange list 0 -1  #
1) "two"
#############################################
LTRIM 截取
127.0.0.1:6379> lrange list 0 -1 
1) "v0"
2) "v1"
3) "v2"
4) "v3"
5) "v4"
127.0.0.1:6379> ltrim list 2 3 # 截取下标2和下标3 的数据，返回的是2和3的数据
OK
127.0.0.1:6379> lrange list 0 -1 
1) "v2"
2) "v3"

#############################################
rpoplpush #移除集合的最后一个元素，并将它移动到新的集合中
127.0.0.1:6379> rpush list v0 v1 v2  #新建一个集合
(integer) 3
127.0.0.1:6379> rpoplpush list list1 #将list中的最后一个元素v2移动到新的集合list1中
"v2"
127.0.0.1:6379> lrange list 0 -1 
1) "v0"
2) "v1"
127.0.0.1:6379> lrange list1 0 -1
1) "v2"
#############################################
LSET 根据下标设置集合中的某个数值
127.0.0.1:6379> lset list 0 v0 # 集合不存在，无法设置
(error) ERR no such key
127.0.0.1:6379> rpush list v0 # 新建一个list集合
(integer) 1
127.0.0.1:6379> lset list 0 vx # 将list集合中的下标为0的元素设置为vx
OK
127.0.0.1:6379> lrange list 0 -1 #获取list的全部元素
1) "vx"
127.0.0.1:6379> lset list 1 v1 # 设置index 1 的值 ，没有下标1 ，所以设置失败
(error) ERR index out of range
#############################################
LINSERT 
127.0.0.1:6379> rpush list v0 v1
(integer) 2
127.0.0.1:6379> linsert list before v0 vv # 在v0前面插入一个vv   
(integer) 3
127.0.0.1:6379> linsert list after v1 vvv # 在v1后面插入一个vvv
(integer) 4 
127.0.0.1:6379> lrange list 0 -1
1) "vv"
2) "v0"
3) "v1"
4) "vvv"
#############################################

小结：

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

Set

set中的值是不能重复的

127.0.0.1:6379> sadd set v0 v1 v2  #新建一个set，添加v0 v1 v2元素
(integer) 3
127.0.0.1:6379> sadd set v3 # 继续给set添加v3元素
(integer) 1
127.0.0.1:6379> smembers set # 查看set的所有元素
1) "v3"
2) "v1"
3) "v0"
4) "v2"
127.0.0.1:6379> sismember set v0 # 查看v0是否是set其中的元素  返回1 则为true
(integer) 1
127.0.0.1:6379> sismember set v5 # 查看v5是否是set其中的元素 返回0  则为false
(integer) 0
127.0.0.1:6379> scard set # 查看set集合中的元素个数
(integer) 4
#############################################
127.0.0.1:6379> srem set v0 # 删除set集合中的v0元素
(integer) 1
#############################################
SRANDMEMBER 随机抽选n个元素
127.0.0.1:6379> SRANDMEMBER set
"v2"
127.0.0.1:6379> SRANDMEMBER set
"v3"
127.0.0.1:6379> SRANDMEMBER set
"v1"
127.0.0.1:6379> SRANDMEMBER set
"v1"
127.0.0.1:6379> SRANDMEMBER set 2 #随机抽取两个元素
1) "v3"
2) "v2"
#############################################
随机删除n个元素
127.0.0.1:6379> spop set
"v1"
127.0.0.1:6379> SMEMBERS set
1) "v3"
2) "v2"
#############################################
将一个指定的值，移动到另外一个set集合中
127.0.0.1:6379> sadd set v0 v1 v2 v3
(integer) 4
127.0.0.1:6379> sadd set1 v9 v8 
(integer) 2
127.0.0.1:6379> smove set set1 v0  # 将set集合中的v0移动到set1集合中
(integer) 1
127.0.0.1:6379> SMEMBERS set1
1) "v0"
2) "v8"
3) "v9"

#############################################
获取set集合的差集、交集、并集
127.0.0.1:6379> sadd set v0 v1 v2
(integer) 3
127.0.0.1:6379> sadd set1 v0 v3 v4
(integer) 3
127.0.0.1:6379> sadd set2 v0 v5 v6
(integer) 3
127.0.0.1:6379> SDIFF set set1 set2   # 查看set集合与set1、set2的差集 
1) "v1"
2) "v2"
127.0.0.1:6379> SINTER set set1 set2   # 查看set集合与set1、set2的交集
1) "v0"
127.0.0.1:6379> SUNION set set1 set2   # 查看set集合与set1、set2的并集
1) "v5"
2) "v6"
3) "v0"
4) "v2"
5) "v4"
6) "v3"
7) "v1"

Hash

Map集合 key-Map集合：key-
更适合用户信息之类的存贮

#############################################
127.0.0.1:6379> hset map f v ff vv ## 向map集合中添加了f 和ff 分别对应的值是 v 和 vv
(integer) 2
127.0.0.1:6379> hget map f  # 获取map中的f 
"v"
127.0.0.1:6379> hget map ff # 获取map中的f f
"vv"
127.0.0.1:6379> hmset map0 f v ff vv fff vvv # 批量插入map0 的一些值
OK
127.0.0.1:6379> hget map0 f # 获取map0 的f值
"v"
127.0.0.1:6379> hmget map f ff #批量获取map中的f和ff值
1) "v"
2) "vv"
127.0.0.1:6379> hgetall map0 # 获取map0 中的所有元素
1) "f"
2) "v"
3) "ff"
4) "vv"
5) "fff"
6) "vvv"

#############################################
127.0.0.1:6379> hdel map0 ff  #删除map中指定的key
(integer) 1
127.0.0.1:6379> hlen map0  #获取map的元素个数
(integer) 2
127.0.0.1:6379> HEXISTS map0 f # 判断map中的某个元素是否存在
(integer) 1
#############################################
#只获取所有的key
127.0.0.1:6379> HKEYS map0
1) "f"
2) "fff"
#获取所有的value
127.0.0.1:6379> HVALS map0
1) "v"
2) "vvv"
#############################################
127.0.0.1:6379> clear
127.0.0.1:6379> hset map2 f 1 ff 2
(integer) 2
127.0.0.1:6379> HINCRBY map2 f 5
(integer) 6
127.0.0.1:6379> hgetall map2
1) "f"
2) "6"
3) "ff"
4) "2"
#############################################
127.0.0.1:6379> hset map f 1 ff 2 ## 
(integer) 2
127.0.0.1:6379> HINCRBY map f 3 ##给map中的f增长3 。没有负增长，一般使用负数表示负增长
(integer) 4
127.0.0.1:6379> hget map f ##
"4"
127.0.0.1:6379> HSETNX map fff vvv ## 如果fff不存在，设置map中的fff值为vvv
(integer) 1
127.0.0.1:6379> HSETNX map fff vvvv ##如果fff存在，设置失败
(integer) 0

Zset （有序集合）

在set的基础上增加了一个只，zset k1 score1 v1

127.0.0.1:6379> zadd set 1 one #给set中添加一个值
(integer) 1
127.0.0.1:6379> zadd set 2 two 3 three 4 four #给set中添加多个值
(integer) 3
127.0.0.1:6379> ZRAnge set 0 -1 # 获取set的所有元素
1) "one"
2) "two"
3) "three"
4) "four"
#############################################
排序
127.0.0.1:6379> zadd set 0 zero 1 one 2 two 3 three
(integer) 4
127.0.0.1:6379> ZRANGEBYSCORE set -inf +inf  #通过score排序，-inf代表负无穷  +inf代表正无穷
1) "zero"
2) "one"
3) "two"
4) "three"
127.0.0.1:6379> ZRANGEBYSCORE set -inf +inf withscores  #通过score排序，同时显示score
1) "zero"
2) "0"
3) "one"
4) "1"
5) "two"
6) "2"
7) "three"
8) "3"
127.0.0.1:6379> ZREVRANGE set 0 -1 # 倒序排列
1) "two"
2) "one"
3) "zero"
#############################################
zrem移除有序集合中的元素
127.0.0.1:6379> zrange set 0 -1 #
1) "zero"
2) "one"
3) "two"
4) "three"
127.0.0.1:6379> ZREM set three # 移除有序集合中的元素 three
(integer) 1
127.0.0.1:6379> zrange set 0 -1 #
1) "zero"
2) "one"
3) "two"
#############################################
#zcard获取有序集合中的个数
127.0.0.1:6379> ZCARD set 
(integer) 3
#############################################
#zcount 查看某个区间内的元素个数[0,1]
127.0.0.1:6379> ZCOUNT set 0 1
(integer) 2

三种特殊数据类型

geospatial 地理位置

将指定的地理空间位置（经度、纬度、名称）添加到指定的key中
有效的经度从-180度到180度。
有效的纬度从-85.05112878度到85.05112878度。

#############################################
#添加数据  
#两极地区无法直接添加

127.0.0.1:6379[1]> GEOADD china:city 116.40 39.90 beijing # 添加北京到地理数据中
(integer) 1
127.0.0.1:6379[1]> GEOADD china:city 121.47 31.23 shanghai 106.50 29.53 chongqing 114.05 22.52 shenzhen #添加多个城市到地理数据中
(integer) 3
127.0.0.1:6379[1]> GEOADD china:city 120.16 30.24 hangzhou 108.96 34.26 xian
(integer) 2
#############################################
geopos 从key里返回所有给定位置元素的位置（经度和纬度）
127.0.0.1:6379> geopos china:city beijing
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
#############################################
##返回两个给定位置之间的距离
GEODIST
127.0.0.1:6379> GEODIST china:city beijing chongqing  #默认是以米为单位
"1464070.8051"
127.0.0.1:6379> GEODIST china:city beijing chongqing km #以千米为单位
"1464.0708"
#############################################
##GEORADIUS
##以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km #查找经度110 ，维度30的地址半径1000km的所有位置
1) "chongqing"
2) "xian"
3) "shenzhen" 
4) "hangzhou"
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km withdist #显示距离中心点的位置
1) 1) "chongqing"
   2) "341.9374"
2) 1) "xian"
   2) "483.8340"
3) 1) "shenzhen"
   2) "924.6408"
4) 1) "hangzhou"
   2) "977.5143"
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km withcoord#显示各个位置的经纬度
1) 1) "chongqing"
   2) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) 1) "108.96000176668167114"
      2) "34.25999964418929977"
3) 1) "shenzhen"
   2) 1) "114.04999762773513794"
      2) "22.5200000879503861"
4) 1) "hangzhou"
   2) 1) "120.1600000262260437"
      2) "30.2400003229490224"
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km withcoord withdist count 2 #只显示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 2000 km withdist withcoord count 2
1) 1) "beijing"
   2) "0.0000"
   3) 1) "116.39999896287918091"
      2) "39.90000009167092543"
2) 1) "xian"
   2) "910.0565"
   3) 1) "108.96000176668167114"
      2) "34.25999964418929977"
#############################################
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 shanghai #移除上海
(integer) 1

Hyperloglogs 超级日志

什么是基数？

基数（cardinal number）在数学上，是集合论中刻画任意集合大小的一个概念

简介

HyperLogLog是一种概率数据结构，用于对唯一事物进行计数（从技术上讲，这是指估计集合的基数）
通常，对唯一项目进行计数需要使用与要计数的项目数量成比例的内存量，因为您需要记住过去已经看到的元素，以避免多次对其进行计数。但是，有一组算法会以内存换取精度：在Redis实现的情况下，您得出的带有标准误差的估计度量最终会小于1％。该算法的神奇之处在于，您不再需要使用与所计数项目数成正比的内存量，而是可以使用恒定数量的内存！在最坏的情况下为12k字节。

127.0.0.1:6379> PFADD list a b c d e f g h i  #创建第一组元素 list
(integer) 1
127.0.0.1:6379> PFCOUNT list #统计list中元素的基数（数量）
(integer) 9
127.0.0.1:6379> pfadd list2 i oe jd g d g a d e g e d g d ac d  #创建第二组元素 list2 
(integer) 1
127.0.0.1:6379> PFCOUNT list2  #重复的只算做一个（去重）
(integer) 8
127.0.0.1:6379> PFMERGE list3 list list2 # 合并两组元素到list3 并集
OK
127.0.0.1:6379> PFCOUNT list3
(integer) 12

允许容错的话，建议使用Hyperloglogs ，如果不允许容错，建议使用set

Bitmaps

通过位运算来表示值 0 1
用sign来表示某个人一周的打卡情况
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QuX6Y4PU-1616726776383)(en-resource://database/863:1)]
查看周二和周六是否打开
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8R7kHlxP-1616726776384)(en-resource://database/867:1)]
统计打卡情况
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y8ItRiIZ-1616726776385)(en-resource://database/869:1)]

Redis事务

事务中没有隔离级别的概念
Redis单条命令是保证原子性的，但是Redis事务本身没有原子性

• 一次性
• 顺序性
• 排他性

用法

• 开启事务（Multi）
• 命令入队（Queue）
• 执行事务（Exec）

127.0.0.1:6379> MULTI   ##  开始事务
OK
127.0.0.1:6379(TX)> hset map k0 0   ##  向map中添加k0  值为0
QUEUED
127.0.0.1:6379(TX)> hset map k1 one   ##  向map中添加k1  值为one
QUEUED
127.0.0.1:6379(TX)> HINCRBY map k1 2   ##  给k1加2 （这一步是错误的）
QUEUED
127.0.0.1:6379(TX)> hset map k2 3   ##  向map中添加k02 值为3
QUEUED
127.0.0.1:6379(TX)> EXEC   ##  结束事务
1) (integer) 1
2) (integer) 1
3) (error) ERR hash value is not an integer   ##  第三步执行失败 ，但是接着的第四步执行成功，表明Redis的事务并不具有原子性
4) (integer) 1
127.0.0.1:6379> HGETALL map   ##  获取map
1) "k0"
2) "0"
3) "k1"
4) "one"
5) "k2"
6) "3"

放弃事务 DISCARD

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> DISCARD ## 事务被放弃，不执行中间的语句
OK
127.0.0.1:6379> get k1
(nil)

监控

悲观锁

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

乐观锁

很乐观，认为什么时候都不会出问题，所以不会上锁！更新数据的时候去判断下，再次期间是否有人修改过这个数据

获取version
更新的时候比较version

Redis监视测试

1、正常执行完成

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 
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 20
QUEUED
127.0.0.1:6379(TX)> INCRBY out 20
QUEUED
127.0.0.1:6379(TX)> exec # 事务正常结束，数据期间没有任何问题，这个时候正常执行成功。
1) (integer) 80
2) (integer) 20

2、测试多线程修改值，事务失败，使用watch 可以当做redis的乐观锁操作

127.0.0.1:6379> WATCH money
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRby money 10
QUEUED
127.0.0.1:6379(TX)> INCRby out 10
QUEUED
127.0.0.1:6379(TX)> exec ## 在执行exec之前，开启另外一个客户端（线程），另外一个线程修改了数据，执行失败
(nil)
############ 模拟另外一个线程
127.0.0.1:6379> get money
"80"
127.0.0.1:6379> set money 1000
OK

Jedis

1. 在项目中加入jedis的Jar包
2. new Jedis对象，分别写入host 和port

• 连接本地redis  `Jedis jedis = new Jedis("124.70.145.104", 6379);`
  

• 连接远程服务器，需要在远程服务器中设置redis的配置文件
  1、bind 127.0.0.1 -::1  注释这行代码
  2、protected-mode yes ，将yes改为no
  

3.测试连接 System.out.println(jedis.ping());
4.其余的部分和在redis客户端的操作相同
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iYfdleES-1616726776387)(en-resource://database/871:1)]

事务

事务成功
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lFrTVm95-1616726776388)(en-resource://database/873:1)]
事务失败
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nZEKMuCT-1616726776389)(en-resource://database/875:1)]

SpringBoot整合

说明：在Springboot的2.x之后，原来使用的jedis被替换成了lettuce

jedis和lettuce的区别

• Jedis 是直连模式，在多个线程间共享一个Jedis实例时是线程不安全的，可以通过建立多个Jedis实例来解决，但是链接数量增多时，物理连接成本就较高，同时会影响性能，因此较好的解决办法是使用JedisPool。
• Lettuce 的连接是基于Netty的，连接实例可以在多个线程间共享，Netty可以使多线程的应用使用同一个连接实例，而不用担心并发线程的数量。通过异步的方式可以让我们更好的利用系统资源。

源码分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-McTlxnyx-1616726776390)(en-resource://database/877:1)]

测试

1、导入依赖
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ywALmy6o-1616726776391)(en-resource://database/883:1)]

2、配置连接
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8kanowN5-1616726776392)(en-resource://database/881:1)]
3、整合测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ckyNuBd-1616726776393)(en-resource://database/887:1)]

关于对象的保存

Redis.conf详解

单位

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8vxwmlRo-1616726776394)(en-resource://database/889:1)]

包含其他文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EAG6eXbD-1616726776395)(en-resource://database/891:1)]

网络

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-loeWSHtx-1616726776397)(en-resource://database/893:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IAi1TRXw-1616726776398)(en-resource://database/895:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9vHeRAqq-1616726776400)(en-resource://database/897:1)]

通用

守护进程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XVudpBnW-1616726776401)(en-resource://database/899:1)]

进程文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x3ebFh5I-1616726776402)(en-resource://database/901:1)]

日志记录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dH7XWkUM-1616726776404)(en-resource://database/903:1)]

数据库数量 默认16

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NcNW7NIy-1616726776405)(en-resource://database/905:1)]

logo显示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rgl1pFM5-1616726776406)(en-resource://database/907:1)]

修改进程名称

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D7yaLxDc-1616726776408)(en-resource://database/909:1)]

快照

持久化，在规定的时间内，执行了多少次操作，则会持久化到文件 包括 .rdb 和.aof文件
Redis是内存数据库，如果没有持久化，那么断点及失。！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8KUThORx-1616726776409)(en-resource://database/911:1)]

持久化出错

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-00SH8B0w-1616726776412)(en-resource://database/913:1)]

压缩持久化文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VpTHv6aw-1616726776414)(en-resource://database/915:1)]
是否压缩rdb文件，徐亚消耗一些cpu资源！

持久化校验

保存rdb文件的时候，会进行检查校验
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qu1kp7dw-1616726776417)(en-resource://database/917:1)]

安全

密码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AcHe8ye4-1616726776418)(en-resource://database/919:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lr0mesTp-1616726776419)(en-resource://database/921:1)]

客户端

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GzFUwnu4-1616726776421)(en-resource://database/923:1)]

内存

内存最大容量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W2CJ0ekx-1616726776422)(en-resource://database/925:1)]

内存上限处理策略

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dIDHuz3d-1616726776423)(en-resource://database/927:1)]

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持久化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rcrgkmpF-1616726776423)(en-resource://database/929:1)]

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

RDB (Redis Database)

什么是RDB

在指定的时间间隔内将内存中的数据集快照写入磁盘，它回复时是将快照文件直接读取到内存中。

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就保证了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是很敏感，那么RDB方式要比AOF方式更加高效。
RDB的缺点是最后一次持久化后的数据可能丢失。
默认使用RDB的方式持久化，一般无需进行修改。
rdb保存的文件名称是 dump.rdb 文件,该文件可以在config文件中配置

触发机制

1. 在满足save规则的调间隙啊，会自动触发rdb规则
2. 执行flushall命令，也会触发rdb规则
3. 退出redis，也会产生rdb文件
4. 执行save命令

[root@lqLinux bin]# redis-cli -p 6379
127.0.0.1:6379> shutdown  #关闭redis服务
not connected> exit
[root@lqLinux bin]# redis-server redisConfig/redis.conf  #重启redis服务
[root@lqLinux bin]# redis-cli -p 6379
127.0.0.1:6379> get k #获取关闭之前存贮的key
"v"
127.0.0.1:6379> config get dir #获取redis目录
1) "dir"
2) "/usr/local/bin"
127.0.0.1:6379> save #执行save命令，触发备份
OK

备份自动生成dump.rdb

如何恢复rdb文件

恢复数据只需将备份文件（dump.rdb）移动到redis安装目录下并启动服务即可。
查看redis目录可以使用config 命令 config get dir

优缺点

优点	缺点
适合大规模的数据恢复，相比于AOF机制，如果数据及很大，RDB的启动效率会更高	需要一定的时间间隔进行操作，如果Redis意外宕机，最后一次修改的数据就没有了
对数据的完整性要求不高	fork进程的时候，会占用一定的内存空间

在生产环境下，会对dump.rdb进行备份

AOF（Append Only File）

将所有命令都记录下来，append到文件的末尾
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CPCrn8qt-1616726776424)(en-resource://database/931:1)]

以日志的形式来记录每一个操作，将Redis的执行过程的所有命令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，Redis重启的话，就根据日志文件的内容将写指令从前到后执行一次完成数据的恢复工作。
AOF保存的是appendonly.aof文件
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FgNvUbJ9-1616726776425)(en-resource://database/933:1)]
默认不开启，需要手动修改appendonly no为appendonly yes

如果aof文件错误，redis可能无法启动，需要修复aof文件
redis提供了可以修复aof文件的工具 redis-check-aof
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DQgV8R1d-1616726776426)(en-resource://database/935:1)]
执行 redis-check-aof --fix appendonly.aof 命令，确认即可。

优点和缺点

优点：

1. 每一次修改都同步，文件的完整性会更好。
2. 默认每秒同步一次，可能会丢失一秒的数据
3. 从不同步，效率最高

缺点：

1. 相对于数据文件来说，aof远远大于rdb，修复速度较慢
2. aof运行效率要比rdb慢

持久化总结

1. RDB持久化方式能够在指定的时间间隔内对数据进行快照存储
2. AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候回重新执行这些命令来恢复原始数据，AOF命令以Redis协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，是的AOF文件的体积不至于过大
3. 如若Redis只做缓存使用，如果只希望数据在服务器运行的时候存在，可以不使用任何持久化操作
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 Replication实现高可用性也可以，能省掉一大笔IO操作，也减少了rewrite带来的系统波动。代价就是如果Master-Slave同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave中的RDB文件，载入较新的哪一个。
     

Redis 订阅

Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2QzvWGYD-1616726776427)(en-resource://database/937:1)]

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jVxPJIfT-1616726776428)(en-resource://database/939:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L3QswPya-1616726776429)(en-resource://database/951:1)]

演示

第一个redis客户端
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YvDxX2UW-1616726776430)(en-resource://database/943:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BMLtGq5U-1616726776432)(en-resource://database/947:1)]

第二个redis客户端
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OGpkRp9z-1616726776433)(en-resource://database/945:1)]

命令

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2D57YEBl-1616726776435)(en-resource://database/949:1)]

使用场景

1. 实时消息系统
2. 实时聊天
3. 订阅、关注 系统

稍微复杂的场景建议使用消息中间件MQ（kafka）

主从复制

主从复制，读写分离！！80%的情况下都是在进行读操作，减缓服务器的压力。

概念

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器上。 前者称为主节点（master），后者被称为从节点（Slave）；数据的复制是单向的，只能由主节点到从节点。Master以写为主，Slave以读为主。
默认情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点或者没有从节点，但一个从节点只能有一个主节点。

作用

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

一般来说，要将Redis运用于项目中，只使用一台Redis是万万不能够的，原因如下：

1. 从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大
2. 从容量上来说，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台Redis服务器的最大使用内存不应该超过20G。
   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VX7tbHw5-1616726776437)(en-resource://database/953:1)]

环境配置

只配置从库，不用配置主库
查看当前库的信息 info replication
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vOyLNtjk-1616726776438)(en-resource://database/955:1)]

模拟

复制3个配置文件修改对应的信息

1. 端口号
2. pid名字
3. log文件名字
4. dump.rdb名称

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IfyyuXsv-1616726776438)(en-resource://database/957:1)]

一主二从

默认情况下，每台Redis服务器都是主节点 ，一般情况下主需要配置从机即可！
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ROecgTJ7-1616726776439)(en-resource://database/959:1)]

在从机配置即可
命令： SLAVEOF 127.0.0.1 6379
SLAVEOF [host] [port]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I1IQqn7t-1616726776441)(en-resource://database/961:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-evJuNjqb-1616726776442)(en-resource://database/963:1)]
以上的配置是通过命令行配置的，是暂时的，如果需要永久设置，需要在配置文件中自行设置。操作如下
1、打开从机的配置文件
2、修改replication的相关信息
replicaof 设置主机地址和端口
masterauth 如有需要设置主机密码
masteruser 如有需要设置主机用户
3、重新启动Redis服务即可。

细节

主机可以写，但是从机不可以写。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TKrNNfhS-1616726776444)(en-resource://database/965:1)]
主机宕机，从机仍然是从机。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OxjY8lGp-1616726776447)(en-resource://database/967:1)]主机恢复后，写入的值，从机仍然可以读取。

从机宕机，从新设置后，仍然可以读取主机的全部数据。

复制原理

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

如果一个Redis服务及时从机，同时也是其他Redis服务的主机，但是它只能作为从机来使用，其info replication仍然是从机，只能读取，不能写入，从机的从机仍然支持主从的复制原理。

主机宕机，从机变主机（手动）

从机执行 SLAVEOF no one,此时的从机变成了主机，其他的节点就可以手动的连接到这个主节点。即使之前的主机重新开始了服务，其下面也不会有从机

哨兵模式

概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内的服务不可用。这不是一种更好的解决办法。更过时候我们优先考虑哨兵模式。 从redis2.8开始正式提供了Sentinel（哨兵）架构来解决这个问题
如果主机故障，根据投票数自动将从库转换为主库。
首先Redis提供了哨兵模式，哨兵是一个独立的进程，作为进程，它 可以独立运行。其原理是 哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FiBrgl2i-1616726776448)(en-resource://database/969:1)]

作用

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

然而，一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了 多哨兵模式。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ScDgLveP-1616726776449)(en-resource://database/970:1)]
假设主服务器宕机，哨兵1先检测到了这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为服务器不可用，这个现象称为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵直接就会进行一次投票，投票的结果由一个哨兵发起，进行failover【故障转移】操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称之为客观下线。

目前的状态是 一主二从
哨兵的启动器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5tzoQx6z-1616726776450)(en-resource://database/971:1)]
1、编写哨兵配置文件
输入sentinel monitor myredis 127.0.0.1 6379 //myredis是随意起的名字
2、保存配置文件，输入redis-sentinel redisConfig/sentinel.conf 启动哨兵
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fMEt9VAS-1616726776451)(en-resource://database/974:1)]
3、关闭主机，稍等一会，自动更改主机
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sz1J4o0N-1616726776452)(en-resource://database/973:1)]
6380自动切换为主机，6381为其从机
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ID5R9qQs-1616726776453)(en-resource://database/972:1)]

如果这时启动6379Redis服务器，此时哨兵模式会将其作为从机使用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u6QbTa0a-1616726776454)(en-resource://database/975:1)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vcJHJMSu-1616726776455)(en-resource://database/976:1)]

优缺点

优点

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 配置多少个sentinel哨兵同意认为master主节点失联，那么这是客观上认为主节点失联
# sentinel monitor    
sentinel monitor mymaster 127.0.0.1 6379 2

# 当在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  
 sentinel parallel-syncs mymaster 1
 
 # 故障 转移的超市时间 failover-time可以用在一下这些方面：
 # 1、同一个sentinel对同一个maste两侧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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Etsojiex-1616726776455)(en-resource://database/978:1)]

缓存穿透

概念

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

解决方案

布隆过滤器

布隆过滤器是一种数据结构，对多有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力。
布隆过滤器是如何解决redis中的缓存穿透呢？很简单首先也是对所有可能查询的参数以hash形式存储，当用户想要查询的时候，使用布隆过滤器发现不在集合中，就直接丢弃，不再对持久层查询[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6f490B5G-1616726776456)(en-resource://database/980:0)]

缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Lk7nXRN-1616726776457)(en-resource://database/982:0)]
问题

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

缓存雪崩

概念

缓存雪崩是指，缓存层出现了错误，不能正常工作了。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况

解决方案

Redis高可用

这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群

限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待

数据预热

数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀

缓存击穿

概念

缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞

解决方案

设置热点数据永远不过期

加互斥锁