Redis===》数据类型之列表有序无序，常用命令，RDBAOFRDB+AOF

Posted 2021-05-18 一夜暴富--gogogo

一、redis数据类型

1.列表

redis列表就是redis的字符串类型的集合，按照插入顺序排序

#1.从左边插入数据（后进先出）
127.0.0.1:6379> lpush peopel yyy
(integer) 1
127.0.0.1:6379> lrange peopel 0 -1
1) "yyy"
127.0.0.1:6379> lpush peopel yyy man shanghai
(integer) 4
127.0.0.1:6379> lrange peopel 0 -1  #从头部插入
1) "shanghai"
2) "man"
3) "yyy"
4) "yyy"

#2.从右边插入数据（先进先出）
127.0.0.1:6379> rpush peopel abc
(integer) 5
127.0.0.1:6379> lrange peopel 0 -1
1) "shanghai"
2) "man"
3) "yyy"
4) "yyy"
5) "abc"

#3.查看看数据
127.0.0.1:6379> lrange peopel 0 -1  #从开始到结束
1) "shanghai"
2) "man"
3) "yyy"
4) "yyy"
5) "abc"
127.0.0.1:6379> lrange peopel 2 4  #从第二位到第四位
1) "yyy"
2) "yyy"
3) "abc"

#4.从左边追加数据（与sting类型中的nx类似，只有当list存在时才会从左边依次追加元素）
127.0.0.1:6379> lrange peopel 0 -1
1) "shanghai"
2) "man"
3) "yyy"
4) "yyy"
5) "abc"
127.0.0.1:6379> lpushx peopel 345  #从头部追加345
(integer) 6
127.0.0.1:6379> lrange peopel 0 -1
1) "345"
2) "shanghai"
3) "man"
4) "yyy"
5) "yyy"
6) "abc"

#5.从右边追加数据（只有当list存在时才会从右边依次追加元素）
127.0.0.1:6379> lrange peopel 0 -1
1) "345"
2) "shanghai"
3) "man"
4) "yyy"
5) "yyy"
6) "abc"
127.0.0.1:6379> rpushx peopel 123  #从尾部追加123
(integer) 7
127.0.0.1:6379> lrange peopel 0 -1
1) "345"
2) "shanghai"
3) "man"
4) "yyy"
5) "yyy"
6) "abc"
7) "123"

#6.在某个key的前面或者后面追加一个数据
127.0.0.1:6379> lrange peopel 0 -1
1) "345"
2) "shanghai"
3) "man"
4) "yyy"
5) "yyy"
6) "abc"
7) "123"
127.0.0.1:6379> linsert peopel before shanghai 111  #在上海的前边添加111
(integer) 8
127.0.0.1:6379> lrange peopel 0 -1
1) "345"
2) "111"
3) "shanghai"
4) "man"
5) "yyy"
6) "yyy"
7) "abc"
8) "123"

#7.指定删除多少个values（从列表左侧开始移除）
127.0.0.1:6379> lrange peopel 0 -1
1) "345"
2) "111"
3) "shanghai"
4) "man"
5) "yyy"
6) "yyy"
7) "abc"
8) "123"
127.0.0.1:6379> lrem peopel 1 111  #从列表左侧开始删除1个111
(integer) 1
127.0.0.1:6379> lrange peopel 0 -1
1) "345"
2) "shanghai"
3) "man"
4) "yyy"
5) "yyy"
6) "abc"
7) "123"

#8.修改数据（指定下标修改数据）
127.0.0.1:6379> lrange peopel 0 -1
1) "shanghai"
2) "man"
3) "yyy"
4) "yyy"
5) "abc"
6) "123"
127.0.0.1:6379> lset peopel 4 111  #指定第4位修改成111
OK
127.0.0.1:6379> lrange peopel 0 -1
1) "shanghai"
2) "man"
3) "yyy"
4) "yyy"
5) "111"
6) "123"

#9.截取字符串
127.0.0.1:6379> lrange peopel 0 -1
1) "shanghai"
2) "man"
3) "yyy"
4) "yyy"
5) "111"
6) "123"
127.0.0.1:6379> ltrim peopel 1 3  #截取从1到3
OK
127.0.0.1:6379> lrange peopel 0 -1
1) "man"
2) "yyy"
3) "yyy"

#10.查看长度
127.0.0.1:6379> llen peopel
(integer) 3
127.0.0.1:6379> lrange peopel 0 -1
1) "man"
2) "yyy"
3) "yyy"

