MybatisPlus--入门笔记（日志配置+CRUD+主键生成策略+自动更新时间+乐观锁+逻辑删除）

朴灿烈づ我的快乐病毒、 2022-12-23 03:30 57阅读 0赞

### mybatis\_plus ###

*  mybatis\_plus使用步骤
 *   *  1、导入依赖
     *  2、定义Mapper接口
     *  3、定义配置类
     *  测试
 *  日志配置
 *  添加Insert操作
 *   *  主键生成策略
     *   *  使用方法
 *  更新update操作
 *   *  1、根据id更新user
     *  2、自动填充策略
     *   *  （1）数据库表中添加自动填充字段
         *  （2）实体上添加注解
         *  （3）定义配置类
         *  （4）测试
     *  乐观锁
     *   *  1、在表中添加version字段
         *  2、在实体类上添加注解
         *  3、元对象处理器接口添加version的insert默认值
         *  4、在配置类中配置乐观锁插件
         *  5、模拟乐观锁更新数据
         *  6、模仿乐观锁更新数据失败
 *  查询操作
 *   *  1、通过id查询
     *  2、通过id批量查询
     *  3、通过map集合查询
     *  4、分页查询
     *   *  1、在配置类中添加分页插件
         *  2、直接使用
 *  删除操作
 *   *  1、通过id删除
     *  2、通过id批量删除
     *  3、通过map删除
     *  4、逻辑删除
     *   *  1、在数据中添加deleted字段
         *  2、在属性上添加deleted字段
         *  3、在元数据配置中给新增的记录deleted字段默认添加值
         *  4、application.properties文件
         *  5、在 MybatisPlusConfig 中注册 Bean
         *  6、测试逻辑删除
 *  Wrapper条件构造器
 *   *  1、ge、gt、le、lt、isNull、isNotNull
     *  2、eq、ne
     *  3、between、notBetween
     *  4、allEq
     *  5、like、notLike、likeLeft、likeRight
 *  代码生成器

# mybatis\_plus使用步骤 #

## 1、导入依赖 ##

<dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

## 2、定义Mapper接口 ##

/**
     * User持久层接口
     */
    public interface UserMapper extends BaseMapper<User> {
    }

接口继承BaseMapper之后，只需要传入实体类的泛型，就可以直接使用这个接口为我们提供的各种方法。如下图

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

## 3、定义配置类 ##

/**
     * 配置类
     */
    @Configuration
    @MapperScan("com.gzgs.mybatis_plus.mapper")//开启mapper扫描
    public class MyConfig {
    
    }

> 也可以直接在项目引导类上配置mapperscan，但是后面肯定需要生成各种插件，为了统一管理，直接新建一个配置类即可。另外配置MapperScan之后，在mapper接口上可以不再配置mapper接口。

## 测试 ##

这样就可以直接使用了

@Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectList() {
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

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

# 日志配置 #

myabtsi\_plus的日志配置只需要在配置类中添加以下内容即可

#mtbatis日志配置
    mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

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

# 添加Insert操作 #

@Test
    public void testInsert(){
        User user=new User();
        user.setName("老孙");
        user.setAge(18);
        user.setEmail("1106@qq.com");
        userMapper.insert(user);
    }

![在这里插入图片描述][20201123205911596.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70_pic_center 2]  
可以看到上面插入的数据是中文乱码，解决这个现象只需要在配置数据库信息加上这个即可。

spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8

## 主键生成策略 ##

可以看到上面我们插入数据时并没有指定插入的id，但是myabtis\_plus自动为我们生成了id，这个id几乎是全球唯一的，它采用的是雪花算法生成的id，mybatis\_plus的主键生成策略有如下几种。

<table> 
 <thead> 
  <tr> 
   <th>主键生成策略</th> 
   <th>表达式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>默认策略，雪花算法</td> 
   <td>ID_WORKER</td> 
  </tr> 
  <tr> 
   <td>用于主键类型是String的时候</td> 
   <td>ID_WORKER_STR</td> 
  </tr> 
  <tr> 
   <td>需要用户自己输入</td> 
   <td>INPUT</td> 
  </tr> 
  <tr> 
   <td>自动增长</td> 
   <td>AUTO</td> 
  </tr> 
 </tbody> 
</table>

以下是IdType的源码

public enum IdType {
        AUTO(0),//自动增长
        NONE(1),
        INPUT(2),//用户输入
        ID_WORKER(3), //默认生成策略，雪花算法
        UUID(4), 
        ID_WORKER_STR(5);  //也是雪花算法，当主键类型是String的时候使用
    
        private int key;
    
        private IdType(int key) {
            this.key = key;
        }
    
        public int getKey() {
            return this.key;
        }
    }

### 使用方法 ###

只需要在实体类的主键字段上添加注解即可，如下

/\*\*  
\* User实体类  
\*/

@Data
    public class User {
        @TableId(type = IdType.AUTO)
        private Long id;
        private String name;
        private Integer age;
        private String email;
    }

# 更新update操作 #

## 1、根据id更新user ##

@Test
    public void testUpdate(){
        User user = new User();
        user.setId(1l);
        user.setName("张三");
       userMapper.updateById(user);
    
    }

## 2、自动填充策略 ##

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的创建时间，更新时间等。  
我们可以使用MyBatis Plus的自动填充功能，完成这些字段的赋值工作：

### （1）数据库表中添加自动填充字段 ###

在User表中添加datetime类型的新的字段 create\_time、update\_time，这也是阿里巴巴开发手册的开发规范，它建议我们在创建表的时候给表添加上这个两个字段。

ALTER TABLE USER ADD COLUMN create_time DATE;
    ALTER TABLE USER ADD COLUMN update_time DATE;

### （2）实体上添加注解 ###

@Data
    public class User {
        @TableId(type = IdType.ID_WORKER)
        private Long id;
        private String name;
        private Integer age;
        private String email;
        @TableField(fill = FieldFill.INSERT)
        private Date createTime;
        @TableField(fill = FieldFill.INSERT_UPDATE)
        private Date updateTime;
    }

### （3）定义配置类 ###

@Component  
public class MyMetaObjectHandler implements MetaObjectHandler \{

private static final Logger LOGGER = LoggerFactory.getLogger(MyMetaObjectHandler.class);
        @Override
        public void insertFill(MetaObject metaObject) {
            LOGGER.info("start insert fill ....");
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);
        }
    
        @Override
        public void updateFill(MetaObject metaObject) {
            LOGGER.info("start update fill ....");
            this.setFieldValByName("updateTime", new Date(), metaObject);
        }
    }

