19、聊聊redis(二)

你的名字 2022-05-27 06:20 95阅读 0赞

## 集群 ##

Redis 集群是一组能进行数据共享的Redis 实例（服务或者节点）的设施，集群可以使用的功能是普通单机 Redis 所能使用的功能的一个子集；Redis 集群通常具有高可用、可扩展性、分布式、容错等特性。了解redis的集群后，这些晦涩的概念可结合redis的主从、集群分区和集群运维等角度理解体会。

### 槽(slot)的基本概念 ###

从上面集群的简单操作中，我们已经知道redis存取key的时候，都要定位相应的槽(slot)。  
Redis 集群键分布算法使用数据分片（sharding）而非一致性哈希（consistency hashing）来实现： 一个 Redis 集群包含 16384 个哈希槽（hash slot）， 它们的编号为0、1、2、3……16382、16383，这个槽是一个逻辑意义上的槽，实际上并不存在。redis中的每个key都属于这 16384 个哈希槽的其中一个，存取key时都要进行key->slot的映射计算。  
下面我们来看看启动集群时候打印的信息:

>>> Creating cluster
    >>> Performing hash slots allocation on 6 nodes...
    Using 3 masters:
    192.168.2.128:7031
    192.168.2.128:7032
    192.168.2.128:7033
    Adding replica 192.168.2.128:7034 to 192.168.2.128:7031
    Adding replica 192.168.2.128:7035 to 192.168.2.128:7032
    Adding replica 192.168.2.128:7036 to 192.168.2.128:7033
    M: bee706db5ae182c5be9b9bdf94c2d6f3f8c8ec5c 192.168.2.128:7031
       slots:0-5460 (5461 slots) master
    M: 72826f06dbf3be163f2f456ca24caed76a15bdf4 192.168.2.128:7032
       slots:5461-10922 (5462 slots) master
    M: ab6e9d1dfc471225eef01e57be563157f81d26b3 192.168.2.128:7033
       slots:10923-16383 (5461 slots) master
    ......
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.

从上面信息可以看出，创建集群的时候，哈希槽被分配到了三个主节点上，从节点是没有哈希槽的。7031负责编号为0-5460 共5461个 slots，7032负责编号为 5461-10922共5462 个 slots，7033负责编号为10923-16383 共5461个 slots。

### 键-槽映射算法 ###

和memcached一样，redis也采用一定的算法进行键-槽（key->slot）之间的映射。memcached采用一致性哈希（consistency hashing）算法进行键-节点（key-node）之间的映射，而redis集群使用集群公式来计算键 key 属于哪个槽：

HASH\_SLOT（key）= CRC16(key) % 16384

其中 CRC16(key) 语句用于计算键 key 的 CRC16 校验和 。key经过公式计算后得到所对应的哈希槽，而哈希槽被某个主节点管理，从而确定key在哪个主节点上存取，这也是redis将数据均匀分布到各个节点上的基础。  
![20160829133131758][]  
无论是memcached的一致性哈希算法，还是redis的集群分区，最主要的目的都是在移除、添加一个节点时对已经存在的缓存数据的定位影响尽可能的降到最小。redis将哈希槽分布到不同节点的做法使得用户可以很容易地向集群中添加或者删除节点， 比如说：

1）、如果用户将新节点 D 添加到集群中， 那么集群只需要将节点 A 、B 、 C 中的某些槽移动到节点 D 就可以了。

2)、与此类似， 如果用户要从集群中移除节点 A ， 那么集群只需要将节点 A 中的所有哈希槽移动到节点 B 和节点 C ， 然后再移除空白（不包含任何哈希槽）的节点 A 就可以了。

因为将一个哈希槽从一个节点移动到另一个节点不会造成节点阻塞， 所以无论是添加新节点还是移除已存在节点， 又或者改变某个节点包含的哈希槽数量， 都不会造成集群下线，从而保证集群的可用性。

### 查看集群信息 ###

cluster info 查看集群状态，槽分配，集群大小等，cluster nodes也可查看主从节点。

192.168.2.128:7031> cluster info
    cluster_state:ok
    cluster_slots_assigned:16384
    cluster_slots_ok:16384
    cluster_slots_pfail:0
    cluster_slots_fail:0
    cluster_known_nodes:6
    cluster_size:3
    cluster_current_epoch:6
    cluster_my_epoch:1
    cluster_stats_messages_sent:119
    cluster_stats_messages_received:119
    192.168.2.128:7031>

