基于Docker搭建Mycat环境实现Mysql数据库的读写分离

Love The Way You Lie 2023-07-10 15:31 112阅读 0赞

[基于Docker搭建Mycat环境实现Mysql数据库的读写分离][Docker_Mycat_Mysql]

## 1.搭建环境 ##

#### 1.1 搭建Mysql主从服务 ####

###### 1.1.1 下载Mysql镜像 ######

docker pull mysql:5.7
    
       
        
       
        
         1

###### 1.1.2 创建Mysql挂载目录 ######

mkdir -p /opt/mysql/master/{ conf,data,logs}
    
       
        
       
        
         1

mkdir -p /opt/mysql/slave/{ conf,data,logs}
    
       
        
       
        
         1

###### 1.1.3 进入conf目录中编辑my.cnf ######

主配置文件

[client]     
    port=3306   
    default-character-set=utf8
    [mysql]   
    default-character-set=utf8
    [mysqld]
    character_set_server=utf8
    sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
    # 配置大小写不敏感
    lower_case_table_names=1
    server_id=66  ###服务器id
    log-bin=mysql-bin   ###开启日志文件
    
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12

从配置文件

port=3306   
    default-character-set=utf8
    [mysql]   
    default-character-set=utf8
    [mysqld]
    character_set_server=utf8
    sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
    # 配置大小写不敏感
    lower_case_table_names=1
    server_id=88  ###服务器id 
    log-bin=mysql-bin   ###开启日志文件
    binlog_do_db=test
    
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12

###### 1.1.4 运行Mysql容器 ######

docker run -it --name mysql-master -p 3308:3306 -e MYSQL_ROOT_PASSWORD=root --privileged=true -v /opt/mysql/master/conf/my.cnf:/etc/mysql/my.cnf -v /opt/mysql/master/data:/var/lib/mysql -v /opt/mysql/master/logs:/var/log/mysql -d --restart=always mysql:5.7 
    
       
        
       
        
         1

docker run -it --name mysql-slave -p 3309:3306 -e MYSQL_ROOT_PASSWORD=root --privileged=true -v /opt/mysql/slave/conf/my.cnf:/etc/mysql/my.cnf -v /opt/mysql/slave/data:/var/lib/mysql -v /opt/mysql/slave/logs:/var/log/mysql -d --restart=always mysql:5.7 
    
       
        
       
        
         1

###### 1.1.5 查看容器 ######

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

###### 1.1.6 连接到主服务器 ######

查询主对应配置文件中的server\_id，查询到了说明已经以上步骤ok。

show variables like '%server_id%';
    
       
        
       
        
         1

![在这里插入图片描述][20190718190305656.png]  
查询主状态信息

show master status;
    
       
        
       
        
         1

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

###### 1.1.6 连接从服务器 ######

同步主服务器配置

change master to master_host='192.168.0.171',master_user='root',master_password='root',
             master_log_file='mysql-bin.000005',master_log_pos=1188;
    
       
        
       
        
         1
         2

开始同步

start slave;
    
       
        
       
        
         1

检查从服务器复制功能状态

SHOW SLAVE STATUS;
    
       
        
       
        
         1

![在这里插入图片描述][2019071819144478.png]  
Slave\_IO\_Running 、Slave\_SQL\_Running 都为Yes说明配置成功，验证效果就不截图了。

#### 1.2 搭建Mycat环境 ####

参考博客：https://blog.csdn.net/weixin\_39781526/article/details/84867397

###### 1.2.1 获取资源 ######

#先获取mycat包
    wget Mycat-server-1.6.5-release-20180122220033-linux.tar.gz;
    
       
        
       
        
         1
         2

###### 1.2.2 编写Dockerfile ######

FROM java:8
    USER root
    COPY Mycat-server-1.6.5-release-20180122220033-linux.tar.gz /
    RUN tar -zxf /Mycat-server-1.6.5-release-20180122220033-linux.tar.gz
    ENV MYCAT_HOME=/mycat
    ENV PATH=$PATH:${ MYCAT_HOME}/bin
    WORKDIR $MYCAT_HOME/bin
    RUN chmod u+x ./mycat
    EXPOSE 8066 9066
    CMD ["./mycat", "console"]
    
       
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10

