Redis

一、引言

---

1.1 数据库压力过大

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

如何减轻db的压力？

1.2 共享数据

多台服务器之间，如何共享数据

session可用么？

1.3 分布式锁

如果应用部署在多个服务器上，传统锁会失效，如何跨服务器进行加锁呢？

二、Redis介绍

---

2.1 NoSQL介绍

• Redis就是一款NoSQL。

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

• Key-Value：Redis。。。

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

• 面向列：Hbase，Cassandra，Monetdb 。。。

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

• 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还提供了主从，哨兵以及cluster的搭建方式，可以更方便的横向扩展以及垂直扩展。

Redis之父

三、Redis安装

---

3.1 安装Redis

docker-compose.yml

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对应一个有序的集合。

  

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

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

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

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

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

4.2 string常用命令

string常用操作命令

#1.  添加值  命令本身就包含了能操作哪种类的数据的语义了，也就是说，如果看到set命令，那么就只能操作String类型的数据
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
setex age 10 50   # 设置age为50，并且过期时间为10秒
#8. 设置值，如果当前key不存在的话（如果这个key存在，什么事都不做，如果这个key不存在，和set命令一样）  (not exist)
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是否存在
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. 根据分数从小到大排序，获取指定范围内，坐标，从0开始，包含0到指定坐标（包含指定坐标） 的数据（withscores如果添加这个参数，那么会返回member对应的分数）
zrange key start stop [withscores]

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

#9. 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。
# 返回所有符合条件 1 < score <= 5 的成员
ZRANGEBYSCORE zset (1 5
# 则返回所有符合条件 5 < score < 10 的成员。
ZRANGEBYSCORE zset (5 (10
ZRANGEBYSCORE z1 -inf +inf               # 显示整个有序集
ZRANGEBYSCORE z1 -inf +inf WITHSCORES    # 显示整个有序集及成员的 score 值
ZRANGEBYSCORE z1 -inf 10 WITHSCORES      # 显示分数 <=10 的所有成员
ZRANGEBYSCORE z1 (1 20            # 显示分数大于 1 小于等于 20 的成员

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的剩余生存时间,单位为秒，单位为毫秒（-2 - 当前key不存在，-1 - 当前key没有设置生存时间，具体剩余的生存时间）
ttl key
pttl key

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

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

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

4.8 库的常用命令

db常用命令

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

#2. 清空全部数据库
flushall

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

五、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","李四");
        //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>4.3.18.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);

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

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

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

5.5 Springboot访问Redis

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

 @Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory){

        final RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        // 设置 redis链接工厂对象
        redisTemplate.setConnectionFactory(connectionFactory);

        // 设置 key 的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        // 设置 value部分使用的序列化器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        //设置Hash数据类型的field字段和value值的序列化方式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        

        return redisTemplate;
    }

}

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    @Test
    void contextLoads() {
        final HashMap<String, String> map = new HashMap<>();
        map.put("aaa","中国");
        map.put("bbb","哈哈");
        redisTemplate.opsForValue().set("name",map);
        final Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }

}

package com.qf.redis02;

import com.qf.redis02.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.*;

@SpringBootTest
class Redis02ApplicationTests {


    @Qualifier("redisTemplate")
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void test1() {
        final String name = (String) redisTemplate.opsForValue().get("myname");
        System.out.println(name);
    }


    @Test
    void test2() {
        redisTemplate.opsForValue().set("myname","luffy");
    }


    @Test
    void test3() {
        redisTemplate.opsForHash().put("user01","name","luffy");
        redisTemplate.opsForHash().put("user01","age","20");

        final String name = (String) redisTemplate.opsForHash().get("user01", "name");
        System.out.println(name);
        final String age = (String) redisTemplate.opsForHash().get("user01", "age");
        System.out.println(age);

    }


    @Test
    void test4() {
        final HashMap<String, String> map = new HashMap<>();
        map.put("name","zero");
        map.put("age","30");

        redisTemplate.opsForHash().putAll("user02",map);
        final Map user02 = redisTemplate.opsForHash().entries("user02");

        System.out.println(user02);

    }


    /**
     * 缓存一张表
     * 整合 mp ，查user表的数据 
     * 小练习： 如何把一张表用map进行缓存 ，key：用id，value用数据行
     */
    @Test
    void test5() {

        // mp 查询所有用户  userService.list();   List<User> list

        final List<User> users = new ArrayList<>();
        users.add(new User(1,"luffy",new Date()));
        users.add(new User(2,"zero",new Date()));
        users.add(new User(3,"nami",new Date()));

        redisTemplate.opsForList().rightPushAll("userlist",users);

        final List userlist = redisTemplate.opsForList().range("userlist", 0, -1);
        userlist.forEach(System.out::println);

    }


    /**
     * 把user对象存入redis
     */
    @Test
    void test6() {
//        redisTemplate.opsForValue().set("luffy",new User(100,"luffy",new Date()));
        redisTemplate.opsForValue().set("zero",new User(200,"zero",new Date()));
    }


    /**
     * java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to com.qf.redis02.entity.User
     *
     */
    @Test
    void test7() {
//        final LinkedHashMap luffy = (LinkedHashMap) redisTemplate.opsForValue().get("luffy");

//        final User luffy = (User) redisTemplate.opsForValue().get("luffy");
//        System.out.println(luffy);


        final User zero = (User) redisTemplate.opsForValue().get("zero");
        System.out.println(zero);
    }
}

六、Redis其他配置及集群【重点】

---

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

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);

