Redis学习笔记

Author：Eric

Version：9.0.1

目录

• 一、引言
  • 1.1 数据库压力过大
  • 1.2 数据不同步
  • 1.3 传统锁失效
• 二、Redis介绍
  • 2.1 NoSQL介绍
  • 2.2 Redis介绍
• 三、Redis安装
  • 3.1 安装Redis
  • 3.2 使用redis-cli连接Redis
  • 3.3 使用图形化界面连接Redis
• 四、Redis常用命令
  • 4.1 Redis存储数据的结构
  • 4.2 string常用命令
  • 4.3 hash常用命令
  • 4.4 list常用命令
  • 4.5 set常用命令
  • 4.6 zset的常用命令
  • 4.7 key常用命令
  • 4.8 库的常用命令
• 五、Java连接Redis
  • 5.1 Jedis连接Redis
    • 5.1.1 创建Maven工程
    • 5.1.2 导入需要的依赖
    • 5.1.3 测试
  • 5.2 Jedis存储一个对象到Redis以byte[]的形式
    • 5.2.1 准备一个User实体类
    • 5.2.2 导入spring-context依赖
    • 5.2.3 创建Demo测试类，编写内容
  • 5.3 Jedis存储一个对象到Redis以String的形式
    • 5.3.1 导入依赖
    • 5.3.2 测试
  • 5.4 Jedis连接池的操作
  • 5.5 Redis的管道（流水线）操作
• 六、Redis其他配置及集群
  • 6.1 Redis的AUTH
  • 6.2 Redis的事务
  • 6.3 Redis持久化机制
    • 6.3.1 RDB
    • 6.3.2 AOF
    • 6.3.3 注意事项
  • 6.4 Redis的主从架构
  • 6.5 哨兵
  • 6.6 Redis的集群
  • 6.7 Java连接Redis集群
• 七、Redis常见问题
  • 7.1 key的生存时间到了，Redis会立即删除吗？
  • 7.2 Redis的淘汰机制
  • 7.3 缓存的常问题
    • 7.3.1 缓存穿透问题
    • 7.3.2 缓存击穿问题
    • 7.3.3 缓存雪崩问题
    • 7.3.4 缓存倾斜问题

一、引言

---

1.1 数据库压力过大

由于用户量增大，请求数量也随之增大，数据库压力过大

1.2 数据不同步

多台服务器之间，数据不同步

1.3 传统锁失效

多台服务器之间的锁，已经不存在互斥性了。

由Redis来解决上述的问题

二、Redis介绍

---

2.1 NoSQL介绍

• Redis就是一款NoSQL。

• NoSQL -> 非关系型数据库 -> Not Only SQL。

• Key-Value：Redis。。。

• 文档型：ElasticSearch，Solr，Mongodb。。。

• 面向列：Hbase，Cassandra。。。

• 图形化：Neo4j。。。

• 除了关系型数据库都是非关系型数据库。

• NoSQL只是一种概念，泛指非关系型数据库，和关系型数据库做一个区分。

2.2 Redis介绍

• 有一位意大利人，在开发一款LLOOGG的统计页面，因为MySQL的性能不好，自己研发了一款非关系型数据库，并命名为Redis。Salvatore。

• Redis（Remote Dictionary Server）即远程字典服务，Redis是由C语言去编写，Redis是一款基于Key-Value的NoSQL，而且Redis是基于内存存储数据的，Redis还提供了多种持久化机制，性能可以达到110000/s读取数据以及81000/s写入数据，Redis还提供了主从，哨兵以及集群的搭建方式，可以更方便的横向扩展以及垂直扩展。

Redis之父

三、Redis安装

---

3.1 安装Redis

Docker-Compose安装

version: '3.1'
services:
  redis:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379

3.2 使用redis-cli连接Redis

进去Redis容器的内部

docker exec -it 容器id bash

在容器内部，使用redis-cli连接

链接效果

3.3 使用图形化界面连接Redis

下载地址：https://github.com/lework/RedisDesktopManager-Windows/releases/download/2019.5/redis-desktop-manager-2019.5.zip

傻瓜式安装

RedisDesktopManager

四、Redis常用命令

---

4.1 Redis存储数据的结构

常用的5种数据结构：

• key-string：一个key对应一个值。
• key-hash：一个key对应一个Map。
• key-list：一个key对应一个列表。
• key-set：一个key对应一个集合。
• key-zset：一个key对应一个有序的集合。

