Redis-2

迈不过友情╰ 2021-12-10 16:15 117阅读 0赞

# Redis #

## 一、Redis 的读并发量太大怎么办？ ##

使用读写分离  
10w/s  
8w/s  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70]

## 二、单机版的Redis 挂掉怎么办？ ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 1]

## 三、需要写并发又要安全 ##

之前我们只有一个主机，写的并发量有限，使用多个主机来做  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 2]  
在redis 3.0 后，官方发布了集群方案  
**3.1 中心化**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 3]  
**3.2 去中心化**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 4]

## 四、Redis集群的执行流程分析 ##

16384个key  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 5]

## 五、搭建集群 ##

[http://redis.cn/topics/cluster-tutorial.html][http_redis.cn_topics_cluster-tutorial.html]  
**5.1 集群原理**  
去中心化  
**5.2 集群的规划**  
![在这里插入图片描述][20190711165417203.png]

**5.3 搭建过程  
5.3.1 新建文件夹**  
![在这里插入图片描述][20190711165428222.png]  
**5.3.2 准备一个服务端程序**  
![在这里插入图片描述][20190711165433196.png]  
**5.3.3准备6个redis的配置文件**  
![在这里插入图片描述][20190711165448443.png]  
**Redis-1**

daemonize yes
    bind 0.0.0.0
    port 7000
    # 开启集群
    cluster-enabled yes
    # 集群的配置文件,该文件自动生成
    cluster-config-file nodes-1.conf
    # 集群的超市时间
    cluster-node-timeout 5000
    # 打开aof 持久化
    appendonly yes

**Redis-2**

daemonize yes
    bind 0.0.0.0
    port 7001
    # 开启集群
    cluster-enabled yes
    # 集群的配置文件,该文件自动生成
    cluster-config-file nodes-2.conf
    # 集群的超市时间
    cluster-node-timeout 5000
    # 打开aof 持久化
    appendonly yes

**Redis-3**

daemonize yes
    bind 0.0.0.0
    port 7002
    # 开启集群
    cluster-enabled yes
    # 集群的配置文件,该文件自动生成
    cluster-config-file nodes-3.conf
    # 集群的超市时间
    cluster-node-timeout 5000
    # 打开aof 持久化
    appendonly yes

**Redis-4**

daemonize yes
    bind 0.0.0.0
    port 7003
    # 开启集群
    cluster-enabled yes
    # 集群的配置文件,该文件自动生成
    cluster-config-file nodes-4.conf
    # 集群的超市时间
    cluster-node-timeout 5000
    # 打开aof 持久化
    appendonly yes

**Redis-5**

daemonize yes
    bind 0.0.0.0
    port 7004
    # 开启集群
    cluster-enabled yes
    # 集群的配置文件,该文件自动生成
    cluster-config-file nodes-5.conf
    # 集群的超市时间
    cluster-node-timeout 5000
    # 打开aof 持久化
    appendonly yes

**Redis-6**

daemonize yes
    bind 0.0.0.0
    port 7005
    # 开启集群
    cluster-enabled yes
    # 集群的配置文件,该文件自动生成
    cluster-config-file nodes-6.conf
    # 集群的超市时间
    cluster-node-timeout 5000
    # 打开aof 持久化
    appendonly yes

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

**5.3.4 同时启动所有的redis**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][20190711165647427.png]  
**5.3.5 使用脚本创建集群（分配槽）**  
![在这里插入图片描述][2019071116565325.png]  
使用该脚本就可以创建

使用docker 下载redis-trib的镜像运行  
**A: 下载镜像**  
docker pull inem0o/redis-trib  
**B:创建集群**

docker run -t -i inem0o/redis-trib create --replicas 1 192.168.231.143:7000 192.168.231.143:7001 
    192.168.231.143:7002 192.168.231.143:7003 192.168.231.143:7004 192.168.231.143:7005

\-t(打开bash)  
\-i（能输入命令）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 8]  
**5.3.6 测试redis集群的路由效果**  
![在这里插入图片描述][20190711165749584.png]  
![在这里插入图片描述][20190711165752663.png]  
![在这里插入图片描述][20190711165756625.png]  
![在这里插入图片描述][2019071116580092.png]  
![在这里插入图片描述][20190711165802938.png]

## 六、使用Redis 做缓存和位集合 ##

Map->Redis  
@annotation(注解)  
**6.1 配置文件**

**6.2 改造代码**