### （4）测试 ###

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

## 乐观锁 ##

> 主要适用场景：当要更新一条记录的时候，希望这条记录没有被别人更新，也就是说实现线程安全的数据更新

乐观锁实现方式：

取出记录时，获取当前version  
更新时，带上这个version  
执行更新时， set version = newVersion where version = oldVersion  
如果version不对，就更新失败

### 1、在表中添加version字段 ###

ALTER TABLE `user` ADD COLUMN `version` INT

### 2、在实体类上添加注解 ###

@Version
    @TableField(fill = FieldFill.INSERT)
    private Integer version;

### 3、元对象处理器接口添加version的insert默认值 ###

@Override
        public void insertFill(MetaObject metaObject) {
            LOGGER.info("start insert fill ....");
            this.setFieldValByName("createTime", new Date(), metaObject);
            this.setFieldValByName("updateTime", new Date(), metaObject);
            this.setFieldValByName("version", 1, metaObject);
        }

特别说明:

*  支持的数据类型只有 int,Integer,long,Long,Date,Timestamp,LocalDateTime
 *  整数类型下 newVersion = oldVersion + 1
 *  newVersion 会回写到 entity 中
 *  仅支持 updateById(id) 与 update(entity, wrapper) 方法
 *  在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

### 4、在配置类中配置乐观锁插件 ###

/**
     * 乐观锁插件
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

### 5、模拟乐观锁更新数据 ###

//测试乐观锁查询
    
    @Test
    public void testOptimisticLocker(){
        //根据id查询
        User user = userMapper.selectById(1l);
        //修改
        user.setName("李四");
        //执行
        userMapper.updateById(user);
    }

### 6、模仿乐观锁更新数据失败 ###

//测试乐观锁失败查询
    
    @Test
    public void testOptimisticLockerFaild(){
        //根据id查询
        User user = userMapper.selectById(1l);
        //修改
        user.setName("李四");
        //模拟并发修改
        user.setVersion(user.getVersion()-1);
        //执行
        userMapper.updateById(user);
    }

# 查询操作 #

## 1、通过id查询 ##

//根据id查询
    @Test
    public void testSelectById(){
        User user = userMapper.selectById(1l);
        System.out.println(user);
    }

## 2、通过id批量查询 ##

//根据id批量查询
    @Test
    public void testSelectBatchId(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }

## 3、通过map集合查询 ##

//根据map查询
    @Test
    public void testSelectByMap(){
        HashMap<String, Object> map = new HashMap<>();
    
        map.put("name","Jack");
        map.put("age",20);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

## 4、分页查询 ##

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

### 1、在配置类中添加分页插件 ###

/**
     * 分页插件
     */
    
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        //此时可以删除主类中的 @MapperScan 扫描注解
        return new PaginationInterceptor();
    }

### 2、直接使用 ###