另外三种数据结构：

• HyperLogLog：计算近似值的。
• GEO：地理位置。
• BIT：一般存储的也是一个字符串，存储的是一个byte[]。

五种常用的存储数据结构图

• key-string：最常用的，一般用于存储一个值。

• key-hash：存储一个对象数据的。

• key-list：使用list结构实现栈和队列结构。

• key-set：交集，差集和并集的操作。

• key-zset：排行榜，积分存储等操作。

4.2 string常用命令

string常用操作命令

#1.  添加值
set key value

#2. 取值
get key

#3. 批量操作
mset key value [key value...]
mget key [key...]

#4. 自增命令（自增1）
incr key 

#5. 自减命令（自减1）
decr key

#6. 自增或自减指定数量
incrby key increment
decrby key increment

#7. 设置值的同时，指定生存时间（每次向Redis中添加数据时，尽量都设置上生存时间）
setex key second value

#8. 设置值，如果当前key不存在的话（如果这个key存在，什么事都不做，如果这个key不存在，和set命令一样）
setnx key value

#9. 在key对应的value后，追加内容
append key value

#10. 查看value字符串的长度
strlen key

4.3 hash常用命令

hash常用命令

#1. 存储数据
hset key field value

#2. 获取数据
hget key field

#3. 批量操作
hmset key field value [field value ...]
hmget key field [field ...]

#4. 自增（指定自增的值）
hincrby key field increment

#5. 设置值（如果key-field不存在，那么就正常添加，如果存在，什么事都不做）
hsetnx key field value

#6. 检查field是否存在，存在则返回1，不存在则返回0
hexists key field 

#7. 删除key对应的field，可以删除多个
hdel key field [field ...]

#8. 获取当前hash结构中的全部field和value
hgetall key

#9. 获取当前hash结构中的全部field
hkeys key

#10. 获取当前hash结构中的全部value
hvals key

#11. 获取当前hash结构中field的数量
hlen key

4.4 list常用命令

list常用命令

#1. 存储数据（从左侧插入数据，从右侧插入数据）
lpush key value [value ...]
rpush key value [value ...]

#2. 存储数据（如果key不存在，什么事都不做，如果key存在，但是不是list结构，什么都不做）
lpushx key value
rpushx key value

#3. 修改数据（在存储数据时，指定好你的索引位置,覆盖之前索引位置的数据，index超出整个列表的长度，也会失败）
lset key index value

#4. 弹栈方式获取数据（左侧弹出数据，从右侧弹出数据）
lpop key
rpop key

#5. 查看指定索引范围的数据（start从0开始，stop输入-1，代表最后一个，-2代表倒数第二个）
lrange key start stop

#6. 查看指定索引位置的数据
lindex key index

#7. 查看整个列表的长度
llen key

#8. 删除列表中的数据（他是删除当前列表中的count个value值，count > 0从左侧向右侧删除，count < 0从右侧向左侧删除，count == 0删除列表中全部的value）
lrem key count value

#9. 保留列表中的数据（保留你指定索引范围内的数据，超过整个索引范围被移除掉）
ltrim key start stop

#10. 将一个列表中最后的一个数据，插入到另外一个列表的头部位置
rpoplpush list1 list2

4.5 set常用命令

set常用命令

#1. 存储数据
sadd key member [member ...]

#2. 查看数据（获取全部数据）
smembers key

#3. 随机获取一个数据（获取的同时，移除数据，count默认为1，代表弹出数据的数量）
spop key [count]

#4. 交集（取多个set集合交集）
sinter set1 set2 ...

#5. 并集（获取全部集合中的数据，重复的数据只会输出一个）
sunion set1 set2 ...

#6. 差集（获取多个集合中不一样的数据，要看哪个集合在前面，则展示的是该集合中不一样的数据）
sdiff set1 set2 ...

# 7. 删除数据
srem key member [member ...]

# 8. 查看当前的set集合中是否包含这个值
sismember key member

4.6 zset的常用命令

zset常用命令

#1. 添加数据(score必须是数值。member不允许重复的。)
zadd key score member [score member ...]

#2. 修改member的分数（如果member是存在于key中的，正常增加分数，如果memeber不存在，这个命令就相当于zadd）
zincrby key increment member

#3. 查看指定的member的分数
zscore key member

