Redis学习之旅

最新推荐文章于 2022-04-28 18:38:07 发布
最新推荐文章于 2022-04-28 18:38:07 发布
阅读量651 收藏
点赞数
分类专栏： java Redis 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49349430/article/details/110746799
版权
java 同时被 2 个专栏收录
29 篇文章 0 订阅
订阅专栏
Redis
1 篇文章 0 订阅
订阅专栏

1586740065742

Author：Eric

Version：9.0.1

文章目录

一、引言

1.1 数据库压力过大

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

1.2 数据不同步

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

1.3 传统锁失效

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

由Redis来解决上述的问题
2

二、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之父
1586747559955

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

在/opt目录下先创建一个文件docker_redis，再创建一个.yml格式的文件docker-compose.yml

image-20201022141501496

docker-compose.yml文件添加如下内容，然后启动

image-20201022141248022

3.2 使用redis-cli连接Redis

进去Redis容器的内部

docker exec -it 容器id bash

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

链接效果
1586757208129

image-20201022141945899

3.3 使用图形化界面连接Redis

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

傻瓜式安装

RedisDesktopManager
1586757262085

四、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[]。
五种常用的存储数据结构图
1586759101828

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

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

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

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

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

4.2 string常用命令

string常用操作命令

#1.  添加值
set key value
#栗子：set name zhangsan

#2. 取值
get key
#get name

#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

image-20201022174748948

image-20201022175409418

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和dield都存在，什么事都不做，如果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

image-20201022190923449

image-20201022191205947

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

image-20201022194516813

image-20201022194804290

image-20201022195355959

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

image-20201022200503049

image-20201022200655269

image-20201022201005423

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]

image-20201022202437720

image-20201022202723705

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

image-20201022203513329

image-20201022204602231

image-20201022205343087

4.8 库的常用命令

db常用命令

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

#2. 清空全部数据库
flushall

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

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

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

monitor命令需要2个界面

其中一个输入monitor，另外一个进入容器内部，并连接，做操作(添加数据等)

image-20201022205954921

image-20201022210006279