### 新增节点 ###

（1）新增节点配置文件  
执行下面的脚本创建脚本配置文件

\[root@localhost redis-cluster\]\# mkdir /usr/local/redis-cluster/7037 && cp /usr/local/redis-cluster/7031/redis.conf /usr/local/redis-cluster/7037/redis.conf && sed -i “s/7031/7037/g” /usr/local/redis-cluster/7037/redis.conf

（2）启动新增节点

\[root@localhost bin\]\# /usr/local/redis/bin/redis-server /usr/local/redis-cluster/7037/redis.conf

（3）添加节点到集群  
现在已经添加了新增一个节点所需的配置文件，但是这个这点还没有添加到集群中，现在让它成为集群中的一个主节点

[root@localhost redis-cluster]# cd /usr/local/redis/bin/
    [root@localhost bin]# ./redis-trib.rb add-node 192.168.2.128:7037 192.168.2.128:7036
    >>> Adding node 192.168.2.128:7037 to cluster 192.168.2.128:7036
    >>> Performing Cluster Check (using node 192.168.2.128:7036)
    S: 2c8d72f1914f9d6052065f7e9910cc675c3c717b 192.168.2.128:7036
       slots: (0 slots) slave
       replicates 6dbb4aa323864265c9507cf336ef7d3b95ea8d1b
    M: 6dbb4aa323864265c9507cf336ef7d3b95ea8d1b 192.168.2.128:7033
       slots:10923-16383 (5461 slots) master
       1 additional replica(s)
    S: 791a7924709bfd7ef5c36d9b9c838925e41e3c2e 192.168.2.128:7034
       slots: (0 slots) slave
       replicates d9e3c78a7c49689c29ab67a8a17be9d95cb08452
    M: d9e3c78a7c49689c29ab67a8a17be9d95cb08452 192.168.2.128:7031
       slots:0-5460 (5461 slots) master
       1 additional replica(s)
    M: 69b63d8db629fa8a689dd1ed25ed941c076d4111 192.168.2.128:7032
       slots:5461-10922 (5462 slots) master
       1 additional replica(s)
    S: e669a91866225279aafcac29bf07b826eb5be91c 192.168.2.128:7035
       slots: (0 slots) slave
       replicates 69b63d8db629fa8a689dd1ed25ed941c076d4111
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.
    >>> Send CLUSTER MEET to node 192.168.2.128:7037 to make it join the cluster.
    [OK] New node added correctly.
    [root@localhost bin]#

./redis-trib.rb add-node 命令中，7037 是新增的主节点，7036 是集群中已有的从节点。再来看看集群信息

192.168.2.128:7031> cluster info
    cluster_state:ok
    cluster_slots_assigned:16384
    cluster_slots_ok:16384
    cluster_slots_pfail:0
    cluster_slots_fail:0
    cluster_known_nodes:7
    cluster_size:3
    cluster_current_epoch:6
    cluster_my_epoch:1
    cluster_stats_messages_sent:11256
    cluster_stats_messages_received:11256

![20160829133410113][]  
（4）分配槽  
从添加主节点输出信息和查看集群信息中可以看出，我们已经成功的向集群中添加了一个主节点，但是这个主节还没有成为真正的主节点，因为还没有分配槽（slot），也没有从节点，现在要给它分配槽（slot）

[root@localhost bin]# ./redis-trib.rb reshard 192.168.2.128:7031
    >>> Performing Cluster Check (using node 192.168.2.128:7031)
    M: 1a544a9884e0b3b9a73db80633621bd90ceff64a 192.168.2.128:7031
       ......
    [OK] All nodes agree about slots configuration.
    >>> Check for open slots...
    >>> Check slots coverage...
    [OK] All 16384 slots covered.
    How many slots do you want to move (from 1 to 16384)? 1024
    What is the receiving node ID?

系统提示要移动多少个配槽（slot）,并且配槽（slot）要移动到哪个节点，任意输入一个数，如1024，再输入新增节点的ID cf48228259def4e51e7e74448e05b7a6c8f5713f.

（5）指定从节点  
现在从节点7036的主节点是7033，现在我们要把他变为新增加节点（7037）的从节点，需要登录7036的客户端

[root@localhost bin]# /usr/local/redis/bin/redis-cli -c -h 192.168.2.128 -p 7036
    192.168.2.128:7036> cluster replicate cf48228259def4e51e7e74448e05b7a6c8f5713f
    OK