#4. 获取zset中数据的数量
zcard key

#5. 根据score的范围查询member数量，小于等于，大于等于
zcount key min max

#6. 删除zset中的成员
zrem key member [member...]

#7. 根据分数从小到大排序，获取指定范围内的数据（withscores如果添加这个参数，那么会返回member对应的分数）
zrange key start stop [withscores]

#8. 根据分数从大到小排序，获取指定范围内的数据（withscores如果添加这个参数，那么会返回member对应的分数）
zrevrange key start stop [withscores]

#9. 根据分数的范围去查看member(withscores代表同时返回score，添加limit，就和MySQL中一样，如果不希望等于min或者max的值被查询出来可以采用 ‘(分数’ 相当于 < 但是不等于的方式，最大值和最小值使用+inf和-inf来标识)
zrangebyscore key min max [withscores] [limit offset count]

#10. 根据分数的范围去查看member(withscores代表同时返回score，添加limit，就和MySQL中一样)
zrevrangebyscore key max min [withscores] [limit offset count]

4.7 key常用命令

key常用命令

#1. 查看Redis中的全部的key（pattern：* ，xxx*，*xxx）
keys pattern

#2. 查看某一个key是否存在（1 - key存在，0 - key不存在）
exists key

#3. 删除key
del key [key ...]

#4. 设置key的生存时间，单位为秒，单位为毫秒,设置还能活多久
expire key second
pexpire key milliseconds

#5. 设置key的生存时间，单位为秒，单位为毫秒,设置能活到什么时间点
expireat key timestamp
pexpireat key milliseconds

#6. 查看key的剩余生存时间,单位为秒，单位为毫秒（-2 - 当前key不存在，-1 - 当前key没有设置生存时间，具体剩余的生存时间）
ttl key
pttl key

#7. 移除key的生存时间（1 - 移除成功，0 - key不存在生存时间，key不存在）
persist key

#8. 选择操作的库
select 0~15

#9. 移动key到另外一个库中
move key db

4.8 库的常用命令

db常用命令

#1. 清空当前所在的数据库
flushdb

#2. 清空全部数据库
flushall

#3. 查看当前数据库中有多少个key
dbsize

#4. 查看最后一次操作数据保存到磁盘的时间，时间戳
lastsave

#5. 实时监控Redis服务接收到的命令
monitor

五、Java连接Redis

---

5.1 Jedis连接Redis

5.1.1 创建Maven工程

idea创建

5.1.2 导入需要的依赖

<dependencies>
    <!--    1、 Jedis-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <!--    2、 Junit测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!--    3、 Lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.20</version>
    </dependency>
</dependencies>

5.1.3 测试

public class Demo1 {

    @Test
    public void set(){
        //1. 连接Redis
        Jedis jedis = new Jedis("192.168.199.109",6379);
        //2. 操作Redis - 因为Redis的命令是什么，Jedis的方法就是什么
        jedis.set("name","李四");
        
         jedsi.auth("xx")
        //3. 释放资源
        jedis.close();
    }

    @Test
    public void get(){
        //1. 连接Redis
        Jedis jedis = new Jedis("192.168.199.109",6379);
        //2. 操作Redis - 因为Redis的命令是什么，Jedis的方法就是什么
        String value = jedis.get("name");
        System.out.println(value);
        //3. 释放资源
        jedis.close();
    }
}

5.2 Jedis存储一个对象到Redis以byte[]的形式

5.2.1 准备一个User实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {

    private Integer id;

    private String name;

    private Date birthday;

}

5.2.2 导入spring-context依赖

<!-- 4. 导入spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.6.RELEASE </version>
</dependency>

5.2.3 创建Demo测试类，编写内容

public class Demo2 {

    // 存储对象 - 以byte[]形式存储在Redis中
    @Test
    public void setByteArray(){
        //1. 连接Redis服务
        Jedis jedis = new Jedis("192.168.199.109",6379);
        //------------------------------------------------
        //2.1 准备key(String)-value(User)
        String key = "user";
        User value = new User(1,"张三",new Date());
        //2.2 将key和value转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        byte[] byteValue = SerializationUtils.serialize(value);
        //2.3 将key和value存储到Redis
        jedis.set(byteKey,byteValue);
        //------------------------------------------------
        //3. 释放资源
        jedis.close();
    }