#11.根据下标查询数据
127.0.0.1:6379> lrange peopel 0 -1
1) "man"
2) "yyy"
3) "yyy"
127.0.0.1:6379> lindex peopel 2
"yyy"

#12.从左边开始消费
127.0.0.1:6379> lrange peopel 0 -1
1) "man"
2) "yyy"
3) "yyy"
127.0.0.1:6379> lpop peopel 
"man"
127.0.0.1:6379> lrange peopel 0 -1
1) "yyy"
2) "yyy"

#13.从右边开始消费
127.0.0.1:6379> lrange peopel 0 -1
1) "yyy"
2) "yyy"
127.0.0.1:6379> rpop peopel
"yyy"
127.0.0.1:6379> lrange peopel 0 -1
1) "yyy"

#14.消费一个元素追加另一个列表里 （从尾开始）
127.0.0.1:6379> lrange peopel 0 -1
1) "555"
2) "444"
3) "333"
4) "222"
5) "111"
6) "111"
127.0.0.1:6379> rpoplpush peopel newlist
"111"
127.0.0.1:6379> lrange peopel 0 -1
1) "555"
2) "444"
3) "333"
4) "222"
5) "111"
127.0.0.1:6379> lrange newlist 0 -1
1) "111"

#15.实时获取某一个值

2.无序集合

Redis 的 Set 是 string 类型的无序集合。集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。集合中最大的成员数为 2^32 - 1 (4294967295, 每个集合可存储 40多亿个成员）。

#1.增加数据
127.0.0.1:6379> sadd mysqlset 1
(integer) 0
127.0.0.1:6379> sadd mysqlset 12
(integer) 0
127.0.0.1:6379> sadd mysqlset 123
(integer) 0
127.0.0.1:6379> sadd mysqlset 1234
(integer) 1
127.0.0.1:6379> sadd mysqlset 12345
(integer) 1

#2.查看数据
127.0.0.1:6379> smembers mysqlset
1) "1"
2) "12"
3) "123"
4) "1234"
5) "12345"

#3.删除数据
127.0.0.1:6379> smembers mysqlset
1) "1"
2) "12"
3) "123"
4) "1234"
5) "12345"
127.0.0.1:6379> srem mysqlset 123
(integer) 1
127.0.0.1:6379> smembers mysqlset
1) "1"
2) "12"
3) "1234"
4) "12345"

#4.移动数据
127.0.0.1:6379> sadd myset qqq
(integer) 1
127.0.0.1:6379> smembers myset
1) "qqq"
127.0.0.1:6379> smove mysqlset myset 1234
(integer) 1
127.0.0.1:6379> smembers myset
1) "qqq"
2) "1234"

#5.返回集合当中的个数
127.0.0.1:6379> smembers myset
1) "qqq"
2) "1234"
127.0.0.1:6379> scard myset
(integer) 2

#6.随机返回两个数据
127.0.0.1:6379> srandmember mysqlset 2
1) "12345"
2) "1"

#7.判断一个数据是否存在一个集合中
127.0.0.1:6379> sismember mysqlset abc
(integer) 0  #不存在返回0
127.0.0.1:6379> sismember mysqlset 12
(integer) 1  #存在返回1

#8.随机消费一个成员并从集合中删除该成员
127.0.0.1:6379> smembers mysqlset
1) "1"
2) "12"
3) "12345"
127.0.0.1:6379> spop mysqlset 1
1) "12"
127.0.0.1:6379> smembers mysqlset
1) "1"
2) "12345"

#9.返回多个集合中的交集
127.0.0.1:6379> sadd myseta 1 2 3 4 5
(integer) 5
127.0.0.1:6379> sadd mysetb 1 2 3 7 8 9
(integer) 6
127.0.0.1:6379> sadd mysetc 1 2 3 4 5 6 7 8
(integer) 8
127.0.0.1:6379> sinter myseta mysetb mysetc
1) "1"
2) "2"
3) "3"

#10.返回多个集合的并集
127.0.0.1:6379> sadd myseta 1 2 3 4 5
(integer) 5
127.0.0.1:6379> sadd mysetb 1 2 3 7 8 9
(integer) 6
127.0.0.1:6379> sadd mysetc 1 2 3 4 5 6 7 8
(integer) 8
127.0.0.1:6379> sunion myseta mysetb mysetc
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"
9) "9"

