Redis万字总结，面试必备！！！

一时失言乱红尘 2023-02-25 15:22 213阅读 0赞

### 文章目录 ###

*  简介
 *  Redis常用命令
 *  String
 *  Hash
 *  List
 *  Set
 *  ZSet
 *  Redis事务
 *  Redis主从复制
 *  redis订阅发布

**写作背景**

> Redis学了也有一段时间了，而且也写了很多篇博客，最近面试，发现好多公司都有要求，而且有问到，当问到的时候，感觉已经有点忘了，复习之前博客的时候，有点乱也不好统一复习，于是就有了这篇文章。

# 简介 #

Redis（Remote Dictionary Server）远程字典服务，是一个开源的使用C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，可以用来做缓存，举个例子，当我们要从数据库查询数据的时候，我们可以首先通过Redis，如果Redis中存在，那么就直接读取Redis中的数据，如果不存在，再去数据库中查询，并把查询的结果放到Redis中，以方便下次直接访问，这样一来就减轻了数据库的压力，而且提高了查询效率，因为Redis数据是在内存中的，所以速度比数据库快，这篇文章着重讲解Reids的使用及底层实现。

# Redis常用命令 #

*  **设置键值对**  
    `set myKey abc`
 *  **获取键值对**  
    `get myKey`
 *  **查看所有的key**  
    `keys *`
 *  **删除key，可以删除多个**  
    `del key [key ...]`
 *  **判断某个key是否存在**  
    `exists key`
 *  **查看key剩余多久有效时间，-1代表永久，-2代表失效**  
    `ttl key`
 *  **给key设置有效时间，单位是秒**  
    `expire key seconds`
 *  **设置key为永久有效**  
    `persist key`
 *  **查看符合条件的key，“\*”代表所有，“?”代表一个字符**  
    `keys pattern`
 *  **切换数据库，redis中默认有16个数据库，其下标是从0到15，默认是在0数据库中**  
    `select index`
 *  **从当前数据库中随机返回一个key**  
    `randomkey`
 *  **修改key的名称**  
    `rename key newkey`
 *  **将当前数据库中的key移动到指定的数据库中**  
    `move key db`
 *  **查看key的类型**  
    `type key`

# String #

**String类型是Redis最基本的数据类型一个键最大能存储512MB**

*  **set用于给key设定值，如果key已经有值了set会复写旧值**  
    `set key value`
 *  **获取指定key的值，如果key不存在返回nil，如果key存储的不是字符串类型，返回一个错误**  
    `get key`
 *  **只有key不存在时设置key的值**  
    `setnx key value`
 *  **获取指定key中的字符串的子字符串**  
    `getrange key start end`
 *  **返回key所存储的字符串的长度**  
    `strlen key`
 *  **将key中存储的数字值增加1，如果key不存在，那么key的值会被先初始化为0，然后加1**  
    `incr key`
 *  **将指定的key自增自定义值**  
    `incrby key increment`
 *  **将key中存储的数字值减1**  
    `decr key`
 *  **将指定的key自减自定义值**  
    `decrby key decrement`  
    **String底层实现简单动态字符串（Simple Dynamic String，SDS）**

**底层是一个SDS，内部包含三部分**

char buf[];// 字节数组，用于保存字符串
    int len; // buf数组中已使用的字节数量，即是SDS字符串的长度
    int free;// buf数组中未使用的字节数量