@Component
    @Aspect
    public class CacheAspect {
        
    
    //	private static Map<String,Object> caches = new HashMap<>();
    	
    	@Autowired
    	private JedisPool pool;
    	
    	private static final String ALL_MENU_LABEL = "alll-menu-data"; 
    	
    	@Around("execution (* com.sxt.service.impl.MenuServiceImpl.loadAllMenu())")
    	public Object cache(ProceedingJoinPoint ponit) {
        
    		Jedis jedis = pool.getResource();
    		if(jedis.exists(ALL_MENU_LABEL)) {
        
    			String menuJson = jedis.get(ALL_MENU_LABEL);
    			List<Menu> menu = JSON.parseArray(menuJson, Menu.class);
    			return menu ;
    		}
    //		if(caches.containsKey(ALL_MENU_LABEL)) {
        
    //			System.out.println("缓存里面有");
    //			return caches.get(ALL_MENU_LABEL);
    //		}
    		
    		Object result = null ; 
    		try {
        
    			System.out.println("执行真实方法的调用");
    			result = ponit.proceed(ponit.getArgs()); // 在此实现了真实方法的调用
    //			放入缓存
    //			caches.put(ALL_MENU_LABEL, result);
    			jedis.set(ALL_MENU_LABEL,JSON.toJSONString(result));
    		} catch (Throwable e) {
        
    			e.printStackTrace();
    		}
    
    		return result;
    	}
    }

**6.3 测试**  
开启redis（单机） mysql zk  
![在这里插入图片描述][2019071116585234.png]  
![在这里插入图片描述][20190711165855407.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 9]

## 七、在SpringBoot 里面使用Redis ##

**7.1 新建项目  
7.2 选择依赖  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 10]  
7.3 spring boot 是一个什么东西**  
Spring 项目创建的脚手架，里面充分利用习惯大于约束的原则来初始化一些常用对象，使得Spring的开发变得更简洁，可以做到不用写配置文件（或写很少的配置文件就可以实现功能）。  
**7.4 spring boot 如何加载默认的对象**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][20190711165945851.png]  
![在这里插入图片描述][20190711165952406.png]  
为什么加上redis 的依赖就能创建redis的操作对象，不加就不创建？

**7.5 Spring boot的核心**  
包扫描的使用（扫描文件夹）  
**7.6 修改配置文件**

spring:
      redis:
        host: 192.168.231.143
        port: 6379
        pool:
          max-active: 25 
          max-idle: 20
          min-idle: 10

## 八、Spring boot 操作Redis ##

**8.1 StringRedisTemplate(使用最多)**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 12]

/**
     * spring 和junit 整合的测试框架
     * @author CodeLab
     *
     */
    /**
     * 可以把是sping boot的项目启动起来
     * @author CodeLab
     *
     */
    @RunWith(SpringRunner.class) 
    @SpringBootTest
    public class StringRedisTemplateTest {
        
    	
    	@Autowired
    	private StringRedisTemplate redisTemplate;
    	
    	/**
    	 * redis数据类型为String的操作
    	 */
    	@Test
    	public void testString() {
        
    		// 操作String类型
    		ValueOperations<String, String> opsValue = redisTemplate.opsForValue();
    		// 给redis 里面set 一个key
    		opsValue.set("boot", "spring-boot"); // k -v 都是String
    		// 从redis 里面获取key
    		String value = opsValue.get("boot");
    		System.out.println(value);
    		// 从redis 里面或多个key
    		List<String> asList = Arrays.asList("boot","alll-menu-data");
    		List<String> mulitValues = opsValue.multiGet(asList);
    		System.out.println(mulitValues);
    //		 redis的自动增长
    		Long increment = opsValue.increment("boot-incr", 2);// delta 可以+ 任意的数（步长）
    		System.out.println(increment);
    	}
    
    	@Test
    	public void testHash() {
        
    		HashOperations<String, Object, Object> opsForHash = redisTemplate.opsForHash();
    		// hset
    		opsForHash.put("object-1", "name", "ltd"); // 后面的2 个参数都是object,但是只支持String 类型
    		opsForHash.put("object-1", "age", "27"); // 后面的2 个参数都是object,但是只支持String 类型
    		opsForHash.put("object-1", "sex", "man"); // 后面的2 个参数都是object,但是只支持String 类型
    		Object value = opsForHash.get("object-1", "sex");
    		System.out.println(value);
    		// 取多个值
    		List<Object> multiGet = opsForHash.multiGet("object-1", Arrays.asList("name","sex"));
    		System.out.println(multiGet);
    	}
    	
    	@Test
    	public void testZset() {
        
    		ZSetOperations<String, String> opsForZSet = redisTemplate.opsForZSet();
    		// 放到zset集合里面
    		opsForZSet.add("lol", "ltd", 2500);
    		opsForZSet.add("lol", "lz", 0);
    		opsForZSet.add("lol", "ln", 1400);
    		opsForZSet.add("lol", "ll", -10);
    		opsForZSet.add("lol", "lt", 2700);
    		Set<String> rangeAsc = opsForZSet.range("lol", 0, 2); // 通过排序取值 ll lz ln
    		System.out.println(rangeAsc);
    		Set<String> reverseRange = opsForZSet.reverseRange("lol", 0, 2);//lt ltd ln
    		System.out.println(reverseRange);
    		Set<TypedTuple<String>> tuples = new HashSet<ZSetOperations.TypedTuple<String>>();
    		tuples.add(new DefaultTypedTuple<String>("ltd", 1000.00) );
    		tuples.add(new DefaultTypedTuple<String>("lv", 1200.00) );
    		tuples.add(new DefaultTypedTuple<String>("lz", 2900.00) );
    		tuples.add(new DefaultTypedTuple<String>("lt", 100.00) );
    		// 若redis 存在该key ，则需要数据类型相同，不然报错
    		opsForZSet.add("dnf", tuples);
    		
    	}
    
    }

