Redis超全知识总结

Redis

1. 官网： https://redis.io/
2. 中文网：http://www.redis.cn/

NoSQL数据库

NoSQL(Not Only SQL)，不仅仅是SQL，泛指非关系型数据库。

NoSQL不依赖业务逻辑方式存储，以简单的key-value模式存储。大大增加了数据库的拓展能力。

• 不遵守SQL标准
• 不支持ACID
• 远超于SQL的性能

NoSQL适用场景：

• 对数据高并发的读写
• 海量数据的读写
• 对数据高可拓展性的

​ NoSQL不适用场景

• 需要事务支持
• 基于sql的结构化查询存储，处理复杂的关系，需要即席查询
• 用不着sql和用来sql也不行的情况，考虑使用Nosql

行式数据库

列式数据库

NoSQL特点

解耦！

• 方便拓展，数据之间没有关系

• 大数据量高性能（Redis一秒写8w次，读取11w，NoSQL的缓存记录级，是一种细粒度的缓存，性能比较高！）

• 数据类型多样（不需要事先设计数据库！随去随用！）

• 传统关系型数据库(RDBMS)和NoSQL

  传统的RDBMS
  - 结构化组织
  - SQL语句
  - 数据和关系都存在单独的表中
  - 操作，数据定义语句
  - 严格一致性
  - 基础事务
  - ......
  

  NoSQL
  - 不仅仅是数据
  - 没有固定查询语言
  - 键值对存储，列存储，文档存储，图形数据库(社交关系)
  - 最终一致性
  - CAP定理和BASE（异地多活）
  - 高性能，高可用，高可拓展性
  - ......
  

NoSQL的四大分类

• KV键值对：
  • 新浪：Redis
  • 美团：Redis+Tair
  • 阿里、百度：Redis+memecache
• 文档型数据库(bson格式和json一样)：
  • MongoDB（一般必须掌握）
    • MongoDB是一个基于分布式文件存储的数据库，c++编写，主要用于处理大量的文档！
    • MongoDB是一个介于关系型数据库和非关系型数据库的中间产品！MongoDB是非关系型数据库中功能最丰富，最像关系型数据库！
    • CouchDB
• 列存储数据库：
  • HBase
  • 分布式文件系统
• 图关系数据库：
  • 不是存图形，存储的是关系，如：朋友圈社交网络，广告推荐
  • Neo4j, InfoGrid

Redis概述

Redis是什么？

Redis(Remote Dictionary Server) 远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。

Redis能干什么？

1. 内存存储、持久化、内存是断电即失、持久化主要是rdb和aof
2. 效率高，可以用于高速缓存
3. 发布订阅系统
4. 地图信息分析
5. 计时器、计数器(浏览量)
6. …

Redis的特性

1. 多样的数据类型
2. 持久化
3. 集群
4. 事务
5. …

学习相关

1. 官网： https://redis.io/
2. 中文网：http://www.redis.cn/
3. 下载 在github(官网)

Redis推荐都是在Linux服务器上搭建的，在Linux中学习开发

Linux安装Redis

下载解压Redis

1. 下载redis的压缩包(6.2.6)

   wget https://download.redis.io/releases/redis-6.2.6.tar.gz
   

2. 解压redis

   tar xzf redis-6.2.6.tar.gz
   

3. 移动redis目录，一般会放在/user/local/redis下

   mv redis-6.2.6 /user/local/redis
   

   编译并安装redis

   1. 进入redis安装目录，执行make命令编译redis

      cd /user/local/redis
      make
      make install
      #如果报错cc未找到命令，就是虚拟机系统中缺少gcc，执行以下命令安装gcc:
      yum -y install gcc automake autoconf libtool make
      

   2. 执行指令安装redis，并指定安装目录

      make install PREFIX=/user/local/redis
      

   3. 推荐将解压路径下的redis.conf复制到移动到安装目录下便于备份更改

      cp /opt/redis-6.2.6/redis.conf conf
      

启动redis

1. 将redis.conf中的daemonize改为yes （后台启动）

   

2. 启动redis服务(在bin目录下)

   redis-server conf/redis.conf
   

3. 连接端口

   redis-cli [主机(默认是本机)] -p 6379
   ping
   set name sjp
   get name
   

性能测试

redis-benchmark是一个压力测试工具！（官方自带的性能测试工具）

redis-benchmark命令参数：

简单测试：

redis-benchmark -h localhost -p 6379 -c 100 -n 100000

数据分析

基础知识

默认有16个数据库 默认使用的是第0个数据库 使用select切换数据库

127.0.0.1:6379> select 4   #切换到第四个数据库
OK
127.0.0.1:6379[4]> dbsize   #查看数据库大小
(integer) 0
127.0.0.1:6379[4]> set name sjp   
OK
127.0.0.1:6379[4]> dbsize
(integer) 1
127.0.0.1:6379[4]> keys *   #查看所有的key
1) "name"
127.0.0.1:6379[4]> get name   #获取key为name的值
"sjp"
127.0.0.1:6379[4]> flushdb      #清空当前库
OK
127.0.0.1:6379[4]> flushall     #清空全部库
OK

Redis 是单线程的！(Redis6.0以上引入了多线程)

Redis是很快的，官方表示，Redis是基于内存操作，CPU不是Redis的性能瓶颈，Redis的瓶颈是根据机器的内存和网络带宽，既然可以使用单线程实现，就使用了单线程！

Redis是C语言写的，官方提供的数据为10w+的QPS(每秒查询率)，完全不比同样使用key-value的Memecache差！

Redis为什么是单线程还这么快？

核心：redis是将所有的数据全部存放在内存中，所以使用单线程去操作效率是最高的(不存在cpu上下文切换的问题)，多线程(CPU需要上下文切换，消耗资源！！)，对于内存系统来说，没有上下文切换，效率是最高的！多次读写都是在一个CPU上的，在内存情况下，就是最佳方案

