redis

1 CAP原则

CAP原则又称CAP定理，指的是在一个分布式系统中， Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可得兼。
一致性（C）：在分布式系统中的所有数据备份，在同一时刻是否同样的值。（等同于所有节点访问同一份最新的数据副本）
可用性（A）：在集群中一部分节点故障后，集群整体是否还能响应客户端对数据更新具备高可用性）
分区容忍性（P）：以实际效果而言，分区相当于对通信的时限要求。系统如果不能在时限内达成数据一致性，就意味着发生了分区的情况，必须就当前操作在C和A之间做出选择。

2 Redis介绍

Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。Redis是单线程的。
Redis以内存作为数据存储介质，所以读写数据的效率极高，远远超过数据库。以设置和获取一个256字节字符串为例，它的读取速度可高达110000次/s，写速度高达81000次/s。

3 Redis在centos下安装

3.1 下载安装包并解压

wget http://download.redis.io/releases/redis-5.0.8.tar.gz ./
tar -zxvf redis-5.0.8.tar.gz

3.2 安装依赖与redis

yum install gcc-c++
make & make install

默认安装路径：/usr/local/bin

3.3 复制配置文件到安装目录，以便自定义配置启动

 cp ~/redis-5.0.8/^Cdis.conf /usr/local/bin/

3.4 设置后台启动

设置后台启动

3.5 启动redis服务，并测试连接

./redis-server redis.conf 
./redis-cli

测试redis

3.5 关闭redis服务

关闭redis

查看后发现后台已无redis进程，也可以通过kill强制关闭

4 五大数据类型

4.1 String字符串

[root@master bin]# ./redis-cli 
127.0.0.1:6379> set aa aa #设置aa的值为aa
OK
127.0.0.1:6379> get aa #获取aa的值
"aa"
127.0.0.1:6379> keys * #查看当前所有键
1) "aa"
127.0.0.1:6379> exists aa  #判断key=aa是否存在
(integer) 1
127.0.0.1:6379> append aa bb  #若aa存在，则在aa的值后添加bb，若不存在则设置aa为bb
(integer) 4
127.0.0.1:6379> get aa
"aabb"
127.0.0.1:6379> strlen aa #获取aa的字符串长度
(integer) 4
127.0.0.1:6379> set bb 0
OK
127.0.0.1:6379> get bb
"0"
127.0.0.1:6379> incr bb  #将bb的value+1
(integer) 1
127.0.0.1:6379> get bb
"1"
127.0.0.1:6379> decr bb #将bb的value-1
(integer) 0
127.0.0.1:6379> get bb
"0"
127.0.0.1:6379> incrby bb 5 #将bb的value+5
(integer) 5
127.0.0.1:6379> get bb
"5"
127.0.0.1:6379> decrby bb 3 #将bb的value-3
(integer) 2
127.0.0.1:6379> get bb
"2"
127.0.0.1:6379> set cc "hello,world"
OK
127.0.0.1:6379> get cc
"hello,world"
127.0.0.1:6379> getrange cc 0 4 #输出key为cc的value中的0-4位
"hello"
127.0.0.1:6379> getrange cc 0 -1 #等价于get cc
"hello,world"
127.0.0.1:6379> setrange cc 6 china #将key为cc的值中第6位开始的相应位置换成china
(integer) 11
127.0.0.1:6379> get cc
"hello,china"
127.0.0.1:6379> setex dd 20 "hello" #设置过期时间20秒
OK
127.0.0.1:6379> ttl dd  #查看剩余有效时间（秒）
(integer) 16
127.0.0.1:6379> get dd
"hello"
127.0.0.1:6379> get dd
(nil)
127.0.0.1:6379> set dd test
OK
127.0.0.1:6379> setnx dd test1 #如果dd不存在就创建，存在则不替换
(integer) 0
127.0.0.1:6379> get dd
"test"
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 # 同时设置多个值
OK
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字符来保存一个对象
OK
127.0.0.1:6379> getset ee test # 如果不存在值，则返回 nil，并将值设置为test
(nil)
127.0.0.1:6379> get ee
"test"
127.0.0.1:6379> getset ee test1 # 如果存在值，获取原来的值test，并设置新的值test1
"test"
127.0.0.1:6379> get ee
"test1"