#11.返回多个集合的差集
127.0.0.1:6379> sadd myseta 1 2 3 4 5
(integer) 5
127.0.0.1:6379> sadd mysetb 1 2 3 7 8 9
(integer) 6
127.0.0.1:6379> sadd mysetc 1 2 3 4 5 6 7 8
(integer) 8
127.0.0.1:6379> sdiff mysetc mysetb myseta
1) "6"

3.有序集合

Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一 个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序。有序集合的成员是唯一的, 但分数(score)却可以重复。集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。 集合中最大 的成员数为 2^32 - 1 (4294967295, 每个集合可存储 40多亿个成员）。

#1.添加数据
127.0.0.1:6379> zadd myset1 1 one
(integer) 1
127.0.0.1:6379> zadd myset1 2 two
(integer) 1
127.0.0.1:6379> zadd myset1 30 qqq
(integer) 1
127.0.0.1:6379> zadd myset1 3 three
(integer) 1

#2.查看数据
127.0.0.1:6379> zrange myset1 0 -1
1) "one"
2) "two"
3) "three"
4) "qqq"

#3.删除数据
127.0.0.1:6379> zrange myset1 0 -1
1) "one"
2) "two"
3) "three"
4) "qqq"
127.0.0.1:6379> zrem myset1 qqq
(integer) 1
127.0.0.1:6379> zrange myset1 0 -1
1) "one"
2) "two"
3) "three"

二、Redis常用命令

1.查看所有key

127.0.0.1:6379> keys *
 1) "newlist"
 2) "myset"
 3) "mysetb"
 4) "myset1"
 5) "peopel"
 6) "myseta"
 7) "people"
 8) "age"
 9) "mysetc"
10) "name"
11) "mysqlset"

2.查看key的类型

127.0.0.1:6379> type myset1
zset  #有序集合
127.0.0.1:6379> type name
string  #字符串
127.0.0.1:6379> type peopel
list  #列表

3.随机返回一个key

127.0.0.1:6379> randomkey
"mysetc"
127.0.0.1:6379> randomkey
"age"
127.0.0.1:6379> randomkey
"myset"

4.删除key

127.0.0.1:6379> del name
(integer) 1  #返回状态0/1，true/false
127.0.0.1:6379> keys *
 1) "newlist"
 2) "myset"
 3) "mysetb"
 4) "myset1"
 5) "peopel"
 6) "myseta"
 7) "people"
 8) "age"
 9) "mysetc"
10) "mysqlset"

5.判断一个key是否存在

127.0.0.1:6379> exists name
(integer) 0  #不存在返回0
127.0.0.1:6379> exists peopel
(integer) 1  #存在返回1

6.重命名一个key

127.0.0.1:6379> rename myset myset0
OK

7.查看key的剩余时间

#1.以秒为单位
127.0.0.1:6379> ttl peopel
(integer) -1  #-1永不过期

#2.以毫秒为单位
127.0.0.1:6379> pttl peopel
(integer) -1  #-1永不过期

三、数据持久化

1.Redis数据安全问题

Redis 是一个缓存中间件，它的最大特点是使用内存从而使其性能强悍。但是使用内存的方 式有一个致命的特点就是数据没办法持久化保存。然而 Redis 持久化存储有两种持久化方案，RDB(Redis DataBase) 和 AOF(Append-Only File)。其中 RDB 是将内存中的数据进行快照存储到磁盘，AOF 则为可回放的命令日志记录 redis 内的所有操作。它们各有特点也相互独立。Redis4 之后支持 RDB-AOF 混合持久化的方式，结合了两者的优 点，可以通过 aof-use-rdb-preamble 配置项可以打开混合开关。

2.快照持久化（RDB）

RDB是将Redis内存中的数据进行snaptshot快照存储在磁盘内存，是Redis的默认持久化方案。使用RDB持久化默认有三种策略，该持久化策略在redis.conf中可配置，会以一段时间内有指定此数据修改的规则触发快照的动作，快照文件名为dump.rdb，该文件默认使用LZF压缩算法。每当Redis服务重启的时候会从该文件中加载数据进内存。

RDB持久化除了可以根据配置文件的策略触发，也可以手动触发,使用save和bgsave命令即可。这两个命令的区别是save会阻塞服务器的进程，在进行save的过程中，服务器不能处理任何请求，而bgsave会通过一个子进程在后台处理rdb持久化。事实上save和bgsave调用的都是sdbsave函数，因此Redis不允许save和bgsave同时运行，这也是为了避免出现竞争导致rdb文件数据不准确。

