MybatisPlus详解

野性酷女 2024-03-22 18:56 63阅读 0赞

#### 文章目录 ####

*  1.MyBatisPlus的介绍
 *   *  1.1 MybatisPlus的特性讲解
     *  1.2 支持的数据库
     *  1.3 MybatisPlus的日志
 *  2.映射
 *   *  2.1 自动映射规则
     *  2.2 表映射
     *  2.3 字段映射
     *  2.4 字段失效
     *  2.5 视图属性
 *  3. 条件构造器
 *   *  3.1 等值查询
     *   *  3.1.1 eq
         *  3.1.2 allEq
         *  3.1.3 ne 不等于
     *  3.2 范围查询
     *   *  3.2.1 gt 大于
         *  3.2.2 ge 大于等于
         *  3.2.3 lt 小于
         *  3.2.4 le 小于等于
         *  3.2.5 between
         *  3.2.6 notBetween
     *  3.3 模糊查询
     *   *  3.3.1 like 匹配包含关键字的数据
         *  3.3.2 notLike 匹配不包含关键字的数据
         *  3.3.3 likeLeft 左边数据是模糊的
         *  3.3.4 likeRight 右边的数据是模糊的
     *  3.4 判空查询
     *   *  3.4.1 isNull
         *  3.4.2 isNotNull
     *  3.5 包含查询
     *   *  3.5.1 in 包含任意一个
         *  3.5.2 notIn 任意一个都不包含
         *  3.5.3 inSql
         *  3.5.4 notInSql
     *  3.6 分组查询groupBy
     *  3.7 排序查询
     *   *  3.7.1 orderByAsc 升序排序
         *  3.7.2 orderByDesc 降序排序
         *  3.7.3 orderBy
     *  3.8 func查询
     *  3.9 逻辑查询
     *   *  3.9.1 and
         *  3.9.2 or
         *  3.9.3 nested 在一个查询语句中嵌套多个子查询语句,以获取更复杂的数据
     *  3.10 自定义条件查询 apply
     *  3.11 last查询
     *  3.12 exists查询
     *  3.13 notExists
     *  3.14 字段查询 select
 *  4. 主键策略
 *   *  4.1 主键生成策略介绍
     *  4.2 AUTO策略
     *  4.3 INPUT策略
     *  4.4 ASSIGN\_ID策略
     *  4.5 NONE策略
     *  4.6 ASSIGN\_UUID策略
 *  5. 分页
 *   *  5.1 分页插件
     *  5.2 自定义分页插件

## 1.MyBatisPlus的介绍 ##

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

### 1.1 MybatisPlus的特性讲解 ###

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑  
• 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作  
• 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求  
• 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错  
• 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题  
• 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作  
• 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）  
• 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用  
• 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询  
• 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库  
• 内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询  
• 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

### 1.2 支持的数据库 ###

（1）MyBatis-Plus 支持大部分常见的数据库，包括但不限于：

*  Oracle
 *  MySQL
 *  PostgreSQL
 *  Microsoft SQL Server
 *  DB2
 *  SQLite
 *  H2
 *  HSQL
 *  SQL Server

（2）此外，MyBatis-Plus 还支持一些 NoSQL 数据库，如 MongoDB 和 Redis。不过需要注意的是，具体支持哪些数据库会受到 MyBatis-Plus 版本和对应数据库驱动的限制，可以查看官方文档进行确认。

### 1.3 MybatisPlus的日志 ###

在application.yml中配置

（1）去除mybatisplus的logo

mybatis-plus:
      global-config:
        banner: false

（2）去除springboot的logo

spring:
        main:
         banner-mode: off

（3）添加MybatisPlus的执行日志

mybatis-plus:
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

## 2.映射 ##

### 2.1 自动映射规则 ###

（1）表名和实体类名映射 -> 表名user(小写)，实体类名User(首字母大写)  
（2）字段名和实体类属性名映射 -> 字段名name，实体类属性名name  
①变量名称：private String name;  
②属性：getName -> Name -> name  
（3）字段名下划线命名方式和实体类属性小驼峰命名方式映射 ->  
例如：字段名 user\_email，实体类属性名 userEmail  
MybatisPlus支持这种映射规则，可以通过配置来设置  
①map-underscore-to-camel-case: true 表示支持下划线到驼峰的映射  
②map-underscore-to-camel-case: false 表示不支持下划线到驼峰的映射