**8.2 RedisTemplate（扩展String类型）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 13]  
若不设置序列化规则，它将使用JDK自动的序列化将对象转换为字节，存到Redis 里面  
![在这里插入图片描述][20190711170103344.png]  
可以设置序列化  
![在这里插入图片描述][20190711170107106.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 14]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 15]

/**
     * spring 和junit 整合的测试框架
     * @author CodeLab
     *
     */
    /**
     * 可以把是sping boot的项目启动起来
     * @author CodeLab
     *
     */
    @RunWith(SpringRunner.class) 
    @SpringBootTest
    public class RedisTemplateTest {
        
    	
    	@Autowired
    	private RedisTemplate<Object, Object> redisTemplate ; // 因为创建RedisTemplate 没有使用泛型信息来创建，泛型 本质还是Object，只不过泛型能自动推断并强转
    
    
       
    	@Test
    	public void testString() {
        
    		redisTemplate.setKeySerializer(new  StringRedisSerializer()); // key的序列化使用String 类型来完成 因为key 很多时候都是一个字符串
    		redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); // 优先没有泛型的，因为有泛型后，它支持的数据类型就定了
    		ValueOperations<Object, Object> valueOperations = redisTemplate.opsForValue();
    //		valueOperations.set("boot-redis", "boot-value"); //对象->字符串 json
    		User user = new User(1, "ltd", "124", "liangtiandong@live.com", "xx.jpg");
    //		 KEY : com.sxt.domain.User:1 
    //		com.fasterxml.jackson.databind.JsonSerializer 没有依赖jackson 之前大家可能使用spring-boot-web，这里面会自动依赖
    		valueOperations.set(User.class.getName()+":"+user.getId(), user);
    		
    		// 若该对象的强转转换，则redis 内部会使用JackSon 的工具将字符串-> 转换为java 对象 ，那jackson 转换为对象时，需要一个对象的类型 ，其实它已经自动对象的类型了"@class": "com.sxt.domain.User",
    		User object = (User)valueOperations.get(User.class.getName()+":"+user.getId());
    	    System.out.println(object.getUsername()+":"+object.getIcon());
    	}
    	
    	/**
    	 * hash
    	 */
    	@Test
    	public void testHash() {
        
    		redisTemplate.setKeySerializer(new  StringRedisSerializer()); // key的序列化使用String 类型来完成 因为key 很多时候都是一个字符串
    		redisTemplate.setHashKeySerializer(new  StringRedisSerializer());
    		redisTemplate.setHashValueSerializer(new  StringRedisSerializer()); // 若都是string 则和StringRedisTempalte一样了
    		HashOperations<Object, Object, Object> opsForHash = redisTemplate.opsForHash();
    		opsForHash.put("redis-hash", "prop1", "value");
    	}
    
    }

**8.3 RedisKeyValueTemplate（很少用）**  
![在这里插入图片描述][20190711170146919.png]

数据库的存储引擎  
![在这里插入图片描述][20190711170151620.png]  
InnoDb  
不保存数据的id，我们的做法，只是将数据存入redis ，并没有set 集合

MyISAM，不仅仅保存数据，还把当前表里面存在id 也放在一个文件里面（set集合）  
使用一个文件专门保存已经存入表里面的数据id

我想查询一个没有的数据  
Id = 47 没有？MyISAM  
我想统计当前表里面有多少个数据？  
Innodb需要扫描全表  
MyISAM：得到一个总条数