bgsave操作使用copyonwrite机制进行写时复制，是有一个子进程将内存中的最新数据遍历写入临时文件，此时父进程仍旧处理客户端的操作，当子进程操作完毕后再将该临时文件重命名为dump.rdb替换掉原来的dump.rdb文件，因此无论bgsave是否成功，dump.rdb都不会受到影响。

另外在主从全量同步、debug reload以及shutdown的情况下也会触发RDB数据持久化。

1）save原理

2）bgsave原理

3）快照持久化配置设置

#1.创建持久化文件存储目录
[root@docker ~]# mkdir /usr/local/redis/data

#2.修改持久化文件存储目录
[root@tomcat redis]# vim /usr/local/redis/conf/redis.conf 
dir /usr/local/redis/data

#3.开启数据持久化（RDB触发机制）
[root@docker ~]# vim /usr/local/redis/conf/redis.conf  #默认是开启的
save 900 1  #900秒内至少有1个key被改变则做一次快照
save 300 10  #300秒内至少有10key被改变做一次快照
save 60 10000  #60秒内至少有10000个key被改变则做一次快照

#4.Redis服务在data目录下会生成备份数据文件（dump.rdb）
[root@docker redis]# systemctl start redis
[root@docker redis]# ll
总用量 0
drwxr-xr-x 2 root root 134 4月  30 20:35 bin
drwxr-xr-x 2 root root  24 5月   1 10:36 conf
drwxr-xr-x 2 root root  22 5月   1 10:37 data
[root@docker redis]# cd data/
[root@docker data]# ll
总用量 4
-rw-r--r-- 1 root root 92 5月   1 10:37 dump.rdb

#配置文件详解
save m n
#配置快照(rdb)促发规则，格式：save <seconds> <changes>
#save 900 1 900 秒内至少有 1 个 key 被改变则做一次快照
#save 300 10 300 秒内至少有 300 个 key 被改变则做一次快照
#save 60 10000 60 秒内至少有 10000 个 key 被改变则做一次快照
#关闭该规则使用 svae “”
dbfilename dump.rdb
#rdb 持久化存储数据库文件名，默认为 dump.rdb
stop-write-on-bgsave-error yes
#yes 代表当使用 bgsave 命令持久化出错时候停止写 RDB 快照文件,no 表明忽略错误继续写文件。
rdbchecksum yes
#在写入文件和读取文件时是否开启 rdb 文件检查，检查是否有无损坏，如果在启动是检查发现损坏，则停止启
动。
dir "/etc/redis"
#数据文件存放目录，rdb 快照文件和 aof 文件都会存放至该目录，请确保有写权限
rdbcompression yes
#是否开启 RDB 文件压缩，该功能可以节约磁盘空间、

4）RDB的优缺点

优点：

• RDB是一种表示某个即时点的Redis数据的紧凑文件。RDB文件适合用于备份。例如，你可能想要每小时归档最近24小时的RDB文件，每天保存近30天的RDB快照。这允许你很容易的回复不同版本的数据集以容灾。
• RDB非常适合灾难回复，作为一个紧凑的单一文件，可以被传输到远程的数据中心。
• RDB最大化了Redis的性能，因为Redis父进程持久化是唯一需要做的启动一个子进程，又子进程完成所有剩余工作。父进程实例不需要执行像磁盘IO这样的操作。
• RDB在重启保存了大数据集的实例时比AOF要快

缺点：

• 当你需要在 Redis 停止工作(例如停电)时最小化数据丢失，RDB 可能不太好。你可以配置不同的保存点(save point)来保存 RDB 文件(例如，至少 5 分钟和对数据集 100 次写之后，但是你可以有多个保存点)。然而，你 通常每隔 5 分钟或更久创建一个 RDB 快照，所以一旦 Redis 因为任何原因没有正确关闭而停止工作，你就得 做好最近几分钟数据丢失的准备了。
• RDB 需要经常调用 fork()子进程来持久化到磁盘。如果数据集很大的话，fork()比较耗时，结果就是，当数据 集非常大并且 CPU 性能不够强大的话，Redis 会停止服务客户端几毫秒甚至一秒。AOF 也需要 fork()，但是你 可以调整多久频率重写日志而不会有损(trade-off)持久性(durability)。

总结：

• 优点：速度快，适合用作备份，主从复制也是基于RDB持久化功能实现的
• 缺点：会有数据丢失、导致服务停止几秒