**获取字符串长度**  
由于C字符串没有哦记录自身的长度信息，所以获取C字符串长度的时候，必须遍历整个字符串，其时间复杂度是O(n)，而SDS中有len属性，所以在获取其长度时，时间复杂度为O(1)。  
**缓冲区溢出**  
由于C字符串不记录字符串的长度，当我们进行字符串拼接的时候，可能会出现缓冲区溢出问题，举个例子，我们有s1和s2两个字符串，当我们想要把s2字符串拼接到s1字符串的时候，如果在拼接之前没有给s1分配足够的空间，那么s1的数据就会溢出到s2所在的空间，导致s2中原有的数据被破坏。而SDS在进行修改操作时，会先检查空间是否够用，如果不够用会自动扩展，以解决缓冲区溢出的问题。  
**内存重分配次数**  
对于C字符串而言，当对字符串进行拼接操作时，需要先通过内存重分配来扩展其底层的数组空间大小，如果不扩展，很可能就会出现缓冲区溢出，当金星字符串缩短时，也需要进行内存重分配，进行释放那部分不用的内存，如果忘了这步，会产生内存泄漏。可以看出，不管是字符串拼接，还是字符串缩短，都要执行内存重分配。  
SDS就不一样了，SDS在进行字符串拼接的时候，采用**空间预分配**，举个例子进行讲解，如果我们有s1="hello"和s2=“sds”，两个字符串，以s1为研究对象，s1的len为5，free为0，当s2拼接到s1时，进行内存重分配，s1的len变成了8，**free也变为8**，这就是空间预分配，当你下次进行拼接"world"字符串的时候，由于free的空间够用，就可以直接分配了，而不用再次内存重分配。当我们进行缩短字符串的时候，SDS采用**惰性空间释放**，如果我们有一个字符串为s=“hellosds”，其len为8，free为0，当我们把sds进行截取掉的时候，其len变为了5，**free变为了3**，也就是这三个空间并没有通过内存重分配释放。这样就减少了内存重分配的次数，同时提高了效率，需要注意的是，free空间并不是无限制的大，**free空间上限是1MB**。  
**二进制安全**  
C字符串的编码是ASCII编码，在字符串的末尾是以\\0结束，也就是空字符，所以在字符串中不能包含空字符，要不然会让程序误以为结束，这也限制了C字符串只能保存文本数据，不能保存图片，音频，视频等二进制数据。  
SDS不仅可以保存文本数据，还可以以二进制方式把其他数据存储到buf数组中的，程序不会对数据做任何限制，写入什么样，读取就是什么样，这样不仅可以存储文本，而且可以存储任意格式的二进制数据。  
**SDS兼容部分C字符串函数**  
SDS虽然是二进制安全的，但是他同样遵循C字符串以空字符串解为的惯例，所以SDS可以重用C字符串的一些函数。

# Hash #

**Hash特别适合存储对象也就是我们的JavaBean，每个hash可以存储2^32 - 1个键值对，可以看成是一个key和value的map容器**

*  **为指定的key设定field/value，key可以理解为是数据库表中的一行数据，field可理解为是字段，value就是值**  
    `hset key field value`
 *  **同时可以设置多个，对应hash表中的key**  
    `hmset key field value[filed value ...]`
 *  **获取存储在hash中中的值，根据field获取value**  
    `hget key field value`
 *  **获取当前key的多个field**  
    `hmget key field value`
 *  **获取该hash表中所有字段**  
    `hkeys key`
 *  **获取hash表中字段的数量**  
    `hlen key`
 *  **获取该key对应的所有字段和值**  
    `hgetall key`
 *  **删除一个或多个域（也就是我们数据库中的字段）**  
    `hdel key field`
 *  **只有字段field不存在时，设置hash域的值**  
    `hsetnx key field value`
 *  **为hash表中指定域的整数值加上增量increment**  
    `hincrby key field increment`
 *  **查看hash表中指定的域是否存在**  
    `hexists key field`  
    ![在这里插入图片描述][2020043011320235.png]

Hash的底层是ziplist和hashtable，上面已经说了压缩列表，这里着重讲解HashTable。  
**压缩列表**  
当数据少的时候用压缩列表，存储的时候是成对（键值对）存储的，意思是占用一个压缩列表的连续两个位置，而不是用两个压缩列表存。  
**HashTable**  
哈希表里保存了一个hash表数组、hash表的大小、hash表大小掩码，用于计算索引值、hash表的节点数

type struct dictht {
    dictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
    }dictht;

table是一个hash表数组，该数组里的每个元素都保存着一个指针，保存键值对。 当同一个key对应多个键时，通过链地址法解决冲突（详情可以看[面试官问你什么是Hash表][Hash]），当数据多的时候，用跳跃表来实现，跳跃表基本可以和红黑树相媲美。

# List #

**Redis中List列表是简单的字符串列表，按照插入顺序排序，可以添加一个元素到列表的头部或尾部，一个列表最多可以包含2^32 - 1个元素，其类似于Java中的LinkedList**