    // 获取对象 - 以byte[]形式在Redis中获取
    @Test
    public void getByteArray(){
        //1. 连接Redis服务
        Jedis jedis = new Jedis("192.168.199.109",6379);
        //------------------------------------------------
        //2.1 准备key
        String key = "user";
        //2.2 将key转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        //2.3 jedis去Redis中获取value
        byte[] value = jedis.get(byteKey);
        //2.4 将value反序列化为User对象
        User user = (User) SerializationUtils.deserialize(value);
        //2.5 输出
        System.out.println("user:" + user);
        //------------------------------------------------
        //3. 释放资源
        jedis.close();
    }

}

5.3 Jedis存储一个对象到Redis以String的形式

5.3.1 导入依赖

<!-- 导入fastJSON -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

5.3.2 测试

public class Demo3 {

    // 存储对象 - 以String形式存储
    @Test
    public void setString(){
        //1. 连接Redis
        Jedis jedis = new Jedis("192.168.199.109",6379);
        //2.1 准备key(String)-value(User)
        String stringKey = "stringUser";
        User value = new User(2,"李四",new Date());
        //2.2 使用fastJSON将value转化为json字符串
        String stringValue = JSON.toJSONString(value);
        //2.3 存储到Redis中
        jedis.set(stringKey,stringValue);
        //3. 释放资源
        jedis.close();
    }


    // 获取对象 - 以String形式获取
    @Test
    public void getString(){
        //1. 连接Redis
        Jedis jedis = new Jedis("192.168.199.109",6379);

        //2.1 准备一个key
        String key = "stringUser";
        //2.2 去Redis中查询value
        String value = jedis.get(key);
        //2.3 将value反序列化为User
        User user = JSON.parseObject(value, User.class);
        //2.4 输出
        System.out.println("user:" + user);

        //3. 释放资源
        jedis.close();
    }
}

5.4 Jedis连接池的操作

使用连接池操作Redis，避免频繁创建和销毁链接对象消耗资源

@Test
public void pool2(){
    //1. 创建连接池配置信息
    GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
    poolConfig.setMaxTotal(100);  // 连接池中最大的活跃数
    poolConfig.setMaxIdle(10);   // 最大空闲数
    poolConfig.setMinIdle(5);   // 最小空闲数
    poolConfig.setMaxWaitMillis(3000);  // 当连接池空了之后,多久没获取到Jedis对象,就超时

    //2. 创建连接池
    JedisPool pool = new JedisPool(poolConfig,"192.168.199.109",6379,5000,"xxx");

    //3. 通过连接池获取jedis对象
    Jedis jedis = pool.getResource();

    //4. 操作
    String value = jedis.get("stringUser");
    System.out.println("user:" + value);

    //5. 释放资源
    jedis.close();
}

5.5 Redis的管道（流水线）操作

因为在操作Redis的时候，执行一个命令需要先发送请求到Redis服务器，这个过程需要经历网络的延迟，Redis还需要给客户端一个响应。

如果我需要一次性执行很多个命令，上述的方式效率很低，可以通过Redis的管道，先将命令放到客户端的一个Pipeline中，之后一次性的将全部命令都发送到Redis服务，Redis服务一次性的将全部的返回结果响应给客户端。

操作多次incr命令的执行过程

使用管道方式执行命令

//  Redis管道的操作
@Test
public void pipeline(){
    //1. 创建连接池
    JedisPool pool = new JedisPool("192.168.199.109",6379);
    long l = System.currentTimeMillis();

    /*//2. 获取一个连接对象
    Jedis jedis = pool.getResource();

    //3. 执行incr - 100000次
    for (int i = 0; i < 100000; i++) {
        jedis.incr("pp");
    }

    //4. 释放资源
    jedis.close();*/

    //================================
    //2. 获取一个连接对象
    Jedis jedis = pool.getResource();
    //3. 创建管道
    Pipeline pipelined = jedis.pipelined();
    //3. 执行incr - 100000次放到管道中
    for (int i = 0; i < 100000; i++) {
        pipelined.incr("qq");
    }
    //4. 执行命令
    pipelined.syncAndReturnAll();
    //5. 释放资源
    jedis.close();

    System.out.println(System.currentTimeMillis() - l);
}

六、Redis其他配置及集群

---

修改yml文件，以方便后期修改Redis配置信息

在docker_redis文件目录下创建一个conf文件夹。再创建一个空的redis.conf文件

