Redis

最新推荐文章于 2023-05-05 09:44:14 发布
最新推荐文章于 2023-05-05 09:44:14 发布
阅读量310 收藏
点赞数
分类专栏： 中间件 文章标签： redis 数据库 nosql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47628224/article/details/119721968
版权
本文详细介绍了Redis的基础知识，包括数据类型如String、Hash、List、Set、Zset以及特殊类型，Redis的持久化机制RDB和AOF，过期策略和淘汰机制。还讲解了Redis的安装、配置、客户端连接以及Java操作Redis的方法。此外，文章还涵盖了Redis的主从复制、哨兵和集群的配置与使用，以解决单点故障和扩展性问题。
摘要由CSDN通过智能技术生成

零、Redise基础

  1. Redise: AP-可用性，分区容错性

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

数据类型

常用的5种数据结构：

  • key-string：一个key对应一个值。
  • key-hash：一个key对应一个Map。
  • key-list：一个key对应一个List列表。
  • key-set：一个key对应一个Set集合。
  • key-zset：一个key对应一个有序的Set集合。等价于：Map<Object,Double>

另外3种数据结构：

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

常用的客户端

  1. Jedis
  2. Redission
  3. Spring Data Redise

Redise的底层数据结构

  1. String类型: SDS (动态字符串,空间预分配、惰性空间释放) , 组成: free区域-剩余空间, len区域-长度, buf存放字符数组。

  2. ziplist(压缩列表,连锁更新) ,底层存储键值对的核心技术，节约内存,连续的区域,避免内存碎片

  3. Hash(拉链法) ,扩容和收缩。

  4. Skiplist(跳表),双链式 , header:头，tail尾 , level层数，length长度,实现快速访问-SortSet。

RESP协议: Redis序列化协议,自定义客户端需要使用

现象

击穿

高并发环境下,同时访问某个key,可是Key 失效 了,

导致大量的请求落到了数据库上，导致数据库崩溃。

穿透

高并发下，大量访问 不存在 的Key,导致请求落到了数据库上,从而导致数据库宕机。

雪崩

高并发下,大量访问的 key都过期了, 导致请求落到了数据库上，是数据库宕机。

倾斜

集群下,高并发，大量请求某个key ,

结果都被分配到了固定某台的服务器上，导致这台服务器压力过大。

集群可以 解决 这个问题

过期策略

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

有以下几种策略：

定期删除：

Redis每隔一段时间就会去查看Redis设置了过期时间的key，

会再100ms的间隔中默认查看3个key。

惰性删除：

如果当你去查询一个已经过了生存时间的key时，

Redis会先查看当前key的生存时间，是否已经到了，

直接删除当前key，并且给用户返回一个空值。

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 字节大小

持久化机制

1.AOF 2.RDB

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

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

一、Redis概述

1.1 传统数据库存在的问题

1.数据库压力过大

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

2.数据不同步

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

3.传统锁失效

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

1.2 NoSQL介绍

image.png

Redis就是一款NoSQL

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

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

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

类型部分代表特点
列存储HbaseCassandraHypertable顾名思义，是按列存储数据的。最大的特点是方便存储结构化和半结构化数据，方便做数据压缩，对针对某一列或者某几列的查询有非常大的IO优势。
文档存储MongoDBCouchDB文档存储一般用类似json的格式存储，存储的内容是文档型的。这样也就有机会对某些字段建立索引，实现关系数据库的某些功能。
key-value存储Tokyo Cabinet / TyrantBerkeley DBMemcacheDBRedis可以通过key快速查询到其value。一般来说，存储不管value的格式，照单全收。（Redis包含了其他功能）
图存储Neo4JFlockDB图形关系的最佳存储。使用传统关系数据库来解决的话性能低下，而且设计使用不方便。
对象存储db4oVersant通过类似面向对象语言的语法操作数据库，通过对象的方式存取数据。
xml数据库Berkeley DB XMLBaseX高效的存储XML数据，并支持XML的内部查询语法，比如XQuery,Xpath。

1.3 Redis简介

image.png

  • 有一位意大利人，在开发一款LLOOGG的统计页面，因为MySQL的性能不好，自己研发了一款非关系型数据库，并命名为Redis Salvatore。
  • Redis（Remote Dictionary Server）即远程字典服务，Redis是由C语言去编写，Redis是一款基于Key-Value的NoSQL，而且Redis是基于内存存储数据的，Redis还提供了多种持久化机制，性能可以达到110000/s读取数据以及81000/s写入数据，Redis还提供了主从，哨兵以及集群的搭建方式，可以更方便的横向扩展以及垂直扩展。

