mybatis框架入门（一）

小鱼儿 2023-02-12 10:27 13阅读 0赞

--------------------

![在这里插入图片描述][20200525204054918.png_pic_center]

--------------------

### 文章目录 ###

*   *  一、MyBatis简介
     *   *  （一）什么是MyBatis
         *  （二）为什么要使用MyBatis
     *  二、MyBatis入门
     *   *  （一）准备数据，创建库和表
         *  （二）创建工程，导入所需jar包、创建测试类
         *  （三）添加mybatis-config.xml文件
         *  （四）添加EmpMapper.xml文件
         *  （五）添加并编写Emp实体类
         *  （六）实现测试类,并测试
     *  三、MyBatis入门细节
     *   *  （一）mybatis-config.xml配置文件
         *  （二）EmpMapper.xml配置文件
     *  四、MyBatis增删改查
     *   *  （一）新增员工
         *  （二）修改员工
         *  （三）删除员工
     *  五、mybatis中的占位符
     *   *  （一）\`\#\{\}\`占位符
         *  （二）\`$\{\}\`占位符

--------------------

## 一、MyBatis简介 ##

--------------------

### （一）什么是MyBatis ###

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

MyBatis是一个优秀的**持久层框架**，它对jdbc的操作数据库的过程进行封装，使开发者**只需要关注SQL本身**，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

> 总之，Mybatis对JDBC访问数据库的过程进行了封装，简化了JDBC代码，解决JDBC将结果集封装为Java对象的麻烦。

下图是MyBatis架构图：

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

（1）`mybatis-config.xml`是Mybatis的核心配置文件，通过其中的配置可以生成`SqlSessionFactory`,也就是`SqlSession`工厂

（2）基于`SqlSessionFactory`可以生成`SqlSession`对象

（3）`SqlSession`是一个既可以发送SQL去执行，并返回结果，类似于JDBC中的`Connection`对象，也是Mybatis中至关重要的一个对象。

（4）`Executor`是`SqlSession`底层的对象，用于执行SQL语句

（5）`MapperStatement`对象也是`SqlSession`底层的对象，用于接收输入映射（SQL语句中的参数），以及做输出映射（即将SQL查询的结果映射成相应的结果）

### （二）为什么要使用MyBatis ###

*思考：在开始之前，思考下如何通过JDBC查询Emp表中的所有记录，并封装到一个List集合中返回。（演示：准备数据、导包、导入JDBC程序）*

**1、使用传统方式JDBC访问数据库：**

（1）使用JDBC访问数据库有大量重复代码（比如注册驱动、获取连接、获取传输器、释放资源等）；

（2）JDBC自身没有连接池，会频繁的创建连接和关闭连接，效率低；

（3）SQL是写死在程序中，一旦修改SQL，需要对类重新编译；

（4）对查询SQL执行后返回的ResultSet对象，需要手动处理，有时会特别麻烦；

…

**2、使用mybatis框架访问数据库：**

（1）Mybatis对JDBC对了封装，可以简化JDBC代码；

（2）Mybatis自身支持连接池（也可以配置其他的连接池），因此可以提高程序的效率；

（3）Mybatis是将SQL配置在mapper文件中，修改SQL只是修改配置文件，类不需要重新编译。

（4）对查询SQL执行后返回的ResultSet对象，Mybatis会帮我们处理，转换成Java对象。

…

> 总之，JDBC中所有的问题（代码繁琐、有太多重复代码、需要操作太多对象、释放资源、对结果的处理太麻烦等），在Mybatis框架中几乎都得到了解决！！

--------------------

## 二、MyBatis入门 ##

--------------------

### （一）准备数据，创建库和表 ###

创建yonghedb库、emp表，并插入若干条记录

-- 1、创建数据库 yonghedb 数据库
    create database if not exists yonghedb charset utf8;
    use yonghedb; -- 选择yonghedb数据库
    -- 2、删除emp表（如果存在）
    drop table if exists emp;
    -- 3、在 yonghedb 库中创建 emp 表
    create table emp(
        id int primary key auto_increment,
        name varchar(50),
        job varchar(50),
        salary double
    );
    -- 4、往 emp 表中, 插入若干条记录
    insert into emp values(null, '王一', '程序员', 3300);
    insert into emp values(null, '齐二', '程序员', 2800);
    insert into emp values(null, '刘三', '程序员鼓励师', 2700);
    insert into emp values(null, '陈四', '部门总监', 4200);
    insert into emp values(null, '赵五', '程序员', 3000);
    insert into emp values(null, '董六', '程序员', 3500);
    insert into emp values(null, '苍七', '程序员', 3700);
    insert into emp values(null, '韩八', 'CEO', 5000);

### （二）创建工程，导入所需jar包、创建测试类 ###

`1、创建Maven的java工程`

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

`2、导入junit、mysql、mybaits等开发包`

在pom.xml文件中引入相关依赖包即可

<dependencies>
        
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.8</version>
        </dependency>
        
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
    </dependencies>

3、创建`com.tedu.mybatis.TestMybatis01`测试类，并提供`findAll`方法（查询emp表中所有的员工信息），开发步骤如下：

![在这里插入图片描述][20200525205004759.png_pic_center]

/** 练习1(快速入门): 查询emp表中的所有员工, 返回一个List<Emp>集合 * @throws IOException */
    @Test
    public void findAll() throws IOException { 
        //1.读取mybatis的核心配置文件(mybatis-config.xml)
        //2.通过配置信息获取一个SqlSessionFactory工厂对象
        //3.通过工厂获取一个SqlSession对象
        //4.通过namespace+id找到要执行的sql语句并执行sql语句
        //5.输出结果
    }

### （三）添加mybatis-config.xml文件 ###

**1、在src/main/resources目录下，创建mybatis-config.xml文件**（MyBatis的核心配置文件）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 2]  
**2、mybatis-config.xml文件配置如下:**

`mybatis-config文件头信息如下：`

`mybatis-config文件详细配置如下：`

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
        
    
    <configuration >
    	
    	<environments default="develop">
    		<environment id="develop">
    			
    			
    			<transactionManager type="JDBC"></transactionManager>
    			
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.jdbc.Driver"/>
    				<property name="url" value="jdbc:mysql://localhost:3306/yonghedb?characterEncoding=utf-8"/>
    				<property name="username" value="root"/>
    				<property name="password" value="root"/>
    			</dataSource>
    		</environment>
    	</environments>
    	
    	
    	<mappers>
    		<mapper resource="EmpMapper.xml"/>
    	</mappers>
    </configuration>

dtd文件时xml的约束文件

### （四）添加EmpMapper.xml文件 ###

**1、在src/main/resources目录下，创建EmpMapper.xml文件 （实体类的映射文件）**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 3]

**2、EmpMapper.xml文件配置如下:**

`EmpMapper文件头信息如下：`

`EmpMapper文件详细配置如下：`

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    
    <mapper namespace="EmpMapper">
    	
    	
    	<select id="findAll" resultType="com.tedu.pojo.Emp">
    		select * from emp
    	</select>
    
    </mapper>

### （五）添加并编写Emp实体类 ###

注意：在当前实例中，Emp类中的属性和数据库表的字段名称必须一致，否则将会无法将结果集封装到Java对象中。

在src/main/java目录下创建 com.tedu.pojo.Emp类，并编辑Emp类：提供私有属性以及对应的getter方法、setter方法，并重写toString方法  
（要是添加有参构造函数，就一定要首先添加无参构造函数，否则会报错）

package com.tedu.pojo;
    /** * 实体类,用于封装Emp表中的一条用户信息 */
    public class Emp { 
    	//1.声明实体类中的属性
    	private Integer id;
    	private String name;
    	private String job;
    	private Double salary;
    	
    	//2.提供对应的getter和setter方法
    	public Integer getId() { 
    		return id;
    	}
    	public void setId(Integer id) { 
    		this.id = id;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	public String getJob() { 
    		return job;
    	}
    	public void setJob(String job) { 
    		this.job = job;
    	}
    	public Double getSalary() { 
    		return salary;
    	}
    	public void setSalary(Double salary) { 
    		this.salary = salary;
    	}
    	
    	//3.重写toString方法
    	@Override
    	public String toString() { 
    		return "Emp [id=" + id + ", name=" + name + ", job=" + job + ", salary=" + salary + "]";
    	}
    }

### （六）实现测试类,并测试 ###

**1、实现findAll方法，代码如下：**

/** 练习1(快速入门): 查询emp表中的所有员工, 返回一个List<Emp>集合 * @throws IOException */
    @Test
    public void findAll() throws IOException { 
    	//1.读取mybatis的核心配置文件(mybatis-config.xml)
    	InputStream in = Resources
    			.getResourceAsStream("mybatis-config.xml");
    	//2.通过配置信息获取一个SqlSessionFactory工厂对象
    	SqlSessionFactory fac = 
    			new SqlSessionFactoryBuilder().build( in );
    	//3.通过工厂获取一个SqlSession对象
    	SqlSession session = fac.openSession();
    	//4.通过namespace+id找到要执行的sql语句并执行sql语句
    	List<Emp> list = session
    			.selectList("EmpMapper.findAll");
    	//5.输出结果
    	for(Emp e : list) { 
    		System.out.println( e );
    	}
    }

**2、执行findAll方法，输出结果为：**

Emp [id=1, name=王一, job=程序员, salary=3300.0]
    Emp [id=2, name=齐二, job=程序员, salary=2800.0]
    Emp [id=3, name=刘三, job=程序员鼓励师, salary=2700.0]
    Emp [id=4, name=陈四, job=部门总监, salary=4200.0]
    Emp [id=5, name=赵五, job=程序员, salary=3000.0]
    Emp [id=6, name=董六, job=程序员, salary=3500.0]
    Emp [id=7, name=苍七, job=程序员, salary=3700.0]
    Emp [id=8, name=韩八, job=CEO, salary=5000.0]

--------------------

## 三、MyBatis入门细节 ##

--------------------

### （一）mybatis-config.xml配置文件 ###

*  `environments`标签：该标签内部可以配置多个environment，即多种环境，每种环境可以做不同配置或连接不同数据库。例如，开发、测试、生产环境可能需要不同的配置，连接的数据库可能也不相同，因此我们可以配置三个environment，分别对应上面三种不同的环境。
    
    但是要记住，`environment`可以配置多个，但是最终要使用的只能是其中一个！
 *  `environment`标签：内部可以配置多种配置信息，下面介绍事务管理配置和数据源配置。
 *  `transactionManage`标签：事务管理配置，mybatis中有两种事务管理方式，也就是 `type="[JDBC\|MANAGED]`
    
     *  JDBC：这个配置就是直接使用了 JDBC的提交和回滚设置，它依赖于从数据源得到的连接来管理事务范围。推荐使用。
     *  MANAGED：这个配置几乎没做什么。它从来不提交或回滚一个连接。需要自己手动添加并管理。不推荐使用。
 *  `dataSource`标签：数据源，也就是连接池配置。这里type指定数据源类型，有三种内建的类型：`JNDI`、`POOLED`、`UNPOOLED`
    
     *  `JNDI`：已过时，不推荐使用！
     *  `POOLED`：使用连接池，mybatis会创建连接池，并从连接池中获取连接访问数据库，在操作完成后，将会把连接返回连池。
     *  `UNPOOLED`：不使用连接池，该方式适用于只有小规模数量并发用户的简单应用程序上。
 *  `mappers`标签：用于导入mapper文件的位置，其中可以配置多个mapper，即可以导入多个mapper文件。