Redis的五大数据类型

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作**数据库**、缓存和==消息中间件==。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。

Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

Redis-Key

常见操作

设置过期时间

127.0.0.1:6379> keys *   
1) "age"
127.0.0.1:6379> set name sjp                #创建name-sjp键值对
OK
127.0.0.1:6379> expire name 10              #设置10s后自动过期
(integer) 1
127.0.0.1:6379> ttl name                     #查看剩余时间
(integer) 5
127.0.0.1:6379> keys *                      #查看还在
1) "name"
2) "age"
127.0.0.1:6379> ttl name                     #已经删除2s了
(integer) -2
127.0.0.1:6379> keys *                       #10s后数据清除了
1) "age"

查看value的类型

127.0.0.1:6379> set name sjp
OK
127.0.0.1:6379> type name
string
127.0.0.1:6379> type age
string

String类型(字符串)

append [key] “字符串” key存在就追加字符串，不存在就创建

strlen [key] 获取字符串长度

127.0.0.1:6379> set key v1           #设置值
OK
127.0.0.1:6379> get key              #获得值
"v1"
127.0.0.1:6379> exists key           #查看是否存在
(integer) 1
127.0.0.1:6379> append key "hello world"   #追加字符串
(integer) 13
127.0.0.1:6379> get key                 
"v1hello world"
127.0.0.1:6379> append name yu          #追加字符串，key不存在就创建
(integer) 2
127.0.0.1:6379> keys *
1) "key"
2) "name"
127.0.0.1:6379> get name
"yu"
127.0.0.1:6379> strlen key               #获取字符串长度
(integer) 13
127.0.0.1:6379> strlen name
(integer) 2

加操作 incr [key] 自增一 incrby [key] [数量]自增指定数量

减操作 decr[key] 自减一 decrby [key] [数量]自减指定数量

127.0.0.1:6379> set count 10
OK
127.0.0.1:6379> incr count             #一次增加1
(integer) 11
127.0.0.1:6379> decr count             #一次减少1
(integer) 10
127.0.0.1:6379> incrby count 11        #一次增加指定数量
(integer) 21
127.0.0.1:6379> decrby count 30         #一次减少指定数量
(integer) -9

字符串范围获取 range

getrange [key] [n] [m] 获取从下标n到下标m的字符串

setrange [key] [n] “字符串” 替换下标为n开始的字符串

127.0.0.1:6379> set words "hello world or sky"
OK
127.0.0.1:6379> get words
"hello world or sky"
127.0.0.1:6379> getrange words 0 5         #获取下标为0到下标为5的字符串 包含5
"hello "
127.0.0.1:6379> getrange words 0 8         #获取下标为0到下标为8的字符串 包含8
"hello wor"
127.0.0.1:6379> getrange words 0 -1         #全部字符串
"hello world or sky"
127.0.0.1:6379> setrange words 5 "welcom"     #替换下标为5开始的字符
(integer) 18                                  #返回替换后的字符串长度
127.0.0.1:6379> get words
"hellowelcom or sky"
127.0.0.1:6379> getrange words 0 -1
"hellowelcom or sky"

setex [key] [时间-秒] [值] 设置过期时间

setnx [key] [value] 不存在就设置(分布式锁中常用！)

127.0.0.1:6379> setex v3 15 yu       #设置键为v3值为yu 且 15s后删除
OK
127.0.0.1:6379> ttl v3               #查看剩余时间
(integer) 11
127.0.0.1:6379> keys *               #查看全部key v3存在
1) "v3"
2) "key"
3) "count"
4) "0"
5) "name"
6) "words"
127.0.0.1:6379> setnx key sjp       #如果不存在键为key就设置
(integer) 0                         #存在因此为创建
127.0.0.1:6379> get key             #value没变
"v1hello world"
127.0.0.1:6379> ttl v3
(integer) -2
127.0.0.1:6379> keys *             #v3已经被删除
1) "key"
2) "count"
3) "0"
4) "name"
5) "words"

mset [key] [value] [key] [value] [key] [value] [key] [value] 批量设置键值对

mget [key] [key] [key] 批量获取

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 k4 v4          #批量设置值
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"
4) "k4"
127.0.0.1:6379> mget k1 k2 k3                       #批量获取值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v2 k5 v5   #mset是原子性操作要么全部成功，要么全部失败
(integer) 0
127.0.0.1:6379> msetnx k6 v6 k5 v5
(integer) 1
127.0.0.1:6379> keys *
1) "k5"
2) "k1"
3) "k2"
4) "k6"
5) "k3"
6) "k4"

对象操作

127.0.0.1:6379> set user:1 {name:sjp,age:3}    #创建user:1的对象
OK
127.0.0.1:6379> get user                       #直接无法获取，需要加上id
(nil)
127.0.0.1:6379> get user:1                    #获取user:1对象
"{name:sjp,age:3}"
127.0.0.1:6379> mset user:1:name sjp user:1:age 3  #批量设置user:1对象
OK
127.0.0.1:6379> mget user:1                   #获取 user:1对象
1) "{name:sjp,age:3}"
127.0.0.1:6379> mget user:1:name user:1:age   #获取user:1中的属性值
1) "sjp"
2) "3"

getset [key] [value] 先get然后set

127.0.0.1:6379> getset db redis     #第一次获取db没有值返回nil 并设置值
(nil)
127.0.0.1:6379> get db              #执行完getset后 set db redis
"redis"
127.0.0.1:6379> getset db mongodb
"redis"
127.0.0.1:6379> get db
"mongodb"

String类似的使用场景：value除了是字符串还可以是数字！