• springboot 连接方式

• 使用JedisPool的方式

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

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

后续向再次操作Redis时，需要先AUTH做一下校验。

6.2 Redis的事务

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

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

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

127.0.0.1:6379> keys *
1) "ip:0:0:0:0:0:0:0:1"
2) "name"
3) "category:getCategoryList"
4) "a"
5) "v2"
6) "age"
7) "zhangsan"
8) "v1"
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set jmj:name jmj123
QUEUED
127.0.0.1:6379> set jmj:age 19
QUEUED
127.0.0.1:6379> set jmj:sex 1
QUEUED
127.0.0.1:6379> incr name
QUEUED
127.0.0.1:6379> set jmj:wei 69kg
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
3) OK
4) (error) ERR value is not an integer or out of range
5) OK
127.0.0.1:6379> keys *
 1) "ip:0:0:0:0:0:0:0:1"
 2) "name"
 3) "jmj:wei"
 4) "category:getCategoryList"
 5) "a"
 6) "v2"
 7) "age"
 8) "jmj:age"
 9) "jmj:name"
10) "zhangsan"
11) "jmj:sex"
12) "v1"

错了就错了。不回滚，其他正常执行

不执行就在后面加 discard

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set jmj:name 1231
QUEUED
127.0.0.1:6379> set jmm asd
QUEUED
127.0.0.1:6379> discard
OK

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

127.0.0.1:6379> watch name
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set name wangwu
QUEUED
127.0.0.1:6379> set age 20
QUEUED
127.0.0.1:6379> incr name
QUEUED
127.0.0.1:6379> exec
(nil)

Aliyun:0>get name
"lisi"
Aliyun:0>set name jj
"OK"

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

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

6.3 Redis持久化机制

6.3.1 RDB

RDB是Redis默认的持久化机制 名字叫 dump.rdb

也可以称之为RDB镜像，本身也就是对数据的一次快照，去覆盖这个文件dump.rdb

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

• 

• RDB持久化的时机：

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

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

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

• RDB无法保证数据的绝对安全。

save 可以立刻执行一次RDB持久化

多学一个命令 history

通过！对应命令ID可以再次执行一遍那个命令

6.3.2 AOF

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

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

• AOF持久化时机。appendonly.aof 文件名

  appendfsync always：每执行一个写操作，立即持久化到AOF文件中，性能比较低。
  appendfsync everysec：每秒执行一次持久化。会把这一秒内所有的修改语句全部写入AOF文件appendonly.aof
  appendfsync no：会根据你的操作系统不同，环境的不同，在一定时间内执行一次持久化。

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

6.3.3 注意事项

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

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

如果先开启了RDB，再次开启AOF，如果RDB执行了持久化，那么RDB文件中的内容会被AOF覆盖掉。

问题？

如果先开启了RDB，在开启AOF，怎么让他们的数据合并？

不可能数据有差，因为是同一个缓存，RDB是快照，AOF更为详细，若AOF后进来，优先加载AOF，会把库清空，然后覆盖RDB快照中的二进制文件，

若AOF先进来，肯定详情比RDB多，然后RDB就会存上AOF的快照!!!

为什么有AOF机制还要RDB机制？

是因为有一些命令有些bug 导致AOF机制无法恢复，RDB是在启动后，才会覆盖的，因为重启，redis根本不会理睬RDB文件，只会读取AOF文件，如果没有读取成功，他不会正常启动,也就是不会覆盖RDB文件，这时候想恢复，就得靠RDB了!!!

这时候把AOF关了，用RDB的方式恢复，就是为了做一个备选。

6.4 Redis的主从架构

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

主从架构

指定yml文件