###### 1.2.3 获取配置文件 ######

tar -zxvf Mycat-server-1.6.5-release-20180122220033-linux.tar.gz 
    mv mycat/conf/ conf
    
       
        
       
        
         1
         2

###### 1.2.4 修改mycat配置文件 ######

真正需要修改的只有三个文件，具体官方文档写的很详细；  
（1）:schema.xml ,(2):server.xml,(3):rule.xml;  
现在搭建的是Mysql读写分离，修改schema.xml、server.xm即可。rule.xml用于分表分库配置文件。

<?xml version="1.0"?>
 <!DOCTYPE mycat:schema SYSTEM "schema.dtd">
 <mycat:schema xmlns:mycat="http://io.mycat/">
 
 <schema name="mycat_testdb" checkSQLschema="false" sqlMaxLimit="100" dataNode="dn1"></schema>
 
 <dataNode name="dn1" dataHost="localhost1" database="test" />
 <!--
 dataNode节点中各属性说明：
 name：指定逻辑数据节点名称；
 dataHost：指定逻辑数据节点物理主机节点名称；
 database：指定物理主机节点上。如果一个节点上有多个库，可使用表达式db$0-99， 表示指定0-99这100个数据库；
 dataHost 节点中各属性说明：
 name：物理主机节点名称；
 maxCon：指定物理主机服务最大支持1000个连接；
 minCon：指定物理主机服务最小保持10个连接；
 writeType：指定写入类型；
 0，只在writeHost节点写入；
 1，在所有节点都写入。慎重开启，多节点写入顺序为默认写入根据配置顺序，第一个挂掉切换另一个；
 dbType：指定数据库类型；
 dbDriver：指定数据库驱动；
 balance：指定物理主机服务的负载模式。
 0，不开启读写分离机制；
 1，全部的readHost与stand by writeHost参与select语句的负载均衡，简单的说，当双主双从模式(M1->S1，M2->S2，并且M1与 M2互为主备)，正常情况下，M2,S1,S2都参与select语句的负载均衡；
 2，所有的readHost与writeHost都参与select语句的负载均衡，也就是说，当系统的写操作压力不大的情况下，所有主机都可以承担负载均衡；

–> 
<dataHost name=“localhost1” maxCon=“1000” minCon=“10” balance=“3” writeType=“0” dbType=“mysql” dbDriver=“native” switchType=“1” slaveThreshold=“100”> 
<heartbeat>select user()</heartbeat> 
<!– 可以配置多个主从 –> 
<writeHost host=“hostM1” url=“192.168.0.171:3308” user=“root” password=“root”> 
<!– 可以配置多个从库 –> 
<readHost host=“hostS2” url=“192.168.0.171:3309” user=“root” password=“root” /> 
</writeHost> 
</dataHost> 
</mycat:schema>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36

<?xml version="1.0" encoding="UTF-8"?>
 
 <!DOCTYPE mycat:server SYSTEM "server.dtd">
 <mycat:server xmlns:mycat="http://io.mycat/">

<!– 读写都可用的用户 –> 
<user name=“root” defaultAccount=“true”> 
<property name=“password”>123456</property> 
<property name=“schemas”>mycat\_testdb</property>

</user>
 
 
 <user name="user">
 <property name="password">user</property>
 <property name="schemas">mycat_testdb</property>
 <property name="readOnly">true</property>
 </user>

</mycat:server>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37

###### 1.2.5 执行Dockerfile ######

docker build -t mycat:1.6.5 . 
    
     
      
     
      
       1

###### 1.2.6 编写mycat启动脚本 ######

docker run -d --rm  -p:8066:8066 --name mycat-mysql -p 9066:9066 -v $PWD/logs:/mycat/logs -v $PWD/conf:/mycat/conf mycat:1.6.5
    
     
      
     
      
       1

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

###### 1.2.7 验证效果 ######

连接这四个服务  
![在这里插入图片描述][20190719085342579.png]  
在root服务修改数据，其他三个服务的数据自动同步相应的修改。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5_size_16_color_FFFFFF_t_70]  
在user服务修改数据报错，只允许读数据。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5_size_16_color_FFFFFF_t_70 1]

## 2 SpringBoot整合Mycat实现读写分离 ##