//测试分页查询
    @Test
    public void testSelectByPage(){
        Page<User> page=new Page<>(1,5);
    
        userMapper.selectPage(page,null);
        page.getRecords().forEach(System.out::println);
        System.out.println("=======>"+page.getCurrent());
        System.out.println("=======>"+page.getPages());
        System.out.println("=======>"+page.getSize());
        System.out.println("=======>"+page.getTotal());
        System.out.println("=======>"+page.hasNext());
        System.out.println("=======>"+page.hasPrevious());
    }

**测试selectMapsPage分页：结果集是Map**

//测试分页查询,返回结果为map
    @Test
    public void testSelectByPageMap(){
        Page<User> page=new Page<>(1,5);
        IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page, null);
    
        mapIPage.getRecords().forEach(System.out::println);
        System.out.println("=======>"+page.getCurrent());
        System.out.println("=======>"+page.getPages());
        System.out.println("=======>"+page.getSize());
        System.out.println("=======>"+page.getTotal());
        System.out.println("=======>"+page.hasNext());
        System.out.println("=======>"+page.hasPrevious());
    }

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

# 删除操作 #

## 1、通过id删除 ##

//通过id删除
    @Test
    public void testDeleteById() {
        userMapper.deleteById(1330877639665135617l);
    }

## 2、通过id批量删除 ##

//通过id批量删除
    @Test
    public void testDeleteByBatchIds(){
        userMapper.deleteBatchIds(Arrays.asList(1330859355859353601l,5));
    }

## 3、通过map删除 ##

@Test
    //通过map删除
    public void testDeleteByMap(){
        HashMap<String, Object> stringObjectHashMap = new HashMap<>();
        stringObjectHashMap.put("name","张三");
        stringObjectHashMap.put("age",18);
    
        userMapper.deleteByMap(stringObjectHashMap);
    }

## 4、逻辑删除 ##

*  物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除数据
 *  逻辑删除：假删除，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

### 1、在数据中添加deleted字段 ###

ALTER TABLE `user` ADD COLUMN `deleted` BOOLEAN

### 2、在属性上添加deleted字段 ###

@TableLogic
    @TableField(fill = FieldFill.INSERT)
    private Integer deleted;

### 3、在元数据配置中给新增的记录deleted字段默认添加值 ###

@Override
    public void insertFill(MetaObject metaObject) {
        LOGGER.info("start insert fill ....");
        this.setFieldValByName("createTime", new Date(), metaObject);//创建时间
        this.setFieldValByName("updateTime", new Date(), metaObject);//更新时间
        this.setFieldValByName("version", 1, metaObject);//乐观锁
        this.setFieldValByName("deleted", 0, metaObject);//逻辑删除
    }

### 4、application.properties文件 ###

#配置逻辑删除
    mybatis-plus.global-config.db-config.logic-delete-value=1
    mybatis-plus.global-config.db-config.logic-not-delete-value=0

### 5、在 MybatisPlusConfig 中注册 Bean ###

/**
     * 逻辑删除
     */
    @Bean
    public ISqlInjector iSqlInjector(){
        return new LogicSqlInjector();
    }

### 6、测试逻辑删除 ###

//逻辑删除
    @Test
    public void testLoginDelete(){
        userMapper.deleteById(2l);
    }

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

> 可以看到，虽然我们执行的是delete操作，但是在数据库中实际上执行的是更新操作，将deleted的值改为1

# Wrapper条件构造器 #

Wrapper条件构造器是mybatis\_plus为我们提供的一个方便我们对sql语句执行条件进行简易包装的插件。

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

*  Wrapper ： 条件构造抽象类，最顶端父类
    
     *  AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
        
         *  QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
         *  UpdateWrapper ： Update 条件封装，用于Entity对象更新操作
     *  AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
        
         *  LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
         *  LambdaUpdateWrapper ： Lambda 更新封装Wrapper

## 1、ge、gt、le、lt、isNull、isNotNull ##

//测试添加构造器
    @Test
    public void testWrapper1(){
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.isNull("name").ge("age",10).isNotNull("email");
        userMapper.delete(userQueryWrapper);
    }

ge：大于 ，gt：大于等于  
le：小于，lt：小于等于

> 真实的sql语句===》 UPDATE user SET deleted=1 WHERE deleted=0 AND name IS NULL AND age >= ? AND email IS NOT NULL

## 2、eq、ne ##

//测试添加构造器
        @Test
        public void testWrapper2(){
            QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
            userQueryWrapper.eq("name","Jack");
            List<User> users = userMapper.selectList(userQueryWrapper);
            System.out.println(users);
        }

> 真实的sql语句===》 SELECT id,name,age,email,create\_time,update\_time,version,deleted FROM user WHERE deleted=0 AND name = ?

## 3、between、notBetween ##

**包含边界大小**

//测试添加构造器
    @Test
    public void testWrapper1(){
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.between("age",10,20);
        userMapper.selectList(userQueryWrapper);
    }