### 删除节点 ###

需要重新分区(即把当前节点的槽分出去)才可以删除节点。  
添加节点、分配槽、删除节点的过程，不用停止集群，不阻塞集群的其他操作

## 生存时间（expire）管理 ##

lazy expiration机制：  
1、在访问key的时候判定key是否过期，如果过期，则进行过期处理。  
2、每秒对volatile keys 进行抽样测试，如果有过期键，那么对所有过期key进行处理。  
redis术语里面，把设置了expire time的key 叫做：volatile keys。 意思就是不稳定的key。

## 内存淘汰机制 ##

我们可以通过配置redis.conf中的maxmemory这个值来开启内存淘汰功能，至于这个值有什么意义，我们可以通过了解内存淘汰的过程来理解它的意义：

1.  客户端发起了需要申请更多内存的命令（如set）。
2.  Redis检查内存使用情况，如果已使用的内存大于maxmemory则开始根据用户配置的不同淘汰策略来淘汰内存（key），从而换取一定的内存。
3.  如果上面都没问题，则这个命令执行成功。

maxmemory为0的时候表示我们对Redis的内存使用没有限制。

Redis提供了下面几种淘汰策略供用户选择，其中默认的策略为noeviction策略：

· noeviction：当内存使用达到阈值的时候，所有引起申请内存的命令会报错。

· allkeys-lru：在主键空间中，优先移除最近未使用的key。

· volatile-lru：在设置了过期时间的键空间中，优先移除最近未使用的key。

· allkeys-random：在主键空间中，随机移除某个key。

· volatile-random：在设置了过期时间的键空间中，随机移除某个key。

· volatile-ttl：在设置了过期时间的键空间中，具有更早过期时间的key优先移除。

这里补充一下主键空间和设置了过期时间的键空间，举个例子，假设我们有一批键存储在Redis中，则有那么一个哈希表用于存储这批键及其值，如果这批键中有一部分设置了过期时间，那么这批键还会被存储到另外一个哈希表中，这个哈希表中的值对应的是键被设置的过期时间。设置了过期时间的键空间为主键空间的子集。

我们了解了Redis大概提供了这么几种淘汰策略，那么如何选择呢？淘汰策略的选择可以通过下面的配置指定：

maxmemory-policy noeviction

但是这个值填什么呢？为解决这个问题，我们需要了解我们的应用请求对于Redis中存储的数据集的访问方式以及我们的诉求是什么。同时Redis也支持Runtime修改淘汰策略，这使得我们不需要重启Redis实例而实时的调整内存淘汰策略。

下面看看几种策略的适用场景

· allkeys-lru：如果我们的应用对缓存的访问符合幂律分布（也就是存在相对热点数据），或者我们不太清楚我们应用的缓存访问分布状况，我们可以选择allkeys-lru策略。

· allkeys-random：如果我们的应用对于缓存key的访问概率相等，则可以使用这个策略

· volatile-ttl：这种策略使得我们可以向Redis提示哪些key更适合被eviction。

另外，volatile-lru策略和volatile-random策略适合我们将一个Redis实例既应用于缓存和又应用于持久化存储的时候，然而我们也可以通过使用两个Redis实例来达到相同的效果，值得一提的是将key设置过期时间实际上会消耗更多的内存。

## 对象存储 ##

### 序列化对象为二进制 ###

使用redis的接口：

> jedis.get(byte\[\] key)  
> jedis.set(byte\[\] key, byte\[\] value)

序列化方式，我们有很多种选择，比如：Java serialize,Protobuf,或者自己手动序列化都行

### 序列化对象为字符串 ###

使用redis的接口：

> jedis.get(String key);  
> jedis.set(String key, String value);

序列化为字符串，我们也有很多选择：Json(Jackson,FastJson),Xml等方式

### 转换对象为Map ###

使用redis的接口：

jedis.hgetAll(String key);
    jedis.hmset(String key, Map<String,String> values);

一般情况使用改写的序列化工具。

## Raft算法 ##

虽然现在很广泛使用的Zookeeper也是基于Paxos算法来实现，但是Zookeeper使用的ZAB（Zookeeper Atomic Broadcast）协议对Paxos进行了很多的改进与优化，算法复杂我想会是制约他发展的一个重要原因；引出本篇文章的主角Raft一致性算法，没错Raft就是在这个背景下诞生的，文章开头也说到了Paxos最大的问题就是复杂，Raft一致性算法就是比Paxos简单又能实现Paxos所解决的问题的一致性算法。