version: "3.1"
services:
  redis1:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis1
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7001:6379
    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:
      - 7002:6379
    volumes:
      - ./conf/redis2.conf:/usr/local/redis/redis.conf
    #告诉redis2主节点是谁 master相当于是域名  
    links:
      - redis1:master
    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:
      - 7003:6379
    volumes:
      - ./conf/redis3.conf:/usr/local/redis/redis.conf
       #告诉redis3主节点是谁 master相当于是域名  
    links:
      - redis1:master
    command: ["redis-server","/usr/local/redis/redis.conf"]

redis1.conf

save 3600 1
save 300 100 
save 60 10000
appendonly yes
appendfsync everysec

这是从节点的配置文件redis2.conf redis3.conf

# redis2和redis3从节点配置  6379不是宿主机的端口，而是容器里对外开放的端口
replicaof master 6379

# 如果主节点有密码的话
masterauth 主节点的密码 

info命令查看状态

192.168.0.3代表虚拟机里的本地虚拟地址，相当于容器的IP，也可以认为就是容器ID或容器名，后面是容器内部对应的端口号.

若主节点崩了，就只能读了，所以引出了哨兵机制

6.5 哨兵

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

添加哨兵

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

version: "3.1" #表示docker的版本,不用动
services:
  redis1:
    image: daocloud.io/library/redis:5.0.7
    restart: always
    container_name: redis1
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7001:6379
    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
    ports:
      - 7002:6379
    volumes:
      - ./conf/redis2.conf:/usr/local/redis/redis.conf
      - ./conf/sentinel2.conf:/data/sentinel.conf        # 添加的内容
    links:
      - redis1:master
    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:
      - 7003:6379
    volumes:
      - ./conf/redis3.conf:/usr/local/redis/redis.conf
      - ./conf/sentinel3.conf:/data/sentinel.conf        # 添加的内容 
    links:
      - redis1:master
    command: ["redis-server","/usr/local/redis/redis.conf"]

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

# 哨兵需要后台启动
daemonize yes
# 指定Master节点的ip和端口（主）
sentinel monitor master localhost 6379 2 #主和从写一个，这个2代表主节点挂了两个从节点
# 指定Master节点的ip和端口（从）
sentinel monitor master master 6379 2
# 哨兵每隔多久监听一次redis架构
sentinel down-after-milliseconds master 10000

在Redis容器内部启动sentinel即可

每个不管是主从节点，都必须要把这个启动，进入容器里输入这行命令

redis-sentinel sentinel.conf

多学一个命令 tree

但是必须先装 tree命令

yum install tree

tree

6.6 Redis的集群（Cluster）

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

Redis集群架构图

为什么是2n+1？

答：因为他有个投票机制，当一个主节点坏了的时候其他主节点进行投票机制，在坏了的主节点里的从节点选择一个主节点，票数过半的选为主节点，奇数比偶数命中率高。所以选择奇数。

准备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:
    #外部访问端口：容器内部端口
      - 7001:7001
       #外部访问总线端口：容器内部总线端口
      - 17001:17001
    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:
      - 7002:7002
      - 17002:17002
    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:
      - 7003:7003
      - 17003:17003
    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:
      - 7004:7004
      - 17004:17004
    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:
      - 7005:7005
      - 17005:17005
    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:
      - 7006:7006
      - 17006:17006
    volumes:
      - ./conf/redis6.conf:/usr/local/redis/redis.conf
    command: ["redis-server","/usr/local/redis/redis.conf"]  

配置文件 写6个 700x 1700x

# redis.conf
# 指定redis的端口号  配置容器内部的端口号
port 7001
# 开启Redis集群
cluster-enabled yes   #让此节点加入到docker-compose管理的集群里
# 集群信息的文件
cluster-config-file nodes-7001.conf  #这是存在内部/usr/local/redis/redis.conf 当前目录下的一个配置信息文件
# 集群的对外ip地址
cluster-announce-ip 192.168.57.202  #这是虚拟机外部的ip地址，阿里云或者本地虚拟机的ip
# 集群的对外port
cluster-announce-port 7001          #这是虚拟机外部的端口
# 集群的总线端口  这也是虚拟机外部对应的端口
cluster-announce-bus-port 17001  #他会在创建集群的时候找到它们相互总线的端口发送 ping-pong机制，相互响应，判断对方是否还存在

启动了6个Redis的节点。

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

记得换192.168.199.109 ip地址为 虚拟机外部的ip地址，

redis-cli --cluster create 192.168.199.109:7001 192.168.199.109:7002 192.168.199.109:7003 192.168.199.109:7004 192.168.199.109:7005 192.168.199.109:7006 --cluster-replicas 1 #这个1代表一个主节点绑定一个从节点

#进入客户端的命令：redis-cli -h ip -p port -c

-c 代表会自动重定向到负责你写入的那个节点里

-h 外部IP

-P 外部对应的端口号

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);
    jedisCluster.close();
}