mybatis-plus:
      configuration:
        map-underscore-to-camel-case: true

### 2.2 表映射 ###

（1）通过@TableName()注解指定映射的数据库表名，就会按照指定的表名进行映射  
如：此时将数据库的表名改为powershop\_user,要完成表名和实体类名的映射，需要将实体类名也要指定为powershop\_user

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    @TableName("powershop_user")
    public class User {
        
        private Long id;
        private String name;
        private Integer age;
        private String email;
    }

（2）如果有很多实体类，对应到数据库中的很多表，我们不需要每个依次配置，只需要配置一个全局的设置，他都会给每个实体类名前面添加指定的前缀，这里我们演示一下全局配置的效果

mybatis-plus:
      global-config:
        db-config:
          table-prefix: powershop_

### 2.3 字段映射 ###

（1）什么场景下会改变字段映射呢？  
①当数据库字段和表实体类的属性不一致时，我们可以使用@TableField()注解改变字段和属性的映射，让注解中的名称和表字段保持一致  
②如：此时将数据库字段的名称我们改为username，在根据实体类的属性拼接SQL的使用，就会使用@TableField()中指定的名称username进行拼接，完成查询

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        
        @TableField("username")
        private String name;
       }

③此时的SQL语句是这样的

SELECT username AS name FROM powershop_user

（2）数据库字段和表实体类的属性一致，框架在拼接SQL语句的时候，会使用属性名称直接拼接sql语句，例如：  
SELECT id,username AS name,age,email,desc FROM powershop\_user  
①这条语句直接进行查询的时候，会出现错误

Error querying database.  Cause: java.sql.SQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'desc  FROM powershop_user' at line 1