二、Redis安装

2.1 Linux原生安装Redis

a.找到Redis的下载地址

进入官网找到下载地址 https://redis.io/download

image.png

b.下载Redis

cd /usr/local

wget https://download.redis.io/releases/redis-6.2.1.tar.gz

image.png

c.解压Redis

tar -zxf redis-6.2.1.tar.gz

image.png

d.编译

cd redis-6.2.1

make

需要一段时间

image.png

ps：如果编译报错，可能缺乏c语言编译环境，可以通过以下命令检测

image.png

cc -v

image.png

如果报cc不是命令，那就是缺乏环境

yum -y install gcc

e.安装

make install

ps: 默认安装在/usr/local/bin目录

image.png

f.启动

/usr/local/bin/redis-server /usr/local/redis-6.2.1/redis.conf

image.png

2.2 Docker-Compose安装Redis

version: '3.1'
services:
  redis:
    image: redis:5.0.7
    restart: always
    container_name: redis6379
    command: ["redis-server" ,"--appendonly" ,"yes"]
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379
    volumes:
    - /docker/redis/redis6379/:/usr/local/tomcat/webapps   #挂载数据卷

2.3 Docker命令安装Redis

1.创建映射文件夹实现配置文件

mkdir -p /docker/redis/redis6380

上传（拷贝）redis.conf配置文件

2.创建并运行容器

docker run -d --name redis6380 -p 6380:6379 -v /docker/redis/redis6380/redis.conf:/etc/redis/redis.conf redis:6.2.1 redis-server /etc/redis/redis.conf

image.png

docker ps

image.png

image.png

3.开放端口

开放端口6380

2.3 Redis的配置文件

redis.conf

📎redis.conf.txt

配置项名称配置项值范围说明
daemonizeyes、noyes表示启用守护进程，默认是no即不以守护进程方式运行。其中Windows系统下不支持启用守护进程方式运行
port指定 Redis 监听端口，默认端口为 6379
bind绑定的主机地址,如果需要设置远程访问则直接将这个属性备注下或者改为bind * 即可,这个属性和下面的protected-mode控制了是否可以远程访问 。
protected-modeyes 、no默认是yes，即开启。设置外部网络连接redis服务，设置方式如下：1、关闭protected-mode模式，此时外部网络可以直接访问2、开启protected-mode保护模式，需配置bind ip或者设置访问密码
timeout300当客户端闲置多长时间后关闭连接，如果指定为 0，表示关闭该功能
logleveldebug、verbose、notice、warning日志级别，默认为 notice
databases16设置数据库的数量，默认的数据库是0。整个通过客户端工具可以看得到
rdbcompressionyes、no指定存储至本地数据库时是否压缩数据，默认为 yes，Redis 采用 LZF 压缩，如果为了节省 CPU 时间，可以关闭该选项，但会导致数据库文件变的巨大。
dbfilenamedump.rdb指定本地数据库文件名，默认值为 dump.rdb
dir指定本地数据库存放目录
requirepass设置 Redis 连接密码，如果配置了连接密码，客户端在连接 Redis 时需要通过 AUTH 命令提供密码，默认关闭
maxclients0设置同一时间最大客户端连接数，默认无限制，Redis 可以同时打开的客户端连接数为 Redis 进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis 会关闭新的连接并向客户端返回 max number of clients reached 错误信息。
maxmemoryXXX 指定 Redis 最大内存限制，Redis 在启动时会把数据加载到内存中，达到最大内存后，Redis 会先尝试清除已到期或即将到期的 Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis 新的 vm 机制，会把 Key 存放内存，Value 会存放在 swap 区。配置项值范围列里XXX为数值。

如果我们想在项目中使用Redis,至少需要配置如下几个信息：

1.bind 外网访问

2.requirepass 设置密码

3.daemonize yes 设置后台启动

2.4 客户端连接

自带的redis-cli连接Redis

/usr/local/bin/redis-cli

auth 密码

image.png

也可以使用可视化工具连接Redis

image.png

ps:记得关闭防火墙或者放行6379端口号，要是云服务器就是安全组开放6379端口

三、Redis核心

3.1 数据类型