从2013年发布到现在不过只有两年，到现在已经有了十多种语言的Raft算法实现框架，较为出名的有etcd，Google的Kubernetes也是用了etcd作为他的服务发现框架；由此可见易懂性是多么的重要。

Raft和Paxos一样只要保证n/2+1节点正常就能够提供服务；众所周知但问题较为复杂时可以把问题分解为几个小问题来处理，Raft也使用了分而治之的思想把算法流程分为三个子问题：选举（Leader election）、日志复制（Log replication）、安全性（Safety）三个子问题；这里先简单介绍下Raft的流程;  
　　Raft开始时在集群中选举出Leader负责日志复制的管理，Leader接受来自客户端的事务请求（日志），并将它们复制给集群的其他节点，然后负责通知集群中其他节点提交日志，Leader负责保证其他节点与他的日志同步，当Leader宕掉后集群其他节点会发起选举选出新的Leader；

### 角色 ###

Raft把集群中的节点分为三种状态：Leader、 Follower 、Candidate，理所当然每种状态负责的任务也是不一样的，Raft运行时提供服务的时候只存在Leader与Follower两种状态；  
　　Leader（领导者）：负责日志的同步管理，处理来自客户端的请求，与Follower保持heartBeat的联系；  
　　Follower（追随者）：刚启动时所有节点为Follower状态，响应Leader的日志同步请求，响应Candidate的请求，把请求到Follower的事务转发给Leader；  
　　Candidate（候选者）：负责选举投票，Raft刚启动时由一个节点从Follower转为Candidate发起选举，选举出Leader后从Candidate转为Leader状态；

![这里写图片描述][70]

### Term ###

在Raft中使用了一个可以理解为周期（第几届、任期）的概念，用Term作为一个周期，每个Term都是一个连续递增的编号，每一轮选举都是一个Term周期，在一个Term中只能产生一个Leader；先简单描述下Term的变化流程： Raft开始时所有Follower的Term为1，Follower的逻辑时钟到期后转换为Candidate，Term加1这是Term为2（任期），然后开始选举，这时候有几种情况会使Term发生改变：  
　　1：如果当前Term为2的任期内没有选举出Leader或出现异常，则Term递增，开始新一任期选举  
　　2：当这轮Term为2的周期选举出Leader后，过后Leader宕掉了，然后其他Follower转为Candidate，Term递增，开始新一任期选举  
　　3：当Leader或Candidate发现自己的Term比别的Follower小，Leader或Candidate将转为Follower，Term递增  
　　4：当Follower的Term比别的Term小，Follower也将更新Term保持与其他Follower一致；  
　　可以说每次Term的递增都将发生新一轮的选举，Raft保证一个Term只有一个Leader，在Raft正常运转中所有的节点的Term都是一致的，如果节点不发生故障一个Term（任期）会一直保持下去，当某节点收到的请求中Term比当前Term小时则拒绝该请求；

### 选举（Election） ###

Raft的选举由定时器来触发，每个节点的选举定时器时间都是不一样的，开始时状态都为Follower某个节点定时器触发选举后Term递增，状态由Follower转为Candidate，向其他节点发起RequestVote RPC请求，这时候有三种可能的情况发生：  
　　1：该RequestVote请求接收到n/2+1（过半数）个节点的投票，从Candidate转为Leader，向其他节点发送heartBeat以保持Leader的正常运转  
　　2：在此期间如果收到其他节点发送过来的AppendEntries RPC请求，如该节点的Term大则当前节点转为Follower，否则保持Candidate拒绝该请求  
　　3：Election timeout发生则Term递增，重新发起选举  
　　**在一个Term期间每个节点只能投票一次**，所以当有多个Candidate存在时就会出现每个Candidate发起的选举都存在接收到的投票数都不过半的问题，这时每个Candidate都将Term递增、重启定时器并重新发起选举，由于**每个节点中定时器的时间都是随机的**，所以就不会多次存在有多个Candidate同时发起投票的问题。  
　　有这么几种情况会发起选举，1：Raft初次启动，不存在Leader，发起选举；2：Leader宕机或Follower没有接收到Leader的heartBeat，发生election timeout从而发起选举;

![这里写图片描述][70 1]