• 计数器
• 粉丝数量统计
• 统计多单位数量
• 对象缓存存储！

List列表

在redis中，可以将list变化为 栈、队列、阻塞队列等

所有的list命令都是l开头的

lpush [listname] [value] 将一个值插入到list的头部(左)

lrange [listname] [start] [end] 获取下标为star到下标为end的值

rpush [listname] [value] 将值插入list底部(右)

127.0.0.1:6379> lpush list one     #插入one
(integer) 1
127.0.0.1:6379> lpush list two     #插入two
(integer) 2
127.0.0.1:6379> lpush list three   #插入three
(integer) 3
127.0.0.1:6379> lpush list four    #插入four
(integer) 4
127.0.0.1:6379> lrange list 0 -1   #获取全部值
1) "four"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379> lrange list 0 2   #获取下标从0到2的值
1) "four"
2) "three"
3) "two"
127.0.0.1:6379> rpush list end    #在列表最底部插入数据
(integer) 5
127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "two"
4) "one"
5) "end"

lpop [listname] [count] 移除（弹出）列表的前几个元素，默认一个

rpop [listname] [count] 移除（弹出）列表的最后几个元素，默认一个

127.0.0.1:6379> lrange list 0 -1
1) "four"
2) "three"
3) "two"
4) "one"
5) "end"
127.0.0.1:6379> lpop list 2         #移除后前两个元素
1) "four"
2) "three"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
3) "end"
127.0.0.1:6379> rpop list 1          #移除最后一个元素
1) "end"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"

lindex [listname] [num] 获取下标为num的值

127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> lindex list 1            #下标是从左到右开始的
"one"
127.0.0.1:6379> lindex list 0
"two"
127.0.0.1:6379> lpush list three           #左侧插入
(integer) 3
127.0.0.1:6379> lindex list 2          
"one"
127.0.0.1:6379> rpush list four
(integer) 4
127.0.0.1:6379> lindex list 2
"one"
127.0.0.1:6379> lindex list 3
"four"

llen [listname] 获取列表长度

127.0.0.1:6379> llen list
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"

Lrem [listname] [count] [value] 移除count个指定的value值

127.0.0.1:6379> lrange list 0 -1      #列表中又三个three数据
1) "three"
2) "six"
3) "three"
4) "five"
5) "three"
6) "two"
7) "one"
8) "four"
127.0.0.1:6379> lrem list 2 three      #自上而下(从左到右)移除两个three数据
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "five"
3) "three"
4) "two"
5) "one"
6) "four"

ltrim [listname] [start] [end] 截取指定的长度 对原有的list进行操作

127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "five"
3) "three"
4) "two"
5) "one"
6) "four"
127.0.0.1:6379> ltrim list 0 3
OK
127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "five"
3) "three"
4) "two"

rpoplpush [oldlist] [newlist] 移除列表的最后一个元素并移动到新的列表中

127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "five"
3) "three"
4) "two"
127.0.0.1:6379> rpoplpush list list1    #移除list最后一个元素移动到list1中
"two"
127.0.0.1:6379> lrange list 0 -1
1) "six"
2) "five"
3) "three"
127.0.0.1:6379> lrange list1 0 -1
1) "two"

lset [listname] [index] [value] 将列表指定下标的值替换为另一个值，更新

127.0.0.1:6379> lrange list 0 -1   
1) "six"
2) "five"
3) "three"
127.0.0.1:6379> lset list 0 one     #替换列表下标为0的值为one
OK
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "five"
3) "three"
127.0.0.1:6379> lset list 4 one      #超出下标会报错
(error) ERR index out of range
127.0.0.1:6379> lset list2 1 one     #没有列表也报错
(error) ERR no such key

linsert [listname] [before|after] [value] [value] 在列表中一个值的前面或者后面插入值

127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "five"
3) "three"
127.0.0.1:6379> linsert list before five four      #在列表中five前面插入four
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "four"
3) "five"
4) "three"
127.0.0.1:6379> linsert list after five two      #在列表five后面插入two
(integer) 5
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "four"
3) "five"
4) "two"
5) "three"

总结

• list实际上是一个链表，可以往前面插入，后面插入都可以
• 如果key不存在，插入就创建新链表
• 如果key存在，新增内容
• 如果移除了所有值，空链表=不存在
• 在头和尾进行操作是，效率最高！中间效率略低
• 实现内容：
  • 消息排队
  • 消息队列
  • 栈
  • 队列

Set集合(值不可重复)

sadd [setname] [value] 新建或插入数据到set中

smembers [setname] 查看set中的数据

smember [value] 查看value是否在set中

scard [setname] 查看集合中的value总数

127.0.0.1:6379> sadd myset "one"     #创建 并 插入
(integer) 1
127.0.0.1:6379> sadd myset "two"     #插入
(integer) 1  
127.0.0.1:6379> sadd myset "three"   #插入
(integer) 1
127.0.0.1:6379> smembers myset       #查看set集合中的值
1) "two"
2) "three"
3) "one"
127.0.0.1:6379> sismember myset hello  #判断hello是否在set集合中
(integer) 0
127.0.0.1:6379> sismember myset one
(integer) 1
127.0.0.1:6379> sismember myset two
(integer) 1
127.0.0.1:6379> scard myset          #查看set集合中元素个数
(integer) 3

srem [setname] [value] 移除set集合中的指定元素

127.0.0.1:6379> smembers myset
1) "two"
2) "three"
3) "one"
127.0.0.1:6379> srem myset "one"     #移除myset集合中one元素
(integer) 1
127.0.0.1:6379> smembers myset
1) "two"
2) "three"
127.0.0.1:6379> scard myset
(integer) 2

srandmember [setname] [count] 随机筛选出count个元素