#### 2.1 导入Maven依赖 ####

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.wanzh</groupId>
 <artifactId>mycat_demo</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
 		<version>2.0.4.RELEASE</version>
 		<relativePath /> 
 	</parent>
 	<dependencies>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-aop</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>org.mybatis.spring.boot</groupId>
 			<artifactId>mybatis-spring-boot-starter</artifactId>
 			<version>1.3.2</version>
 		</dependency>
 	<dependency>
 		<groupId>mysql</groupId>
 		<artifactId>mysql-connector-java</artifactId>
 		<scope>runtime</scope>
 	</dependency>
 	<dependency>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-test</artifactId>
 		<scope>test</scope>
 	</dependency>
 
 	<dependency>
 		<groupId>com.alibaba</groupId>
 		<artifactId>druid</artifactId>
 		<version>1.0.23</version>
 	</dependency>
 </dependencies>
 
 <build>
 	<plugins>
 		<plugin>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-maven-plugin</artifactId>
 		</plugin>
 	</plugins>
 </build>

</project>

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53

#### 2.2 配置application.yml ####

spring:
      datasource:
        ###可读数据源
        select:
          jdbc-url: jdbc:mysql://192.168.0.171:8066/mycat_testdb
          driver-class-name: com.mysql.jdbc.Driver
          username: user
          password: user
        ####可写数据源  
        update:
          jdbc-url: jdbc:mysql://192.168.0.171:8066/mycat_testdb
          driver-class-name: com.mysql.jdbc.Driver
          username: root
          password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15

#### 2.3 配置多数据源环境 ####

package com.wanzh.config;

import org.springframework.context.annotation.Lazy;  
import org.springframework.stereotype.Component;

@Component 
@Lazy(false) 
public class DataSourceContextHolder \{ 
// 采用ThreadLocal 保存本地多数据源 
private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

// 设置数据源类型
 public static void setDbType(String dbType) {
 	contextHolder.set(dbType);
 }
 
 public static String getDbType() {
 	return contextHolder.get();
 }
 
