spring boot 配置和使用redis （包含spring data redis 1.x和 2.x配置）

桃扇骨 2021-09-29 00:16 495阅读 1赞

# 前言 #

传送门：

spring boot redis官方，目前版本 2.1x，配置和1.x有一定区别。  
[https://spring.io/projects/spring-data-redis][https_spring.io_projects_spring-data-redis]  
阿里云redis开发规范  
[https://yq.aliyun.com/articles/531067][https_yq.aliyun.com_articles_531067]  
spring boot.2x 集成redis–自定义注解实现过期时间  
[https://blog.csdn.net/weixin\_34277853/article/details/87221807][https_blog.csdn.net_weixin_34277853_article_details_87221807]  
redis注解上直接配置过期时间和自动刷新时间最新版本特性：  
@Cacheable(value = “people\#120\#90”, key = “\#[person.id][]”)  
[https://blog.csdn.net/shuxing520/article/details/78787545][https_blog.csdn.net_shuxing520_article_details_78787545]  
springboot与缓存—使用、原理、整合redis  
[https://blog.csdn.net/weixin\_38364973/article/details/82767828][https_blog.csdn.net_weixin_38364973_article_details_82767828]

# redis配置 #

## 首先引入依赖 ##

spring boot 项目中引入redis相关依赖，这里顺便将session保存到redis中。

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-cache</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session-data-redis</artifactId>
            </dependency>

## 配置redis参数 ##

##  redis config
    spring.redis.host=
    spring.redis.port=6379
    spring.redis.password=
    # 最大空闲连接数
    spring.redis.jedis.pool.max-active=8
    # 最小空闲连接数
    spring.redis.jedis.pool.max-idle=8
    # 等待可用连接的最大时间，负数为不限制
    
    spring.redis.jedis.pool.max-wait=-1
    # 最大活跃连接数，负数为不限制
    spring.redis.jedis.pool.min-idle=1
    # 数据库连接超时时间，2.0 中该参数的类型为Duration，这里在配置的时候需要指明单位  1.x可以将此参数配置10000 单位是ms
    # 连接池配置，2.0中直接使用jedis或者lettuce配置连接池
    spring.redis.timeout=60s
    spring.redis.database=0

## 设置redis配置文件 ##

package com.csii.config;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.cache.RedisCacheWriter;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.lang.reflect.Method;
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    /** * redis缓存配置 * * @author * @version V1.0 * @date */
    @Configuration
    public class RedisCacheConfig extends CachingConfigurerSupport { 
        private final static Logger logger = LoggerFactory.getLogger(RedisCacheConfig.class);
    
        /** * 自定义redis key值生成策略 * @return */
        @Bean
        @Override
        public KeyGenerator keyGenerator() { 
            return new KeyGenerator() { 
                @Override
                public Object generate(Object target, Method method, Object... params) { 
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) { 
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    // data-redis 1.x形式
    // @Bean
    // public CacheManager cacheManager(RedisTemplate redisTemplate) { 
    // RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);
    // return redisCacheManager;
    // }
    //
    //
    
        /** * spring-data-redis 版本不同，方法也不一样 上面是1.5 下面是2.0 * @param connectionFactory * @return */
    
       /* @Bean public CacheManager cacheManager(RedisTemplate redisTemplate) { RedisCacheManager manager = new RedisCacheManager(redisTemplate); manager.setUsePrefix(true); RedisCachePrefix cachePrefix = new RedisPrefix("prefix"); manager.setCachePrefix(cachePrefix); // 整体缓存过期时间 manager.setDefaultExpiration(3600L); // 设置缓存过期时间。key和缓存过期时间，单位秒 Map<String, Long> expiresMap = new HashMap<>(); expiresMap.put("user", 1000L); manager.setExpires(expiresMap); return manager; }*/
    
    
        /** * 自定义CacheManager 配置全局缓存时间 data-redis2.x配置 */
    // @Bean
    // public CacheManager cacheManager(RedisTemplate redisTemplate) { 
    // //全局redis缓存过期时间
    // RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration
    // .defaultCacheConfig()
    // .entryTtl(Duration.ofHours(1));
    // RedisCacheWriter redisCacheWriter = RedisCacheWriter
    // .nonLockingRedisCacheWriter(redisTemplate.getConnectionFactory());
    // RedisCacheManager redisCacheManager = new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
    // return redisCacheManager;
    // }
    
    	/** * data-redis 2.x配置 支持配置对应key缓存时间 * @param factory * @return */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory factory) { 
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();  // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
            config = config.entryTtl(Duration.ofMinutes(30))     // 设置缓存的默认过期时间，也是使用Duration设置
                    .disableCachingNullValues();     // 不缓存空值
    
            // 设置一个初始化的缓存空间set集合
            Set<String> cacheNames =  new HashSet<>();
            cacheNames.add("device");
            cacheNames.add("project_type");
    
            // 对每个缓存空间应用不同的配置
            Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
            configMap.put("device", config);
            configMap.put("project_type", config.entryTtl(Duration.ofHours(1)));
            // 使用自定义的缓存配置初始化一个cacheManager
            RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                    .initialCacheNames(cacheNames)
                    // 注意这两句的调用顺序，一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
                    .withInitialCacheConfigurations(configMap)
                    .build();
            return cacheManager;
        }
    
        /** * @Description: 防止redis入库序列化乱码的问题 * @return 返回类型 * @date */
        @Bean
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){ 
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<Object, Object>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            //key序列化
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            //value序列化
            redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Object.class));
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    }

## 开启缓存配置 ##

这里吧  
`@EnableCaching`  
`@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600 * 24`  
配置在main主类上，也可以配置 在configuration的类，只要项目启动后可以扫到注解进行初始化

/** * */
    @SpringBootApplication
    @MapperScan("com.csii.dao")
    @EnableCaching
    @EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600 * 24)
    public class AppCsiiServerApplication { 
    
        private static Logger logger = LoggerFactory.getLogger(AppCsiiServerApplication.class);
        public static ConfigurableApplicationContext context;
        public static void main(String[] args) { 
            context=SpringApplication.run(AppCsiiServerApplication.class, args);
        }
    
    }

### redis集成Spring原理是什么？ ###

Spring缓存抽象模块通过CacheManager来创建、管理实际缓存组件，当SpringBoot应用程序引入spring-boot-starter-data-redi依赖后吗，容器中将注册的是CacheManager实例RedisCacheManager对象，RedisCacheManager来负责创建RedisCache作为缓存管理组件，由RedisCache操作redis服务器实现缓存数据操作。实际测试发现默认注入的RedisCacheManager操作缓存用的是RedisTemplate<Object, Object>，因此我们需要自定义cacheManager，替换掉默认的序列化器。

### @Configuration作用 ###

@Configuration底层是含有@Component ，所以@Configuration 具有和 @Component 的作用。

@Configuration可理解为用spring的时候xml里面的标签。

注：

配置类必须以类的形式提供（不能是工厂方法返回的实例），允许通过生成子类在运行时增强（cglib 动态代理）。  
配置类不能是 final 类（没法动态代理）。  
配置注解通常为了通过 @Bean 注解生成 Spring 容器管理的类。  
配置类必须是非本地的（即不能在方法中声明，不能是 private）。  
任何嵌套配置类都必须声明为static。

@Bean方法不能创建进一步的配置类（也就是返回的bean如果带有@Configuration，也不会被特殊处理，只会作为普通的 bean）。

### @EnableCaching作用是什么？ ###

@EnableCaching注解是spring framework中的注解驱动的缓存管理功能。自spring版本3.1起加入了该注解。  
当你在配置类(@Configuration)上使用@EnableCaching注解时，会触发一个post processor，这会扫描每一个spring bean，查看是否已经存在注解对应的缓存。如果找到了，就会自动创建一个代理拦截方法调用，使用缓存的bean执行处

因此我们只要在使用的地方注入即可：

@Autowired  
StringRedisTemplate stringRedisTemplate; //操作 k-v 字符串  
@Autowired  
RedisTemplate redisTemplate; //k- v 都是对象  
StringRedisTemplate 提供opsForValue用来操作key-value，如上面的示例，另外还提供了一系列opsForHash()、opsForList()、opsForSet()、opsForZSet()等方法用来操作不同结构类型的数据

## redis注解使用案例 ##

package com.sl.cache.service;
    import com.sl.cache.entity.Product;
    import com.sl.cache.mapper.ProductMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CacheConfig;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.CachePut;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.cache.annotation.Caching;
    import org.springframework.stereotype.Service;
    
    @Service
    @CacheConfig(cacheNames = "product")
    public class ProductService { 
        @Autowired
        private ProductMapper productMapper;
    
        @Cacheable(cacheNames = "product1",key = "#root.methodName+'['+#id+']'")
        //@Cacheable(cacheNames = {"product1","product2"})// 默认key为参数，多个参数SimpleKey [arg1,arg2]
        //@Cacheable(cacheNames = "product",key = "#root.methodName+'['+#id+']'")
        //@Cacheable(cacheNames = "product",keyGenerator = "myKeyGenerator")
        //@Cacheable(cacheNames = "product",key = "#root.methodName+'['+#id+']'",condition="#a0>10",unless = "#a0==11") //或者condition="#id>10")
        public Product getProductById(Long id){ 
           Product product =productMapper.getProductById(id);
           System.out.println(product);
           return product;
        }
    
        @CachePut(value="product",key = "#result.productId",condition = "#result!=null")
        public  Product updateProduct(Product product){ 
            int count = productMapper.updateProduct(product);
            System.out.println("影响行数："+count);
            if(count>0){ 
                return product;
            }else{ 
                return null;
            }
        }
    
        //@CacheEvict(value="product",key="#id")
        //@CacheEvict(value="product",allEntries = true) //清楚所有缓存
        @CacheEvict(value="product",allEntries = true,beforeInvocation = true) //清楚所有缓存
        public boolean deleteProductById(Long id) { 
            productMapper.deleteProductById(id);
            return true;
        }
    
        //含有CachePut注解，所以执行这个方法时一定会查询数据库，及时有cacheable注解
        @Caching(
                cacheable = { @Cacheable(value="product",key="#productName")},
                put = { 
                        @CachePut(value="product",key="#result.productId"),
                        @CachePut(value="product",key="#result.productName")
                }
        )
        public  Product getProductByName(String productName){ 
    
            Product product =productMapper.getProductByName(productName);
    
             return product;
        }
    }

## Spring Boot缓存实战 Redis 设置有效时间和自动刷新缓存 ##

### 方式一：直接扩展注解的Value值 ###

相关步骤参考：[https://www.jianshu.com/p/275cb42080d9][https_www.jianshu.com_p_275cb42080d9]

参考配置如下：

@Override
    @Cacheable(value = "people#${select.cache.timeout:1800}#${select.cache.refresh:600}", key = "#person.id", sync = true)
    public Person findOne(Person person, String a, String[] b, List<Long> c) { 
        Person p = personRepository.findOne(person.getId());
        System.out.println("为id、key为:" + p.getId() + "数据做了缓存");
        System.out.println(redisTemplate);
        return p;
    }

### 方式一：通过CancheManager配置（业务量不大推荐） ###

spring-data-redis 1.x版本配置

/* * spring-data-redis 1.5X版本 * @param connectionFactory * @return */
    
       @Bean
        public CacheManager cacheManager(RedisTemplate redisTemplate) { 
            RedisCacheManager manager = new RedisCacheManager(redisTemplate);
            manager.setUsePrefix(true);
            RedisCachePrefix cachePrefix = new RedisPrefix("prefix");
            manager.setCachePrefix(cachePrefix);
            // 整体缓存过期时间
            manager.setDefaultExpiration(3600L);
            // 设置缓存过期时间。key和缓存过期时间，单位秒
            Map<String, Long> expiresMap = new HashMap<>();
            expiresMap.put("user", 1000L);
            manager.setExpires(expiresMap);
            return manager;
        }

2.x版本配置

/** * data-redis 2.x配置 支持配置对应key缓存时间 * @param factory * @return */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory factory) { 
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();  // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
            config = config.entryTtl(Duration.ofMinutes(30))     // 设置缓存的默认过期时间，也是使用Duration设置
                    .disableCachingNullValues();     // 不缓存空值
    
            // 设置一个初始化的缓存空间set集合
            Set<String> cacheNames =  new HashSet<>();
            cacheNames.add("device");
            cacheNames.add("project_type");
    
            // 对每个缓存空间应用不同的配置
            Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
            configMap.put("device", config);
            configMap.put("project_type", config.entryTtl(Duration.ofHours(1)));
            // 使用自定义的缓存配置初始化一个cacheManager
            RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                    .initialCacheNames(cacheNames)
                    // 注意这两句的调用顺序，一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
                    .withInitialCacheConfigurations(configMap)
                    .build();
            return cacheManager;
        }

## 常用缓存注解使用 ##

<table> 
 <thead> 
  <tr> 
   <th>注解类型</th> 
   <th>作用</th> 
   <th>应用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Cacheable</td> 
   <td>触发缓存入口</td> 
   <td>查询数据缓存</td> 
  </tr> 
  <tr> 
   <td>@CacheEvict</td> 
   <td>触发移除缓</td> 
   <td>缓存移除</td> 
  </tr> 
  <tr> 
   <td>@CacahePut</td> 
   <td>更新缓存</td> 
   <td>用于插入和更新数据操作</td> 
  </tr> 
  <tr> 
   <td>@Caching</td> 
   <td>将多种缓存操作分组</td> 
   <td>支持更多缓存操作</td> 
  </tr> 
  <tr> 
   <td>@CacheConfig</td> 
   <td>类级别的缓存注解，允许共享缓存名称</td> 
   <td>class级别配置</td> 
  </tr> 
 </tbody> 
</table>

使用案例集锦：

@Cacheable("product")
    @Cacheable(value = {"product","order"}, key = "#root.targetClass+'-'+#id")
    @Cacheable(value = "product", key = "#root.targetClass+'-'+#id")
    自定义cacheManager
    @Cacheable(value = "product", key = "#root.targetClass+'-'+#id” cacheManager="cacheManager")
    @CachePut
    应用到写数据的方法上，如新增/修改方法
    @CachePut(value = "product", key = "#root.targetClass+'-'+#product.id")
    @CacheEvict 
    即应用到移除数据的方法上，如删除方法
    @CacheEvict(value = "product", key = "#root.targetClass+'-'+#id")
    提供的SpEL上下文数据

Spring Cache提供了一些供我们使用的SpEL上下文数据，下表直接摘自Spring官方文档：

<table> 
 <thead> 
  <tr> 
   <th>名字</th> 
   <th>位置</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>methodName</td> 
   <td>root对象</td> 
   <td>当前被调用的方法名</td> 
   <td>#root.methodName</td> 
  </tr> 
  <tr> 
   <td>method</td> 
   <td>root对象</td> 
   <td>当前被调用的方法</td> 
   <td>#<a href="http://root.method.name" rel="nofollow">root.method.name</a></td> 
  </tr> 
  <tr> 
   <td>target</td> 
   <td>root对象</td> 
   <td>当前被调用的目标对象</td> 
   <td>#root.target</td> 
  </tr> 
  <tr> 
   <td>targetClass</td> 
   <td>root对象</td> 
   <td>当前被调用的目标对象类</td> 
   <td>#root.targetClass</td> 
  </tr> 
  <tr> 
   <td>args root对象</td> 
   <td>当前被调用的方法的参数列表</td> 
   <td>#root.args[0]</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>caches root对象</td> 
   <td>当前方法调用使用的缓存列表</td> 
   <td>（如@Cacheable(value={“cache1”, “cache2”})），则有两个cache</td> 
   <td>#root.caches[0].name</td> 
  </tr> 
  <tr> 
   <td>argument name</td> 
   <td>执行上下文</td> 
   <td>当前被调用的方法的参数，如findById(Long id)，我们可以通过#id拿到参数</td> 
   <td>#<a href="http://user.id" rel="nofollow">user.id</a></td> 
  </tr> 
  <tr> 
   <td>result</td> 
   <td>执行上下文</td> 
   <td>方法执行后的返回值（仅当方法执行之后的判断有效，如‘unless’，'cache evict’的beforeInvocation=false）</td> 
   <td>#result</td> 
  </tr> 
 </tbody> 
</table>

### @Cacheable ###

`@Cacheable`：作用是主要针对方法配置，能够根据方法的请求参数对其结果进行缓存,已经缓存就不再调用注解修饰的方法，适用于查询接口

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.cache.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Inherited;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.core.annotation.AliasFor;
    
    @Target({ ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Cacheable { 
        @AliasFor("cacheNames")
        String[] value() default { };
    
        @AliasFor("value")
        String[] cacheNames() default { };
    
        String key() default "";
    
        String keyGenerator() default "";
    
        String cacheManager() default "";
    
        String cacheResolver() default "";
    
        String condition() default "";
    
        String unless() default "";
    
        boolean sync() default false;
    }

主要参数说明：

1、value ：缓存的名称，在 spring 配置文件中定义，必须指定至少一个，

例如：@Cacheable(value=”mycache”) 或者 @Cacheable(value=\{”cache1”,”cache2”\}。

2、key ：缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合，

例如：@Cacheable(value=”testcache”,key=”\#userName”)。

3、condition ：缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存，  
例如：@Cacheable(value=”testcache”,condition=”\#userName.length()>2。  
4、keyGenerator 配置key自动生成器  
例如：  
@Cacheable(value=“cat”, keyGenerator = “accountKeyGenerator”)

### @CachePut ###

@CachePut：作用是主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 @Cacheable 不同的是，它每次都会触发真实查询

方法的调用

主要参数说明：

参数配置和@Cacheable一样。

### @CacheEvict ###

@CacheEvict：作用是主要针对方法配置，能够根据一定的条件对缓存进行清空

在这里插入代码片

主要参数说明：  
1、value 和 cacheName， key 和 condition 参数配置和@Cacheable一样。  
2、allEntries ：是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存，  
例如：

@CachEvict(value=”testcache”,allEntries=true)。

3、beforeInvocation ：是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存，

例如

@CachEvict(value=”testcache”，beforeInvocation=true)。

### @Caching ###

通过注解的属性值可以看出来，这个注解将其他注解方式融合在一起了，我们可以根据需求来自定义注解，并将前面三个注解应用在一起

public @interface Caching { 
        Cacheable[] cacheable() default { };
     
        CachePut[] put() default { };
     
        CacheEvict[] evict() default { };
    }

使用：

@Caching(
      put = { 
               @CachePut(value = "user", key = "\"user_\" + #user.id"),
               @CachePut(value = "user", key = "#user.name"),
               @CachePut(value = "user", key = "#user.account")
       }
        )
        public User saveUserByCaching(User user){ 
            userMapper.insert(user);
            return user;
        }

通过这种方式可以添加多个key

127.0.0.1:6379> keys *
    1) "user~keys"
    2) "dsjkf"
    3) "dkjd"
    4) "user_3"

### @CacheConfig 类级别的缓存注解，允许共享缓存名称 ###

该注解是可以将缓存分类，它是类级别的注解方式。我们可以这么使用它。  
这样的话，UseCacheRedisService的所有缓存注解例如@Cacheable的value值就都为user。

@CacheConfig(cacheNames = "user")
    @Service
    public class UseCacheRedisService { }

在redis的缓存中显示如下

127.0.0.1:6379> keys \*

1.  “user~keys”
2.  “user\_1”  
    127.0.0.1:6379> get user~keys  
    (error) WRONGTYPE Operation against a key holding the wrong kind of value  
    127.0.0.1:6379> type user~keys  
    zset  
    127.0.0.1:6379> zrange user~keys 0 10
3.  “user\_1”  
    我们注意到，生成的user~keys，它是一个zset类型的key，如果使用get会报WRONGTYPE Operation against a key holding the wrong kind of value。这个问题坑了我很久

[https_spring.io_projects_spring-data-redis]: https://spring.io/projects/spring-data-redis
[https_yq.aliyun.com_articles_531067]: https://yq.aliyun.com/articles/531067
[https_blog.csdn.net_weixin_34277853_article_details_87221807]: https://blog.csdn.net/weixin_34277853/article/details/87221807
[person.id]: http://person.id
[https_blog.csdn.net_shuxing520_article_details_78787545]: https://blog.csdn.net/shuxing520/article/details/78787545
[https_blog.csdn.net_weixin_38364973_article_details_82767828]: https://blog.csdn.net/weixin_38364973/article/details/82767828
[https_www.jianshu.com_p_275cb42080d9]: https://www.jianshu.com/p/275cb42080d9