Redis笔记

已于 2023-02-17 11:10:43 修改
阅读量101 收藏 1
点赞数 1
分类专栏： 笔记 文章标签： redis 缓存 java spring
于 2023-01-12 19:59:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45783700/article/details/128665466
版权

Redis

一个基于内存的key-value结构数据库，本质上是一个map，key永远是字符串，一般的，Redis的所有key都需要加时间

Redis 5种常用数据类型

  • 字符串 string: 普通字符串，较为常用
  • 哈希 hash: 适合存储对象
  • 列表 list: 按照插入顺序排序，可以有重复
  • 集合 set: 无序集合，没有重复元素
  • 有序集合 sorted set: 有序集合，没有重复元素

不常用数据类型

  • HyperLogLog(基数)
  • Bitmap(位集合)
  • Geospatial(地理空间索引)
  • Streams(流信息)

Redis常用命令

RedisAPI

字符串操作命令

  • Set key value: 设置指定key的值
  • Get key: 获取指定key的值
  • SETEX key seconds value: 设置指定key的值，并将key的过期时间设定为seconds秒
  • SETNX key value: 只有在key不存在时设置key的值

哈希操作命令

hash是一个string类型的field和value的映射表，hash特别适合用于存储对象，常用命令

  • HSET key field value: 将哈希表key中的字段field的值设为value
  • HGET key field: 获取存储在哈希表中指定字段的值
  • HDEL key field: 删除存储在哈希表中的指定字段
  • HKEYS key: 获取哈希表中所有字段
  • HVALS key: 获取哈希表中所有值
  • HGETALL: 获取在哈希表中指定key的所有字段和值