127.0.0.1:6379> smembers myset
1) "two"
2) "one"
3) "three"
127.0.0.1:6379> SRANDMEMBER myset
"three"
127.0.0.1:6379> SRANDMEMBER myset
"two"
127.0.0.1:6379> srandmember myset 2
1) "two"
2) "three"
127.0.0.1:6379> srandmember myset 2
1) "two"
2) "one"

spop [setname] 随机删除一个元素

127.0.0.1:6379> smembers myset
1) "two"
2) "one"
3) "three"
4) "four"
5) "five"
127.0.0.1:6379> spop myset    #随机删除
"one"
127.0.0.1:6379> spop myset
"two"
127.0.0.1:6379> smembers myset
1) "three"
2) "four"
3) "five"

smove [oldset] [newset] [value] 移动指定的元素到另一个集合(不存在就创建)

127.0.0.1:6379> smove myset set2 three     #移动three到set2中，set2不存在就创建
(integer) 1
127.0.0.1:6379> scard myset
(integer) 2
127.0.0.1:6379> smembers myset
1) "four"
2) "five"
127.0.0.1:6379> smembers set2
1) "three"

sdiff [set1] [set2] 以set1为基础与set2做差集 — 猜你喜欢、推荐好友

sinter [set1] [set2] set1和set2做交集 ---- 共同关注、共同好友

sunion [set1] [set2] set1和set2做并集

127.0.0.1:6379> smembers myset
1) "three"
2) "four"
3) "one"
4) "five"
127.0.0.1:6379> smembers set2
1) "one"
2) "three"
3) "eight"
127.0.0.1:6379> sdiff myset set2  #以myset为基础与set2做差集(myset有，set2没有的)
1) "five"
2) "four"
127.0.0.1:6379> sinter myset set2  #myset和set2做交集 (双方都有的)
1) "one"
2) "three"
127.0.0.1:6379> sunion myset set2  #myset和set2做并集  (双方汇总)
1) "three"
2) "eight"
3) "four"
4) "one"
5) "five"

Hash（哈希）

Map集合，key-map! 值是一个map集合！本质和spring相似!

hset [hashname] [hashkey] [hashvalue] 设置hashname的key和value

hget[hashname] [hashkey] 获取hash中hashkey的值

hmset [hashname] [hashkey] [hashvalue] [hashkey] [hashvalue]… 批量设置

hmget [hashname] [hashkey] [hashvalue] [hashkey] [hashvalue]… 批量获取

hgetall [hashname] 获取全部hashkey和hashvalue

127.0.0.1:6379> hset myhash field1 sjp
(integer) 1
127.0.0.1:6379> hget myhash field1
"sjp"
127.0.0.1:6379> hmset myhash field1 yu field2 eq field3 max
OK
127.0.0.1:6379> hmget myhash field1 field2
1) "yu"
2) "eq"
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "yu"
3) "field2"
4) "eq"
5) "field3"
6) "max"

hdel [hashname] [hashkey] [hashkey] 删除一条或者多条数据

127.0.0.1:6379> hgetall myhash
1) "field1"
2) "yu"
3) "field2"
4) "eq"
5) "field3"
6) "max"
127.0.0.1:6379> hdel myhash field2 field3    #删除hash中指定的key字段
(integer) 2
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "yu"

hlen [hashname] 获取hash表的字段长度

127.0.0.1:6379> hgetall myhash
1) "field1"
2) "yu"
127.0.0.1:6379> hlen myhash
(integer) 1
127.0.0.1:6379> hmset myhash field2 high field3 eq
OK
127.0.0.1:6379> hlen myhash
(integer) 3

hexists [hashname] [hashkey] 判断是否存在指定字段

127.0.0.1:6379> HEXISTS myhash field2
(integer) 1
127.0.0.1:6379> HEXISTS myhash field5
(integer) 0

hkeys [hashname] 获取全部keys

hvals [hashname] 获取全部values

127.0.0.1:6379> hkeys myhash
1) "field1"
2) "field2"
3) "field3"
127.0.0.1:6379> hvals myhash
1) "yu"
2) "high"
3) "eq"

hincr [hashname] [hashkey] [num] 增加

127.0.0.1:6379> hset v1 field 5
(integer) 1
127.0.0.1:6379> hset v1 field2 4
(integer) 1
127.0.0.1:6379> hset v1 field3 -4
(integer) 1
127.0.0.1:6379> hvals v1
1) "5"
2) "4"
3) "-4"

hsetnx [hashname] [hashkey] [value] 如果不存在可以设置，存在就不能设置

127.0.0.1:6379> hsetnx v1 filed 5        #存在就无法设置
(integer) 0
127.0.0.1:6379> hget v1 filed
"10"
127.0.0.1:6379> hsetnx v1 filed "hi"      
(integer) 0
127.0.0.1:6379> hsetnx v1 filed2 "hi"     #不存在便可以设置
(integer) 1
127.0.0.1:6379> hgetall v1
 1) "field"
 2) "15"
 3) "field2"
 4) "4"
 5) "field3"
 6) "-4"
 7) "filed"
 8) "10"
 9) "filed2"
10) "hi"

哈希的用途

哈希存储变更的数据 user name age ，主要是用户类信息，经常变动的信息！

哈希更适合对象的存储，string适合字符串

Zset(有序集合)

在set的基础上，增加了一个值，用于进行排序

zadd [zsetname] [score] [value] 插入一条数据

zadd [zsetname] [score] [value] [score] [value] [score] [value] 插入多条数据

zrange [zsetname] [start] [end]

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> zadd myset 0 zero
(integer) 1
127.0.0.1:6379> zrange myset 0 -1
1) "zero"
2) "one"
3) "two"
4) "three"

zrangebyscore [zsetname] [start] [end] [withscores]

从start到end 实现排序 -inf表负无穷 +inf表正无穷

