Redis

Redis_第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 Springboot访问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的集群(Cluster)
        • 6.7 Java连接Redis集群
        • 6.8 springboot 连接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 数据库压力过大

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

如何减轻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_第2张图片

三、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连接

链接效果
Redis_第3张图片

3.3 使用图形化界面连接Redis

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

傻瓜式安装

RedisDesktopManager
Redis_第4张图片

四、Redis常用命令【重点


4.1 Redis存储数据的结构

常用的5种数据结构:

  • key-string:一个key对应一个值。

  • Redis_第5张图片

  • key-hash:一个key对应一个Map。

    Redis_第6张图片

  • key-list:一个key对应一个列表。

    Redis_第7张图片

  • key-set:一个key对应一个集合。

    Redis_第8张图片

  • key-zset:一个key对应一个有序的集合。

    Redis_第9张图片

  • 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>
    
    <dependency>
        <groupId>redis.clientsgroupId>
        <artifactId>jedisartifactId>
        <version>2.9.0version>
    dependency>
    
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>
    
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <version>1.16.20version>
    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依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>4.3.18.RELEASEversion>
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 导入依赖

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>1.2.47version>
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.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        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 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 连接方式

Redis_第10张图片

  • 使用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持久化

Redis_第11张图片

多学一个命令 history

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

6.3.2 AOF

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

Redis_第12张图片

  • 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存在读写瓶颈的问题

主从架构
Redis_第13张图片

指定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

Redis_第14张图片

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

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

info命令查看状态
在这里插入图片描述

Redis_第15张图片

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

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

6.5 哨兵

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

添加哨兵
Redis_第16张图片

Redis_第17张图片

修改了以下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

Redis_第18张图片

6.6 Redis的集群(Cluster)

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

Redis集群架构图
Redis_第19张图片

为什么是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_第20张图片

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

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

-h 外部IP

-P 外部对应的端口号

6.7 Java连接Redis集群

使用JedisCluster对象连接Redis集群

@Test
public void test(){
    // 创建Set 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 缓存穿透问题

缓存穿透

缓存穿透
Redis_第21张图片
7.3.2 缓存击穿问题

缓存击穿

缓存击穿
Redis_第22张图片

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


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;

/**
 * 

* 商品分类 服务实现类 *

* * @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 缓存雪崩问题

缓存雪崩

缓存雪崩
Redis_第23张图片
7.3.4 缓存倾斜问题

缓存倾斜

缓存倾斜
Redis_第24张图片

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

``

你可能感兴趣的:(Redis,redis,数据库,缓存)