*  **将一个或多个值插入到列表的头部，从左侧添加**  
    `lpush key value1 [value2]`
 *  **将一个或多个值插入到列表的尾部，从右侧添加**  
    `rpush key value1 [value2]`
 *  **遍历一个列表，从起始下标到中止下标，-1代表最后一个**  
    `lrange key start stop`
 *  **获取列表的长度**  
    `llen key`
 *  **通过索引获取列表元素的值**  
    `lindex key index`
 *  **从左删除列表的第一个元素，返回被删元素的值**  
    `lpop key`
 *  **从右删除列表的第一个元素**  
    `rpop key`
 *  **移除并获取列表的第一个元素，如果列表中没有元素，会阻塞列表直到等待超时或者发现可弹出元素，单位是秒**  
    `blpop key timeout`
 *  **移除并获取列表的最后一个元素，如果列表中没有元素，会阻塞列表直到等待超时或者发现可弹出元素**  
    `brpop key timeout`
 *  **对列表进行修剪，只保留指定区间的元素**  
    `ltrim key start stop`
 *  **通过索引设置指定元素的值**  
    `lset key index value`
 *  **在指定元素前或后插入值**  
    `linsert key before | after privot value`
 *  **将第一个列表中最后一个元素移除，并添加到第二个列表中第一个位置**  
    `rpoplpush source destination`
 *  **将本列表的最后一个元素移动到第一个位置**  
    `rpoplpush source destination`  
    ![在这里插入图片描述][20200430112918638.png]

**List的底层实现是压缩列表（ziplist）和链表（双向链表linkedlist）**  
当列表键（是指列表的value底层实现）包含的列表项比较少的时候，就用压缩列表来做列表的底层实现  
**压缩列表实现**  
`zlbytes`占4字节，记录压缩列表占用的内存字节  
`zltail`占4字节，记录压缩列表尾到表头距离的字节  
`zllen`占2字节，记录压缩列表包含的节点数  
`entryx`占不定字节，压缩列表的各个节点（可以是字节数组和整数值）  
`zlend`占1字节，标记压缩列表的表尾  
压缩列表很像数组，可以简单理解为把数组进行了封装，里面包含了，一些属性，像zlend属性等  
**链表实现**  
下面给出每一个节点的底层实现

typedef struct listNode {
    	struct listNode *prev;
    	struct ListNode *next;
    	void *value;// 保存节点的值
    }listNode;

而list的底层就是多个链表节点连在一起的，另外，list还提供了一些固有的属性，方便操作，下面给出list的简单底层实现

typedef struct list {
    	listNode *head;// 该指针指向链表的表头
    	listNode *tail;// 该指针指向链表的表尾
    	unsigned long len;// 记录链表的长度
    	void *(*dup) (void *ptr);
    	void (*free) (void *ptr);
    	void (*match) (void *ptr,void *key);
    }list;

list在操作链表的表头表尾和长度时，时间复杂度是O(1)，list中还封装了有dup、free和match函数，分别用于复制链表节点所保存的值，释放链表节点所保存的值，对比链表节点所保存的值和另一个输入值是否相等。

# Set #

**Redis的Set是String类型的无序集合，集合成员是唯一的，不能重复，底层是intset和hashtable两种数据结构，intset我们可以理解为数组，该数组是有序的，查找时通过二分，hashtable就是普通的哈希表**

*  **给指定集合添加值**  
    `sadd key member`
 *  **获取集合的大小**  
    `scard key`
 *  **获取集合的所有值，无序的**  
    `smembers key`
 *  **判断member元素是否是集合key的成员**  
    `sismember key member`
 *  **返回一个或多个随机set值，count可以不写默认返回一个**  
    `srandmember key [count]`
 *  **移除集合中一个或多个成员**  
    `srem key member1 [member2]`
 *  **随机移除count个元素，并返回这count个元素，不写默认为1**  
    `spop key [count]`
 *  **将第一个集合中的元素移动到第二个集合**  
    `smove source destination member`
 *  **第一个集合和第二个集合的差集，以第一个集合为准**  
    `sdiff key [key...]`
 *  **集合的交集**  
    `sinter key [key...]`
 *  **并集**  
    `sunion key [key...]`  
    底层是整数集合（intset）和hashtable  
    **整数集合**

typedef struct intset {
    	uint32_t encoding;
    	uint32_t length;
    	int8_t contents[];// 这里保存的int类型，会根据存储数据而改变，可能是int_8、int_16、int_32等
    }intset;

其底层是一个数组，该数组中的元素不可重复。

# ZSet #

**Redis中ZSet集合和普通集合一样，也是String类型元素的集合，也不能重复，不同的是每个元素都会关联一个float类型的分数，redis正是通过分数来为集合中的成员进行从小到大排序的，该分数是可以重复的**