/usr/local/redis/redis.conf路径的文件redis容器在运行时不会管它，通过command指定在启动redis服务的同时加载redis.conf这个文件

version: '3.1'
services:
  redis:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379
    volumes:
      - ./conf/redis.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]

6.1 Redis的AUTH

方式一：通过修改Redis的配置文件，实现Redis的密码校验

# redis.conf
requirepass 密码

三种客户端的连接方式

• redis-cli：在输入正常命令之前，先输入auth 密码即可。

• 图形化界面：在连接Redis的信息中添加上验证的密码。

• Jedis客户端：

  • jedis.auth(password);

• 使用JedisPool的方式

// 使用当前有参构造设置密码
public JedisPool(final GenericObjectPoolConfig poolConfig, final String host, int port,int timeout, final String password)

方式二：在不修改redis.conf文件的前提下，在第一次链接Redis时，输入命令：config set requirepass 密码

后续向再次操作Redis时，需要先AUTH做一下校验。注意：如果重启了redis容器，则之前设置的密码就失效了

6.2 Redis的事务

Redis的事务：一次事务操作，该成功的成功，该失败的失败。

先开启事务，执行一系列的命令，但是命令不会立即执行，会被放在一个队列中，如果你执行事务，那么这个队列中的命令全部执行，如果取消了事务，一个队列中的命令全部作废。

• 开启事务：multi
• 输入要执行的命令：被放入到一个队列中
• 执行事务：exec
• 取消事务：discard

Redis的事务想发挥功能，需要配置watch监听机制

在开启事务之前，先通过watch命令去监听一个或多个key，在开启事务之后，如果有其他客户端修改了我监听的key，事务会自动取消。

如果执行了事务，或者取消了事务，watch监听自动消除，一般不需要手动执行unwatch。

redis事务的相关操作

6.3 Redis持久化机制

6.3.1 RDB

RDB是Redis默认的持久化机制

• RDB持久化文件，速度比较快，而且存储的是一个二进制的文件，传输起来很方便。

• RDB持久化的时机：

  save 900 1：在900秒内，有1个key改变了，就执行RDB持久化。

  save 300 10：在300秒内，有10个key改变了，就执行RDB持久化。

  save 60 10000：在60秒内，有10000个key改变了，就执行RDB持久化。

• RDB无法保证数据的绝对安全，会能数据丢失的情况。

redis.conf文件中添加关键的配置项

RDB持久化的时机
save 900 1
save 300 10
save 60 10000

开启RDB持久化的压缩
rdbcompression yes

RDB文件的名称
dbfilename dump.rdb

redis持久化后，持久化文件默认会放在容器的/data目录下
在docker-compose.yml文件中添加数据卷映射 ./data:/data

version: '3.1'
services:
  redis:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379
    volumes:
      - ./conf/redis.conf:/usr/local/redis/redis.conf
      - ./data:/data
    command: ["redis-server","/usr/local/redis/redis.conf"]

持久化操作

1，进入 redis容器内部，执行set操作

2，执行shutdown save指令，这样会关闭redis服务时会进行持久化操作

3，重启redis容器，如果是没有持久化的情况下，之前set的数据将不存在。而持久化后，redis会读取rdb文件把数据放回到内存中

4，查询之前set的数据是否还存在

6.3.2 AOF

AOF持久化机制默认是关闭的，Redis官方推荐同时开启RDB和AOF持久化，更安全，避免数据丢失。

• AOF持久化的速度，相对RDB较慢的，存储的是一个文本文件，到了后期文件会比较大，传输困难。

• AOF持久化时机。

  appendfsync always：每执行一个写操作，立即持久化到AOF文件中，性能比较低。
  appendfsync everysec：每秒执行一次持久化。
  appendfsync no：会根据你的操作系统不同，环境的不同，在一定时间内执行一次持久化。

• AOF相对RDB更安全，推荐同时开启AOF和RDB。

在redis.conf文件中添加如下关键配置项

是否开启aof持久化
appendonly no
aof持久化文件的名称
appendfilename "appendonly.aof"

appendonly yes
appendfilename "redis.aof"
#appendfsync always
appendfsync everysec
#appendfsync no

进行redis容器内部，执行shutdown nosave后，再查询redis.aof文件

6.3.3 注意事项

同时开启RDB和AOF的注意事项：

