mybatisPlus进阶篇

ゝ一世哀愁。 2024-03-22 21:09 22阅读 0赞

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

*  映射
 *   *  自动映射规则
     *  表映射
     *  字段映射
     *  字段失效
     *  视图属性
 *  条件构造器
 *   *  条件构造器介绍
 *  等值查询
 *   *  eq
     *  allEq
     *  ne
 *  范围查询
 *   *  gt
     *  ge(>=)
     *  lt(<)
     *  le(<=)
     *  between
     *  notBetween
 *  模糊查询
 *   *  like
     *  notLike
     *  likeLeft
     *  likeRight
 *  判空查询
 *   *  isNull
     *  isNotNull
 *  包含查询
 *   *  in
     *  notIn
     *  inSql
     *  notInSql
 *  分组查询
 *   *  groupBy
 *  聚合查询
 *   *  having
 *  排序查询
 *   *  orderByAsc
     *  orderByDesc
     *  orderBy
 *  func查询
 *   *  func
 *  逻辑查询
 *   *  and
     *  or
     *  nested
 *  自定义条件查询
 *   *  apply
 *  last查询
 *   *  last
 *  exists查询
 *   *  exists
     *  notExists
 *  字段查询
 *   *  select

## 映射 ##

*  Mybatis框架之所以能够简化数据库操作，是因为内部的映射机制，通过自动映射，进行数据的封装，我们只要符合映射规则，就可以快速高效的完成SQL操作的实现。
 *  既然MybatisPlus是基于Mybatis的增强工具，所以也具有这样的映射规则。

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

1.  表名和实体类名映射 -> 表名user 实体类名User
2.  字段名和实体类属性名映射 -> 字段名name 实体类属性名name
3.  字段名下划线命名方式和实体类属性小驼峰命名方式映射 -> 字段名 user\_email 实体类属性名 userEmail

*  MybatisPlus支持这种映射规则，可以通过配置来设置

map-underscore-to-camel-case: true #表示支持下划线到驼峰的映射
    map-underscore-to-camel-case: false #表示不支持下划线到驼峰的映射

mybatis-plus:
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
        map-underscore-to-camel-case: true

### 表映射 ###

*  通过@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;
    }

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

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

### 字段映射 ###

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

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

*  此时的SQL语句

SELECT id,username AS name,email FROM powershop_user

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