### （二）EmpMapper.xml配置文件 ###

（1）第1行是xml的文档声明，用于声明xml的版本和编码

（2）第2、3、4行，引入了xml约束文档，当前xml文档将会按照mybatis-3-mapper.dtd文件所要求的规则进行书写。

（3）`Mapper`标签：根标签，其中namespace(名称空间，也叫命名空间)，要求不能重复。在程序中通过`[ namespace + id ]`定位到要执行哪一条SQL语句

（4）`select`标签：用于指定将来要执行的各种SQL语句。标签上可以声明属性，下面介绍常用的属性：`id`、`resultType`、`resultMap`

*  `id`属性：要求值不能重复。将来在执行SQL时，可以通过`[ namespace + id ]`找到指定SQL并执行。
 *  `resultType`属性：从这条SQL语句中返回所期望类型的类的完全限定名称（包名+类名）。注意如果是集合情形，那应该是集合可以包含的类型，而不能是集合本身。
    
    简而言之，resultType控制查询SQL执行后返回值的类型或集合中的泛型，例如查询emp表中的单条记录，返回值是一个Emp对象，因此，`resultType="com.tedu.pojo.Emp"；`
    
    如果查询emp表中的多条记录，返回值是一个List，此时resultType的值应该集合中的泛型，因此`resultType="com.tedu.pojo.Emp"；`
 *  `resultMap`属性：复杂对象结构（例如多表关联查询等）。 使用 `resultType` 或`resultMap`，但不能同时使用。