zrevrange [zsetname] [start] [end] [withscores] 降序下标排序

127.0.0.1:6379> zadd class 99 zhangsan
(integer) 1
127.0.0.1:6379> zadd class 70 lisi 90 wangwu 80 xiaoming
(integer) 3
127.0.0.1:6379> zrange class 0 -1
1) "lisi"
2) "xiaoming"
3) "wangwu"
4) "zhangsan"
127.0.0.1:6379> ZRANGEBYSCORE class -inf +inf     #负无穷到正无穷排序（所有排序）
1) "lisi"
2) "xiaoming"
3) "wangwu"
4) "zhangsan"
127.0.0.1:6379> zrangebyscore class 80 100 withscores #80到100排序 附带成绩
1) "xiaoming"
2) "80"
3) "wangwu"
4) "90"
5) "zhangsan"
6) "99"
127.0.0.1:6379> zrevrange class 0 -1  
1) "zhangsan"
2) "wangwu"
3) "lisi"

zrem [zsetname] [zsetvalues] 移除指定元素

zcard [zsetname] 查看全部元素数量

127.0.0.1:6379> zrange class 0 -1 withscores
1) "lisi"
2) "70"
3) "xiaoming"
4) "80"
5) "wangwu"
6) "90"
7) "zhangsan"
8) "99"
127.0.0.1:6379>  zrem class xiaoming
(integer) 1
127.0.0.1:6379> zcard class
(integer) 3

zcount [zsetname] [start] [end] 获取指定区间的成员数量

127.0.0.1:6379> zadd v1 1 zhangsan
(integer) 1
127.0.0.1:6379> zadd v1 2 lisi
(integer) 1
127.0.0.1:6379> zadd v1 3 wangwu 4 zhaosi
(integer) 2
127.0.0.1:6379> zcount v1 2 4
(integer) 3

总结

存储成绩排序 薪水排序 权重！ 设置事件紧急性！ 排行榜!!!

三种特殊数据类型

geospatial地理位置

定位、距离计算等

Redis的Geo在Redis3.2就退出了，可以推算地理位置信息，两地之间距离，方圆几里的人

geoadd [geospaticalname] [经度] [纬度] [名称]

添加地理位置数据 两极无法直接添加，一般通过java导入

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 120.16 30.24 hangzhou
(integer) 2
127.0.0.1:6379> geoadd china:city 108.96 34.26 xian
(integer) 1
127.0.0.1:6379> geoadd china:city 39.90 116.40  beijing
(error) ERR invalid longitude,latitude pair 39.900000,116.40000 #报错超出了经纬度范围

geopos [geoname] [名称] 获取指定位置的经纬度

127.0.0.1:6379> geopos china:city shanghai
   1) "121.47000163793563843"
   2) "31.22999903975783553"

geodist [geoname] [name] [name] 返回两个给定位置的距离

m 是米(默认) km是千米 mi是英里 ft是英尺

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"
127.0.0.1:6379> geodist china:city beijing chongqing ft
"4803381.9063"
127.0.0.1:6379> geodist china:city beijing chongqing mi
"909.7337"

georadius 以给定的经纬度为中心，找出某一半径内的元素

127.0.0.1:6379> GEORADIUS china:city 100 40 5000 km 
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> GEORADIUS china:city 100 40 5000 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"
5) 1) "shanghai"
   2) 1) "121.47000163793563843"
      2) "31.22999903975783553"
6) 1) "beijing"
   2) 1) "116.39999896287918091"
      2) "39.90000009167092543"
127.0.0.1:6379> GEORADIUS china:city 100 40 5000 km withcoord withdist
1) 1) "chongqing"
   2) "1306.2784"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) "1018.3338"
   3) 1) "108.96000176668167114"
      2) "34.25999964418929977"
3) 1) "shenzhen"
   2) "2352.1971"
   3) 1) "114.04999762773513794"
      2) "22.5200000879503861"
4) 1) "hangzhou"
   2) "2123.8104"
   3) 1) "120.1600000262260437"
      2) "30.2400003229490224"
5) 1) "shanghai"
   2) "2164.8380"
   3) 1) "121.47000163793563843"
      2) "31.22999903975783553"
6) 1) "beijing"
   2) "1396.4397"
   3) 1) "116.39999896287918091"
      2) "39.90000009167092543"
127.0.0.1:6379> GEORADIUS china:city 100 40 5000 km withcoord withdist count 2
1) 1) "xian"
   2) "1018.3338"
   3) 1) "108.96000176668167114"
      2) "34.25999964418929977"
2) 1) "chongqing"
   2) "1306.2784"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"

georadiusbymember 找出指定位置的元素

0.0.1:6379> georadiusbymember china:city beijing 1000 km
1) "beijing"
2) "xian"

geohash 返回当前位置的11个经纬度字符串

127.0.0.1:6379> geohash china:city beijing
1) "wx4fbxxfke0"
127.0.0.1:6379> geohash china:city beijing chongqing
1) "wx4fbxxfke0"
2) "wm5xzrybty0"

geo的底层就是zset 可以通过zset指令操作geo！！！！！

Hyperloglog 数据结构

Redis Hyperloglog 基数统计算法！

优点：占用内存是固定的，2^64不同的元素基数，只占用12k！

网页的UV（一个人多次访问网站，只算做一个人）

• 传统方式，set保存用户id，统计set中的元素数量作为判断标准！
• 主要目的是为了计数，而不是存储id

测试使用 求并集个数

127.0.0.1:6379> pfadd mykey a s d f g h j
(integer) 1
127.0.0.1:6379> pfadd mykey2 f g h j k l 
(integer) 1
127.0.0.1:6379> pfcount mykey
(integer) 7
127.0.0.1:6379> pfcount mykey2
(integer) 6
127.0.0.1:6379> pfmerge mykey3 mykey mykey2   #求并集
OK
127.0.0.1:6379> pfcount mykey3    #看并集个数
(integer) 9