1.  数据库字段和表实体类的属性一致，框架在拼接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`,就可以解决这个问题

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

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

### 字段失效 ###

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

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

*  生成的SQL语句如下  
    ![在这里插入图片描述][ff3bd979ed784a94881674e230c2146f.png]

### 视图属性 ###

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

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

*  可以看到查询结果中不包含该字段  
    ![在这里插入图片描述][b2dc0ec18f5a411e8ed8271ddfeee160.png]

## 条件构造器 ##

### 条件构造器介绍 ###

*  想要使用MybatisPlus完成条件查询，基于面向对象的思想，万物皆对象，那么查询条件也需要使用对象来完成封装。理清楚MybatisPlus中，和条件有关的类以及其之关系,在传递条件对象的时候，更有助于理清思路。

1.  `Wrapper`——抽象类，条件类的顶层，提供了一些获取和判断相关的方法
2.  `AbstractWrapper`——抽象类，`Wrapper`的子类，提供了所有的条件相关方法
3.  `AbstractLambdaWrapper`——抽象类，`AbstractWrapper`的子类，确定字段参数为方法引用类型
4.  `QueryWrapper`——AbstractWrapper的子类，如果**需要传递`String`类型的字段信息，创建该对象**
5.  `LambdaQueryWrapper`——AbstractLambdaWrapper的子类，如果**需要传递方法引用方式的字段信息，创建该对象**

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

*  该图为以上各类的关系，在编写代码的时候，只需要关注`QueryWrappe`r和`LambdaQueryWrapper`
 *  需要重点掌握`QueryWrapper`和`LambdaQueryWrapper`这两个类，在一般情况下，大多选择`LambdaQueryWrapper`，因为选择这种方式传递参数，不用担心拼写错误问题。

## 等值查询 ##

### eq ###

*  使用QueryWrapper对象，构建查询条件

@Test
    void eq(){
        
        //1.创建QueryWrapper对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2.设置条件，指定String字段名称和值
        queryWrapper.eq("name","Jack");
        //3.使用条件完成查询
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }

测试效果  
![在这里插入图片描述][fcc820a3bc1341c59feed49544cdded6.png]

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

*  如果每次都是自己进行字段名称的编写，有可能会出现名称写错的情况，为避免这种情况，可以使用LambdaQueryWrapper对象，在构建字段时，使用方法引用的方式来选择字段，这样做可以避免字段拼写错误出现问题。  
    代码如下：

@Test
    void eq2(){
        
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定String字段名称和值
        lambdaQueryWrapper.eq(User::getName,"Jack");
        //3.使用条件完成查询
        User user = userMapper.selectOne(lambdaQueryWrapper);
        System.out.println(user);
    }

*  有时不能确定所有的条件都是有值的，部分条件可能用户没有传值，那该条件就为null。为null的条件，是不需要进行查询条件拼接的，否则就会出现如下情况，将为null的条件进行拼接，筛选后无法查询出结果
 *  要解决这个问题，可以先判断是否为空，根据判断结果选择是否拼接该字段

@Test
    void isNull2(){
        
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        String name = null;
        lambdaQueryWrapper.eq(name != null,User::getName,name);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

### allEq ###

*  先演示一下通过多个eq,构建多条件查询

@Test
    void allEq1(){
        
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName,"Jone");
        lambdaQueryWrapper.eq(User::getAge,18);
    
        User user = userMapper.selectOne(lambdaQueryWrapper);
        System.out.println(user);
    }

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

@Test
    void allEq2(){
        
        //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);
        System.out.println(user);
    }

allEq(Map<R, V> params, boolean null2IsNull)

*  参数params：表示传递的Map集合
 *  参数null2IsNull：表示对于为null的条件是否判断isNull

### ne ###

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

*  拼接的SQL如下:  
    ![在这里插入图片描述][6e196c9dc1224b09ae7cb396892fd6d4.png]

## 范围查询 ##

### gt ###

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

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

### ge(>=) ###

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

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

### lt(<) ###

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

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

### le(<=) ###

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

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

### between ###

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

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

### notBetween ###

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

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

## 模糊查询 ##

### like ###

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

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

### notLike ###

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

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

### likeLeft ###

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

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

### likeRight ###

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

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

## 判空查询 ##

### isNull ###

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

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

### isNotNull ###

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

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

## 包含查询 ##

### in ###

@Test
    void in(){
        
        //1.创建QueryWrapper对象
        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);
        System.out.println(users);
    }

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

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

### notIn ###

@Test
    void notIn(){
        
        //1.创建QueryWrapper对象
        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);
        System.out.println(users);
    }

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

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

### inSql ###

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

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

@Test
    void inSql2(){
        
        //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);
        System.out.println(users);
    }

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

### notInSql ###

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

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

@Test
    void notInSql2(){
        
        //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);
        System.out.println(users);
    }

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

## 分组查询 ##

### groupBy ###

@Test
    void groupBy(){
        
        //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);
        System.out.println(maps);
    }

*  拼接的SQL如下  
    ![在这里插入图片描述][4af3ab39ed044855a6bdf71412001299.png]
 *  实际查询结果  
    ![在这里插入图片描述][98584716bd3e4ac98afea6d0079c2016.png]
 *  封装结果  
    ![在这里插入图片描述][842fbcc5fd92470988630732338330be.png]

## 聚合查询 ##

### having ###

@Test
    void having(){
        
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //分组字段
        queryWrapper.groupBy("age");
        //查询字段
        queryWrapper.select("age,count(*) as field_count");
        //聚合条件筛选
        queryWrapper.having("field_count = 1");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        System.out.println(maps);
    }

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

## 排序查询 ##

### orderByAsc ###

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

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

### orderByDesc ###

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

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

### orderBy ###

@Test
    void orderBy(){
        
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定降序排序字段
        lambdaQueryWrapper.orderBy(true,true,User::getId);
        lambdaQueryWrapper.orderBy(true,false,User::getAge);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

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

## func查询 ##

### func ###

@Test
    void func(){
        
        //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);
        System.out.println(users);
    }

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

## 逻辑查询 ##

### and ###

*  正常拼接默认就是and

@Test
    void and(){
        
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
        lambdaQueryWrapper.gt(User::getAge,22).lt(User::getAge,30);
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

*  拼接的SQL如下  
    ![在这里插入图片描述][6a3387c6a667435a9b389f5a26adf5db.png]
 *  and也可以进行嵌套

@Test
    void and2(){
        
        //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);
        System.out.println(users);
    }

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

### or ###

@Test
    void or(){
        
        //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);
        System.out.println(users);
    }

*  拼接的SQL如下  
    ![在这里插入图片描述][d5151e81e98b4ca19139350f2063fc57.png]
 *  OR嵌套

@Test
    void or2(){
        
         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);
         System.out.println(users);
    }

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

### nested ###

@Test
    void nested(){
        
        //1.创建QueryWrapper对象
        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);
        System.out.println(users);
    }

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

## 自定义条件查询 ##

### apply ###

@Test
    void apply(){
        
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建条件查询语句
        lambdaQueryWrapper.apply("id = 1");
        //3.完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

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

## last查询 ##

### last ###

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

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

## exists查询 ##

### exists ###

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

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

### notExists ###

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

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

## 字段查询 ##

### select ###

@Test
    void select(){
        
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建查询条件
        lambdaQueryWrapper.select(User::getId,User::getName);
        //3.查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

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

[e7b0a01eb7fb4a849b3e6a65f14c290e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/87209c83606a401ebf00cc4e33a6e6e4.png
[ff3bd979ed784a94881674e230c2146f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0a021d5cc7014f28a3f6b97177f632b2.png
[b2dc0ec18f5a411e8ed8271ddfeee160.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/00451addbb8e45d9916cfcbf0870755d.png
[24edbcfed8424b48a9977f12663f0f5d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e23b3699c29748ff86a7dee97c9b44f9.png
[fcc820a3bc1341c59feed49544cdded6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/90c20188c9974ff28fdffa08fc9439c5.png
[6e196c9dc1224b09ae7cb396892fd6d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2eeb0eb6e2174ea7bf1354507d9ee301.png
[5d2acabb1c3f44fb8cd1be973507105a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0a403dc3f7fb416894bc32197ddf14f4.png
[56909a659c6c4d96b47719e9d885ac67.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8364e6840baf407c8990fb6121b9e135.png
[714cc8b5c67e42369d4fdf03c784f87d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/278ab606832c4b50856b74f655de9906.png
[b68166bb9ab242db834057626e226102.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/38399c80f78f41fbbeb277b92d3faf87.png
[0614afc338f54a6fbc3c1e22ee6f0e55.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/bccb9adb7df84b78b44520982b1abc39.png
[68b491237eda4fd699a4d18b51c586f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ef516ca14d414cb2b3f12bee683184a9.png
[17312b3930734358b198bb9110ed821c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8edfd2f0c0a44c9cb9f2e3060a07cd44.png
[ab27c8a34606476eb424b00a7bc2502d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f19565c2a249458a806e65502d2c7a54.png
[658ddc87e4284d8a98fc21a985ee409a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/68954250944942ba9c11f612e8772942.png
[f4e101f978e24b769541aa9f59f1777b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f59e427d51bf4823b8cd60a41cd4610c.png
[8d996822cb4e4effa1e0cd4e617ada2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a2f36ac47a39446db52ff4ce50699f23.png
[6e9b44279af444efbf40237de94c9310.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f883239430744d3b88d2716fc8fff2e7.png
[6207aee3b1c146469e81abefc54c4348.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6aca5e4d543d4890ad19a5d06f4ac498.png
[1f81323503fc4a7a846d0cb7c01121e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f958411795414ab9913163eb2adcf879.png
[0679bb95aa3c4444a022e6b7e9e2e26a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1fb0724a4a6d4d3f88530bc79bac15ca.png
[6f94296e21e64d3ba6a5427c1604309b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/614c2026ec764b7abd58a40b93b48d7a.png
[edd7001d304e4c8fbc851ac69cccbb06.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3fb4ad683195412ba1a87d4d26de3643.png
[9dcbadf762e6411f85ae076b9598e6e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c92b3869f4c3485b95ec68d5ba76ccd0.png
[4af3ab39ed044855a6bdf71412001299.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/67b365e191f848538b37cc9eeae73471.png
[98584716bd3e4ac98afea6d0079c2016.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e29d0ee7f44447aea74131d6ebd424ff.png
[842fbcc5fd92470988630732338330be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/109e842420f14b91bcba0ba77dcb7b22.png
[be35edc9d39549d984d74d6d831ca23f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/935be9273448428e92537881bd5279d9.png
[ce75630a1d92494fae73e1479a11c46d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/74519187b39046f589cd45ff822355de.png
[51ca16ca670248cb95a3ecb1dbbd81c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2d316121ea1348bca3459ab66a699d5c.png
[ab7ffcb2c8a64b1eb98bd0bb082617e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5e59de7e762e4f62af37f622e363c3e6.png
[49d3aeec19d94a67b93ffa03a9db1cbf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/474f3a7ea2b743b18955a2a694bdf0b2.png
[6a3387c6a667435a9b389f5a26adf5db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/78a3ceb395d04c769c000d79f85cdbe1.png
[672a1080571b4311ae698b036e5bc692.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4bbe9c2cf8e4488f8dd2db6fd4461401.png
[d5151e81e98b4ca19139350f2063fc57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/903d51c9e48d4c9081d0274599f3c4a1.png
[72b98f6fa284432f8292d57edc78b0c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/17724714d41f463ba7503d33bf99f3a8.png
[fe2082b793714156a2fb876accfed4b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0b842601e0ef42e9b6064858313fabba.png
[42cf704d61bd442bb1547c42b3201c17.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0574d280ca0f4896ac354553627b5f05.png
[c326705264a64e66a27fea141b93da10.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/716149729f9f4496b3071c242539a8c1.png
[a692f71a9e734861aff25cbb2a59093b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9dbb1b42adaf40a097c08e531c3afea0.png
[7a5013f43f6445ad82b65ae084518e05.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4c5508bd15b3433c921f76caac69f8d4.png
[95a2417db8a346afa1a1cdb983c34007.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/17a2b33775f14ed092cb7173df7d0641.png