![这里写图片描述][70 2]

![这里写图片描述][70 3]

Raft采用心跳机制触发Leader选举。系统启动后，全部节点初始化为Follower，term为0.节点如果收到了RequestVote或者AppendEntries，就会保持自己的Follower身份。如果一段时间内没收到AppendEntries消息直到选举超时，说明在该节点的超时时间内还没发现Leader，Follower就会转换成Candidate，自己开始竞选Leader。一旦转化为Candidate，该节点立即开始下面几件事情：

1、增加自己的term。  
2、启动一个新的定时器。  
3、给自己投一票。  
4、向所有其他节点发送RequestVote(term + commit\_index)，并等待其他节点的回复。  
如果在这过程中收到了其他节点发送的AppendEntries，就说明已经有Leader产生，自己就转换成Follower，选举结束。  
如果在计时器超时前，节点收到多数节点的同意投票，就转换成Leader。同时向所有其他节点发送AppendEntries，告知自己成为了Leader。

每个节点在一个term内只能投一票，采取先到先得的策略，Candidate前面说到已经投给了自己，Follower会投给第一个收到RequestVote的节点。每个Follower有一个计时器，在计时器超时时仍然没有接受到来自Leader的心跳RPC, 则自己转换为Candidate, 开始请求投票，就是上面的的竞选Leader步骤。

如果多个Candidate发起投票，每个Candidate都没拿到多数的投票（Split Vote），那么就会等到计时器超时后重新成为Candidate，重复前面竞选Leader步骤。

Raft协议的定时器采取随机超时时间，这是选举Leader的关键。每个节点定时器的超时时间随机设置，随机选取配置时间的1倍到2倍之间。由于随机配置，所以各个Follower同时转成Candidate的时间一般不一样，在同一个term内，先转为Candidate的节点会先发起投票，从而获得多数票。多个节点同时转换为Candidate的可能性很小。即使几个Candidate同时发起投票，在该term内有几个节点获得一样高的票数，只是这个term无法选出Leader。由于各个节点定时器的超时时间随机生成，那么最先进入下一个term的节点，将更有机会成为Leader。连续多次发生在一个term内节点获得一样高票数在理论上几率很小，实际上可以认为完全不可能发生。一般1-2个term类，Leader就会被选出来。

### 日志复制（Log Replication） ###

日志复制（Log Replication）主要作用是用于保证节点的一致性，这阶段所做的操作也是为了保证一致性与高可用性；当Leader选举出来后便开始负责客户端的请求，所有事务（更新操作）请求都必须先经过Leader处理，这些事务请求或说成命令也就是这里说的日志，我们都知道要保证节点的一致性就要保证每个节点都按顺序执行相同的操作序列，日志复制（Log Replication）就是为了保证执行相同的操作序列所做的工作；在Raft中当接收到客户端的日志（事务请求）后先把该日志追加到本地的Log中，然后通过heartbeat把该Entry同步给其他Follower，Follower接收到日志后记录日志然后向Leader发送ACK，当Leader收到大多数（n/2+1）Follower的ACK信息后将该日志设置为已提交并追加到本地磁盘中，通知客户端并在下个heartbeat中Leader将通知所有的Follower将该日志存储在自己的本地磁盘中。

### 安全性（Safety） ###

安全性是用于保证每个节点都执行相同序列的安全机制，如当某个Follower在当前Leader commit Log时变得不可用了，稍后可能该Follower又会选举为Leader，这时新Leader可能会用新的Log覆盖先前已committed的Log，这就是导致节点执行不同序列；Safety就是用于保证选举出来的Leader一定包含先前 commited Log的机制；  
　　选举安全性（Election Safety）  
　　每个Term只能选举出一个Leader  
　　Leader完整性（Leader Completeness）  
　　这里所说的完整性是指Leader日志的完整性，当Log在Term1被Commit后，那么以后Term2、Term3…等的Leader必须包含该Log；Raft在选举阶段就使用Term的判断用于保证完整性：当请求投票的该Candidate的Term较大或Term相同Index更大则投票，否则拒绝该请求；

### leader选举的效率 ###

Raft中的每个server在某个term轮次内只能投一次票，哪个candidate先请求投票谁就可能先获得投票，这样就可能造成split vote，即各个candidate都没有收到过半的投票，Raft通过candidate设置不同的超时时间，来快速解决这个问题，使得先超时的candidate（在其他人还未超时时）优先请求来获得过半投票  
ZooKeeper中的每个server，在某个electionEpoch轮次内，可以投多次票，只要遇到更大的票就更新，然后分发新的投票给所有人。这种情况下不存在split vote现象，同时有利于选出含有更新更多的日志的server，但是选举时间理论上相对Raft要花费的多。