5）停止备份

在配置文件中设置save“” 或在命令行执行config set save “”

6）手动开始备份

save：会立即生成 dump.rdb，但是会阻塞往 redis 内存中写入数据。

bgsave：后台异步备份。

如果是使用 flushdb 命令，会把之前的快照更新成当前的空状态，所以执行了 flushdb 后更新的快照是没有数 据的

7）save 与 bgsave 对比

3.持久化（AOF）

AOF(Append-Only File)记录 Redis 中每次的写命令，类似 mysql 中的 binlog，服务重启时会重新执行 AOF 中的 命令将数据恢复到内存中，RDB(按策略持久化)持久化方式记录的粒度不如 AOF(记录每条写命令)，因此很多生产 环境都是开启 AOF 持久化。AOF 中记录了操作和数据，在日志文件中追加完成后才会将内存中的数据进行变更。

1）原理

• 客户端的请求写命令会被 append 追加到 AOF 缓冲区内；
• AOF 缓冲区根据 AOF 持久化策略[always,everysec,no]将操作 sync 同步到磁盘的 AOF 文件中；
• AOF 文件大小超过重写策略或手动重写时，会对 AOF 文件 rewrite 重写，压缩 AOF 文件容量；
• Redis 服务重启时，会重新 load 加载 AOF 文件中的写操作达到数据恢复的目的

2）AOF配置

开启了 AOF 之后，RDB 就默认不使用了。使用下面的配置开启 AOF 以及策略。(如果使用 AOF，推荐选择 always 方式持久化，否则在高并发场景下，每秒钟会有几万甚至百万条请求，如果使用 everysec 的方式的话，万一服务 器挂了那几万条数据就丢失了)。

#开启 AOF 持久化
appendonly yes
#AOF 文件名
appendfilename "appendonly.aof"
#AOF 文件存储路径 与 RDB 是同一个参数
dir "/opt/app/redis6/data"
#AOF 策略，一般都是选择第一种[always:每个命令都记录],[everysec:每秒记录一次],[no:看机器的心
情高兴了就记录]
appendfsync always
#appendfsync everysec
# appendfsync no
#aof 文件大小比起上次重写时的大小,增长 100%(配置可以大于 100%)时,触发重写。[假如上次重写后大小为
10MB，当 AOF 文件达到 20MB 时也会再次触发重写，以此类推]
auto-aof-rewrite-percentage 100
#aof 文件大小超过 64MB 时,触发重写
auto-aof-rewrite-min-size 64mb
#是否在后台写时同步单写，默认值 no(表示需要同步).这里的后台写，表示后台正在重写文件(包括 bgsave
和 bgrewriteaof.bgrewriteaof 网上很多资料都没有涉及到。其实关掉 bgsave 之后，主要的即是 aof 重
写文件了).no 表示新的主进程的 set 操作会被阻塞掉，而 yes 表示新的主进程的 set 不会被阻塞，待整个后
台写完成之后再将这部分 set 操作同步到 aof 文件中。但这可能会存在数据丢失的风险(机率很小)，如果对性
能有要求，可以设置为 yes，仅在后台写时会异步处理命令.
no-appendfsync-on-rewrite no
# 指 redis 在恢复时，会忽略最后一条可能存在问题的指令。默认值 yes。即在 aof 写入时，可能存在指令写
错的问题(突然断电，写了一半)，这种情况下，yes 会 log 并继续，而 no 会直接恢复失败.
aof-load-truncated

3）AOF持久化策略

AOF 分别有三种备份策略，分别是[always:每个命令都记录],[everysec:每秒记录一次],[no:看机器的心情高兴了 就记录]，针对这三种策略给出如下说明。

4）策略说明

5）策略抉择

6）AOF重写

AOF 持久化机制记录每个写命令，当服务重启的时候会复现 AOF 文件中的所有命令，会消耗太多的资源且 重启很慢。因此为了避免 AOF 文件中的写命令太多文件太大，Redis 引入了 AOF 的重写机制来压缩 AOF 文件体积。 AOF 文件重写是把 Redis 进程内的数据转化为写命令同步到新 AOF 文件的过程。

7）AOF重写配置

8）AOF重写触发机制

根据配置，AOF 持久化触发机制如下： 1. aof_current_size > auto-aof-rewrite-min-size 2. (aof_current_size - aof_base_size) / aof_base_size > auto-aof-rewrite-percentage