*  **添加一个或多个有序集合，该集合有一个分数，用来排序**  
    `zadd key score member`
 *  **获取有序集合中的成员数**  
    `zcard key`
 *  **获取指定范围集合的值，默认从低到高**  
    `zrange key start stop`
 *  **获取指定范围分数的集合元素的个数**  
    `zcount key min max`
 *  **返回指定元素的下标**  
    `zrank key member`
 *  **获取指定范围集合的值，从高到低**  
    `zrevrange key start stop`
 *  **移除集合中的指定的一个或多个元素**  
    `zrem key member [member...]`
 *  **移除有序集合中给定的排名区间的所有成员，默认是从低到高排名，第一名是0**  
    `zremrangebyrank key start stop`
 *  **移除有序集合中分数区间的成员**  
    `zremrangebyscore key min max`  
    底层是ziplisst和skiplist，即是压缩列表和跳跃表  
    zset的特点就是可以通过分值排序。

# Redis事务 #

Redis支持事务吗，有说支持的，有说半支持的，我这里进行一波演示，看看到底支持不支持。在演示事务之前，首先要了解一下这几个命令。  
`multi`开启事务  
`exec`执行事务  
`discard`取消事务  
`watch key [key ...]`监视事务  
`unwatch`取消监视事务  
下面通过一个转账的例子进行演示事务。

127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> set money 100
    QUEUED
    127.0.0.1:6379> get money
    QUEUED
    127.0.0.1:6379> exec
    1) OK
    2) "100"

这是一个正常的事务问题，就是开启了一个事务，事务里有一组数据，然后执行，这里的每一条指令都是放到一个队列里的，当执行的时候，会逐条执行。  
下面演示一个取消事务的

127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> set money 100
    QUEUED
    127.0.0.1:6379> get money
    QUEUED
    127.0.0.1:6379> discard
    OK

这个也是正常的取消了  
如果在我们执行事务的时候，出现了语法错误，那么整个事务都不会被执行了

127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> set money 100
    QUEUED
    127.0.0.1:6379> sett age 20
    (error) ERR unknown command `sett`, with args beginning with: `age`, `20`, 
    127.0.0.1:6379> get money
    QUEUED
    127.0.0.1:6379> exec
    (error) EXECABORT Transaction discarded because of previous errors.

可以看出，当出现语法错误的时候，整个事务都不会被执行，还有一种错误，不是语法错误，而是运行时错误。

127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> set name "hzy"
    QUEUED
    127.0.0.1:6379> incr name
    QUEUED
    127.0.0.1:6379> get name
    QUEUED
    127.0.0.1:6379> exec
    1) OK
    2) (error) ERR value is not an integer or out of range
    3) "hzy"

我们让一个字符串自增，出现了错误，但是事务的其他语句还是正常执行了（这应该就是别人说的Redis是半支持事务吧）。  
还有一种情况就是，当我们执行事务的时候，还未执行exec，然后有其他客户端来干扰了。

127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> set money 100
    QUEUED
    127.0.0.1:6379> incr money
    QUEUED
    127.0.0.1:6379> exec
    1) OK
    2) (integer) 101

如果在执行exec之前，另一个客户端执行了如下操作

127.0.0.1:6379> set money 500
    OK

然后客户端1再执行exec，我们get一下

127.0.0.1:6379> get money
    "101"

可以看出，这是事务执行完的结果，而那个500就没有成功，为了解决这一问题，出现了锁，用watch监视，也就是我们的乐观锁。

127.0.0.1:6379> watch money
    OK
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> set money 100
    QUEUED
    127.0.0.1:6379> incr money
    QUEUED
    127.0.0.1:6379> exec
    (nil)
    127.0.0.1:6379> get money
    "500"

这里我们对money进行了监视，在执行exec之前我们在客户端2执行如下

127.0.0.1:6379> set money 500
    OK

然后再执行exec，由于对money进行了watch监视，所以就返回了nil。当我们再get money的时候，此时就是刚刚设置的500了，而事务相当于没有执行。  
**这里需要注意，当我们执行了exec、discard或unwatch的时候，都会自动的取消监视。**

# Redis主从复制 #