6.8 springboot 连接Redis集群

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/fmmall2?characterEncoding=utf-8
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource
  redis:
    cluster:
      nodes: 192.168.57.162:7001,192.168.57.162:7002,192.168.57.162:7003,192.168.57.162:7004,192.168.57.162:7005,192.168.57.162:7006
#  redis:
#    host: 192.168.57.140
mybatis:
  mapper-locations: classpath:mappers/*Mapper.xml

七、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：（默认）在内存不足时，直接报错。

redis.conf里配置 配置空格隔开

指定淘汰机制的方式：maxmemory-policy 具体策略，

设置Redis的最大内存：maxmemory 字节大小

7.3 缓存的常问题

7.3.1 缓存穿透问题

缓存穿透

缓存穿透

7.3.2 缓存击穿问题

缓存击穿

缓存击穿

分布式锁解决缓存击穿问题

package com.qf.fmall.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.qf.fmall.entity.Category;
import com.qf.fmall.entity.Product;
import com.qf.fmall.entity.ProductImg;
import com.qf.fmall.mapper.CategoryMapper;
import com.qf.fmall.service.ICategoryService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qf.fmall.service.IProductImgService;
import com.qf.fmall.service.IProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * <p>
 * 商品分类 服务实现类
 * </p>
 *
 * @author jmj
 * @since 2023-08-21
 */
@Service
@Slf4j
public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> implements ICategoryService {

    @Autowired
     private IProductService iProductService;

    @Autowired
    private IProductImgService iProductImgService;

    @Autowired
    RedisTemplate redisTemplate;

    //获取分类信息，有结构的
    @Override
    public List<Category> getCategoryList() throws Exception {

        String methodName = new Object(){}.getClass().getEnclosingMethod().getName();
        log.info("当前执行的方法为{}",methodName);
        String key="category:"+methodName;
        Boolean aBoolean = redisTemplate.hasKey(key);
        if (aBoolean){
            log.info("数据已存在，在缓存里拿出来");
            redisTemplate.expire(key,300,TimeUnit.SECONDS);
            return redisTemplate.opsForList().range(key,0,-1);
        }
        // 解决缓存击穿问题
        // 申请一把分布式锁，如果申请锁成功的线程，继续去访问数据库查询数据  setnx
        // 申请锁失败的线程，不要访问数据库了，自旋(循环结构中等一会去检查一次缓存，有就退出自旋)

        String lockkey ="fmall:categoryList:lock";
        Boolean flag =redisTemplate.opsForValue().setIfAbsent(lockkey,new Date());

        if (flag){
            log.info("数据不存在，重新存入缓存中");
            List<Category> list = null;
            try {
                list = getlist(0);
                redisTemplate.opsForList().rightPushAll(key,list);
                redisTemplate.expire(key,300, TimeUnit.SECONDS);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                redisTemplate.delete(lockkey);//释放分布式锁
            }
            return list;
        }else {
            //申请分布式锁失败的线程如何处理?
            // 自旋等待redis中的数据被拿到分布式锁的线程写入
            for (int i = 0; i < 10 ; i++) {
                Thread.sleep(200);
                List<Category> list = redisTemplate.opsForList().range(key, 0, -1);
                if (list.size()>0){
                    return list;
                }
            }
            //如果10次自旋之内仍然没有拿到数据，抛异常

            throw new Exception("服务器目前有问题，请稍后再试");
        }



    }





    public  List<Category> getlist(Integer parentId){

        List<Category> categoryList = list(new QueryWrapper<Category>().eq("parent_id", parentId));
        if (categoryList.size()==0){
            return new ArrayList<Category>();
        }
        for (Category category : categoryList) {
            Integer categoryId = category.getCategoryId();
            List<Category> getlist = getlist(categoryId);
            category.setCategories(getlist);
        }

        return categoryList;
    }






    @Override
    public List<Category> getCategoryProductsList() {
        List<Category> categoryList = list(new QueryWrapper<Category>().eq("parent_id", 0));
        for (Category category : categoryList) {
            List<Product> products = iProductService.list(new QueryWrapper<Product>().eq("root_category_id", category.getCategoryId()).orderByDesc("sold_num").last("limit 6"));
            for (Product product : products) {
                List<ProductImg> imgs = iProductImgService.list(new QueryWrapper<ProductImg>().eq("item_id", product.getProductId()));
                product.setImgs(imgs);
            }
            category.setProducts(products);
        }

        return categoryList;
    }







}

7.3.3 缓存雪崩问题

缓存雪崩

缓存雪崩

7.3.4 缓存倾斜问题

缓存倾斜

缓存倾斜

解决方案可以：平衡一下插槽，把多部份的平分一下

``