如果同时开启了AOF和RDB持久化，那么在Redis宕机重启之后，需要加载一个持久化文件，优先选择AOF文件。

如果先开启了RDB，再次开启AOF，如果RDB执行了持久化，那么RDB文件中的内容会被AOF覆盖掉。这样会导致数据不全，因此建议同时开启AOF和RDB持久化，避免单独使用某一种持久化操作

6.4 Redis的主从架构

单机版 Redis存在读写瓶颈的问题

主从架构

指定yml文件

Docker中的host模式指定是容器与主机享受相同的network namespace，在这种情况下，我们访问主机端口就能访问我们的容器。比如说我们运行tomcat容器并且用-- network=host 来指定我们的网络模式为host，这样我们访问本机的8080端口就能访问到我们的tomcat容器。

version: "3.1"
services:
  redis1:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis1
    environment:
      - TZ=Asia/Shanghai
    network_mode: host
    volumes:
      - ./conf/redis1.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis2:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis2
    environment:
      - TZ=Asia/Shanghai
    network_mode: host
    volumes:
      - ./conf/redis2.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis3:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis3
    environment:
      - TZ=Asia/Shanghai
    network_mode: host
    volumes:
      - ./conf/redis3.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]

# redis1主节点的配置
port 6379
# redis2从节点配置
replicaof 192.168.206.140 6379
port 6380
# redis3从节点配置
replicaof 192.168.206.140 6379
port 6381

主从架构搭建步骤

1，在opt目录下创建一个docker_redis_master_salve文件夹，并创建docker-compose.yml文件，输入配置内容

2，在docker_redis_master_salve文件夹下创建一个conf文件夹

3，在conf文件夹下分别创建redis1.conf，redis2.conf，redis3.conf文件

4，在redis2.conf，redis3.conf文件在分别配置replicaof 192.168.206.140 6379来连接上master主机，并设置相应的端口

5，docker-compose up -d启动容器，如果出现UnixHTTPConnectionPool(host='localhost', port=None): Read timed out. (read timeout=60)的错误，则需要在/etc/profile配置文件中添加如下配置：

export DOCKER_CLIENT_TIMEOUT=120

export COMPOSE_HTTP_TIMEOUT=120

6，通过docker-compose logs -f 查看日志，没问题后进行测试

7，在master主机进行set和get操作，测试是否成功

8，在slave从机测试是否可以获取主机set的数据，再测试slave从机set数据

6.5 哨兵

哨兵可以帮助我们解决主从架构中的单点故障问题

添加哨兵

修改了以下docker-compose.yml，为了可以在容器内部使用哨兵的配置

version: "3.1"
services:
  redis1:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis1
    environment:
      - TZ=Asia/Shanghai
    network_mode: host
    volumes:
      - ./conf/redis1.conf:/usr/local/redis/redis.conf
      - ./conf/sentinel1.conf:/data/sentinel.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis2:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis2
    environment:
      - TZ=Asia/Shanghai
    network_mode: host
    volumes:
      - ./conf/redis2.conf:/usr/local/redis/redis.conf
      - ./conf/sentinel2.conf:/data/sentinel.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis3:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis3
    environment:
      - TZ=Asia/Shanghai
    network_mode: host
    volumes:
      - ./conf/redis3.conf:/usr/local/redis/redis.conf
      - ./conf/sentinel3.conf:/data/sentinel.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]

准备哨兵的配置文件，并且在容器内部手动启动哨兵即可

# 哨兵需要后台启动
daemonize yes
# 指定Master节点的ip和端口,要配置对主节点的监控即可，通过向主节点发送info，获取从节点的信息
sentinel monitor master 192.168.206.140 6379 2
# 指定哨兵的端口号
port 26379
# 哨兵每隔多久监听一次redis架构
sentinel down-after-milliseconds master 10000

在Redis容器内部启动sentinel即可

redis-sentinel sentinel.conf

6.6 Redis的集群

Redis集群在保证主从加哨兵的基本功能之外，还能够提升Redis存储数据的能力。

Redis集群架构图

在opt目录下创建一个docker_redis_cluster目录，编辑docker-compose.yml文件，内容如下