Redis中，可以通过执行slaveof命令或者设置slaveof选项，让一个服务器去复制另一个服务器，以达到同步的目的，其中被复制的服务器称为主服务器，复制的服务器是从服务器，主服务器负责写工作，从服务器负责读工作。  
下面进行演示主从复制，我们需要准备两台Redis服务器，简单起见，我在我的阿里云上配置两台不同端口号的Redis服务器，另一台端口号为6380  
在配置服务器的时候，需要修改这四个东西**以守护进程启动`daemonize yes`，端口号`port 6380`，进程文件`pidfile /var/run/redis_6380.pid`，持久化文件`dbfilename dump6380.rdb`**  
![在这里插入图片描述][20200502081228359.png]  
接下来我们客户端连接6380服务器，记得带上-p参数，不带默认连接6379  
`./redis-cli -p 6380`  
![在这里插入图片描述][20200502082348871.png]  
连接上6380服务器之后，我们设置该服务器的主服务器为6379  
`SLAVEOF 127.0.0.1 6379`  
![在这里插入图片描述][20200502082554757.png]  
下面我们打印一下从服务器6380的信息,可以看出，这是个从服务器，其主服务器端口号是6379  
`INFO replication`  
![在这里插入图片描述][20200502082839786.png]  
下面是主服务器的信息，他有一个从服务器  
![在这里插入图片描述][20200502083018663.png]  
下面我们给主服务器set一个值  
![在这里插入图片描述][20200502083220586.png]  
可以看出，我们可以直接在从服务器中获得，这就是主从复制  
![在这里插入图片描述][20200502083248664.png]  
当我们在从服务上设置值的时候，会报一个错，因为从服务器只负责读，不负责写  
![在这里插入图片描述][20200502083354162.png]  
当我们的主服务器宕机的时候，我们可以看到，从服务器还是从服务器，只能负责读工作  
![在这里插入图片描述][20200502083545636.png]  
![在这里插入图片描述][20200502083608112.png]  
当主服务器宕机的时候，从服务不能充当主服务器，导致不能完成写操作，如果想要从服务器负责写操作，需要手动复制，比较麻烦，于是就出现了一个哨兵模式，哨兵可以监视着，主服务器是否宕机，如果宕机了，就在从服务器中选出来一个，当做主服务器  
哨兵也是一个进程，其中还有一个sentinel.conf配置文件，我们可以在这里面进行配置他所监视的服务器。这里是配置了一个哨兵，监视6379端口，当这个服务器宕机的时候，需要在从服务器中选举主服务器，该哨兵有两票的权利（可以配置多个哨兵，因为哨兵也有可能被暗杀）。

`sentinel monitor mymaster 127.0.0.1 6379 2`  
![在这里插入图片描述][20200502091646309.png]  
接下来我们准备**一台主服务器，两台从服务器**  
![在这里插入图片描述][20200502091343698.png]![在这里插入图片描述][20200502091449222.png]

接下来我们启动哨兵，可以看出，该哨兵监视的主服务器是6379，还有两台从服务器  
`./redis-sentinel ../sentinel.conf`  
![在这里插入图片描述][2020050411392127.png]  
接下来我们关闭主服务器，也就是让主服务器宕机，此时还剩下6380、6381服务，还有一个是26379哨兵  
![在这里插入图片描述][20200502093325970.png]  
大约经过30秒再次info replication时，你会发现，新选举了一个主服务器，这个主服务器就是哨兵投票选举的。  
![在这里插入图片描述][20200504114039326.png]  
可以看到此时选出了6381为主服务器。  
![在这里插入图片描述][20200504114123325.png]  
当我们的6379服务器再次回来时，可以看出，主服务器还是被新选举的6381，而6379只能做从服务器。  
![在这里插入图片描述][20200504114352601.png]![在这里插入图片描述][20200504114324416.png]

# redis订阅发布 #

**简介**  
首先我们得知道，当一个用户订阅了某个频道，那么他就会一直在那监听该频道是否发出消息，是一种阻塞的状态，所以，我们把订阅功能用多线程来实现，给每一个订阅者都分配一个线程。  
**发布消息**  
![在这里插入图片描述][20200509101242750.png]  
发布消息这个方法比较简单，我们只需要指定像哪个频道发布什么内容就行了，这里我把他们封装到了一个util类下，用静态方法，方便使用。

public static void publishMsg(String channel, String message) {
            // Jedis jedis = getJedis();
            Jedis jedis = new Jedis("127.0.0.1",6379);
            try {
                jedis.publish(channel, message);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            } finally {
                jedis.close();
            }
        }

**订阅发布处理**  
这个类是用来处理订阅发布的，也就是当我们订阅了某个频道做什么处理，取消订阅某个频道做什么处理，收到了某条消息做什么处理。因为我把他们都封装到util类下了，所以这里用到内部类来实现。