* spring 和junit 整合的测试框架
     * @author CodeLab
     *
     */
    /**
     * 可以把是sping boot的项目启动起来
     * @author CodeLab
     *
     */
    @RunWith(SpringRunner.class) 
    @SpringBootTest
    public class KeyValueRedisTemplateTest {
        
    
    	@Autowired
    	private RedisKeyValueTemplate redisKeyValue;
    
    	@Autowired
    	private StringRedisTemplate strRedis;
    	
    	/**
    	 * 别人写的有set 集合，有的好处就是查询一个不存在的对象，和统计数据的个数，已经获取前几条比较高效
    	 */
    	@Test // 和数据库的操作很像 可以根据对象的属性来查找数据
    	public void testCurd() {
        
    		User user = new User(1, "mjm", "1231", "4e12421", "r23r.jpg");
    		redisKeyValue.insert(user); //redis 如何存储一个对象？map - > hash 最合适 属性 属性值
    		//        对象->Map集合
    		//		redisKeyValue.delete(objectToDelete);
    		//		redisKeyValue.findById(id, type);
    	}
    	
    	@Test
    	public void testFind() {
        
    		User findById = redisKeyValue.findById(3, User.class); // 1 先查询set（com.sxt.domain.User）集合里面是否有3 ，有：拼接key（com.sxt.domain.User：3） ，获取数据，没有，直接结束
    		System.out.println(findById);
    	}
    	
    	@Test
    	public void testDelete() {
        
    		User delete = redisKeyValue.delete(3, User.class);
    		System.out.println(delete.getId());
    	}
    	
    	@Test
    	public void testFindAll() {
        
    		Iterable<User> findInRange = redisKeyValue.findInRange(0, 2, User.class); // 从set 集合获取keys ，使用keys 查询
    		Iterator<User> iterator = findInRange.iterator();
    		while(iterator.hasNext()) {
        
    			System.out.println(iterator.next().getId());
    		}
    	}
    
    	/**
    	 *自己写的存储对象。没有那个set 集合
    	 */
    //	@Test
    	public void testInsertObject() {
        
    		User user = new User(3, "mjm", "1231", "4e12421", "r23r.jpg");
    		HashOperations<String, Object, Object> opsForHash = strRedis.opsForHash();
    		String key = user.getClass().getName()+":"+user.getId();
    		Map<String, Object> map = new HashMap<String,Object>();
    		map = object2Map(user);
    		opsForHash.putAll(key, map);
    	}
    
    	private static Map<String, Object> object2MapXiaoWen(Object key) {
        
    		HashMap<String,Object> map = new HashMap<String,Object>();
    		String objectJson = JSON.toJSONString(key);
    		Map parseObject = JSON.parseObject(objectJson, Map.class);
    		return parseObject;
    	}
    	
    	private static Map<String, Object> object2Map(Object object){
        
    		Class<?> clazz = object.getClass();
    		Map<String,Object> map = new HashMap<String,Object>();
    		Field[] declaredFields = clazz.getDeclaredFields();
    		for (Field field : declaredFields) {
        
    			field.setAccessible(true);
    			String key = field.getName();
    			Object value = null ;
    			try {
        
    				value = String.valueOf(field.get(object));
    			} catch (IllegalArgumentException | IllegalAccessException e) {
        
    				e.printStackTrace();
    			}
    			map.put(key, value);
    		}
    		return map ;
    	}
    	
    	public static void main(String[] args) {
        
    		User user = new User(2, "mjm", "1231", "4e12421", "r23r.jpg");
    		Map<String, Object> object2Map = object2Map(user);
    		object2Map.forEach((k,v)->{
        
    			System.out.println("k:"+k+"-----"+"v:"+v);
    		});
    	}
    }

**8.4 集群的额外操作**

@Test
    	public void testCluster() {
        
    		ClusterOperations<String, String> opsForCluster = redisTemplate.opsForCluster();
    		opsForCluster.shutdown(new RedisClusterNode("192.168.231.143", 7000));
    	}

## 九、使用Redis 做缓存 ##

**9.1 在boot 里面使用Redis 做缓存**  
![在这里插入图片描述][20190711170249271.png]  
**9.2 在你需要添加缓存的方法上面，添加注解**  
![在这里插入图片描述][2019071117025730.png]  
**9.2.1 cacheable（使用最多）**  
就是一个完整的切面，先从缓存里面查询，若没有，查询数据库，把结果放入缓存里面  
![在这里插入图片描述][2019071117030971.png]