9）AOF重写流程

4.RDB和AOF抉择

1）RDB和AOF比较

2）RDB 与 AOF 之间的优劣

• RDB优点：

  ​ 压缩后的二进制文件，适用于备份、全量复制及灾难恢复

  ​ RDB 恢复数据性能优于 AOF 方式

• RDB 的缺点：

  ​ 无法做到实时持久化，每次都要创建子进程，频繁操作成本过高

  ​ 保存后的二进制文件，不同版本直接存在兼容性问题

• AOF 的优点：

  ​ 以文本形式保存，易读

  ​ 记录写操作保证数据不丢失

• AOF 的缺点：

  ​ 存储所有写操作命令，且文件为文本格式保存，未经压缩，文件体积高。

  ​ 恢复数据时重放 AOF 中所有代码，恢复性能弱于 RDB 方式

5.AOF 与 RDB 混合

看了上面的 RDB 和 AOF 的介绍后，我们可以发现，使用 RDB 持久化会有数据丢失的风险，但是恢复速度快， 而使用 AOF 持久化可以保证数据完整性，但恢复数据的时候会很慢。于是从 Redis4 之后新增了混合 AOF 和 RDB 的模式，先使用 RDB 进行快照存储，然后使用 AOF 持久化记录所有的写操作，当重写策略满足或手动触发重写 的时候，将最新的数据存储为新的 RDB 记录。这样的话，重启服务的时候会从 RDB 何 AOF 两部分恢复数据，即 保证了数据完整性，又提高了恢复的性能。

开启混合模式后，每当 bgrewriteaof 命令之后会在 AOF 文件中以 RDB 格式写入当前最新的数据，之后的新 的写操作继续以 AOF 的追加形式追加写命令。当 redis 重启的时候，加载 aof 文件进行恢复数据：先加载 rdb 的 部分再加载剩余的 aof部分

1）混合配置

修改下面的参数即可开启 AOF，RDB 混合持久化 aof-use-rdb-preamble yes

2）混合模式的使用

开启混合持久化模式后，重写之后的 aof 文件里和 rdb 一样存储二进制的快照数据，继续往 redis 中进行写 操作，后续操作在 aof 中仍然是以命令的方式追加。因此重写后 aof 文件由两部分组成，一部分是类似 rdb 的二 进制快照，另一部分是追加的命令文本。

# step: 进入 Redis， 写入数据
[root@alvin-test-os redis]# redis-cli --raw
127.0.0.1:6379> set name alvin
OK
127.0.0.1:6379> set age 18
OK
127.0.0.1:6379> set add 上海
OK
127.0.0.1:6379> exit
# Step 2: 查看备份文件
[root@alvin-test-os redis]# ll data/
总用量 8
-rw-r--r--. 1 root root 121 11 月 24 15:39 appendonly.aof
-rw-r--r--. 1 root root 116 11 月 24 15:39 dump.rdb
[root@alvin-test-os redis]# cat data/appendonly.aof | grep add
add
[root@alvin-test-os redis]# cat data/appendonly.aof
*2
$6
SELECT
$1
0
*3
$3
set
$4
name
$5
alvin
*3
$3
set
$3
age
$2
18
*3
$3
set
$3
add
$6
上海
# Step 3： 启动备份
[root@alvin-test-os redis]# redis-cli --raw
127.0.0.1:6379> BGREWRITEAOF
Background append only file rewriting started
127.0.0.1:6379> exit
# Step 4: 查看配置文件发现 AOF 备份文件变成了二进制文件
[root@alvin-test-os redis]# cat data/appendonly.aof
REDIS0009� redis-ver6.0.9�
�edis-bits�@�ctime��_used-mem��4
aof-preamble���namealvinadd 上海 age���6����&[root@alvin-test-os redis]#
# Step 5： 再次写入文件
[root@alvin-test-os redis]# redis-cli --raw
127.0.0.1:6379> set company 上海老男孩
OK
127.0.0.1:6379> exit
# Step 6：再次查看备份文件发现被分成了两份，一份二进制，一份 AOF 备份
[root@alvin-test-os redis]# cat data/appendonly.aof
REDIS0009� redis-ver6.0.9�
�edis-bits�@�ctime��_used-mem��4
aof-preamble���namealvinadd 上海 age���6����&*2
$6
SELECT
$1
0
*3
$3
set
$7
company
$15
上海老男孩
[root@alvin-test-os redis]