### 怎么发现已完成选举的leader？ ###

一个server启动后（该server本来就属于该集群的成员配置之一，所以这里不是新加机器），如何加入一个已经选举完成的集群  
Raft：比较简单，该server启动后，会收到leader的AppendEntries RPC,这时就会从RPC中获取leader信息，识别到leader，即使该leader是一个老的leader，之后新leader仍然会发送AppendEntries RPC,这时就会接收到新的leader了（因为新leader的term比老leader的term大，所以会更新leader）

ZooKeeper：该server启动后，会向所有的server发送投票通知，这时候就会收到处于LOOKING、FOLLOWING状态的server的投票（这种状态下的投票指向的leader），则该server放弃自己的投票，判断上述投票是否过半，过半则可以确认该投票的内容就是新的leader。

### 分区的应对 ###

目前ZooKeeper和Raft都是过半即可，所以对于分区是容忍的。如5台机器，分区发生后分成2部分，一部分3台，另一部分2台，这2部分之间无法相互通信

其中，含有3台的那部分，仍然可以凑成一个过半，仍然可以对外提供服务，但是它不允许有server再挂了，一旦再挂一台则就全部不可用了。

含有2台的那部分，则无法提供服务，即只要连接的是这2台机器，都无法执行相关请求。

所以ZooKeeper和Raft在一旦分区发生的情况下是是牺牲了高可用来保证一致性，即CAP理论中的CP。但是在没有分区发生的情况下既能保证高可用又能保证一致性，所以更想说的是所谓的CAP二者取其一，并不是说该系统一直保持CA或者CP或者AP，而是一个会变化的过程。在没有分区出现的情况下，既可以保证C又可以保证A，在分区出现的情况下，那就需要从C和A中选择一样。ZooKeeper和Raft则都是选择了C

### 上一轮次的leader的残留的数据怎么处理？ ###

Raft：对于之前term的过半或未过半复制的日志采取的是保守的策略，全部判定为未提交，只有当当前term的日志过半了，才会顺便将之前term的日志进行提交  
ZooKeeper：采取激进的策略，对于所有过半还是未过半的日志都判定为提交，都将其应用到状态机中

Raft的保守策略更多是因为Raft在leader选举完成之后，没有同步更新过程来保持和leader一致（在可以对外处理请求之前的这一同步过程）。而ZooKeeper是有该过程的

## 应用 ##

### 注册中心 ###

dubbo利用redis作为注册中心

### 分布式锁 ###

### 全局主键 ###

利用redis的lua脚本执行功能，在每个节点上通过lua脚本生成唯一ID。

### 秒杀 ###

总数自减

### 共享session ###

### MQ ###

### 利用list实现队列 ###

## duboo利用redis注册服务 ##

redis没有watch机制，只能轮询检测了..

参考：  
[https://blog.csdn.net/javaloveiphone/article/details/52352894][https_blog.csdn.net_javaloveiphone_article_details_52352894]  
[https://www.cnblogs.com/cchust/p/5634782.html][https_www.cnblogs.com_cchust_p_5634782.html]  
[http://m635674608.iteye.com/blog/2337085][http_m635674608.iteye.com_blog_2337085]

[20160829133131758]: /images/20220527/50aabec9e2694671ac34b83a2d252d19.png
[20160829133410113]: /images/20220527/932843d04c8e43b0be75cbd275a36d94.png
[70]: /images/20220527/52c2eb723aa54040bbb2eb86c9d43a6f.png
[70 1]: /images/20220527/4b61b6384d404d63874ef8704dc7e21d.png
[70 2]: /images/20220527/9e73983597c44953ada94f0326341989.png
[70 3]: /images/20220527/fb211132fbb343cc9b5775dac504850f.png
[https_blog.csdn.net_javaloveiphone_article_details_52352894]: https://blog.csdn.net/javaloveiphone/article/details/52352894
[https_www.cnblogs.com_cchust_p_5634782.html]: https://www.cnblogs.com/cchust/p/5634782.html
[http_m635674608.iteye.com_blog_2337085]: http://m635674608.iteye.com/blog/2337085