4.2 List列表

127.0.0.1:6379> lpush list a #将一个或者多个值，插入到名为list的列表的左边
(integer) 1
127.0.0.1:6379> lpush list b
(integer) 2
127.0.0.1:6379> lpush list c
(integer) 3
127.0.0.1:6379> lrange list 0 -1 #获取list中的所有元素
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> lrange list 0 1
1) "c"
2) "b"
127.0.0.1:6379> rpush list d #将一个或者多个值，插入到名为list的列表的右边
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "c"
2) "b"
3) "a"
4) "d"
127.0.0.1:6379> lpop list  #将list列表左边第一个元素弹出
"c"
127.0.0.1:6379> rpop list #将list列表右边第一个元素弹出
"d"
127.0.0.1:6379> lrange list 0 -1
1) "b"
2) "a"
127.0.0.1:6379> lindex list 1  #获取list中下表为1的元素
"a"
127.0.0.1:6379> llen list  #获取列表长度
(integer) 2
127.0.0.1:6379> lpush list a
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "a"
2) "b"
3) "a"
127.0.0.1:6379> lrem list 2 a  #移除list中指定个数的值，这里是移除2个a
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "b"
127.0.0.1:6379> exists list  #判断列表list是否存在
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "b"
127.0.0.1:6379> lpush list a
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "a"
2) "b"
127.0.0.1:6379> linsert list before b e  #在list中的b元素前面插入e
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "a"
2) "e"
3) "b"
127.0.0.1:6379> linsert list after e d #在list中的e元素后面插入d
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "a"
2) "e"
3) "d"
4) "b"

ps:其实redis中的List是一个链表，如果key存在，就新增内容，不存在则创建链表

4.3 Set集合（值不能重复）

127.0.0.1:6379> sadd set hello  #往名为set的集合中添加元素hello
(integer) 1
127.0.0.1:6379> sadd set world
(integer) 1
127.0.0.1:6379> sadd set ok
(integer) 1
127.0.0.1:6379> smembers set  #查看set中的所有元素
1) "ok"
2) "world"
3) "hello"
127.0.0.1:6379> sismember set ok  #判断set集合中是否有元素值为ok
(integer) 1
127.0.0.1:6379> scard set  #查看set集合中的元素个数
(integer) 3
127.0.0.1:6379> srem set hello #移除set中的指定元素
(integer) 1
127.0.0.1:6379> smembers set
1) "ok"
2) "world"
127.0.0.1:6379> srandmember set  #随机选出一个元素
"ok"
127.0.0.1:6379> srandmember set 2 #随机选出两个元素
1) "world"
2) "ok"
127.0.0.1:6379> spop set #随机删除集合中的一个元素
"ok"
127.0.0.1:6379> srandmember set
"world"
127.0.0.1:6379> sadd set1 a
(integer) 1
127.0.0.1:6379> sadd set1 b
(integer) 1
127.0.0.1:6379> sadd set1 c
(integer) 1
127.0.0.1:6379> sadd set2 d
(integer) 1
127.0.0.1:6379> sadd set2 e
(integer) 1
127.0.0.1:6379> sadd set2 f
(integer) 1
127.0.0.1:6379> smembers set1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> smembers set2
1) "e"
2) "d"
3) "f"
127.0.0.1:6379> smove set1 set2 a  #将set1中的a移动到set2中
(integer) 1
127.0.0.1:6379> smembers set1
1) "b"
2) "c"
127.0.0.1:6379> smembers set2
1) "a"
2) "e"
3) "d"
4) "f"
127.0.0.1:6379> sadd set3 a
(integer) 1
127.0.0.1:6379> sadd set3 b
(integer) 1
127.0.0.1:6379> sadd set3 c
(integer) 1
127.0.0.1:6379> sadd set4 b
(integer) 1
127.0.0.1:6379> sadd set4 c
(integer) 1
127.0.0.1:6379> sadd set4 d
(integer) 1
127.0.0.1:6379> smembers set3
1) "a"
2) "c"
3) "b"
127.0.0.1:6379> smembers set4
1) "d"
2) "c"
3) "b"
127.0.0.1:6379> sdiff set3 set4  #求差集
1) "a"
127.0.0.1:6379> sinter set3 set4 #求交集
1) "c"
2) "b"
127.0.0.1:6379> sunion set3 set4 #求并集
1) "b"
2) "c"
3) "d"
4) "a"