允许容错可以使用Hyperloglog

Bitmap

统计用户信息，活跃，不活跃！登录，未登录！

Bitmaps位图，数据结构！二进制位进行记录，只有0和1两个状态~

创建打卡

127.0.0.1:6379> setbit sign 0 1        
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 1
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 0
(integer) 0
127.0.0.1:6379> setbit sign 5 1
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379> getbit sign 3   #获取某一天状态
(integer) 1

统计

127.0.0.1:6379> bitcount sign
(integer) 4
127.0.0.1:6379> bitcount sign 0 5
(integer) 4
127.0.0.1:6379> bitcount sign 0 3
(integer) 4

事务

Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行！ 一次性、顺序型、怕他性！执行一列命令

Redis事务没有隔离级别的概念

所有命令在事务中，没有直接被执行！只有发起执行命令时，才会执行！

Redis单条命令是保证原子性的，但事务是不保证原子性的

Redis的事务：

• 开启事务(multi)
• 命令入队(…)
• 执行事务(exec)
• 取消事务(discard) --事务队列中的命令不执行
• 如果在执行事务时，输入的命令有错误，**命令队列都不执行 ** （类似java编译错误）
• 在执行事务时，命令语法正确，但是出现异常(若1/0)，其他命令可以执行，报错命令抛出异常 （类似java中的执行过程中抛出异常）

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)> get k1
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec       #执行事务
1) OK
2) OK
3) "v1"
4) OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> get key1
QUEUED
127.0.0.1:6379(TX)> get key2
QUEUED
127.0.0.1:6379(TX)> discard      #取消事务
OK

乐观锁 （可实现）

乐观锁：指的是在操作数据的时候非常乐观,乐观地认为别人不会同时修改数据,因此乐观锁默认是不会上锁的,只有在执行更新的时候才会去判断在此期间别人是否修改了数据,如果别人修改了数据则放弃操作,否则执行操作

Redis实现乐观锁

watch [key] 监控(加锁) unwatch[key] 放弃监控(解锁)

127.0.0.1:6379> get money
"500"
127.0.0.1:6379> watch money    #监视 money
OK
127.0.0.1:6379> multi          #开启事务
OK
127.0.0.1:6379(TX)> decrby money 100
QUEUED
127.0.0.1:6379(TX)> incrby out 100
QUEUED
127.0.0.1:6379(TX)> exec   #执行前另外一个线程(插入执行下面代码)修改了我们的money值
(nil)

# 插入执行 类似前面命令队列未执行，这边先执行
127.0.0.1:6379> get money
"500"
127.0.0.1:6379> set money 600   
OK

事务执行失败

1. 解锁（无论事务是否执行成功都会解锁）
2. 获取锁
3. 执行事务

127.0.0.1:6379> unwatch              #解锁（失败会自动解锁）
OK
127.0.0.1:6379> watch money          #获取锁
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 100
QUEUED
127.0.0.1:6379(TX)> incrby out 100
QUEUED
127.0.0.1:6379(TX)> exec           #执行事务
1) (integer) 500
2) (integer) 110
127.0.0.1:6379> 

Jedis

是什么？

jedis就是集成了redis的一些命令操作，封装了redis的java客户端。提供了连接池管理。一般不直接使用jedis，而是在其上在封装一层，作为业务的使用。

测试

1. 导入对应依赖

          <!-- jedis -->
           <dependency>
               <groupId>redis.clients</groupId>
               <artifactId>jedis</artifactId>
               <version>3.3.0</version>
           </dependency>
           <!--fastjson-->
           <dependency>
               <groupId>com.alibaba</groupId>
               <artifactId>fastjson</artifactId>
               <version>1.2.83</version>
            </dependency>
   

2. 编码测试

   1. 连接数据库
   2. 操作命令
   3. 断开连接

       public static void main(String[] args) {
           Jedis jedis = new Jedis("127.0.0.1", 6379);
           System.out.println(jedis.ping());
           System.out.println("创建：" + jedis.set("key1", "v1"));
           System.out.println(jedis.get("key1"));
       }
   

   //控制台输出
   pool2\2.6.2\commons-pool2-2.6.2.jar" TestPing
   PONG
   创建：OK
   v1
   

   事务

// 执行成功
public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "sjp");
        // 开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        try {
            multi.set("user1", result);
            multi.set("user2", result);
            // 执行事务
            multi.exec();
        } catch (Exception e) {
            multi.discard();
            e.printStackTrace();
        } finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            // 关闭连接
            jedis.close();
        }

    }

// 结果
{"name":"sjp","hello":"world"}
{"name":"sjp","hello":"world"}

SpringBoot整合Redis

springbot2.x之后，原来的jedis被替换为lettuce了

**jedis：**采用直连方式，多个线程操作，没有安全性，除非使用jedis pool连接池！BIO

**lettuce：**实例可以在多个线程中进行共享，保障了线程安全性，可以减少线程数量！NIO

步骤

1、导入依赖

2、配置连接

spring:
    redis:
        host: 127.0.0.1
        port: 6379

3、测试使用

@SpringBootTest
//测试时不加会报空指针异常
@RunWith(SpringRunner.class)
public class TestRedis {


    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void contexLoad(){

        redisTemplate.opsForValue().set("v1", 1);
        System.out.println(redisTemplate.opsForValue().get("v1"));
    }

}

存储对象需要对对象进行序列化

未进行序列化报错：

改后：

@Test
    void contextLoads() throws JsonProcessingException {
        User user = new User("孙宇", 20);
        //一般开发通过json传递对象 企业开发中都需要序列化
        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("v3", jsonUser);
        System.out.println(redisTemplate.opsForValue().get("v3"));
    }