 public static void clearDbType() {
 	contextHolder.remove();
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25

package com.wanzh.config;

import javax.sql.DataSource;

import org.springframework.boot.context.properties.ConfigurationProperties;  
import org.springframework.boot.jdbc.DataSourceBuilder;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;

@Configuration  
public class DataSourceConfig \{

// 创建可读数据源
 @Bean(name = "selectDataSource")
 @ConfigurationProperties(prefix = "spring.datasource.select") // application.properteis中对应属性的前缀
 public DataSource dataSource1() {
 	return DataSourceBuilder.create().build();
 }
 
 // 创建可写数据源
 @Bean(name = "updateDataSource")
 @ConfigurationProperties(prefix = "spring.datasource.update") // application.properteis中对应属性的前缀
 public DataSource dataSource2() {
 	return DataSourceBuilder.create().build();
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27

package com.wanzh.config;
    import java.util.HashMap;
    import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.beans.factory.annotation.Qualifier;  
import org.springframework.context.annotation.Primary;  
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;  
import org.springframework.stereotype.Component;

//在Spring 2.0.1中引入了AbstractRoutingDataSource, 该类充当了DataSource的路由中介, 能有在运行时, 根据某种key值来动态切换到真正的DataSource上。

@Component  
@Primary  
public class DynamicDataSource extends AbstractRoutingDataSource \{   
@Autowired  
@Qualifier(“selectDataSource”)  
private DataSource selectDataSource;

@Autowired
 @Qualifier("updateDataSource")
 private DataSource updateDataSource;
 
 /**
 * 这个是主要的方法，返回的是生效的数据源名称
 */
 @Override
 protected Object determineCurrentLookupKey() {
 	System.out.println("DataSourceContextHolder：：：" + DataSourceContextHolder.getDbType());
 	return DataSourceContextHolder.getDbType();
 }
 
 /**
 * 配置数据源信息
 */
 @Override
 public void afterPropertiesSet() {
 	Map<Object, Object> map = new HashMap<>();
 	map.put("selectDataSource", selectDataSource);
 	map.put("updateDataSource", updateDataSource);
 	setTargetDataSources(map);
 	setDefaultTargetDataSource(updateDataSource);
 	super.afterPropertiesSet();
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47

#### 2.4 AOP拦截动态切换数据源 ####

package com.wanzh.aop;

import org.aspectj.lang.JoinPoint;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Before;  
import org.springframework.context.annotation.Lazy;  
import org.springframework.core.annotation.Order;  
import org.springframework.stereotype.Component;

import com.wanzh.config.DataSourceContextHolder;

@Aspect  
@Component  
@Lazy(false)  
@Order(0) // Order设定AOP执行顺序 使之在数据库事务上先执行  
public class SwitchDataSourceAOP \{   
// 这里切到你的方法目录  
@Before(“execution(\* com.wanzh.service.*.*(…))”)  
public void process(JoinPoint joinPoint) \{   
String methodName = joinPoint.getSignature().getName();  
if (methodName.startsWith(“get”) || methodName.startsWith(“count”) || methodName.startsWith(“find”)  
|| methodName.startsWith(“list”) || methodName.startsWith(“select”) || methodName.startsWith(“check”)) \{   
DataSourceContextHolder.setDbType(“selectDataSource”);  
\} else \{   
// 切换dataSource  
DataSourceContextHolder.setDbType(“updateDataSource”);  
\}  
\}  
\}

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30

#### 2.5 整合Mybatis ####

package com.wanzh.entity;

public class User \{

private int id;
 
 private String name;
 
 public int getId() {
 	return id;
 }
 
 public void setId(int id) {
 	this.id = id;
 }
 
 public String getName() {
 	return name;
 }
 
 public void setName(String name) {
 	this.name = name;
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28

package com.wanzh.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;  
import org.apache.ibatis.annotations.Select;

import com.wanzh.entity.User;

public interface UserMapper \{ 
@Select("SELECT id,name FROM sys\_user ") 
public List<User> findUser();

@Select("insert into sys_user(name) values (#{name}); ")
 public List<User> insertUser(@Param("name") String name);

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17

package com.wanzh.service;

import java.util.List;  
import com.wanzh.entity.User;

public interface UserService \{

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13

package com.wanzh.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;

import com.wanzh.entity.User;  
import com.wanzh.mapper.UserMapper;  
import com.wanzh.service.UserService;

@Service(“userService”)  
public class UserServiceImpl implements UserService \{   
@Autowired  
private UserMapper userMapper;

public List<User> findUser() {
 	return userMapper.findUser();
 }
 
 public List<User> insertUser(String name) {
 	return userMapper.insertUser(name);
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27

package com.wanzh.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.RestController;

import com.wanzh.entity.User;  
import com.wanzh.service.UserService;

@RestController  
public class UserController \{

@Autowired
 private UserService userService;
 
 @RequestMapping("/findUser")
 public List<User> findUser() {
 	return userService.findUser();
 }
 
 @RequestMapping(value="/insertUser",method=RequestMethod.POST)
 public List<User> insertUser(String name) {
 	return userService.insertUser(name);
 }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31

package com.wanzh;

import org.mybatis.spring.annotation.MapperScan;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication  
@MapperScan(basePackages = “com.wanzh.mapper”)  
public class App \{   
public static void main(String\[\] args) \{   
SpringApplication.run(App.class, args);  
\}  
\}

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14

#### 2.6 Postman测试 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][20190719095027544.png]

参考每特教育Mycat课程内容，但是电脑配置有点低，这边就改用docker进行搭建了。

[Docker_Mycat_Mysql]: https://blog.csdn.net/qq_29648139/article/details/96443696?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
[20190718185009554.png]: https://img-blog.csdnimg.cn/20190718185009554.png
[20190718190305656.png]: https://img-blog.csdnimg.cn/20190718190305656.png
[20190718190541254.png]: https://img-blog.csdnimg.cn/20190718190541254.png
[2019071819144478.png]: https://img-blog.csdnimg.cn/2019071819144478.png
[20190719085250923.png]: https://img-blog.csdnimg.cn/20190719085250923.png
[20190719085342579.png]: https://img-blog.csdnimg.cn/20190719085342579.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190719085841726.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190719090145341.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190719094959291.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjQ4MTM5,size_16,color_FFFFFF,t_70
[20190719095027544.png]: https://img-blog.csdnimg.cn/20190719095027544.png