4.4 Hash哈希

值是一个map集合

127.0.0.1:6379> hset hash name zhangsan  #设置一个具体的map
(integer) 1
127.0.0.1:6379> hget hash name #获取字段值
"zhangsan"
127.0.0.1:6379> hmset hash age 20 hobby football #同时设置两个值
OK
127.0.0.1:6379> hgetall hash #获取所有的键值
1) "name"
2) "zhangsan"
3) "age"
4) "20"
5) "hobby"
6) "football"
127.0.0.1:6379> hdel hash hobby  #删除hobby
(integer) 1
127.0.0.1:6379> hgetall hash 
1) "name"
2) "zhangsan"
3) "age"
4) "20"
127.0.0.1:6379> hlen hash #获取hash表的元素数量
(integer) 2
127.0.0.1:6379> hexists hash name  #判断key=name是否存在
(integer) 1
127.0.0.1:6379> hkeys hash #获取所有的key
1) "name"
2) "age"
127.0.0.1:6379> hvals hash #获取所有的value
1) "zhangsan"
2) "20"
127.0.0.1:6379> hincrby hash age 5  #将age的值+5
(integer) 25
127.0.0.1:6379> hvals hash
1) "zhangsan"
2) "25"

4.5 Zset有序集合

127.0.0.1:6379> zadd zset 1 a  #设置一个a，并设置分数为1
(integer) 1
127.0.0.1:6379> zadd zset 2 b 3 c
(integer) 2
127.0.0.1:6379> zrange zset 0 -1 #查看zset中的所有元素
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> zrangebyscore zset -inf +inf #将zset中的元素按score值从小到大排序
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> zrevrange zset 0 -1 #将zset中的元素按score值从大到小排序
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> zrangebyscore zset -inf +inf withscores #将zset中的元素按score值从小到大排序并显示score值
1) "a"
2) "1"
3) "b"
4) "2"
5) "c"
6) "3"
127.0.0.1:6379> zrangebyscore zset -inf 2 withscores #将zset中的元素按score值从小到大排序且score小于2并显示score值
1) "a"
2) "1"
3) "b"
4) "2"
127.0.0.1:6379> zcard zset #获取zset中的元素个数
(integer) 3
127.0.0.1:6379> zcount zset 1 2  #获取score在指定区内的元素个数
(integer) 2

5 事务

Redis 事务可以一次执行多个命令，并且带有以下三个重要的保证：（不保证原子性）

批量操作在发送 EXEC 命令前被放入队列缓存。
收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：

开启事务。（multi）
命令入队。
执行事务。

127.0.0.1:6379> MULTI #开启事务
OK
127.0.0.1:6379> set k1 v1 ##指令入队
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> EXEC #执行事务
1) OK
2) OK
3) "v2"
4) OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> DISCARD #取消事务
OK
127.0.0.1:6379> get k4 #队列中的命令都不会被执行
(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"

6 监控 Watch

悲观锁：很悲观，认为什么时候都会出问题，无论做什么都会加锁！
乐观锁：很乐观，认为什么时候都不会出问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过这个数据，获取version，更新的时候比较 version

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money  # 监视 money 元素，事务成功后监控就会失效
OK
127.0.0.1:6379> multi # 事务正常结束，数据期间没有发生变动，这个时候就正常执行成功！
OK
127.0.0.1:6379> 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)

如果修改失败，获取最新的值就好，可以采用自旋锁

监控

7 Springboot整合Redis

引入redis依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.编写配置

spring:
  redis:
    host: 192.168.85.128
    port: 6379

ps：需将虚拟机中redis的配置文件redis.conf中的bind 127.0.0.1改为bind 0.0.0.0，否则只能本机访问，外网无法链接。

    //注入redis
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        // redisTemplate 操作不同的数据类型，api和我们的指令是一样的
        // opsForValue 操作字符串 类似String
        // opsForList 操作List 类似List
        // opsForSet
        // opsForHash
        // opsForZSet
        // opsForGeo
        // opsForHyperLogLog
        redisTemplate.opsForValue().set("aaa","测试"); //定义一个字符串类型元素，将aaa=测试
        System.out.println(redisTemplate.opsForValue().get("aaa")); //输出aaa的值
    }