--------------------

## 四、MyBatis增删改查 ##

--------------------

### （一）新增员工 ###

**1、编辑EmpMapper.xml文件, 添加新增员工对应的sql.**

<update id="insert" >
    	insert into emp value(null, '赵云', '保安', 6000)
    </update>

**2、编写TestMybatis类，添加testInsert方法，实现新增员工操作。**

/** 练习2: 新增员工信息: 赵云 保安 6000 */
    @Test
    public void testInsert() { 
      //执行sql语句, 返回执行结果
      int rows = session.update("EmpMapper.insert");
      //提交事务
      session.commit();
      System.out.println("影响的行数: "+rows);
    }

### （二）修改员工 ###

**1、编辑EmpMapper.xml文件, 添加新增员工对应的sql。**

<update id="update">
    	update emp set job='保镖', salary=20000 where name='赵云'
    </update>

**2、编写TestMybatis类，添加testUpdate方法，实现修改员工信息。**

/** 练习3: 修改员工信息, 将赵云的job改为'保镖'，salary改为20000 */
    @Test
    public void testUpdate() { 
      //执行sql语句, 返回执行结果
      int rows = session.update("EmpMapper.update");
      //提交事务
      session.commit();
      System.out.println("影响行数:"+rows);
    }

### （三）删除员工 ###