编写自定义的 RedisTemplate

package com.sjp.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author sjp
 */
@Configuration
public class RedisConfig {

    /**
     * 写自己的使用的RedisTemplate
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate (RedisConnectionFactory redisConnectionFactory) {
        // 我们为了开发方便使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 连接redis工厂
        template.setConnectionFactory(redisConnectionFactory);
        // json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // string的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key使用string序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key使用string序列化方式
        template.setHashKeySerializer(stringRedisSerializer);

        // value使用jackson序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value使用jackson序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

配置完序列化后就可以直接对对象执行

  @Autowired
    RedisTemplate redisTemplate;

    @Test
    void contextLoads() throws JsonProcessingException {
        User user = new User("孙宇", 20);
        //一般开发通过json传递对象
//        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("v3", user);
        System.out.println(redisTemplate.opsForValue().get("v3"));
    }

127.0.0.1:6379> keys *
1) "v3"                            #string序列化
2) "v5"  
3) "\xac\xed\x00\x05t\x00\x02v3"   #jdk序列化(默认)
4) "\xac\xed\x00\x05t\x00\x02v1"

推荐封装写RedisUtils使用

设置密码

Redis持久化 （面试和工作重点！！！！）

Redis是内存数据库，如果不将内存中的数据库状态保存到磁盘，如果服务器进程退出，服务器中的数据库状态也会小时，因此持久化是必不可少的！

RDB(Redis DataBase)

中从复制中，rdb是备用的，发在从机中！！

概念：在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话中的Snapshot快照，它恢复时是将快照文件直接读到内存中。

Redis会单独创建(fork)一个子进程来进行持久化，会先将数据写入一个临时文件中，等待持久化过程结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何I/O操作的。确保了极高的性能。==如果需要进行大规模数据恢复，且对数据回复的完整性不是非常敏感，哪RDB方式比AOF要更加高效。==RDB的缺点就是最后一次持久化后的数据可能丢失。默认使用RDB，一般不会修改.

rdb保存的文件是dump.rdb

rdg的redis.conf配置

触发文件保存机制

1、满足save规则 触发规则，产生文件

2、执行flushall命令，触发规则，产生文件

3、退出Redis，触发规则，产生文件

备份自动生成dump.rdb文件

恢复rdb文件

1. 只需要将rdb文件放在Redis的启动目录下，redis启动时自动检查dump.rdb，恢复数据

2. 查看需要存放的位置：

   

优点：

适合大规模数据恢复(如果对数据的完整性要求不高)

缺点：

1、需要一定的时间间隔进行操作，如果意外宕机了，时间间隔内修改的数据就没有了

2、fork进程时，会占用一定的内存空间

AOF（Append Only File）

概念：以日志的形式记录每个写操作，将redis执行过的所有命令记录下来(读操作不记录)，只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作！

Aof保存的是appendonly.aof

append

如果aof文件有错位，redis会启动不起来，我们要修复aof文件

redis提供了一个redis-check-aof --fix (丢弃错误数据)

优点：

1、每一次修改都同步，文件完整性更好！

2、每秒同步，可能会丢失数据！

3、不同步，效率高

缺点：

1、对应数据文件来说，aof远远大于rdb，修复速度比rdb慢！

2、AOF运行效率比RDB慢，所以redis默认配置是rdb

重写

如果aof文件大于64mb，fork一个新的进程进行重写操作！

Redis发布订阅

Redis发布订阅(pub/sub)是一种消息通讯模式：发送者(pub)发送消息，订阅者(sub)接收消息。(微博、微信、抖音的关注系统)

Redis客户端可以订阅任意数量的频道。

订阅/发布消息图：

第一个：消息发送者，第二个：频道 第三个：消息订阅者

Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。

Redis 客户端可以订阅任意数量的频道。

下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

Redis发布订阅指令

使用测试

#发送端
127.0.0.1:6379> publish sjp "live hard"  #向频道发布订阅消息
(integer) 1

#订阅端
127.0.0.1:6379> SUBSCRIBE sjp                 #订阅频道
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "sjp"
3) (integer) 1                                #发布消息后
1) "message"
2) "sjp"
3) "live hard"

发布订阅原理

Redis是使用C实现的，通过分析Redis源码中的pubsub.c文件，了解发布和订阅机制的底层实现，加深对redis的理解。

Redis是通过PUBLISH、SUBSCRIBE、PSUBSCRIBE等命令实现发布和订阅功能的。

通过SUBSCRIBE命令订阅某频道后，redis-server里维护了一个字典，字典的键就是一个个channel，而字典的值就是一个链表，链表中保存了所有订阅这个channel的客户端。SUBSCRIBE命令的关系，就是将客户端添加到给定channel字典中查找记录了订阅这个频道的所有客户端链表，遍历这个链表，将消息发布给所有订阅者。

Pub/Sub从字面上理解就是发布(Publish)与订阅(Subscribe),在Redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统，如：即时聊天，群聊等。

使用场景

1. 实时消息系统！
2. 实时聊天（频道当作聊天室，信息回显给所有人）
3. 订阅、关注系统

复杂场景使用消息中间件 Kafka mq

Redis主从复制

主从复制,是指将一台Redis服务器的数据，复制到其他的Redis服务器，前者称为主节点(master/leader)，后者称为从节点（slave/follower）,数据的复制是单向的，只能由主节点到从节点，主机(master)以写为主，从机(slave)以读为主。

默认情况下，每个Redis服务器都是主节点；且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。

主从复制的作用：

1、数据冗余：主从复制实现数据热备份，是持久化之外的一种数据冗余方式。

2、故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速故障恢复，实际上是一中服务的冗余。

3、负载均衡：在主从复制基础上，配合读写分离，由主节点提供写服务，从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器并发量！

4、高可用（集群）基石：主从复制还是哨兵和集群能够实施的接触，因此主从复制是Redis高可用的基础。

一般来说，要将Redis运用于工程项目中，只是用一台Redis是万万不能的（宕机），原因：

1、结构上：单个Redis服务器会发生单点故障，且一台服务器需要处理所有的请求负载，压力较大；

2、容量上：单个Redis服务器内存容量有限，就算一台Redis服务器的内存容量为256G，也不能将所有内存用作Redis存储内存。一般来说，单台Redis最大使用内存不应该超过20G！

电商网站上的商品，一般都是一次上传，无限浏览，多读少写，使用一主多从架构！

一主二从 slaveof [地址] [端口] (设置主机) 一次性

在conf配置为永久：

主机才能写，主机只能读！！！！

主机断开连接，从机依旧连接到主机，但是没有写操作，只有读操作！如果主机恢复了，从机依然可以拿到主机的数据信息！从机断了，再次重连也是可以读到数据的！

复制原理

1、Slave启动成功连接到master后会发送一个sync同步命令

2、Master接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集名利，在后台进程执行完毕后，master将传送整个文件到slave，完成一次完全的同步！

• 全量复制：slave服务接收到数据库文件数据后，将其存盘并加载到内存中。
• 增量复制：Master继续将新的所有收集到的修改命令依次传给slave，完成同步。
• 只要是重新连接master，一个完全同步（全量复制）将会被自动执行，我们的数据一点可以在从机中看到！

串联

如果没有主机，可以手动由从机设置出一个主机 slaveof no one,但是原来的主机回复后，不会自动让回主机位置 ，需要重新配置（谋朝篡位）

哨兵模式（重点！！）(自动选取主机)

概述

(自动选主机的方式）
主从切换技术：当主机宕机后，需要手动把一台从（slave）服务器切换为主服务器，这就需要人工干预，费时费力，还回造成一段时间内服务不可用，Redis从2.8就正式提供了哨兵（Sentinel）架构来解决这个问题。

上面谋朝篡位的自动版，能够监控主机是否故障或宕机，如果故障了就根据投票数自动将从库（slave）转化为主库（master）。

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它独立运行。其原理是==哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。==

哨兵模式有两个作用：

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

当一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此可以使用哨兵进行监控， 各个哨兵之间还会进行监控，这就形成了多哨兵模式。

以上过程：假设主服务器宕机，哨兵1先检测到结果，但是系统并不会马上进行failover过程，仅仅是哨兵1主观认为主服务器不可以用，这个现象称为主观下线，当后面的哨兵也检测到主服务器不可用，并且数量达到一定时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover故障转移操作。
操作转移成功后。就会发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这一过程称为客观下线

测试使用

1、配置哨兵配置文件sentinel.conf

#sentinel monitor 被监控的名称 host port 1
sentinel monitor myredis 127.0.0.1 6379 1

后面的数字1表示同意主节点不可用的sentinel数量，达到就投票更换主机

2、启动哨兵

redis-sentinel config/senticel.conf

如果哨兵选完新的主机后，原主机恢复使用了，会自动配置为新的主机的从机—哨兵模式规则

总结

优点：

1、哨兵集群，基于主从复制，所有主从配置的优点，它都有

2、主从可以切换 ，故障可以转移，系统可用性更高

3、哨兵模式就是主从模式的升级，手动变为了自动，更加健壮

缺点：

1、Redis不好在线扩容，集群容量一旦达到上限，在线扩容就十分麻烦！

2、哨兵模式的实现的配置比较繁琐，有许多选择

Redis缓存穿透和雪崩(重点！！)

缓存穿透（查不到导致）

概念

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

解决方案

1.布隆过滤器

布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的压力

---

2、缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时设置一个过期时间，之后再访问这个数据会从缓存中获取，保护了后端数据源。

缓存空对象存在两个问题：

1、如果空值能被缓存起来，这就意味着缓存需要更多的空间存储更多的键

2、即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间的窗口不

缓存击穿（量太大，缓存过期！）

缓存击穿（访问量过大）：某一个key 非常热点，在不停的扛着大的并发，大并发集中对这个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库。
当某个key过期的瞬间，就会有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导致数据库瞬间压力过大。

解决方案

1、设置热点数据永不过期

从缓存层面来看，没有设置过期时间，所以不会出现热点key过期后产生的问题。

2、加互斥锁

分布式锁：使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大

缓存雪崩

概念

缓存雪崩：指在某一个时间段，缓存集中过期失效，Redis宕机
比如 ：双十一零点，抢购，这波商品应该放在缓存区，假设缓存一小时，到了凌晨一点，商品缓存过期，而对于这批商品的访问，都跑到数据库中，对于数据库，产生周期性的压力波峰。所有请求都会到达存储层，存储层的调用量增加，造成存储层崩坏（缓存服务节点的宕机，对数据库服务器造成的压力不可预知）。

数据集中过期并不是非常致命。知名的缓存雪崩是缓存服务器某个节点宕机或者断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，可能瞬间就把数据库压垮！！ 关掉其他不必要服务，保证主要服务！！！

解决方案

1、redis高可用

既然redis可能挂掉，多设几台redis，这样一台redis挂断后还可以继续工作，其实就是搭建的集群(异地多活！！)

2、限流降级

在缓存失效后，通过加锁或者队列来控制读写数据库，写缓存的线程数量。不如某个key只允许一个线程查询和写缓存，其他线程等待。

3、数据预热

在正式部署之前，先把可能的数据预先访问一边，可能大梁访问的数据就会加载到缓存中。在即将发生大并发访问之前手动舒服加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量匀称！