public static JedisPubSub jedisPubSub = new JedisPubSub() {
            @Override
            public void onMessage(String channel, String message) {
                System.out.println("收到了" + channel + "频道发来消息：" +  message);
                System.out.println(channel + ":" + message);
            }
            
            @Override
            public void onSubscribe(String channel, int subscribedChannels) {
                System.out.println("订阅了" + channel + "频道");
                System.out.println(channel + ":" + subscribedChannels);
            }
    
            @Override
            public void onUnsubscribe(String channel, int subscribedChannels) {
                System.out.println("取消订阅了" + channel + "频道");
                System.out.println(channel + ":" + subscribedChannels);
            }
        };

**订阅频道**  
![在这里插入图片描述][20200509101217383.png]  
订阅频道，我们只需要指定订阅了哪个频道即可，这里需要注意的是，我们还需要指定，当做出与该频道相关的操作时（订阅、取消订阅、收到频道消息等）我们需要怎么处理，这也就用到了上面那个类，当然了，因为这是一个阻塞的线程，所以用多线程处理。

/**
         * 接收消息。
         * 该方法调用后，会一直执行下去。当有发布对应消息时，就会在jedisPubSub中接收到！
         * @param channels
         */
        public static void subscribeMsg(String channels) {
            // Jedis jedis = getJedis();
            Jedis jedis = new Jedis ("127.0.0.1", 6379);
            new Thread(()->{
                try {
                    jedis.subscribe(jedisPubSub, channels);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                } finally {
                    // jedis.close();
                }
            }).start();
        }

**测试**  
为了保证发布在订阅之后，这里睡眠100毫秒

public static void main(String[] args) {
            JedisUtil.subscribeMsg("test");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            JedisUtil.publishMsg("test","hello");
            JedisUtil.publishMsg("test","hello aaa");
    }

![在这里插入图片描述][20200509101103294.png]

[2020043011320235.png]: /images/20230209/4ee0d4c1381a4f1fa4735df9c658fc2b.png
[Hash]: https://blog.csdn.net/HeZhiYing_/article/details/105088289
[20200430112918638.png]: /images/20230209/42f1240e9b93448aaf7e94bd8db59fa1.png
[20200502081228359.png]: /images/20230209/2e0a22ecffbc4e5cafe92ab6372b0eae.png
[20200502082348871.png]: /images/20230209/71d2fb1e005f4a64bacbf68f17944e34.png
[20200502082554757.png]: /images/20230209/7abaddac0d7e47de8d57a8b09933d524.png
[20200502082839786.png]: /images/20230209/ebe9b35b698f40f6af2fc79f90711036.png
[20200502083018663.png]: /images/20230209/b31992871b034cebb899afbcdd4c8e0a.png
[20200502083220586.png]: /images/20230209/a34ac9d536784322be17324cece51436.png
[20200502083248664.png]: /images/20230209/9fd3b3a47d404d1aa2598cbd51f94a22.png
[20200502083354162.png]: /images/20230209/6e38392a2026492294c7fac31268b7dc.png
[20200502083545636.png]: /images/20230209/18f208359820443eb72d4ea0012aa8a2.png
[20200502083608112.png]: /images/20230209/859f8c7cec874cc7b80ec6acdd396178.png
[20200502091646309.png]: /images/20230209/00a6bcec34c54c1da2a90f9865fe1212.png
[20200502091343698.png]: https://img-blog.csdnimg.cn/20200502091343698.png
[20200502091449222.png]: /images/20230209/7dd75da4f30e40cc9f179dda2c713ba1.png
[2020050411392127.png]: /images/20230209/33c41bdc3f4f47108787d589d5cfd075.png
[20200502093325970.png]: /images/20230209/49afde96fb4d414bb5cac74932040090.png
[20200504114039326.png]: /images/20230209/8ef6934b10fc4d6896e21d5a51835dc2.png
[20200504114123325.png]: /images/20230209/507f0467727649bf909e7265c0ec56a1.png
[20200504114352601.png]: https://img-blog.csdnimg.cn/20200504114352601.png
[20200504114324416.png]: /images/20230209/67c926237fe644ea81310aaec917e3d6.png
[20200509101242750.png]: /images/20230209/f56859e98a2f47288c5df6cd90c822a2.png
[20200509101217383.png]: /images/20230209/636c048c73eb4bfc9e05183a9bb0986e.png
[20200509101103294.png]: /images/20230209/1369b5ea79394ff18d01085aae89056a.png