> 真实的sql语句===》 SELECT id,name,age,email,create\_time,update\_time,version,deleted FROM user WHERE deleted=0 AND age BETWEEN ? AND ?

## 4、allEq ##

//测试添加构造器
    @Test
    public void testWrapper1(){
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        Map<String,Object> map=new HashMap<>();
        map.put("name","Jack");
        map.put("age",20);
        map.put("email","test2@baomidou.com");
        QueryWrapper<User> userQueryWrapper1 = userQueryWrapper.allEq(map);
        userMapper.selectList(userQueryWrapper);
    }

> 真实的sql语句===》 SELECT id,name,age,email,create\_time,update\_time,version,deleted FROM user WHERE deleted=0 AND name = ? AND age = ? AND email = ?

## 5、like、notLike、likeLeft、likeRight ##

//测试添加构造器
    @Test
    public void testWrapper3(){
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.likeLeft("name","老");
        List<User> users = userMapper.selectList(userQueryWrapper);
        System.out.println(users);
    }

> 真实的sql语句===》 SELECT id,name,age,email,create\_time,update\_time,version,deleted FROM user WHERE deleted=0 AND name LIKE %老(String)

like-------%key%  
nolike--------！%key%  
likeLeft--------%key  
likeRight--------key%

# 代码生成器 #

import com.baomidou.mybatisplus.annotation.DbType;
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.generator.AutoGenerator;
    import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
    import com.baomidou.mybatisplus.generator.config.GlobalConfig;
    import com.baomidou.mybatisplus.generator.config.PackageConfig;
    import com.baomidou.mybatisplus.generator.config.StrategyConfig;
    import com.baomidou.mybatisplus.generator.config.rules.DateType;
    import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    import org.junit.jupiter.api.Test;
    
    public class GetCode {
        @Test
        public void main1() {
            // 1、创建代码生成器
            AutoGenerator mpg = new AutoGenerator();
            // 2、全局配置
            GlobalConfig gc = new GlobalConfig();
            String projectPath = System.getProperty("user.dir");
            System.out.println(projectPath);
            gc.setOutputDir(projectPath + "/src/main/java");
            gc.setAuthor("sdl");
            gc.setOpen(false); //生成后是否打开资源管理器
            gc.setFileOverride(false); //重新生成时文件是否覆盖
            /*
             * mp生成service层代码，默认接口名称第一个字母有 I
             * UcenterService
             * */
            gc.setServiceName("%sService"); //去掉Service接口的首字母I
            gc.setIdType(IdType.ID_WORKER); //主键策略
            gc.setDateType(DateType.ONLY_DATE);//定义生成的实体类中日期类型
            gc.setSwagger2(true);//开启Swagger2模式
            mpg.setGlobalConfig(gc);
            // 3、数据源配置
            DataSourceConfig dsc = new DataSourceConfig();
            dsc.setUrl("jdbc:mysql://localhost:3306/guli?serverTimezone=GMT%2B8");
            dsc.setDriverName("com.mysql.cj.jdbc.Driver");
            dsc.setUsername("root");
            dsc.setPassword("root");
            dsc.setDbType(DbType.MYSQL);
            mpg.setDataSource(dsc);
            // 4、包配置
            PackageConfig pc = new PackageConfig();
            pc.setModuleName("serviceedu"); //模块名
            pc.setParent("com.atguigu");
            pc.setController("controller");
            pc.setEntity("entity");
            pc.setService("service");
            pc.setMapper("mapper");
            mpg.setPackageInfo(pc);
            // 5、策略配置
            StrategyConfig strategy = new StrategyConfig();
            strategy.setInclude("edu_teacher");
            strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略
            strategy.setTablePrefix(pc.getModuleName() + "_"); //生成实体时去掉表前缀
            strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
            strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作
            strategy.setRestControllerStyle(true); //restful api风格控制器
            strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符
            mpg.setStrategy(strategy);
            // 6、执行
            mpg.execute();
        }
    }

码云笔记下载地址：https://gitee.com/sun-dalin/learning-notes.git

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/e496031e92ef49e583695bdd7de24f9c.png
[2020112320534313.png_pic_center]: https://img-blog.csdnimg.cn/2020112320534313.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201123205552561.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg==,size_16,color_FFFFFF,t_70#pic_center
[20201123205911596.png_pic_center]: https://img-blog.csdnimg.cn/20201123205911596.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201123205936354.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg==,size_16,color_FFFFFF,t_70#pic_center
[20201123213024485.png_pic_center]: https://img-blog.csdnimg.cn/20201123213024485.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201123223251186.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg==,size_16,color_FFFFFF,t_70#pic_center
[20201123225331946.png_pic_center]: https://img-blog.csdnimg.cn/20201123225331946.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201123225635757.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg==,size_16,color_FFFFFF,t_70#pic_center