常用的5种数据结构：

  • key-string：一个key对应一个值。
  • key-hash：一个key对应一个Map。
  • key-list：一个key对应一个List列表。
  • key-set：一个key对应一个Set集合。
  • key-zset：一个key对应一个有序的Set集合。等价于：Map<Object,Double>

另外3种数据结构：

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

image.png

  • key-string：最常用的，一般用于存储一个值。
  • key-hash：存储一个对象数据的。
  • key-list：使用list结构实现栈和队列结构。
  • key-set：交集，差集和并集的操作。
  • key-zset：排行榜，积分存储等操作。

Redis命令：http://doc.redisfans.com/

3.2 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

3.3 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

3.4 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

3.5 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

3.6 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中一样)
zrangebyscore key max min [withscores] [limit offset count]

3.7 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

3.8 库常用命令

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

#2. 清空全部数据库
flushall

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

#4. 查看最后一次操作的时间
lastsave

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

四、Java操作Redis

image.png

4.1 Jedis

a.依赖jar

        <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>

b.编写代码

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

c.其他复杂操作

        //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);
        //2.2 将key转换为byte[]
        byte[] byteKey1 = SerializationUtils.serialize(key);
        // jedis去Redis中获取value
        byte[] value1 = jedis.get(byteKey1);
        // 将value反序列化为User对象
        User user = (User) SerializationUtils.deserialize(value);
        String stringKey = "stringUser";
        User value = new User(2,"李四",new Date());
        //2.2 使用fastJSON将value转化为json字符串
        String stringValue = JSON.toJSONString(value);
        //存储到Redis中
        jedis.set(stringKey,stringValue);
         String value2 = jedis.get(key);
        // 将value反序列化为User
        User user2 = JSON.parseObject(value2, User.class);
        //输出
        System.out.println("user:" + user2);
        //------------------------------------------------
        //3. 释放资源
        jedis.close();

d.连接池的使用

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

4.2 Redisson

五、Redis进阶

5.1 Redis密码

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

# redis.conf

requirepass 密码

// 使用当前有参构造设置密码

public JedisPool(final GenericObjectPoolConfig poolConfig, final String host, int port,int timeout, final String password)

auth 密码 进行密码认证

5.2 Redis事务

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

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

- 开启事务：multi

- 输入要执行的命令：被放入到一个队列中

- 执行事务：exec

- 取消事务：discard

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

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

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

5.3 Redis持久化

Redis提供2种方式实现持久化：1.RDB 2.AOF

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

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

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

5.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无法保证数据的绝对安全。

RDB存储的是数据，时间间隔无法实时持久化

5.3.2 AOF

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

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

AOF持久化时机。

appendfsync always：每执行一个写操作，立即持久化到AOF文件中，性能比较低。

appendfsync everysec：每秒执行一次持久化。

appendfsync no：会根据你的操作系统不同，环境的不同，在一定时间内执行一次持久化。

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

AOF存储的是命令（更改数据的命令），可以实时持久化

5.4 Redis主从复制

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

image.png

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
    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
    links:
      - redis1:master
    command: ["redis-server","/usr/local/redis/redis.conf"]

5.5 Redis哨兵

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

image.png

修改了以下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: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
# 指定Master节点的ip和端口（从）
sentinel monitor master master 6379 2
# 哨兵每隔多久监听一次redis架构
sentinel down-after-milliseconds mymaster 10000

5.6 Redis集群

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

image.png

准备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"]

redis.conf配置文件

# redis.conf
# 指定redis的端口号
port 7001
# 开启Redis集群
cluster-enabled yes
# 集群信息的文件
cluster-config-file nodes-7001.conf
# 集群的对外ip地址
cluster-announce-ip 192.168.199.109
# 集群的对外port
cluster-announce-port 7001
# 集群的总线端口
cluster-announce-bus-port 17001

5.7 Jedis连接Redis集群

使用JedisCluster对象连接Redis集群

// 创建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);

5.7 Redis的过期策略

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

有以下几种策略：

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

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

5.8 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 字节大小

5.9 Redis穿透

image.png

5.10 Redis击穿

image.png

5.11 Redis雪崩

image.png

5.12 Redis倾斜

image.png