**9.2.2 cacheput（解决脏读）**  
每次调用该方法，都会执行数据库查询，并且把缓存的值覆盖  
![在这里插入图片描述][20190711170313256.png]  
![在这里插入图片描述][20190711170318841.png]  
**9.2.3 cachEvict（解决脏读）**  
直接把缓存里面值删除  
![在这里插入图片描述][20190711170329987.png]  
**9.2.4 cacheconfig（全局的配置缓存）**  
![在这里插入图片描述][20190711170339280.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70]: /images/20211210/d2e0ec9f774f4b709cd699edd69138a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 1]: /images/20211210/90b09998aebe4e5dbc68e9442f674245.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 2]: /images/20211210/979874712b5242d4b822c6788c0b9640.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 3]: /images/20211210/7fb254c1ba1945c3adf5002a8953216e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 4]: /images/20211210/4f4c01fb9df441fc9787b7cd857ade34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 5]: /images/20211210/05d2da85e74e4fbba685450a1217de28.png
[http_redis.cn_topics_cluster-tutorial.html]: http://redis.cn/topics/cluster-tutorial.html
[20190711165417203.png]: /images/20211210/430946d90fd24560bcd4a0449d5e998d.png
[20190711165428222.png]: /images/20211210/fba7ddff20994e4b980a966e1ac2b52e.png
[20190711165433196.png]: /images/20211210/e7735e96a92e42e583f7c06fe9315fb4.png
[20190711165448443.png]: /images/20211210/018ebd29cc884508b76e2dca7a76706c.png
[20190711165630917.png]: /images/20211210/682b94b553cd4852a776eaebbe07371a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 6]: /images/20211210/cdc35736459c471ba10138432bdfe739.png
[20190711165647427.png]: /images/20211210/750fb730b9a443d48778f2140564e37e.png
[2019071116565325.png]: /images/20211210/9ad83c8e61594e04aeed4bc8262737df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 7]: /images/20211210/057d7e1aaa9243e59809fd05b53e1710.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 8]: /images/20211210/d4c04f2d388a484684ef7d3828d3301e.png
[20190711165749584.png]: /images/20211210/fcaae25e998549249f9718ea6fac80be.png
[20190711165752663.png]: /images/20211210/90f38200add449e19f61fddf76c7091e.png
[20190711165756625.png]: /images/20211210/4ffa8e7977fb45a49cb5b6bc62e6d7cc.png
[2019071116580092.png]: /images/20211210/bb597823889c4baa8b77817b6a5db7c8.png
[20190711165802938.png]: /images/20211210/3ebcc763016e46f4b706a4f3de80caf7.png
[2019071116585234.png]: /images/20211210/89e0546f708446debf87128a4e7398ce.png
[20190711165855407.png]: /images/20211210/51604b5246d849949dfde65dda24e7cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 9]: /images/20211210/b6267a872d10485e90b5a728e83fa2c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 10]: /images/20211210/deabea61e6dc47df8d09b10cf5b8b9e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 11]: /images/20211210/927eb899aabd4a3e9476de9236996a34.png
[20190711165945851.png]: /images/20211210/3023b693185042ce856d6ff9d0f01adf.png
[20190711165952406.png]: /images/20211210/47c36eb06e2f42638d35a96212f836a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 12]: /images/20211210/5dfe92e7af6a4dc591e48cfe259da654.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 13]: /images/20211210/c081452a56714971b570fe7ed2926f29.png
[20190711170103344.png]: /images/20211210/14be2e747e8f4bd587e61ac8a70ec088.png
[20190711170107106.png]: /images/20211210/b88f4ca48283466b8a77e7b82d3debac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 14]: /images/20211210/147616551ddb425a954be71ed85da23e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 15]: /images/20211210/aa928657a8664cc0bdc7917d073a2cc0.png
[20190711170146919.png]: /images/20211210/779a2a664e4b468d8b65e8e0ab7d7353.png
[20190711170151620.png]: /images/20211210/555b9062d0cf4161b550a117359617e0.png
[20190711170249271.png]: /images/20211210/5febd1fad2ff4668aa9a2e572265e9fb.png
[2019071117025730.png]: /images/20211210/914d33e128b849f2a7b54f9f61608a4c.png
[2019071117030971.png]: /images/20211210/fe0ce0d1ecb946e3aac75ce80993d6e2.png
[20190711170313256.png]: /images/20211210/e11f3b03cc8c448f9a7d802a5dd734a4.png
[20190711170318841.png]: /images/20211210/51f0e96e26e24095b41b7a2ff89a9480.png
[20190711170329987.png]: /images/20211210/e16e00ed1fd44273924988e812f464fd.png
[20190711170339280.png]: /images/20211210/ee1a6201788c4548a43abdd444d84815.png