当存储对象时，对象需要序列化，或将对象转换为json字符串进行存储
若需要改变默认创建的redisTemplate，可以重写方法，注册到Bean中，比如默认采用的jdk序列化我不需要，可以重写变为json序列化

// 固定模板
    // 自己定义了一个 RedisTemplate
    @Bean("RedisTemplate")
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String,
                Object>();
        template.setConnectionFactory(factory);
        // 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;
    }

8 redis.conf详解

网络

bind 127.0.0.1 # 绑定的ip
protected-mode yes # 保护模式
port 6379 # 端口设置

通用 GENERAL

daemonize yes # 以守护进程的方式运行，默认是 no，我们需要自己开启为yes！
pidfile /var/run/redis_6379.pid # 如果以后台的方式运行，我们就需要指定一个 pid 文件！
# 日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably) 生产环境
# warning (only very important / critical messages are logged)
loglevel notice
logfile "" # 日志的文件位置名
databases 16 # 数据库的数量，默认是 16 个数据库
always-show-logo yes # 是否总是显示LOGO

快照(主要用于持久化)

# 如果900s内，如果至少有一个1 key进行了修改，我们及进行持久化操作
save 900 1
# 如果300s内，如果至少10 key进行了修改，我们及进行持久化操作
save 300 10
# 如果60s内，如果至少10000 key进行了修改，我们及进行持久化操作
save 60 10000
# 我们之后学习持久化，会自己定义这个测试！
stop-writes-on-bgsave-error yes # 持久化如果出错，是否还需要继续工作！
rdbcompression yes # 是否压缩 rdb 文件，需要消耗一些cpu资源！
rdbchecksum yes # 保存rdb文件的时候，进行错误的检查校验！
dir ./ # rdb 文件保存的目录！

SECURITY 安全

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 # 内存到达上限之后的处理策略
1、volatile-lru：只对设置了过期时间的key进行LRU（默认值）
2、allkeys-lru ： 删除lru算法的key
3、volatile-random：随机删除即将过期key
4、allkeys-random：随机删除
5、volatile-ttl ： 删除即将过期的
6、noeviction ： 永不过期，返回错误

APPEND ONLY 模式 aof配置(持久化)

appendonly no # 默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下，rdb完全够用！
appendfilename "appendonly.aof" # 持久化的文件的名字
# appendfsync always # 每次修改都会 sync。消耗性能
appendfsync everysec # 每秒执行一次 sync，可能会丢失这1s的数据！
# appendfsync no # 不执行 sync，这个时候操作系统自己同步数据，速度最快！

9 Redis持久化

Redis 是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。

9.1 RDB持久化

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

RDB持久化

rdb文件生成触发机制：

save的规则满足的情况下，会自动触发rdb规则
执行 flushall 命令，也会触发我们的rdb规则！
退出redis，也会产生 rdb 文件！

恢复rdb文件

只需要将rdb文件放在redis配置文件配置的目录就可以，redis启动的时候会自动检查dump.rdb并恢复其中的数据！

优点：

适合大规模的数据恢复！
对数据的完整性要不高！

缺点：

需要一定的时间间隔进程操作！如果redis意外宕机了，这个最后一次修改数据就没有的了！
fork进程的时候，会占用一定的内容空间！！

9.2 AOF

默认不开启。以日志的形式来记录每个写操作，将Redis执行过的所有指令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。Aof保存的是 appendonly.aof 文件，在配置文件中有配置，可以在配置文件中修改。

AOF持久化

修复aof文件 redis-check-aof --fix appendonly.aof
优点：

每一次修改都同步，文件的完整会更加好！
每秒同步一次，可能会丢失一秒的数据
从不同步，效率最高的！

缺点：

相对于数据文件来说，aof远远大于 rdb，修复的速度也比 rdb慢！
Aof 运行效率也要比 rdb 慢，所以我们redis默认的配置就是rdb持久化！

扩展：

RDB 持久化方式能够在指定的时间间隔内对你的数据进行快照存储
AOF 持久化方式记录每次对服务器的写操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis 协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化
同时开启两种持久化方式