# docker-compose.yml
version: "3.1"
services:
  redis1:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis1
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 8001:8001
      - 18001:18001
    volumes:
      - ./conf/redis1.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]
  redis2:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis2
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 8002:8002
      - 18002:18002
    volumes:
      - ./conf/redis2.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis3:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis3
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 8003:8003
      - 18003:18003
    volumes:
      - ./conf/redis3.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis4:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis4
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 8004:8004
      - 18004:18004
    volumes:
      - ./conf/redis4.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis5:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis5
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 8005:8005
      - 18005:18005
    volumes:
      - ./conf/redis5.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  
  redis6:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis6
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 8006:8006
      - 18006:18006
    volumes:
      - ./conf/redis6.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  

在docker_redis_cluster目录中创建conf文件夹，放入redis1.conf....redis6.conf文件，注意文件内的端口号等要改

# redis.conf
# 指定redis的端口号
port 8001
# 开启Redis集群
cluster-enabled yes
# 每个群集节点都有一个群集配置文件，确保在同一系统上运行的实例没有重叠的集群配置文件名
cluster-config-file nodes-8001.conf
# 集群对外提供访问的ip地址
cluster-announce-ip 192.168.206.138
# 集群节点对外端口
cluster-announce-port 8001
# 集群中实例相互通信的内部总线端口，bus的端口一般是节点端口加上10000
cluster-announce-bus-port 18001

启动了6个Redis的节点。

随便跳转到一个容器内部，使用redis-cli管理集群

redis-cli --cluster create 192.168.206.146:8001 192.168.206.146:8002 192.168.206.146:8003 192.168.206.146:8004 192.168.206.146:8005 192.168.206.146:8006 --cluster-replicas 1

集合分配置主从结果如图

redis集群搭建成功

往redis集群中存数据和取数据

存数据和取数据

6.7 Java连接Redis集群

使用JedisCluster对象连接Redis集群

@Test
public void test(){
    // 创建Set<HostAndPort> nodes
    Set<HostAndPort> nodes = new HashSet<>();
    nodes.add(new HostAndPort("192.168.199.109",7001));
    nodes.add(new HostAndPort("192.168.199.109",7002));
    nodes.add(new HostAndPort("192.168.199.109",7003));
    nodes.add(new HostAndPort("192.168.199.109",7004));
    nodes.add(new HostAndPort("192.168.199.109",7005));
    nodes.add(new HostAndPort("192.168.199.109",7006));

    // 创建JedisCluster对象
    JedisCluster jedisCluster = new JedisCluster(nodes);

    // 操作
    String value = jedisCluster.get("b");
    System.out.println(value);
}

七、Redis常见问题

---

7.1 key的生存时间到了，Redis会立即删除吗？

不会立即删除。

• 定期删除：Redis每隔一段时间就去会去查看Redis设置了过期时间的key，会再100ms的间隔中默认查看3个key。

• 惰性删除：如果当你去查询一个已经过了生存时间的key时，Redis会先查看当前key的生存时间，是否已经到了，直接删除当前key，并且给用户返回一个空值。

7.2 Redis的淘汰机制

在Redis内存已经满的时候，添加了一个新的数据，执行淘汰机制。

• volatile-lru：在内存不足时，Redis会再设置过生存时间的key中干掉一个最近最少使用的key。

• allkeys-lru：在内存不足时，Redis会再全部的key中干掉一个最近最少使用的key。

• volatile-lfu：在内存不足时，Redis会再设置过生存时间的key中干掉一个最近最少频次使用的key。

• allkeys-lfu：在内存不足时，Redis会再全部的key中干掉一个最近最少频次使用的key。

• volatile-random：在内存不足时，Redis会再设置过生存时间的key中随机干掉一个。

• allkeys-random：在内存不足时，Redis会再全部的key中随机干掉一个。

• volatile-ttl：在内存不足时，Redis会再设置过生存时间的key中干掉一个剩余生存时间最少的key。

• noeviction：（默认）在内存不足时，直接报错。

  LFU根据使用次数的差异来决定。而LRU是根据使用时间的差异来决定的。

指定淘汰机制的方式：maxmemory-policy 具体策略，设置Redis的最大内存：maxmemory 字节大小

7.3 缓存的常问题

7.3.1 缓存穿透问题

缓存穿透

缓存穿透

7.3.2 缓存击穿问题

缓存击穿

缓存击穿

7.3.3 缓存雪崩问题

缓存雪崩

缓存雪崩

7.3.4 缓存倾斜问题

缓存倾斜

缓存倾斜