五、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.246.129",6379);
        //2. 操作Redis - 因为Redis的命令是什么，Jedis的方法就是什么
        jedis.set("name","李四");
        //3. 释放资源
        jedis.close();
    }

    @Test
    public void get(){
        //1. 连接Redis
        Jedis jedis = new Jedis("192.168.246.129",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//注解方式的get、set方法
@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.246.129",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.246.129",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.246.129",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.246.129",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.246.129",6379);

    //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命令的执行过程
3
使用管道方式执行命令
4
//  Redis管道的操作
@Test
public void pipeline(){
    //1. 创建连接池
    JedisPool pool = new JedisPool("192.168.246.129",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"]

添加数据卷

image-20201023115636653

在/opt/docker_redis/conf目录下创建redis.conf文件

image-20201023135149474

6.1 Redis的AUTH

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

# redis.conf
requirepass 密码

在redis.conf文件添加内容

image-20201023134901320

将容器关闭重启

image-20201023141317743

redis设置了密码，代码上的修改

1.string

image-20201023151029577

2.连接池

image-20201023161939334

三种客户端的连接方式

  • 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容器，则之前设置的密码就失效了

将刚刚配置密码的文件redis.conf注释，并重启

image-20201023162329029

image-20201023162954367

密码设置取消

image-20201023163151801

6.2 Redis的事务

Redis的事务：一次事务操作，该成功的成功，该失败的失败。我们之前的事务是有原子性，要么一次成功，要么一次失败，这个有区别

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

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

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

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

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

redis事务的相关操作
image-20201023163749139
监听一个或多个key
image-20201023165042227
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的数据是否还存在

image-20201023165407511

/opt/docker_redis/conf目录下的redis.conf文件的添加内容

image-20201023165859870

在redis操作后并shutdown save后在/opt/docker_redis/data目录下的redis-dump.rdb文件会有二进制数据

image-20201023170749117

二进制数据

image-20201023170459199

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”

#是否开启aof持久化
appendonly yes
#aof持久化文件的名称
appendfilename "redis.aof"
#每秒执行一次持久化
appendfsync everysec
#立即持久化
#appendfsync always
#一定时间内持久化
#appendfsync no

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

/opt/docker_redis/conf目录下的redis.conf文件的添加内容

image-20201023172705160

image-20201023173148044

6.3.3 注意事项

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

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

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

6.4 Redis的主从架构

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

主从架构
1586918773809

指定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
    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.246.129 6379
port 6380
# redis3从节点配置
replicaof 192.168.246.129 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数据

docker-compose.yml文件

image-20201023173813603

在/opt目录下创建docker_redis_master_slave文件夹，在docker_redis_master_slave文件创建docker-compose.yml文件和conf文件夹，

在/opt/docker_redis_master_slave/conf目录下创建3个redis.conf文件

image-20201023175241821

image-20201023191907282

6.5 哨兵

Redis的哨兵机制的作用

1.监控：哨兵会实时监控主redis和从redis的运行情况（健康情况）
2.通知：当主的redis发生故障，可以发送通知告知管理员
3.自动故障转移：当主的redis宕机后，会从的redis中选择一台作为新的主机，其他的从机再连接上这台新的主机

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

添加哨兵
1586922159978

修改了以下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和端口（主）
#  哨兵 		 自己指定名称 虚拟机地址   虚拟机端口 主机数
sentinel monitor master 192.168.246.129 6379 2
# 指定哨兵的端口号
port 26379
# 哨兵每隔多久监听一次redis架构
sentinel down-after-milliseconds master 10000

在Redis容器内部启动sentinel即可

redis-sentinel sentinel.conf

1.在/opt/docker_redis_master_slave目录下的docker-compose.yml文件编辑

image-20201023193418655

2.在/opt/docker_redis_master_slave/conf目录下创建3个sentinel.conf 文件

image-20201023194740450

3.启动哨兵

redis-sentinel sentinel.conf

image-20201023195936142

4.查看redis1的信息

image-20201023200325251

image-20201023200531435

查看redis2的信息

image-20201023200751253

image-20201023200937973

5.让redis1主机宕机挂机，进入redis2查看信息

image-20201023201606426

image-20201023201815630

redis3的信息

image-20201023201933249

image-20201023202135517

6.将原主机redis1恢复正常启动后的变化

image-20201023202707131

image-20201023202831563

7.redis1恢复正常启动后，再次redis3的信息

image-20201023203056351

6.6 Redis的集群

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

Redis集群架构图
1586932636778

在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
# 集群的对外port
cluster-announce-port 8001
# 集群中实例相互通信的内部总线端口
cluster-announce-bus-port 18001

启动了6个Redis的节点。

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

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

集合分配置主从结果如图

redis集群搭建成功
image-20201023203726253
6个redis.conf 文件的配置
image-20201023204300836
image-20201023204743742
image-20201023205421035
启动容器查看各个端口的信息，主从关系
image-20201023210848628
image-20201024091005630
往redis集群中存数据和取数据
image-20201024091529535
6.7 Java连接Redis集群

使用JedisCluster对象连接Redis集群

    @Test
    public void test1(){

        //创建set集合
        Set<HostAndPort> set=new HashSet<>();
        set.add(new HostAndPort("192.168.246.129",8001));
        set.add(new HostAndPort("192.168.246.129",8002));
        set.add(new HostAndPort("192.168.246.129",8003));
        set.add(new HostAndPort("192.168.246.129",8004));
        set.add(new HostAndPort("192.168.246.129",8005));
        set.add(new HostAndPort("192.168.246.129",8006));
        //创建一个jedis集群对象
        JedisCluster jedisCluster=new JedisCluster(set);
        //操作redis
        String value = jedisCluster.get("a");
        System.out.println(value);

    }

image-20201024092530563

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

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

image-20201022235329489

7.3 缓存的常问题
7.3.1 缓存穿透问题

缓存穿透：请求查询的数据，redis没有，数据库也没有，如果并发访问量大的话，导致的所有的请求都会请求数据库，导致数据库宕机

解决方案
接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击
缓存穿透
1586949401099
7.3.2 缓存击穿问题

缓存击穿：redis中的某个热点数据到期，导致的所有的请求都会请求数据库，导致数据库宕机

缓存击穿
1586949585287
解决方案
1、设置热点数据永远不过期。
2、加互斥锁，互斥锁参考代码如下：

20180919143214879

说明：1）缓存中有数据，直接走上述代码13行后就返回结果了

2）缓存中没有数据，第1个进入的线程，获取锁并从数据库去取数据，没释放锁之前，其他并行进入的线程会等待100ms，再重新去缓存取数据。这样就防止都去数据库重复取数据，重复往缓存中更新数据情况出现。

3）当然这是简化处理，理论上如果能根据key值加锁就更好了，就是线程A从数据库取key1的数据并不妨碍线程B取key2的数据，上面代码明显做不到这点。
7.3.3 缓存雪崩问题

缓存雪崩：redis中存在大量热点数据同时到期，导致的所有的请求都会请求数据库，导致数据库宕机

缓存雪崩
1586949725602
解决方案
缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
设置热点数据永远不过期。
7.3.4 缓存倾斜问题

缓存倾斜：redis中存在大量的热点数据，导致的所有的请求数据都会请求这台redis服务器，导致reids宕机

缓存倾斜
1586949955591

​

Masol126
关注
专栏目录
Redis学习之旅 String篇
小萤哥的博客
05-28 165
Redis学习之旅 String篇 String 支持追加，截取，自增，位图等等玩法，大佬们都快把Redis的String玩出花了，本篇总结下Redis 的String 类型 认识type/ object encoding命令 先看下type命令的帮助文档，它说这个命令可以确定一个已存储的Key的类型 可以看到无论输入什么样的数据，字符串也好，数字串也好，他显示的type都是string 但是通过对象编码命令查看，就会看到，Redis在类型之外 ，还单独的维护了一个编码格式 进行编码的好处在于，可
Redis学习之旅 List篇
小萤哥的博客
06-01 203
Redis学习之旅 List篇 List可以组装成队列、栈等容器，还可以拿来实现消息队列 有几个前提要知道，list内的元素是可重复的，每一个元素其实还是一个String类型的对象 命令学习 redis-cli模式下键入 help @list 就可以快速相关的命令集合 在学习Redis命令时,有些东西需要知道，L开头的命令，有些是指的Left ,有些指的是List 1.0时代 命令 起始版本 作用 示例 LINDEX 1.0.0 list index 从左侧0起，按索引查找对应位置的
【Redis学习】-Redis学习之旅～第一篇：Redis简介
weixin_51978362的博客
04-28 168
Redis作为一种高效的NoSql，是一个key-value存储系统，现在在各种系统中的使用越来越多，大部分情况下是因为其高性能的特性，被当做缓存使用。本系列分为几篇来介绍Redis。
Redis学习之旅--持久化
qq_45661125的博客
01-14 414
Redis学习之旅--持久化RDB（Redis DataBase）rdb是什么触发机制如何恢复rdb文件优缺点AOF（Append Only File）aof是什么相关配置容错机制优缺点扩展 Redis是内存数据库，如归不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失，所以Redis提供了持久化的功能。 RDB（Redis DataBase） rdb是什么 在主从复制中，rdb就是备用了！从机上面！ 核心：在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲
Redis学习之旅--事务
qq_45661125的博客
01-14 104
Redis学习之旅--事务Redis中事务的一些特性事务的相关命令一级目录一级目录二级目录三级目录 Redis中事务的一些特性 Redis事务的本质：一组命令的集合！一个事务中所有的命令都会被序列化，在事务执行过程中，会按照顺序执行！ 一次性、顺序性、排他性！执行一系列的命令！ Redis事务没有隔离级别的概念！ Redis单条命令保存原子性，但是事务不保证原子性！ 所有命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行！ 事务的相关命令 开始事务（multi） 命令入队（…） 执行事务(执
Redis学习之旅--初识Redis
qq_45661125的博客
01-11 543
这里写目录标题概述Redis是什么？Redis能干嘛？Redis的特点拓展下载Windows下载一级目录一级目录一级目录二级目录三级目录 概述 Redis是什么？ Redis（Remote Dictionary Server）远程字典服务！是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、key-value数据库，并提供多种语言的API。是免费和开源的！是当下最热门的NoSQL技术之一！也被人们称之为结构化数据库！Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录
Redis学习之旅 Set篇
小萤哥的博客
06-01 136
Redis学习之旅 Set篇 set和list一样都是一个存储容器，但是它的list有两个不同的地方 一是无序 二是元素会自动去重 命令学习 redis-cli模式下键入 help @set 就可以快速相关的命令集合 1.0时代/2.0时代 set也是一个不经常变更的命令集，在1.0时代添加了大量的set命令之后 ，2.0版本增加过一个命令后就再也没有维护过，此处进行合并 项目 Value 作用 示例 SADD 1.0.0 向set里添加元素 SADD key member [m
Redis学习之旅 Hash篇
小萤哥的博客
06-01 124
Redis学习之旅 Hash篇 Hash结构就是在redis本身 的K-V结构基本上，又提供了一个K-V结构，通常用来保存对象结构比较合适，但是不宜将对象结构弄的过大 命令学习 redis-cli模式下键入 help @hash就可以快速相关的命令集合 hash是从2.0开始加入到redis中的，因此从2.0开始总结 2.0时代/3.0时代 hash命令自2.0加入后，在3.2版本新增了一个命令后，就没再更新过，因此合并汇总 命令 起始版本 作用 示例 HDEL 2.0.0 删除
Redis学习之旅 位图(BitMap)
小萤哥的博客
05-28 354
Redis学习之旅 位图(BitMap) 单独给位图开一章，是因为这块的东西确实玩法众多，面试也常常遇到，干脆将其拆分为独立的一章 Redis BIT相关命令 BITCOUNT 从字面意思上来看，bitcount翻译过来叫位统计，那么统计的是什么呢？，其实是01串中1的个数 OK,这不简单么，我知道了，字符串1 BITCOUNT的结果肯定是1，因为1的二进制是 0000 0001嘛，我们看下结果 我了个大擦，怎么会是3？，这就又回到我们在String篇里提到的一个概念，Redis Strin
Redis学习之旅 安装Redis6.0.3
小萤哥的博客
05-27 325
Redis学习之旅 安装Redis6.0.3 一切，从安装开始 友情链接，Redis 英文官方网站 下载编译 可以通过这个链接下载并安装Redis 6.0.3版本，安装的主机版本CentOS 7 wget http://download.redis.io/releases/redis-6.0.3.tar.gz 解压文件 tar zxf redis-6.0.3 cd redis-6.0.3 可以看到一个README.MD的MarkDown文档，打开它，文档中清晰的记录了如何去构建Redis OK，是
Redis学习之旅 管道/脚本/过期/事务
小萤哥的博客
06-02 187
Redis学习之旅 管道/脚本/过期/事务 本文尝试将 管道、脚本、过期和事务一起归纳一下 管道 我们都知道，一个命令通常都是由一个客户端通过网络连接发送到某个服务，由服务做出响应并给出回复，相对于Redis的快速，网络的传输速度往往是制约Redis发挥最大功效的因素，因此Redis设计了管道的概念 常规的使用，就是由客户端 1.通过网络发送请求-2.Redis处理计算-3.通过网络返回结果，所有的命令都是这样123-123-123式的进行处理，性能的消耗基本上都消耗在了网络传输上，在此基础
Redis学习之旅 ZSet(Sorted set)篇
小萤哥的博客
06-01 655
Redis学习之旅 ZSet(Sorted set)篇 为啥它叫ZSet？因为Set的开头字母也是S，Sorted Set缩写为SSet不合适 ，会导致命令冲突 ，所以干脆用Z代替，ZSet出生了~ 它的出现也是解决set天生无序的问题 命令学习 redis-cli模式下键入 help @sorted_set就可以快速相关的命令集合 1.0 时代 命令 起始版本 作用 示例 ZADD 1.2.0 添加元素 ZADD key [NX ZCARD 1.2.0 和SCARD很类似，统计
网页解析
weixin_49349430的博客
12-04 4259
在网络爬虫的系统框架中，主过程由控制，解析，资源库三部分组成。解析是负责网络爬虫的一个部分，其负责的工作主要有：下载网页的功能，对网页的文本进行处理，如过滤功能，抽取特殊HTML标签的功能，分析数据功能。 1. 网页解析： 是来自某些网站搜集来的资料，这些资料包含编号，名称，图片，链接等等元素，在这里只是将信息从标签中提取出来 获取请求返回的页面信息，筛选出我们想要的数据就可以了,有时候我们需要去一些网站上抓取数据，要想抓取数据，就必须先了解网页结构，根据具体的网页结构，编写对应的程序对数据进行采集 2.
Linux学习之旅
weixin_49349430的博客
12-02 2196
Author：Eric Version：9.0.1 文章目录一、引言1.1 开发环境1.2 生产环境1.3 测试环境1.4 操作系统的选择二、Linux介绍2.1 Linux介绍2.2 Linux的版本2.3 Linux和Windows区别三、Linux安装3.1 安装VMware3.2 安装Xterm3.3 在VMware中安装Linux3.3.1 选择安装方式3.3.2 指定镜像方式3.3.3 选择操作系统类型3.3.4 指定虚拟机名称3.3.5 磁盘存储方式3.3.6 指定虚拟机配置3.3.7 ..
ElasticSearch学习之旅
weixin_49349430的博客
12-07 1314
Author：Eric Version：9.0.0 文章目录一、引言1.1 海量数据1.2 高亮显示二、ES概述2.1 ES的介绍2.2 ES的由来2.3 ES和Solr2.4 倒排索引三、 ElasticSearch安装3.1 安装ES&Kibana3.2 安装IK分词器四、 ElasticSearch基本操作4.1 ES的结构4.1.1 索引Index，分片和备份4.1.2 类型 Type4.1.3 文档 Doc4.1.4 属性 Field4.2 操作ES的RESTful语法4.3 索引的..
JavaSE(一)--概述与环境
weixin_49349430的博客
11-21 1248
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
SpringCloud学习之旅
weixin_49349430的博客
12-24 1112
Author：Eric Version：9.0.0 文章目录一、SpringCloud介绍1.1 微服务架构1.2 SpringCloud介绍二、服务的注册与发现-Eureka【`重点`】2.1 引言2.2 Eureka的快速入门2.2.1 创建EurekaServer2.2.2 创建EurekaClient2.2.3 测试Eureka2.3 Eureka的安全性2.4 Eureka的高可用2.5 Eureka的细节三、服务间的负载均衡-Ribbon【`重点`】3.1 引言3.2 Ribbon的快速入..
JavaSE(五)--数组
weixin_49349430的博客
11-22 803
1.数组: 在内存内开辟一组连续空间来存值叫数组. 1.1 数组也是一种变量,也是一种引用数据类型. 1.2 数组由四个组成部分 数组名,数据类型,元素,索引(下标). 1.3 类型 同一个数组中,元素的数据类型相同的;不同的数组数据类型可以是java中任意类型. 1.4 索引 数组的索引从0开始. 1.5 访问数组中某个空间元素 数组名[索引]. 1.6 空间 数组一但分配了空间,它的长度是固定的. 1.7长度 数组的长度:数组名.length 1.8 范围 数组的索引范围在:0~数组名.lengt
揭秘2017云栖大会：云数据库Redis开源之旅与实战应用
在2017年的云栖大会上，...这次演讲不仅展示了阿里云在Redis技术上的创新和实践，也透露了未来的产品规划方向，对于想要了解阿里云Redis产品及其在实际业务中的应用和技术优势的用户来说，是一次非常有价值的学习资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值