②原因是，desc属于关键字，不能直接用于sql查询，要解决这个问题，就需要将desc字段加上\`\`符号，将他变为不是关键字，才能完成查询，那这个问题的根本也是改变生成的SQL语句的字段名称，也就是我们需要通过@TableField()改变实体类的属性名称，将desc变为`desc`,就可以解决这个问题

public class User {
        
        @TableField("`desc`")
        private String desc;
    }

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

### 2.4 字段失效 ###

当数据库中有字段不希望被查询，我们可以通过@TableField(select = false)来隐藏这个字段，那在拼接SQL语句的时候，就不会拼接这个字段。如：如果不想显示年龄信息，那么可以在age属性上添加这个注解，来隐藏这个字段

public class User {
        
        @TableField(select = false)
        private Integer age;
    }

### 2.5 视图属性 ###

（1）在实际开发中，有些字段不需要数据库存储，但是却需要展示，需要展示也就是意味着实体类中需要存在这个字段，我们称这些实体类中存在但是数据库中不存在的字段，叫做**视图字段**。  
（2）框架默认会将实体类中的属性作为查询字段进行拼接，那我们来思考，像这种视图字段，能够作为查询条件么，显示是不能的。因为数据库中没有这个字段，所以查询字段如果包含这个字段，SQL语句会出现问题。我们通过@TableField(exist = false)来去掉这个字段，不让他作为查询字段。

public class User {
        
        @TableField(exist = false)
        private Integer online;
    }

## 3. 条件构造器 ##

![在这里插入图片描述][516565f57e894baab3ca0120ca926349.png]  
（1）Wrapper抽象类  
条件类的顶层，提供了一些获取和判断相关的方法  
（2）AbstractWrapper抽象类  
Wrapper的子类，提供了所有条件相关的方法  
（3）AbstractLambdaWrapper抽象类  
AbstractWrapper的子类，确定字段参数为方法引用类型  
（4）QueryWrapper类  
AbstractWrapper的子类，如果我们需要传递String类型的字段信息，创建该对象  
（5）LambdaQueryWrapper类  
AbstractLambdaWrapper的子类，如果我们需要传递方法引用方式的字段信息，创建该对象

### 3.1 等值查询 ###

#### 3.1.1 eq ####

（1）使用QueryWrapper对象，构建查询条件

//1.创建QueryWrapper对象
    	QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2.设置条件，指定查询的字段名称和匹配的值
        queryWrapper.eq("name","Jack");
        //3.使用条件完成查询
        User user = userMapper.selectOne(queryWrapper);

①测试结果  
![在这里插入图片描述][1d2fcacc86ed4844b8c26dc2d05e4edf.png]  
②如果每次都是自己进行字段名称的编写，有可能会出现名称写错的情况，怎么避免这种情况呢，我们可以使用LambdaQueryWrapper对象，在构建字段时，使用方法引用的方式来选择字段，这样做可以避免字段拼写错误出现问题。  
（2）使用LambdaQueryWrapper对象

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定查询的字段名称和值
        lambdaQueryWrapper.eq(User::getName,"Jack");
        //3.使用条件完成查询
        User user = userMapper.selectOne(lambdaQueryWrapper);

（3）我们构建的条件是从客户端通过请求发送过来的，由服务端接收的。在网站中一般都会有多个条件入口，用户可以选择一个或多个条件进行查询，那这个时候在请求时，我们不能确定所有的条件都是有值的，部分条件可能用户没有传值，那该条件就为null。那为null的条件，我们是不需要进行查询条件拼接的，否则就会出现将为null的条件进行拼接，筛选后无法查询出结果。当然我们要解决这个问题，可以先判断是否为空，根据判断结果选择是否拼接该字段，这个功能其实不需要我们写，由MybatisPlus的方法已经提供好了。

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        String name = null;
        lambdaQueryWrapper.eq(name != null,User::getName,name);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

#### 3.1.2 allEq ####

（1）先演示一下如何通过多个eq,构建多条件查询

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName,"Jone");
        lambdaQueryWrapper.eq(User::getAge,18);
        User user = userMapper.selectOne(lambdaQueryWrapper);

（2）如果有多个条件需要同时判断，我们可以将这多个条件放入到Map集合中，更加的方便

//1.创建QueryWrapper对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2.构建条件Map
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("name","Jone");
        hashMap.put("age",null);
        //3.使用条件完成查询
        queryWrapper.allEq(hashMap,false);
        User user = userMapper.selectOne(queryWrapper);

allEq(Map<R, V> params, boolean null2IsNull)  
①参数params:表示传递的Map集合  
②参数null2IsNull:表示对于为null的条件是否判断isNull

#### 3.1.3 ne 不等于 ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        String name = "Jone";
        lambdaQueryWrapper.ne(User::getName,name);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下

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

### 3.2 范围查询 ###

#### 3.2.1 gt 大于 ####

（1）例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        Integer age = 18;
        lambdaQueryWrapper.gt(User::getAge,age);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下：  
![在这里插入图片描述][bc01628ea2864eed8dc414fb841f2ac8.png]

#### 3.2.2 ge 大于等于 ####

（1）例子

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        Integer age = 18;
        lambdaQueryWrapper.ge(User::getAge,age);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
    }

（2）拼接的SQL如下  
![在这里插入图片描述][db9c98dd0bb84e81a9bb5b1798044f14.png]

#### 3.2.3 lt 小于 ####

（1）例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        Integer age = 18;
        lambdaQueryWrapper.lt(User::getAge,age);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][c99acd18897d4c929fa0779330c4e01d.png]

#### 3.2.4 le 小于等于 ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        Integer age = 18;
        lambdaQueryWrapper.le(User::getAge,age);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][44a2bd4490bc4c35beca4deaece93a14.png]

#### 3.2.5 between ####

（1）例子

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
     	 //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.between(User::getAge,18,30);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][d3f4fdc0f37246b0b2a15de32414d690.png]  
（3）BETWEEN运算符包含指定的上限和下限值

#### 3.2.6 notBetween ####

（1）例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.notBetween(User::getAge,18,30);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][26ff482aa98b4c4e9006f4224ad8081b.png]

### 3.3 模糊查询 ###

#### 3.3.1 like 匹配包含关键字的数据 ####

（1）例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.like(User::getName,"J");
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][81f51a4bd0694af39756c0f9384e4e2c.png]

#### 3.3.2 notLike 匹配不包含关键字的数据 ####

（1）例子

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.notLike(User::getName,"J");
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][76d03a8ac29c4cb7894ecad8e46ca12a.png]

#### 3.3.3 likeLeft 左边数据是模糊的 ####

（1）例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.likeLeft(User::getName,"e");
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下

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

#### 3.3.4 likeRight 右边的数据是模糊的 ####

（1）例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.likeRight(User::getName,"J");
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][ba0d4b2cddd84e888e705555a0d33ee2.png]

### 3.4 判空查询 ###

#### 3.4.1 isNull ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称
        lambdaQueryWrapper.isNull(User::getName);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][cfdf9e6604a94838926a03c36d8f807b.png]

#### 3.4.2 isNotNull ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称
        lambdaQueryWrapper.isNotNull(User::getName);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][169ef522f1ec4939ba252f5bd4e8fb4a.png]

### 3.5 包含查询 ###

#### 3.5.1 in 包含任意一个 ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        ArrayList<Integer> arrayList = new ArrayList<>();
        Collections.addAll(arrayList,18,20,21);
        lambdaQueryWrapper.in(User::getAge,arrayList);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][05b2a77042c24fb6b625d3f423f69734.png]

#### 3.5.2 notIn 任意一个都不包含 ####

（1）例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        ArrayList<Integer> arrayList = new ArrayList<>();
        Collections.addAll(arrayList,18,20,21);
        lambdaQueryWrapper.notIn(User::getAge,arrayList);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][88d89ab9ddab46deaddcac736e810076.png]

#### 3.5.3 inSql ####

（1）方式一  
①实例

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.inSql(User::getAge,"18,20,21");
        //3.使用条件完成查询
         List<User> users = userMapper.selectList(lambdaQueryWrapper);

②拼接的SQL如下  
![在这里插入图片描述][1e5c5f6956a74047b07423bc942b3595.png]  
（2）方式二  
①实例

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.inSql(User::getAge,"select age from powershop_user where age > 20");
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

②拼接的SQL如下

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

#### 3.5.4 notInSql ####

（1）方式一  
①实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.notInSql(User::getAge,"18,20,21");
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

②拼接的SQL如下  
![在这里插入图片描述][1a8916bcd0da4294972c84e795167cee.png]  
（2）方式二  
①实例

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.notInSql(User::getAge,"select age from powershop_user where age > 20");
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

②拼接的SQL如下

select id,name,age,email FROM powershop_user WHERE (age NOT IN (select age from powershop_user where age > 20)

### 3.6 分组查询groupBy ###

（1）实例

//1.创建QueryWrapper对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2.设置条件，指定字段名称和值
        queryWrapper.groupBy("age");
        queryWrapper.select("age,count(*) as field_count");
        //3.使用条件完成查询
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);

（2）拼接的SQL如下

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

### 3.7 排序查询 ###

#### 3.7.1 orderByAsc 升序排序 ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定升序排序字段
        lambdaQueryWrapper.orderByAsc(User::getAge,User::getId);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][15a1e75aae0d43d686847fa91bca5e55.png]

#### 3.7.2 orderByDesc 降序排序 ####

（1）实例

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定降序排序字段
        lambdaQueryWrapper.orderByDesc(User::getAge,User::getId);
         //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][0feb7f03cce14b59a2a8eec17d82c1f8.png]

#### 3.7.3 orderBy ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置排序字段和排序的方式：
        //参数1:如果排序字段的值为null的时候，是否还要作为排序字段参与排序
        //参数2:是否是升序排序
        //参数3:排序字段
        lambdaQueryWrapper.orderBy(true,true,User::getId);
        lambdaQueryWrapper.orderBy(true,false,User::getAge);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][54d153f4b42740f8868664bb54371c7c.png]

### 3.8 func查询 ###

（1）实例

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建逻辑判断语句
        lambdaQueryWrapper.func(i -> {
        
            if(true) {
        
                i.eq(User::getId, 1);
            }else {
        
                i.ne(User::getId, 1);
            }
        });
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下

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

### 3.9 逻辑查询 ###

#### 3.9.1 and ####

（1）正常拼接默认就是and  
①例子

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
        lambdaQueryWrapper.gt(User::getAge,22).lt(User::getAge,30);
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

②拼接的SQL如下  
![在这里插入图片描述][203226da5c6f4ae3b08dd740dd1f9471.png]  
（2）and也可以进行嵌套  
①例子

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
       lambdaQueryWrapper.eq(User::getName,"wang").and(i -> i.gt(User::getAge,26).or().lt(User::getAge,22));
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

②拼接的SQL如下  
![在这里插入图片描述][0410eb151cb444f49f1e46eb4b169b35.png]

#### 3.9.2 or ####

（1）例子

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
        lambdaQueryWrapper.lt(User::getAge,20).or().gt(User::getAge,23);
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][031958165f4d40a89cafb3001baa8834.png]

（3）OR嵌套  
①例子

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
         lambdaQueryWrapper.eq(User::getName,"wang").or(i -> i.gt(User::getAge,22).lt(User::getAge,26));
         List<User> users = userMapper.selectList(lambdaQueryWrapper);

②拼接的SQL如下  
![在这里插入图片描述][ac8dcc6f57324bab9e515f6a75e0ca74.png]

#### 3.9.3 nested 在一个查询语句中嵌套多个子查询语句,以获取更复杂的数据 ####

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
        lambdaQueryWrapper.nested(i -> i.eq(User::getName, "Billie").ne(User::getAge, 22));
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][303c00ff316843c2bfc188f8fb32d10a.png]

### 3.10 自定义条件查询 apply ###

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
        lambdaQueryWrapper.apply("id = 1");
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][715c34ecc09443d38db61a6feaeee94b.png]

### 3.11 last查询 ###

（1）last是MyBatis-Plus中用于拼接SQL的方法之一，它可以拼接SQL语句的末尾部分，比如ORDER BY、LIMIT等。需要注意的是，使用last()方法需要谨慎，因为如果拼接的字符串中包含未经过合法化的变量，可能会导致SQL注入等安全问题。  
（2）实例

//1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
        lambdaQueryWrapper.last("limit 0,2");
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（3）拼接的SQL如下  
![在这里插入图片描述][f698d4f35e244852a52dee43ef66247c.png]

### 3.12 exists查询 ###

exists查询用于判断一个SQL子查询是否有结果集,exists语句常用于查询某个表中是否存在符合条件的数据  
（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建查询条件
        lambdaQueryWrapper.exists("select id from powershop_user where age = 18");
        //3.查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][57d5ec28a3bb460fa7a8273c375dfcda.png]

### 3.13 notExists ###

（1）实例

//1.创建LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建查询条件
        lambdaQueryWrapper.notExists("select id from powershop_user where age = 33");
        //3.查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);

（2）拼接的SQL如下  
![在这里插入图片描述][fc431174e83c41dc88237020d2b1a718.png]

### 3.14 字段查询 select ###

（1）实例

//1.创建 LambdaQueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建查询条件
        lambdaQueryWrapper.select(User::getId,User::getName);
        //3.查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper)

（2）拼接的SQL如下  
![在这里插入图片描述][daa1f46ed607461e8eb2dd93764a10ed.png]

## 4. 主键策略 ##

### 4.1 主键生成策略介绍 ###

（1）首先大家先要知道什么是主键，主键的作用就是唯一标识，我们可以通过这个唯一标识来定位到这条数据。  
（2）当然对于表数据中的主键，我们可以自己设计生成规则，生成主键。但是在更多的场景中，没有特殊要求的话，我们每次自己手动生成的比较麻烦，我们可以借助框架提供好的主键生成策略，来生成主键。这样比较方便快捷  
（3）在MybatisPlus中提供了一个注解，是`@TableId`,该注解提供了各种的主键生成策略，我们可以通过使用该注解来对于新增的数据指定主键生成策略。那么在以后新增数据的时候，数据就会按照我们指定的主键生成策略来生成对应的主键。

### 4.2 AUTO策略 ###

该策略为跟随数据库表的主键递增策略，前提是数据库表的主键要设置为自增  
（1）

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

（2）打勾  
![在这里插入图片描述][85c1a63386f24fe9ae25f44a2c4699bd.png]  
（3）此处要设置好下次递增的数字，下次将会从7开始增加  
![在这里插入图片描述][97bc2bc96ac443c09ac154bea54fd3f1.png]  
（4）实体类添加注解，指定主键生成策略

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

（5）此时，在插入数据时，就不用写主键的字段数据了

@Test
    void primaryKey(){
        
        User user = new User();
        user.setName("Mary");
        user.setAge(35);
        user.setEmail("test7@powernode.com");
        userMapper.insert(user);
    }

### 4.3 INPUT策略 ###

（1）该策略表示，必须由我们手动的插入id,否则无法添加数据

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

（2）由于我们不使用AUTO了，所以把自动递增去掉  
![在这里插入图片描述][a50728c340aa4c41a745aea112a0eb6b.png]  
（3）这里如果我们省略不写id,会发现，无法插入数据

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

### 4.4 ASSIGN\_ID策略 ###

（1）我们来思考一下，像之前这种自动递增的方式，有什么问题？  
如果我们将来一张表的数据量很大，我们需要进行分表。  
（2）常见的分表策略有两种：  
①水平拆分，水平拆分就是将一个大的表按照数据量进行拆分  
②垂直拆分，垂直拆分就是将一个大的表按照字段进行拆分  
![在这里插入图片描述][e452851eb9f04c75be6c6a17989d0fcb.png]  
（3）其实我们对于拆分后的数据，有三点需求，就拿水平拆分来说：  
①之前的表的主键是有序的，拆分后还是有序的  
②虽然做了表的拆分，但是每条数据还需要保证主键的唯一性  
③主键最好不要直接暴露数据的数量，这样容易被外界知道关键信息  
（4）那就需要有一种算法，能够实现这三个需求，这个算法就是雪花算法。  
雪花算法是由一个64位的二进制组成的，最终就是一个Long类型的数值。  
主要分为四部分存储  
①1位的符号位，固定值为0  
②41位的时间戳  
③10位的机器码，包含5位机器id和5位服务id  
④12位的序列号  
![在这里插入图片描述][0610fc26efca4db4b0e43c01223a38a6.png]  
使用雪花算法可以实现有序、唯一、且不直接暴露排序的数字  
（4）实例

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

我们可以在插入后发现一个19位长度的id,该id就是雪花算法生成的id,这是二级制的十进制表示形式  
![在这里插入图片描述][681afc581b4d497486a7e682e8d754b5.png]

### 4.5 NONE策略 ###

（1）实例

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

（2）NONE策略表示不指定主键生成策略，当我们没有指定主键生成策略或者主键策略为NONE的时候，他跟随的是全局策略，那我们来看一下他的全局策略默认是什么

①全局配置中 id-type是用于配置主键生成策略的，我们可以看一下id-type的默认值

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

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

### 4.6 ASSIGN\_UUID策略 ###

（1）UUID（Universally Unique Identifier）全局唯一标识符，定义为一个字符串主键，采用32位数字组成，编码采用16进制，定义了在时间和空间都完全唯一的系统信息。  
（2）UUID的编码规则：  
【1】1~8位采用系统时间，在系统时间上精确到毫秒级保证时间上的唯一性；  
【2】9~16位采用底层的IP地址，在服务器集群中的唯一性；  
【3】17~24位采用当前对象的HashCode值，在一个内部对象上的唯一性；  
【4】25~32位采用调用方法的一个随机数，在一个对象内的毫秒级的唯一性。  
通过以上4种策略可以保证唯一性。在系统中需要用到随机数的地方都可以考虑采用UUID算法。  
（3）我们想要实现UUID的效果，需要改变一下表的字段类型和实体类的属性类型  
将数据库表的字段类型改为varchar(50)  
![在这里插入图片描述][22e2ea0667f54ec1ba9b54a86b50c415.png]

## 5. 分页 ##

### 5.1 分页插件 ###

（1）在大部分场景下，如果我们的SQL没有这么复杂，是可以直接通过MybatisPlus提供的方法来实现查询的，在这种情况下，我们可以通过配置分页插件来实现分页效果  
（2）分页的本质就是需要设置一个拦截器，通过拦截器拦截了SQL，通过在SQL语句的结尾添加limit关键字，来实现分页的效果  
（3）分页插件配置的步骤  
①通过配置类来指定一个具体数据库的分页插件，因为不同的数据库的方言不同，具体生成的分页语句也会不同，这里我们指定数据库为Mysql数据库

@Configuration
    public class MybatisPlusConfig {
        
        @Bean
        public MybatisPlusInterceptor mybatisPlusInterceptor() {
        
            MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
            interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
            return interceptor;
        }
    }

②实现分页查询效果

@Test
    void selectPage(){
        
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.创建分页查询对象,指定当前页和每页显示条数
        IPage<User> page = new Page<>(1,3);
        //3.执行分页查询
        userMapper.selectPage(page, lambdaQueryWrapper);
        //4.查看分页查询的结果
        System.out.println("当前页码值："+page.getCurrent());
        System.out.println("每页显示数："+page.getSize());
        System.out.println("总页数："+page.getPages());
        System.out.println("总条数："+page.getTotal());
        System.out.println("当前页数据："+page.getRecords());
    }

### 5.2 自定义分页插件 ###

在某些场景下，我们需要自定义SQL语句来进行查询。接下来我们来演示一下自定义SQL的分页操作  
（1）在UserMapper.xml映射配置文件中提供查询语句

<?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="com.powernode.mapper.UserMapper">
    
         <select id="selectByName" resultType="com.powernode.domain.User">
            select * from powershop_user where name = #{name}
         </select>
    
    </mapper>

（2）在Mapper接口中提供对应的方法，方法中将IPage对象作为参数传入

@Mapper
    public interface UserMapper extends BaseMapper<User> {
        
           IPage<User> selectByName(IPage<User> page, String name);
    }

（3）实现分页查询效果

@Test
    void selectPage2(){
        
        //1.创建分页查询对象,指定当前页和每页显示条数
        IPage<User> page = new Page<>(1,2);
        //2.执行分页查询
        userMapper.selectByName(page,"Mary");
        //3.查看分页查询的结果
        System.out.println("当前页码值："+page.getCurrent());
        System.out.println("每页显示数："+page.getSize());
        System.out.println("总页数："+page.getPages());
        System.out.println("总条数："+page.getTotal());
        System.out.println("当前页数据："+page.getRecords());
    }

[63a87dea4a30488583e6ba005c28689b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/e1a72c42a19742188356fde9ebafab12.png
[516565f57e894baab3ca0120ca926349.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/402cea906bb34db6b2f61882fb5a8d12.png
[1d2fcacc86ed4844b8c26dc2d05e4edf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a60ce8eab6334b0c8b277a3da05c7427.png
[7eb64b7a08ee4131880565950423b82a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/5a8ed48fc1224a318c32f9281a074d95.png
[bc01628ea2864eed8dc414fb841f2ac8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/188bafb5e31c4323a883672388d7e65b.png
[db9c98dd0bb84e81a9bb5b1798044f14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/91e65db08f7042509ceecb9b0b019677.png
[c99acd18897d4c929fa0779330c4e01d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/fdb409f059cb40f38e9a6d5690091156.png
[44a2bd4490bc4c35beca4deaece93a14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/786d0f3424984e75983a77b5c5bde025.png
[d3f4fdc0f37246b0b2a15de32414d690.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/289e27864de84b25beeb3b69c18a2b43.png
[26ff482aa98b4c4e9006f4224ad8081b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a5ff7154857d4631a29b83026b7926b5.png
[81f51a4bd0694af39756c0f9384e4e2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/cc9c6549164844f0b2db2183a576b4a3.png
[76d03a8ac29c4cb7894ecad8e46ca12a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/2946b2eaa89b4b339dc2c9ed11faf9df.png
[7e67989de82146e89d21b283f6c1395c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/973448fe160c4a58948191808daae3e2.png
[ba0d4b2cddd84e888e705555a0d33ee2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/e806cd692a0648ec830774b88ea2c136.png
[cfdf9e6604a94838926a03c36d8f807b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8b54196d3a324c0ea85e80f2525c2839.png
[169ef522f1ec4939ba252f5bd4e8fb4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/52a217451225452a8945350d4064d039.png
[05b2a77042c24fb6b625d3f423f69734.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f998b5b03d174d77a12d5497aa9f54b0.png
[88d89ab9ddab46deaddcac736e810076.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f2e3867829f74530a3dc26a520fcf8ba.png
[1e5c5f6956a74047b07423bc942b3595.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ebe0ac974d2a4d3ba947d3e8e17c42aa.png
[f0204e23b963414ba799c7344b68a468.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b7ec607139a74b88a3777bfdaa3ba89a.png
[1a8916bcd0da4294972c84e795167cee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/503b1ecba17049bc98c2d62817be49e0.png
[ff0fe83e071b4bed9553afb1f9fbfac3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/fc4e8c42b86e4c4e8e564a575c0349a5.png
[15a1e75aae0d43d686847fa91bca5e55.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/329d4b20e101403997a338d31903167c.png
[0feb7f03cce14b59a2a8eec17d82c1f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/cc1bae2843a34439b1c9a24c2d04f7d8.png
[54d153f4b42740f8868664bb54371c7c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/86e0af2f6f0d492788d9e1829a635dfa.png
[c5835fb5cdb748ce83793def316eed12.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/01b7ad7c0a864c38b6770260c4f04b0d.png
[203226da5c6f4ae3b08dd740dd1f9471.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/601377d3a9d241cc8b99cdaa35c7beeb.png
[0410eb151cb444f49f1e46eb4b169b35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f85b69ad8c5b419180c17a1d49bf8541.png
[031958165f4d40a89cafb3001baa8834.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/13d7749618af46cf9ac8289ba9366a8f.png
[ac8dcc6f57324bab9e515f6a75e0ca74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8dea2aa702fe48f7829034374a46a34a.png
[303c00ff316843c2bfc188f8fb32d10a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/09444711f2044a62aa162ff03c374b08.png
[715c34ecc09443d38db61a6feaeee94b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/0d49ba28c2c849c88a244f8a6a98b49f.png
[f698d4f35e244852a52dee43ef66247c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b2fe0c03959a46538fb89833afcf3733.png
[57d5ec28a3bb460fa7a8273c375dfcda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/32140e86728b49d380e36e28c46e462b.png
[fc431174e83c41dc88237020d2b1a718.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c9dc56d7432b4642bf97baaa00e593a8.png
[daa1f46ed607461e8eb2dd93764a10ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/6cd94054f945435b85e4186d95ca6465.png
[81a85b52c3a14a458ffc72b50be6e81c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/4c7d1993d09c4234991b45fed3250bcb.png
[85c1a63386f24fe9ae25f44a2c4699bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/2bb45576da8c4cb4a4509e535b580e14.png
[97bc2bc96ac443c09ac154bea54fd3f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/9e31b7c994d74b40b2e88f2cf27e2861.png
[a50728c340aa4c41a745aea112a0eb6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ecea44c986934ba0a0e8727b1dec780c.png
[9d2d01824aa049ce9a5fe21d4af0513e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a1b34a7a81404b2cb8f35b233b7a63ad.png
[e452851eb9f04c75be6c6a17989d0fcb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b6c48598982d4ecebc460b4fa35c8afa.png
[0610fc26efca4db4b0e43c01223a38a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ce9834f13f0b40adbc01e3159569b102.png
[681afc581b4d497486a7e682e8d754b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/fc231e829cc74136bfcf8be00c87a5ca.png
[7d784af79f214d83947f9945a4e63c48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c740827d17a549f488111a13df7f00b0.png
[010c3292c18f4a94bfb3be93e1168e90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a37400d187fe4e6bb4d339301e721ee5.png
[22e2ea0667f54ec1ba9b54a86b50c415.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/da324234523a42ff8661082fefa80359.png