**1、编辑EmpMapper.xml文件, 添加新增员工对应的sql。**

<update id="delete">
    	delete from emp where name='赵云'
    </update>

**2、编写TestMybatis类，添加**testDelete**方法，实现删除员工。**

/** 练习4: 删除name为'赵云'的记录 */
    @Test
    public void testDelete() { 
      //执行sql语句, 返回执行结果
      int rows = session.update("EmpMapper.delete");
      //提交事务
      session.commit();
      System.out.println("影响行数:"+rows);
    }

--------------------

## 五、mybatis中的占位符 ##

--------------------

### （一）`#{}`占位符 ###

在上面的增删改查操作中，SQL语句中的值是写死在SQL语句中的，而在实际开发中，此处的值往往是用户提交过来的值，因此这里我们需要将SQL中写死的值替换为占位符。

在mybatis中占位符有两个，分别是 `#{}` 占位符 和 `${}` 占位符：

*  `#{}：`相当于JDBC中的问号（?）占位符,是为SQL语句中的参数值进行占位,大部分情况下都是使用\#\{\}占位符; 并且当\#\{\}占位符是为字符串或者日期类型的值进行占位时,在参数值传过来替换占位符的同时,会进行转义处理(在字符串或日期类型的值的两边加上单引号)
 *  `${}`：是为SQL片段进行占位，将传过来的SQL片段直接拼接在$\{\}占位符所在的位置,不会进行任何的转义处理。（由于是直接将参数拼接在SQL语句中，因此可能会引发SQL注入攻击问题）
 *  需要注意的是:使用$\{\}占位符为SQL语句中的片段占位时,即使只有一个参数,也要先将参数封装再传递!

*  **练习5：查询emp表中指定id的员工信息**

在mapper文件中编写SQL语句：

<select id="findById" resultType="com.tedu.pojo.Emp">
    	select * from emp where id=#{id}
    </select>

Java代码实现：

/** 练习5: 查询emp表中指定id的员工信息 */
    @Test
    public void testFindById() { 
      //执行sql语句, 返回执行结果
      Emp emp = session.selectOne( "EmpMapper.findById", 1 );
      System.out.println( emp );
    }

*  **练习6：新增员工信息: 张飞 Java开发工程师 15000**

在mapper文件中编写SQL语句：