列表操作命令

  • LPUSH key value1 [values2[: 将一个或多个值插入到列表头部
  • RPUSH …
  • LRANGE key start stop: 获取列表指定范围内的元素，0 到 -1 表示全部
  • RPOP key: 移除并获取列表最后一个元素
  • LLEN key: 获取列表长度
  • BRPOP key1 [key2] timeout: 移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时并发现可弹出元素为止

集合操作命令

  • SADD key member1 [member2]: 向集合添加一个或多个成员
  • SMEMBERS key: 返回集合中的所有成员
  • SCARD key: 获取集合的成功数
  • SINTER key1 [key2]: 返回给定所有集合的交集
  • SUNION key1 [key2]: 返回所有给定集合的并集
  • SDIFF key1 [key2]: 返回给定所有集合的差集
  • SREM key member1 [member2]: 移除集合中一个或多个成员

有序集合操作命令

  • ZADD key score1 member1 [score2 member2]: 向有序集合添加一个或多个成员，或者更新已存在成员的分数
  • ZRANGE key start stop [WITHSCORES]: 通过索引区间返回有序集合中指定区间内的成员
  • ZINCRBY key increment member: 有序集合中对指定成员的分数加上增量increment
  • ZREM key member [member …]: 移除有序集合中的一个或多个成员

通用命令

  • KEYS pattern: 查找所有符合给定模式的key
  • EXISTS key: 检查给定key是否存在
  • TYPE key: 返回key所存储的值的类型
  • TTL key: 返回给定key的剩余生存时间，以秒为单位
  • DEL key: 该命令用于在key存在时删除key

Redis常用数据类型其他部分命令

  • 利用Redis实现分布式锁: set lock uuid EX 10 NX
    • 客户端之间的服务器时间要同步
    • EX后面的锁的失效时间低于锁竞争的频率
  • key中存储的数字值增一: incr key
  • key中存储的数字值减一: decr key
  • ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]: 有序集合中所有score值介于min和max之间的值
  • Pub/Sub(发布/订阅)
    • PSUBSCRIBE: 订阅一个或多个符合给定模式的频道
    • PUBLISH: 将信息message发送到指定的频道channel

SpringCache

SpringCache是一个框架,实现了基于注解的缓存功能,提供了一层抽象,底层可以切换不同的cache实现,具体可以通过CacheManager接口来统一不同的缓存技术

常用注解

  • @EnableChching: 开启缓存注解功能
  • @Chcheable: 在方法执行前spring先查看缓存中是否有数据,如果有数据,则直接返回缓存数据;若没有数据,调用方法并将方法返回值放到缓存中
// 如果缓存中没有,且可以查到数据,存入缓存
// 如果缓存中没有,且查不到数据,直接结束
// 如果缓存中有,直接返回
@Cacheable(value = "userCache", key = "#id", condition = "#result != null")
@Cacheable(value = "userCache", key = "#id", unless = "#result != null")
  • @CachePut: 将方法的返回值放到缓存中
  • @CacheEvict: 将一条或多条数据从缓存中删除
@CacheEvict(value = "...Cache", key = "#p0")  // 参数序号
@CacheEvict(value = "...Cache", key = "#id")  // 直接取key
@CacheEvict(value = "...Cache", key = "#root.args[0]")  // 参数序号
// 如果参数是实体类,key也可以从实体类获取
@CacheEvict(value = "...Cache", key = "#user.id")
@CacheEvict(value = "...Cache", key = "#result.id") // 从返回值获取

SpringDataRedis

使用步骤

  1. 导入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. 编写配置文件
server: 
  port: 8080
spring: 
  application:
    name: redis-demo
  redis: 
    host: localhost
    port: 6379
    password: password
  1. 测试
@Autowired
RedisTemplate redisTemplate;

@Test
public void test() {
    redisTemplate.opsForValue().set("name", "zhangsan");
}

Redis持久化

RDB持久化

RDB(Redis数据备份文件)，也被称为Redis数据快照，把内存中的所有数据都记录到磁盘中，当Redis实例故障重启后，从磁盘读取快照文件，恢复数据

RDB执行流程

bgsave开始时会fork主进程到子进程，子进程共享主进程的内存数据，完成fork后读取内存数据并写入RDB文件

  • 当主进程执行读操作时，访问共享内存
  • 当主进程执行写操作时，拷贝一份数据，执行写操作
执行时机
  • 执行save命令
  • 执行bgsave命令
  • Redis停机时
  • 出发RDB条件时
保存RDB文件
  1. save: 由Redis主进程执行RDB，会阻塞所有命令
  2. bgsave: 开启子进程执行RDB，避免主进程收到影响
Redis内部触发机制(redis.conf)
save 900 1	# 900秒内，如果至少有1个key被修改，则执行bgsave，如果是save "" 则表示禁用RDB
rdbcompression yes	# 是否压缩，建议不开启
dbfilename dump.rdb	# RDB文件名称
dir ./	# 文件保存的路径目录
缺点
  • RDB执行时间长，两次RDB之间写入数据有丢失的风险
  • fork子进程、压缩、写出RDB文件都比较耗时

AOF持久化

AOF(追加文件)，Redis处理的每一个写文件都会记录在AOF文件，可以看作是命令日志文件

配置
# AOF默认是关闭的，需要修改redis.conf配置文件来开启AOF
appendonly yes
# AOF文件的名称
appendfilename "appendonly.aof"

# 记录频率
# 表示每执行一次写命令，立即记录到AOF文件
appendfsync always
# 写命令执行完先放入AOF缓冲区，然后表示每个1秒将缓冲区数据写到AOF文件，默认方案
appendfsync everysec
# 写命令执行完先放入AOF缓冲区，由操作系统决定何时将缓冲区内容写回磁盘
appendfsync no

在这里插入图片描述

  • 因为是记录命令，AOF文件会比RDB文件大得多，AOF会记录对同一个key的多次写操作，但只有最后一写操作才有意义，通过执行bgrewriteaof命令，可以让AOF文件执行重写功能，只保留一个key的最后一次写操作
自动触发文件重写
# AOF文件比上次文件增加超过多少百分比触发重写
auto-aof-rewrite-percentage 100
# AOF文件体积最小多大时触发重写
auto-aof-rewrite-min-size 64mb

RDB和AOF对比

在这里插入图片描述

Redis主从集群

搭建主从集群

集群结构

我们搭建的主从集群结构如图：

在这里插入图片描述

共包含三个节点，一个主节点，两个从节点。

这里我们会在同一台虚拟机中开启3个redis实例，模拟主从集群，信息如下(IP使用自己的服务器的IP)：

IPPORT角色
192.168.150.1017001master
192.168.150.1017002slave
192.168.150.1017003slave
准备实例和配置

要在同一台虚拟机开启3个实例，必须准备三份不同的配置文件和目录，配置文件所在目录也就是工作目录。

1）创建目录

我们创建三个文件夹，名字分别叫7001、7002、7003：

# 进入/tmp目录
cd /tmp
# 创建目录
mkdir 7001 7002 7003

如图：

在这里插入图片描述

2）恢复原始配置

修改redis-6.2.4/redis.conf文件，将其中的持久化模式改为默认的RDB模式，AOF保持关闭状态。

# 开启RDB
# save ""
save 3600 1
save 300 100
save 60 10000

# 关闭AOF
appendonly no

3）拷贝配置文件到每个实例目录

然后将redis-6.2.4/redis.conf文件拷贝到三个目录中（在/tmp目录执行下列命令）：

# 方式一：逐个拷贝
cp redis-6.2.4/redis.conf 7001
cp redis-6.2.4/redis.conf 7002
cp redis-6.2.4/redis.conf 7003
# 方式二：管道组合命令，一键拷贝
echo 7001 7002 7003 | xargs -t -n 1 cp redis-6.2.4/redis.conf

4）修改每个实例的端口、工作目录

修改每个文件夹内的配置文件，将端口分别修改为7001、7002、7003，将rdb文件保存位置都修改为自己所在目录（在/tmp目录执行下列命令）：

sed -i -e 's/6379/7001/g' -e 's/dir .\//dir \/tmp\/7001\//g' 7001/redis.conf
sed -i -e 's/6379/7002/g' -e 's/dir .\//dir \/tmp\/7002\//g' 7002/redis.conf
sed -i -e 's/6379/7003/g' -e 's/dir .\//dir \/tmp\/7003\//g' 7003/redis.conf

5）修改每个实例的声明IP

虚拟机本身有多个IP，为了避免将来混乱，我们需要在redis.conf文件中指定每一个实例的绑定ip信息，格式如下：

# redis实例的声明 IP
replica-announce-ip 192.168.150.101

每个目录都要改，我们一键完成修改（在/tmp目录执行下列命令）：

# 逐一执行
sed -i '1a replica-announce-ip 192.168.150.101' 7001/redis.conf
sed -i '1a replica-announce-ip 192.168.150.101' 7002/redis.conf
sed -i '1a replica-announce-ip 192.168.150.101' 7003/redis.conf

# 或者一键修改
printf '%s\n' 7001 7002 7003 | xargs -I{} -t sed -i '1a replica-announce-ip 192.168.150.101' {}/redis.conf
启动

为了方便查看日志，我们打开3个ssh窗口，分别启动3个redis实例，启动命令：

# 第1个
redis-server 7001/redis.conf
# 第2个
redis-server 7002/redis.conf
# 第3个
redis-server 7003/redis.conf

启动后：

在这里插入图片描述

如果要一键停止，可以运行下面命令：

printf '%s\n' 7001 7002 7003 | xargs -I{} -t redis-cli -p {} shutdown
开启主从关系

现在三个实例还没有任何关系，要配置主从可以使用replicaof 或者slaveof（5.0以前）命令。

有临时和永久两种模式：

  • 修改配置文件（永久生效）

    • 在redis.conf中添加一行配置：slaveof <masterip> <masterport>

  • 使用redis-cli客户端连接到redis服务，执行slaveof命令（重启后失效）：

    slaveof <masterip> <masterport>

注：在5.0以后新增命令replicaof，与salveof效果一致。

这里我们为了演示方便，使用方式二。

通过redis-cli命令连接7002，执行下面命令：

# 连接 7002
redis-cli -p 7002
# 执行slaveof
slaveof 192.168.150.101 7001

通过redis-cli命令连接7003，执行下面命令：

# 连接 7003
redis-cli -p 7003
# 执行slaveof
slaveof 192.168.150.101 7001

然后连接 7001节点，查看集群状态：

# 连接 7001
redis-cli -p 7001
# 查看状态
info replication

结果：

在这里插入图片描述

测试

执行下列操作以测试：

  • 利用redis-cli连接7001，执行set num 123

  • 利用redis-cli连接7002，执行get num，再执行set num 666

  • 利用redis-cli连接7003，执行get num，再执行set num 888

可以发现，只有在7001这个master节点上可以执行写操作，7002和7003这两个slave节点只能执行读操作。

数据同步原理

主从第一次同步是全量同步:

在这里插入图片描述

判断是不是第一次来同步数据:

  • Replication Id: 简称replid，是数据集的标记，id一致说明是同一数据集，每一个master都有唯一的replid，slave会继承master的replid
  • offset: 偏移量，随着记录在repl_baklog中的数据增多而逐渐增大，slave完成同步的同时也会记录当前同步的offset，如果slave的offset小于master的offset，说明slave数据落后于master，需要更新

主从同步不是第一次进行同步是增量同步(主从之间只更新存在差异的部分):

在这里插入图片描述

  • 注: repl_baklog大小有上限，如果slave的数据差距过多，说明已经有一些数据还没来得及同步就被新的数据覆盖(可以理解为repl_baklog是一个环)，此时就不得不进行全量同步
主从复制优化
  • 在master中配置repl-diskless-sync yes启动无磁盘复制，避免全量同步时的磁盘IO
  • Redis单节点上的内存占用不要太大，减少RDB导致的过多磁盘IO
  • 适当提高repl_baklog的大小，发现slave宕机时尽快实现故障恢复，尽可能避免全量同步

Redis哨兵

Redis提供了哨兵机制，提供在故障后提供自动恢复策略

作用
  • 监控: Sentinel会不断检查master节点和slave节点是否按照预期工作
  • 自动故障恢复: 如果master故障，Sentinel会将一个slave提升为master节点，当故障恢复后也以新的master为主
  • 通知: Sentinel充当Redis客户端的服务来源，当集群发生故障转移时，会将最新信息推送给Redis的客户端
服务状态监控

Sentinel基于心跳机制检测服务状态，每隔一秒向集群的每个实例发送ping命令

  • 主观下线: 如果某sentinel节点发现某实例未在规定时间响应，则认为该实例主观下线
  • 客观下线: 若超过指定数量的sentinel都认为该实例主观下线，则该实例客观下线(quirum值最好超过Sentinel实例数量的一半)
选取新的master

一旦发现master故障sentinel需要在salve中选择一个作为新的master

策略:

  1. 首先会判断slave节点与master节点断开时间长短，如果超过指定值(down - after - milliseconds * 10)，则会排除该slave节点
  2. 然后判断slave节点的slave-priority值，越小优先级越高，如果是0则永不参与选举
  3. 如果slave-prority一样，则判断slave节点的offset值，越大说明数据越新，优先级越高
  4. 最后判断slave节点的运行id(redis启动时生成)大小，越小优先级越高

当选中了其中一个slave为master之后步骤:

  1. sentinel给备选的slave1节点发送slaveof no one命令，让该节点成为master
  2. sentinel给其他所有slave发送slaveof ip 端口命令，让这些slave成为新master的从节点，开始从新的master上同步数据
  3. 最后，sentinel将故障节点标记为slave，当故障节点恢复后会自动成为新的master的slave节点
搭建哨兵集群
集群结构

这里我们搭建一个三节点形成的Sentinel集群，来监管之前的Redis主从集群。如图：

在这里插入图片描述

三个sentinel实例信息如下：

节点IPPORT
s1192.168.150.10127001
s2192.168.150.10127002
s3192.168.150.10127003
准备实例和配置

要在同一台虚拟机开启3个实例，必须准备三份不同的配置文件和目录，配置文件所在目录也就是工作目录。

我们创建三个文件夹，名字分别叫s1、s2、s3：

# 进入/tmp目录
cd /tmp
# 创建目录
mkdir s1 s2 s3

如图：

在这里插入图片描述

然后我们在s1目录创建一个sentinel.conf文件，添加下面的内容：

port 27001
sentinel announce-ip 192.168.150.101
sentinel monitor mymaster 192.168.150.101 7001 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
dir "/tmp/s1"

解读：

  • port 27001：是当前sentinel实例的端口
  • sentinel monitor mymaster 192.168.150.101 7001 2：指定主节点信息
    • mymaster：主节点名称，自定义，任意写
    • 192.168.150.101 7001：主节点的ip和端口
    • 2：选举master时的quorum值

然后将s1/sentinel.conf文件拷贝到s2、s3两个目录中（在/tmp目录执行下列命令）：

# 方式一：逐个拷贝
cp s1/sentinel.conf s2
cp s1/sentinel.conf s3
# 方式二：管道组合命令，一键拷贝
echo s2 s3 | xargs -t -n 1 cp s1/sentinel.conf

修改s2、s3两个文件夹内的配置文件，将端口分别修改为27002、27003：

sed -i -e 's/27001/27002/g' -e 's/s1/s2/g' s2/sentinel.conf
sed -i -e 's/27001/27003/g' -e 's/s1/s3/g' s3/sentinel.conf
启动

为了方便查看日志，我们打开3个ssh窗口，分别启动3个redis实例，启动命令：

# 第1个
redis-sentinel s1/sentinel.conf
# 第2个
redis-sentinel s2/sentinel.conf
# 第3个
redis-sentinel s3/sentinel.conf

启动后：

在这里插入图片描述

测试

尝试让master节点7001宕机，查看sentinel日志：

在这里插入图片描述

查看7003的日志：

在这里插入图片描述

查看7002的日志：

在这里插入图片描述

RedisTemplate的哨兵模式
  1. 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. 编写配置文件
spring: 
  redis: 
    sentinel: 
      master: mymaster	# 指定的master名称
      nodes: # 指定redis-sentinel集群信息
        - 192.168.150.101: 27001
        - 192.168.150.101: 27002
        - 192.168.150.101: 27003
  1. 配置主从读写分离
@Bean
public LettuceClientConfigurationBuilderCustomizer configurationBuilderCustomizer() {
    return configBuilder -> configBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
    // MASTER: 从主节点读取
    // MASTER_PREFERRED: 优先从master节点读取，master不可用才读取replica
    // REPLICA: 从slave(replica)节点读取
    // REPLICA_PREFERRED: 优先从slave(replica)节点读取，所有的slave都不可用才读取master
}

搭建分片集群

主从和哨兵可以解决高可用、高并发读的问题，但是依然有两个问题没有解决

  • 海量数据存储问题
  • 高并发写的问题

使用分片集群可以解决上述问题，分片集群特征:

  • 集群中有多个master，每个master保存不同的数据
  • 每个master都可以有多个slave节点
  • master之间通过ping检测彼此健康状态
  • 客户端请求可以访问集群任意节点，最终都会被转发到正确节点
集群结构

分片集群需要的节点数量较多，这里我们搭建一个最小的分片集群，包含3个master节点，每个master包含一个slave节点，结构如下：

在这里插入图片描述

这里我们会在同一台虚拟机中开启6个redis实例，模拟分片集群，信息如下：

IPPORT角色
192.168.150.1017001master
192.168.150.1017002master
192.168.150.1017003master
192.168.150.1018001slave
192.168.150.1018002slave
192.168.150.1018003slave
准备实例和配置

删除之前的7001、7002、7003这几个目录，重新创建出7001、7002、7003、8001、8002、8003目录：

# 进入/tmp目录
cd /tmp
# 删除旧的，避免配置干扰
rm -rf 7001 7002 7003
# 创建目录
mkdir 7001 7002 7003 8001 8002 8003

在/tmp下准备一个新的redis.conf文件，内容如下：

port 6379
# 开启集群功能
cluster-enabled yes
# 集群的配置文件名称，不需要我们创建，由redis自己维护
cluster-config-file /tmp/6379/nodes.conf
# 节点心跳失败的超时时间
cluster-node-timeout 5000
# 持久化文件存放目录
dir /tmp/6379
# 绑定地址
bind 0.0.0.0
# 让redis后台运行
daemonize yes
# 注册的实例ip
replica-announce-ip 192.168.150.101
# 保护模式
protected-mode no
# 数据库数量
databases 1
# 日志
logfile /tmp/6379/run.log

将这个文件拷贝到每个目录下：

# 进入/tmp目录
cd /tmp
# 执行拷贝
echo 7001 7002 7003 8001 8002 8003 | xargs -t -n 1 cp redis.conf

修改每个目录下的redis.conf，将其中的6379修改为与所在目录一致：

# 进入/tmp目录
cd /tmp
# 修改配置文件
printf '%s\n' 7001 7002 7003 8001 8002 8003 | xargs -I{} -t sed -i 's/6379/{}/g' {}/redis.conf
启动

因为已经配置了后台启动模式，所以可以直接启动服务：

# 进入/tmp目录
cd /tmp
# 一键启动所有服务
printf '%s\n' 7001 7002 7003 8001 8002 8003 | xargs -I{} -t redis-server {}/redis.conf

通过ps查看状态：

ps -ef | grep redis

发现服务都已经正常启动：

在这里插入图片描述

如果要关闭所有进程，可以执行命令：

ps -ef | grep redis | awk '{print $2}' | xargs kill

或者（推荐这种方式）：

printf '%s\n' 7001 7002 7003 8001 8002 8003 | xargs -I{} -t redis-cli -p {} shutdown
创建集群

虽然服务启动了，但是目前每个服务之间都是独立的，没有任何关联。

我们需要执行命令来创建集群，在Redis5.0之前创建集群比较麻烦，5.0之后集群管理命令都集成到了redis-cli中。

1）Redis5.0之前

Redis5.0之前集群命令都是用redis安装包下的src/redis-trib.rb来实现的。因为redis-trib.rb是有ruby语言编写的所以需要安装ruby环境。

# 安装依赖
yum -y install zlib ruby rubygems
gem install redis

然后通过命令来管理集群：

# 进入redis的src目录
cd /tmp/redis-6.2.4/src
# 创建集群
./redis-trib.rb create --replicas 1 192.168.150.101:7001 192.168.150.101:7002 192.168.150.101:7003 192.168.150.101:8001 192.168.150.101:8002 192.168.150.101:8003

2）Redis5.0以后

我们使用的是Redis6.2.4版本，集群管理以及集成到了redis-cli中，格式如下：

redis-cli --cluster create --cluster-replicas 1 192.168.150.101:7001 192.168.150.101:7002 192.168.150.101:7003 192.168.150.101:8001 192.168.150.101:8002 192.168.150.101:8003

命令说明：

  • redis-cli --cluster或者./redis-trib.rb：代表集群操作命令
  • create：代表是创建集群
  • --replicas 1或者--cluster-replicas 1 ：指定集群中每个master的副本个数为1，此时节点总数 ÷ (replicas + 1) 得到的就是master的数量。因此节点列表中的前n个就是master，其它节点都是slave节点，随机分配到不同master

运行后的样子：

在这里插入图片描述

这里输入yes，则集群开始创建：

在这里插入图片描述

通过命令可以查看集群状态：

redis-cli -p 7001 cluster nodes

在这里插入图片描述

测试

尝试连接7001节点，存储一个数据：

# 连接
redis-cli -p 7001
# 存储数据
set num 123
# 读取数据
get num
# 再次存储
set a 1

结果悲剧了：

在这里插入图片描述

集群操作时，需要给redis-cli加上-c参数才可以：

redis-cli -c -p 7001

这次可以了：

在这里插入图片描述

分片集群散列插槽

Redis会把每一个master节点映射到0~16383共16384个插槽上

数据key并不是与节点绑定的，而是与插槽绑定，Redis会根据key的有效部分计算插槽值:

  • key中包含{}，且{}中至少包含1个字符，{}中的部分是有效部分
  • key中不包含{}，整个key都是有效部分
集群伸缩
  • 添加节点:
redis-cli --cluster \
add-node new_host:new_port existing_host:existing_port \ # 第二个参数是集群中已经存在的ip和端口
 # 如果不添加下面两个参数，就默认为master节点
 --cluster-slave	
 --cluster-master-id <arg>
  • 插槽分配
redis-cli --cluster reshard \
 ip:端口
  • 数据迁移

利用cluster failover命令可以手动让集群中的某个master宕机，切换到执行cluster failover命令的这个slave节点，实现无感知的数据迁移，三种模式:

  1. 缺省: 默认的流程，如图1~6步
  2. force: 省略了对offset的一致性校验
  3. takeover: 直接执行第5步，忽略数据一致性、忽略master的状态和其他master的意见

在这里插入图片描述

RedisTemplate中使用分片集群
  1. 导入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. 编写配置文件
spring: 
  redis: 
    cluster: 
      nodes: 
        - 192.168.150.101: 7001
        - 192.168.150.101: 7002
        - 192.168.150.101: 7003
        - 192.168.150.101: 8001
        - 192.168.150.101: 8002
        - 192.168.150.101: 8003
  1. 配置读写分离
@Bean
public LettuceClientConfigurationBuilderCustomizer clientConfigurationBuilderCustomizer(){
    return clientConfigurationBuilder -> clientConfigurationBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
}
  1. 使用
分片集群中的一些命令
  • 查看节点: redis-cli -p 端口 cluster nodes
  • 连接某节点: redis-cli -c -p 端口
  • 查看帮助文档: redis-cli --cluster help
XLrong2000
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
狂神说Redis笔记.pdf
08-09
狂神Redis课堂笔记，Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. 翻译为：Redis是一个开源的内存中的数据结构存储系统，它可以用作...
Redis注解集成之解决@CacheEvict只能单一清除的扩展 -模糊清除多条缓存
一个有梦想的混子
04-16 4166
1.@CacheEvic(value="xx",key="xxx")只能单一删除,但是 @Cacheable(value = "autocms", key = "#root.targetClass+'.'+#root.method.name+'.'+#p0+'.'+#p1") public <T> PageInfo<T> getActivityByS...
【springboot】缓存之@Cacheable、@CachePut、@CacheEvict的用法
王佑辉的博客
04-20 5826
*** @Description 学生服务实现类*/@Service@Autowired@Override/*** @Description 自定义Key生成器*/@Override/*** @Description 学生服务实现类*/@Service@Autowired@Override/*** @Description 自定义缓存解析器*/@Slf4j。
搭建redis哨兵集群，master宕机后无法执行故障切换的解决方法
njzgIdba的博客
09-07 1448
解决方法：在redis主从集群的每一个redis.conf文件、哨兵集群的每一个sentinel.conf文件添加bind 0.0.0.0
Redis 主从搭建_____ (及遇到的坑____)
禧年
05-02 751
文章目录:前言：开始搭建Redis 主从集群:1.上传下载好的 linux 版本的Redis 的服务器：2.集群规划：3. 我们创建三个文件夹，名字分别叫7001、7002、7003：4.拷贝配置文件到每个实例目录5.修改每个实例的端口、工作目录6.修改每个实例的声明IP逐一执行7.启动8.启动完成之后报错信息:自言自语中:敲黑板：开始测试查看状态主从集群永久生效和临时生效两种：9.总结： 前言： 今天是 五一劳动节 的第二天，心血来潮，买来一台服务器，搭建redis集，解决下本地java 中的另外一个问题
Redis持久化实操
S mile0804的博客
06-01 396
为了防止在 redis 分布式缓存中数据丢失，Redis 提供了两种持久化方案： RDB 持久化 AOF 持久化 Ⅰ. RDB 持久化 RDB 全称 Redis Database Backup file（Redis 数据备份文件），也被叫做 Redis 数据快照。简单来说就是把内存中的所有数据都记录到磁盘中。当 Redis 实例故障重启后，从磁盘读取快照文件，恢复数据。快照文件称为 RDB文 件，默认是保存在当前运行目录。 1.1 执行时机 RDB 持久化在四种情况下会执行： ......
redis笔记
daemon329的博客
05-30 465
1.String set get getset exists append strlen incr decr incrby decrby getrange setrange setex ttl setnx mset mget msetnx
尚硅谷redis笔记
qq_64137391的博客
11-01 1586
Redis（Remote Dictionary Server )，即远程字典服务。是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。免费和开源！是当下最热门的NoSQL技术之一，也被人们称之为结构化数据库。Redis是一个开源的key-value存储系统。
黑马Redis笔记高级篇 | 分布式缓存
2301_77450803的博客
05-11 1155
RDB全称Redis Database Backup file（Redis数据备份文件），也被叫做Redis数据快照。简单来说就是把内存中的所有数据都记录到磁盘中。当Redis实例故障重启后，从磁盘读取快照文件，恢复数据。快照文件称为RDB文件，默认是保存在当前运行目录Redis停机时会执行一次RDB。（save命令由Redis主进程来执行RDB，会阻塞所有命令；bgsave命令则开启子进程执行RDB，是异步的，避免主进程受到影响）
Redis笔记-尚硅谷周阳V1.3-脑图
06-16
根据《Redis笔记-尚硅谷周阳V1.3》整理，脑图、思维导图xmind
狂神说Redis笔记.md
03-25
狂神说Redis笔记.md
狂神说-Redis笔记(完整版).md
03-14
狂神说-Redis笔记(完整版).md
Redis-集群方案
A的博客
05-14 868
Cluster分片集群 : 多主多从 , 解决高并发写的问题, , Cluster 它将数据分片存储到多个节点上，并通过集群间的消息通信(PING命令)来实现数据的自动迁移和故障转移。哨兵（Sentinel）集群 : 主从集群的结构之上 , 加入了哨兵用于监控集群状态 , 主节点出现故障, 执行主从切换 , 解决高可用问题，每个 Sentinel 进程都会监控一组 Redis 实例，并通过投票选举出新的主节点。解决高并发读的问题，主节点负责写操作，从节点复制主节点的数据，并提供读服务。
windows设置Redis服务后台自启动
m0_73774439的博客
05-15 629
windows设置Redis服务后台自启动
Redis04持久化操作
a12jggfdd的博客
05-15 313
Redis持久化操作内容的学习。
安装docker版redis并挂载配置文件redis.conf
最新发布
小杰玩编程
05-17 197
默认情况下，启动docker redis容器没有redis.conf配置文件。因此这里用docker compose来启动容器，下面以redis5.0为例。
【从零开始学习Redis | 第十一篇】快速介绍Redis持久化策略
fckbb的博客
05-14 1014
Redis 作为一种快速、高效的内存数据库，被广泛应用于缓存、消息队列、会话存储等场景。然而，由于其特性是基于内存的，一旦服务器进程退出，内存中的数据就会丢失。为了解决这一问题，Redis 提供了持久化功能，可以将内存中的数据保存到硬盘上，以便在服务器重启时恢复数据。持久化是 Redis 的关键特性之一，对于确保数据的安全性和可靠性至关重要。本文将深入探讨 Redis 的持久化策略，包括常用的持久化方式以及各自的优缺点。
Redis详解（二）
软软的铲屎官的博客
05-13 1069
原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。一致性（Consistency）事务前后数据的完整性必须保持一致。隔离性（Isolation）多个事务并发执行时，一个事务的执行不应影响其他事务的执行持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响Redis的事务总是具有ACID中的一致性和隔离性，其他特性是不支持的。
狂神说redis笔记
07-27
狂神在他的Redis笔记中可能会涉及到一些内容，但是根据提供的引用内容，无法确定具体是哪些内容。可以使用自定义的配置文件来启动Redis服务，使用systemctl命令来启动和关闭服务。\[1\]在复杂的情况下，可以使用专业...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值