在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
RDB 的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢？作者建议不要，因为RDB更适合用于备份数据库（AOF在不断变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。

性能建议

因为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文件，载入较新的那个，微博就是这种架构。

10 Redis主从复制

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

主从复制的作用主要包括：

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

查看当前主从信息

127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:0
master_replid:4432ae524bf805cbdd7e701f2c28d75dd56e37e1
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个配置文件，然后修改对应的信息：

端口
pid 名字
log文件名字
dump.rdb 名字

修改完毕之后，启动我们的3个redis服务器，可以通过进程信息查看！

redis启动情况

配置主从复制很简单，只需要在从机配置文件中加入主机信息即可。修改从机的配置文件，将配置主机ip与端口

replicaof 127.0.0.1 6379

重新启动从机，再次查看角色情况

主机角色

从机1角色

从机2角色

可以发现，主机角色位master，从机角色为slave，从机只能读不能写。，但是此时若主节点挂了从节点无法自动切换为主节点，需要手动切换，这时候就可以使用哨兵模式，来帮助我们管理主从切换。

复制原理

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

哨兵模式
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独
立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。

哨兵模式

这里的哨兵有两个作用：

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

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

多哨兵监控Redis

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

配置哨兵模式

创建配置文件sentinel.conf
配置哨兵

# 禁止保护模式
protected-mode no
# 配置监听的主服务器，这里sentinel monitor代表监控，mymaster代表服务器的名称，可以自定义，127.0.0.1代表监控的主服务器，6379代表端口。
sentinel monitor mymaster 127.0.0.1 6379 1

数字1，表示主机挂掉后salve投票看让谁接替成为主机，得票数多少后成为主机。
数字2，表示只有两个或两个以上的哨兵认为主服务器不可用的时候，才会进行failover操作。

启动哨兵

./redis-sentinel kconfig/sentinel.conf

如果主机此时回来了，只能归并到新的主机下，当做从机，这就是哨兵模式的规则！

优点：

哨兵集群，基于主从复制模式，所有的主从配置优点，它全有
主从可以切换，故障可以转移，系统的可用性就会更好
哨兵模式就是主从模式的升级，手动到自动，更加健壮

缺点：

Redis不好在线扩容，集群容量一旦到达上限，在线扩容就十分麻烦
实现哨兵模式的配置其实是很麻烦的，里面有很多选择

哨兵模式的全部配置

# 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 <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-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的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被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout <master-name> <milliseconds>
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则：
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
#通知脚本
# shell编程
# 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 # 一般都是由运维来配置！

11 Redis缓存穿透与雪崩

11.1 缓存穿透

image.png

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

解决方案

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

布隆过滤器

首先是对所有可能查询的参数以hash形式存储，当用户想要查询的时候，使用布隆过滤器发现不在集合中，就直接丢弃，不再对持久层查询。

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

缓存空对象

存在两个问题：

造成了存储浪费，存储了很多值为空的键
数据一致性问题，可能造成缓存层和存储层的数据不一致，可能对业务造成影响。

11.2 缓存击穿

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

解决方案

设置热点数据永不过期
加互斥锁
分布式锁：使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待，然后查询当线程查询完后给key赋值，其他线程从key中取。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。

11.3 缓存雪崩

缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis 宕机。
比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。

解决方案

搭建分布式redis集群，尽可能多的增加redis服务器
限流降级，缓存失效后，通过加锁或者队列来控制都数据库写缓存的线程数量。
数据预热，在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

redis

1 CAP原则

2 Redis介绍

3 Redis在centos下安装

3.1 下载安装包并解压

3.2 安装依赖与redis

3.3 复制配置文件到安装目录，以便自定义配置启动

3.4 设置后台启动

3.5 启动redis服务，并测试连接

3.5 关闭redis服务

4 五大数据类型

4.1 String字符串

4.2 List列表

4.3 Set集合（值不能重复）

4.4 Hash哈希

4.5 Zset有序集合

5 事务

6 监控 Watch

7 Springboot整合Redis

8 redis.conf详解

9 Redis持久化

9.1 RDB持久化

9.2 AOF

10 Redis主从复制

11 Redis缓存穿透与雪崩

11.1 缓存穿透

11.2 缓存击穿

11.3 缓存雪崩

推荐阅读更多精彩内容