<update id="insert2">
    	insert into emp values (null, #{name}, #{job}, #{salary})
    </update>

Java代码实现：

/** 练习6: 新增员工信息: 张飞 Java开发工程师 15000 */
    @Test
    public void testInsert2() { 
      //将要传输的参数封装到map集合中
      //Map map = new HashMap();
      //map.put("name", "张飞");
      //map.put("job", "Java开发工程师");
      //map.put("salary", 15000);
      //也可以将要传输的参数封装到Emp对象中
      Emp emp = new Emp();
      emp.setName("关羽123");
      emp.setJob("保安");
      emp.setSalary(8000.0);
      //执行sql语句
      intsession rows = session.update("EmpMapper.insert2", emp);
      //提交事务
      session.commit();
      System.out.println( "影响的行数: "+rows );
    }

*  **练习7：修改员工信息: 张飞 架构师 25000**

在mapper文件中编写SQL语句：

<update id="update2">
      update emp set job=#{job}, salary=#{salary}
      where name=#{name}
    </update>

Java代码实现：

/** 练习7: 修改员工信息: 张飞 架构师 25000 */
    @Test
    public void testUpdate2() { 
      //将参数封装到Emp对象中
      Emp emp = new Emp();
      emp.setName("张飞");
      emp.setJob("架构师");
      emp.setSalary(25000.0);
      //执行sql语句
      intsession rows = session.update("EmpMapper.update2", emp);
      //提交事务
      session.commit();
      System.out.println("影响的行数: "+rows);
    }

*  **练习8：删除emp表中指定id的员工信息**

mapper文件配置:

<insert id="delete2" parameterType="String">
    	delete from emp where id=#{id}
    </insert>

java代码示例:

/* 练习8：删除emp表中指定id的员工信息 */
    public void testDelete2() throws IOException{ 
      ......
      //执行SQL语句
      int rows = session.delete("EmpMapper.delete2", 1);
      //提交事务
      session.commit();
      System.out.println("影响行数:"+rows);
    }

在上面的增删改查练习中，当SQL语句中包含的参数值是传递过来的，在SQL语句中我们会通过`#{}`占位符进行占位，在SQL语句真正执行时，再将传递过来的值替换SQL语句中的占位符。

其实，`#{}`就是JDBC中的问号（**?**）占位符，因此为了安全考虑，在执行时会对传递过来的字符串和日期类型高的值进行转译处理。

例如：查询指定name的员工信息，SQL语句为：

select * from emp where name=#{name}

其实就等价于JDBC中： `select * from emp where name=?`，

如果传过来的参数值为：王海涛，那么最终执行的SQL语句为：

-- 在参数替换占位符的同时进行了转义处理(在值的两边加上了单引号)
    select * from emp where name='王海涛'

### （二）`${}`占位符 ###

那么如果我们在传递的时候不是一个参数值，而是一个SQL片段呢？

例如：在查询时，我们想动态的传递查询的列：

select #{columns} from emp

此时传递过来的应该是一个SQL片段，不同于上面的参数值，如果此时还用`#{}`，也会像上面一样被转译处理：`select 'id,name,job' from emp`，这不是我们希望看到的！

如果不想让传过来的SQL片段被转译处理，而是直接拼接在SQL语句中，那么这里可以使用`${}`，例如：

select ${
       columns} from emp

拼接之后：`select id,name,job from emp`

*  **练习9：动态指定要查询的列**

在mapper文件中编写SQL语句：

<select id="findAll2" resultType="com.tedu.pojo.Emp">
    	select ${cols} from emp
    </select>

java代码示例:

/** 练习9: 动态指定要查询的列 */
    @Test
    public void testFindAll2() { 
      Map map = new HashMap();
      //map.put("cols", "id, name");
      //map.put("cols", "id, name, salary");
      map.put("cols", "id,name,job,salary");
      //执行sql语句, 返回结果
      List<Emp> list = session.selectList("EmpMapper.findAll2", map);
      //输出结果
      for ( Emp e : list ) { 
      	System.out.println( e );
      }
    }

*  **示例2: 根据name模糊查询emp表**

在mapper文件中编写SQL语句：

<select id="findAll3" resultType="com.tedu.pojo.Emp">
      select * from emp
      where name like '%${name}%'
    </select>

<select id="findAll4" resultType="com.tedu.pojo.Emp">
      select * from emp
      where name like #{name}
    </select>

Java代码实现：

/** * 练习10: 根据name模糊查询emp表 * '%王%' '%刘%' */
    @Test
    public void testFindAll3() { 
      //将参数封装到map集合中
      Map map = new HashMap();
      map.put("name", "涛");
      //执行sql, 返回结果
      List<Emp> list = session.selectList("EmpMapper.findAll3", map);
      //输出结果
      for (Emp emp : list) { 
      	System.out.println( emp );
      }
    }

/** * 练习11: 根据name模糊查询emp表 * '%王%' '%刘%' */
    @Test
    public void testFindAll4() { 
      //将参数封装到map集合中
      Map map = new HashMap();
      map.put("name", "%刘%");
      //执行sql, 返回结果
      List<Emp> list = session.selectList("EmpMapper.findAll4", map);
      //输出结果
      for (Emp emp : list) { 
      	System.out.println( emp );
      }
    }

需要注意的是，在传递 `${}` 对应的值时，即使只有一个参数，也需要将值存入**map**集合中！！

> 总结：在大多数情况下还是使用\#\{\}占位符，而$\{\}多用于为SQL片段进行占位！

[20200525204054918.png_pic_center]: https://img-blog.csdnimg.cn/20200525204054918.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200525204344613.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200525204935116.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ==,size_16,color_FFFFFF,t_70#pic_center
[20200525205004759.png_pic_center]: https://img-blog.csdnimg.cn/20200525205004759.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200525205035601.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200525205134410.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ==,size_16,color_FFFFFF,t_70#pic_center