qwi
关注
专栏目录
windows下的redis压缩包
03-22
Redis是一种开源的、基于键值对的数据存储系统，常用于数据库、缓存和消息中间件。在Windows环境下，Redis提供了一个方便的压缩包，让用户能够快速地在Windows操作系统上部署和使用Redis服务，无需复杂的安装过程，...
假如Redis同时开了RDB和AOF会怎样？
m0_54385790的博客
01-11 1612
因为前面的数据是RDB记录的二进制形式的数据，所以直接加载进内存即可，而appendonly.aof 后面是少量的 AOF记录的命令，则需要重新执行。虽然是两种持久化方式都开启了，也就是说会产生 dump.rdb 和 appendonly.aof 两种文件，但是掉电恢复时，是只会使用 appendonly.aof 来恢复的！也就是说，这种情况下， appendonly.aof 文件的前部分是 RDB的数据，后部分才是AOF的数据。其实是可以的，我们可以两种持久化方式都开启（AOF默认是不开启的）
redis配置RDB、AOF以及RDB、AOF同时开启
yygr的博客
05-06 6104
https://www.jianshu.com/p/a91329ae210c 1、配置RDB持久化机制 redis.conf文件，也就是/etc/redis/6379.conf，去配置持久化 save 60 1000 每隔60s，如果有超过1000个key发生了变更，那么就生成一个新的dump.rdb文件，就是当前redis内存中完整的数据快照，这个操作也被称之为snapshotting，快照 也可以手动调用save或者bgsave命令，同步或异步执行rdb快照生成 save可以设置多个，
redis 9.Redis持久化之AOF (AOF和RDB同时开启统默认取AOF的数据、AOF启动/修复/恢复)， redis如何选择使用哪种持久化方式 ？
热门推荐
不是一枚开发
04-09 5万+
文章目录1.1 AOF概念1.2 AOF持久化流程1.3 AOF配置以及AOF和RDB同时开启统默认取AOF的数据1.3.1 AOF默认不开启1.3.2 AOF和RDB同时开启，系统默认取AOF的数据1.4 AOF启动/修复/恢复1.5 AOF同步频率设置1.6 Rewrite压缩1.6.1 概念：1.6.2 重写原理，如何实现重写1.6.3 重写流程1.7 优势劣势1.8 redis如何选择使用哪种持久化方式 ？AOF?RDB? 1.1 AOF概念   以日志的形式来记录每个写操作（增量保存），将Red
Redis持久化(六)-RDB+AOF混合持久化
星光之子的博客
01-14 4318
RDB-AOF混合持久化RDB+AOF同时使用RDB-AOF混合持久化 RDB+AOF同时使用 同时使用RDB持久化和AOF持久化是可行的，只要注意以下问题即可： 同时使用两种持久化功能需要耗费大量系统资源，系统的硬件必须能够支撑运行这两种功能所需的资源消耗，否则会给系统性能带来影响 Redis服务器在启动时，会优先使用AOF文件进行数据恢复，只有在没有检测到AOF文件时，才会考虑寻找并使用RDB文件进行数据恢复 当Redis服务器正在后台生成新的RDB文件时，如果有用户向服务器发送BGREWRITEAO
redis 持久化 RDB + AOF
lfssst的博客
05-05 1107
redis 持久化 RDB 、AOF 、混合模式、redis文件恢复
Redis5.0 Windows64
08-26
Redis 5.0是Redis数据库的一个重要版本，它在Windows 64位平台上提供了全面的支持。Redis是一款开源的、基于键值对的数据存储系统，常用于缓存、数据库和消息中间件等场景。以下是关于Redis 5.0在Windows 64位环境中...
redis-windows-7.0.11
05-05
Redis是一种开源的内存数据结构存储系统，它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。Redis可以用作数据库、缓存和消息中间件。Redis在性能、可扩展性和灵活性方面表现出色，因此被广泛应用于Web...
redis-6.2.14-win-amd64
最新发布
05-22
Redis是一种开源的、基于键值对的数据存储系统，常用于数据缓存、消息队列以及数据库功能。在Windows环境下，Redis的安装和使用通常需要经过编译和配置过程。"redis-6.2.14-win-amd64"是专门为Windows AMD64架构编译...
redis-windows-7.2.4.zip
01-14
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值对存储系统，它支持数据的持久化，可以作为数据库、缓存和消息中间件使用。Redis以其高速度和丰富的数据结构而闻名，广泛应用于互联网服务，如计数...
关于redis的RDB和AOF同时使用时的一些看法
weixin_55821558的博客
03-28 3453
同时开启RDB和AOF：在这种情况下当redis重启的时候优先加载AOF文件来恢复原始数据，因为在通常情况下AOF文件保存的数据要比RDB文件保存的数据集要完整。RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件。那要不要只使用AOF呢？建议不要，因为RDB更适合备分数据库（AOF在不断变换不好备分）快速重启，而且不会有AOF可能潜在的Bug，留着做一个万一的手段。 RDB持久化方式能够维持在指定时间间隔能对你的数据进行快照存储 AOF持久化方式记录每次对服务器写的操作，当服务器重启的时..
Redis-持久化讲解
Huangjiazhen711的博客
10-31 930
其中，“*3”表示当前命令有三个部分，每部分都是由“+数字”开头，后面紧跟着具体的命令、键或值。该状态开启后，如果执行bgrewriteaof命令，则会把当前内存中已有的数据弄成二进程存放在aof文件中，这个过程模拟了rdb生成的过程，然后Redis后面有其他命令，在触发下次重写之前，依然采用AOF追加的方式。加载损坏的AOF 文件时会拒绝启动，对于错误格式的AOF文件，先进行备份，然后采用redis-check-aof --fix命令进行修复，对比数据的差异，找出丢失的数据，有些可以人工修改补全。
NoSql之Redis基于Linux开发部署+面试题讲解
07-04
本课程共28节，内容包括nosql基本特点，linux环境下的下载安装与启动，常用命令，配置文件讲解，5种基本数据类型的特点、数存储结构和操作命令，redis安全策略，使用redis实现web服务器的session共享，持久化方式和配置，redis事务，jedis操作，主从复制与读写分离，哨兵机制，ruby环境配置，redis集群搭建，集群特性总结，springmvc集成，面试题讲解等。
黑猴子的家：Redis 持久化 之 AOF 和 RDB 同时开启，Redis听谁的？
黑猴子的博客
10-15 4966
听AOF的，RDB与AOF同时开启 默认无脑加载AOF的配置文件 相同数据集，AOF文件要远大于RDB文件，恢复速度慢于RDB AOF运行效率慢于RDB,但是同步策略效率好，不同步效率和RDB相同 1、Rewrite 重写 AOF采用文件追加方式，文件会越来越大为避免出现此种情况，新增了重写机制,当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩，只保留可以恢复数据的...
Redis 持久化 之 AOF 和 RDB 同时开启，Redis听谁的？
wangxuelei036的博客
05-24 2万+
https://www.jianshu.com/p/9cdf6c6d4cb0
Redis的两种持久化RDB和AOF
不忘初心的博客
10-07 2万+
Redis持久化备份数据的方式有两种：RDB(Redis DataBase) 、 AOF(Append Only  File). RDB 什么是RDB 在指定时间间隔内，将内存中的数据集快照写入磁盘，也就是Snapshot快照，它恢复时是将快照文件直接读到内存中，来达到恢复数据的。  如何持久化 Redis会单独创建(fork)一个子进程来进行持久化，会先将数据写进一个临时文件中，...
Redis如何加载数据以及加载优先级
chenliang
10-27 1263
先说答案： 01：只会加载AOF持久化的数据，不会加载RDB持久化的数据 02：没有什么说是先加载AOF持久化的数据再加载RDB持久化的数据 我的测试过程【在测试环境哈】 01：我redis的配置如下，只例出了关键的几个参数 dir /data/redis/6379/data/ # 数据目录指定了,就可保证在启动时能找不到持久化的数据了 ## RDB save 9000 100 # 900秒内有100个被更.
RDB与AOF的选择
不断总结不断成长
07-05 877
AOF定义：以日志的形式记录每个操作，将Redis执行过的所有指令全部记录下来（读操作不记录），只许追加文件但不可以修改文件，Redis启动时会读取AOF配置文件重构数据 换句话说，就是Redis重启就会根据日志内容从头到尾执行一次来完成数据的恢复工作。Tip:　　一.RDB与AOF同时开启  默认先加载AOF的配置文件　　二.相同数据集，AOF文件要远大于RDB文件，恢复速度慢于RDB　　三.A...
Redis中RDB和AOF使用细节
weixin_47270063的博客
10-20 753
Redis RDB 概念： 指在规定时间间隔内将内存中的数据集快照写入磁盘，也就是行话里讲的sanpshot快照，它恢复时将快照文件直接读入到内存中 Redis会单独的创建（fork）可以理解为复制一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程不进行任何io操作，这就确保了极高的性能，如果需要进行大规模的数据的恢复，且对于数据恢复的完整性不是非常敏感，那么RDB方式要比AOF方式更加高效。RDB缺点时最后一次持久化后数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值