映射和条件构造器

1. 映射   28

学习过Mybatis的同学应该知道，Mybatis框架之所以能够简化数据库操作，是因为他内部的映射机制，通过自动映射，进行数据的封装，我们只要符合映射规则，就可以快速高效的完成SQL操作的实现。

既然MybatisPlus是基于Mybatis的增强工具，所以也具有这样的映射规则。

我们先来了解一下自动映射规则。

1.1 自动映射规则  29

【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

1.2 表映射  30-31

去数据库将user表名改为powershop_user

随便运行一个程序（单元测试中的UserMapper查询所有selectList方法），他说user表找不到

通过@TableName()注解指定映射的数据库表名，就会按照指定的表名进行映射

如：此时将数据库的表名改为powershop_user,要完成表名和实体类名的映射，需要将实体类名也要指定为powershop_user

package com.powernode.domain;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//数据库对应的实体类user   4
@Data  //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射  30
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.3 字段映射  32

将表中的name字段改为username

执行一个程序，说name它找不到

什么场景下会改变字段映射呢？

当数据库字段和表实体类的属性不一致时

我们可以使用@TableField()注解改变字段和属性的映射，让注解中的名称和表字段保持一致

如：此时将数据库字段的名称我们改为username，在根据实体类的属性拼接SQL的使用，就会使用@TableField()中指定的名称username进行拼接，完成查询

package com.powernode.domain;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//数据库对应的实体类user   4
@Data  //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射  30
public class User {
    private Long id;
    @TableField("username") //指定表中的字段名和属性对应  32
    private String name;
    private Integer age;
    private String email;
}

此时的SQL语句是这样的

SELECT id,username AS name,email FROM powershop_user

字段名和关键字相同时   33

我们在表中添加一个desc列

【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`,就可以解决这个问题

package com.powernode.domain;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//数据库对应的实体类user   4
@Data  //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射  30
public class User {
    private Long id;
    @TableField("username") //指定表中的字段名和属性对应  32
    private String name;
    private Integer age;
    private String email;
    @TableField("`desc`") //将desc字段变成普通字段  33
    private String desc;
}

此时可以观察到，框架拼接生成的SQL语句的字段名称变为了`desc`,这样是可以正常完成查询的

1.4 字段失效  34

当数据库中有字段不希望被查询，我们可以通过@TableField(select = false)来隐藏这个字段，那在拼接SQL语句的时候，就不会拼接这个字段

如：如果不想显示年龄信息，那么可以在age属性上添加这个注解，来隐藏这个字段

package com.powernode.domain;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//数据库对应的实体类user   4
@Data  //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射  30
public class User {
    private Long id;
    @TableField("username") //指定表中的字段名和属性对应  32
    private String name;
    @TableField(select = false)//时age字段失效查询不到  34
    private Integer age;
    private String email;
    @TableField("`desc`") //将desc字段变成普通字段  33
    private String desc;
}

生成的SQL语句如下，通过查询生成的SQL语句，发现并没有拼接age字段

1.5 视图属性   35

在实际开发中，有些字段不需要数据库存储，但是却需要展示，需要展示也就是意味着实体类中需要存在这个字段，我们称这些实体类中存在但是数据库中不存在的字段，叫做视图字段。

根据之前的经验，框架会默认将实体类中的属性作为查询字段进行拼接，那我们来思考，像这种视图字段，能够作为查询条件么，显示是不能的。因为数据库中没有这个字段，所以查询字段如果包含这个字段，SQL语句会出现问题。我们通过@TableField(exist = false)来去掉这个字段，不让他作为查询字段。

package com.powernode.domain;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//数据库对应的实体类user   4
@Data  //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射  30
public class User {
    private Long id;
    @TableField("username") //指定表中的字段名和属性对应  32
    private String name;
//    @TableField(select = false)//时age字段失效查询不到  34
    private Integer age;
    private String email;
//    @TableField("`desc`") //将desc字段变成普通字段  33
//    private String desc;

    //online属性在表中没有，但是我们有需要这个属性进行展示，所以使用TableField注解，  35
    // 去掉这个字段，不让他作为查询字段。
    @TableField(exist = false)
    private Integer online; //用户在线或不在线
}

可以看到查询结果中不包含该字段

1.6 小结  35

这一章节，我们讲解了MybatisPlus的映射规则，以及如果通过注解配置来改变这种映射规则。

2.  条件构造器  36

2.1 条件构造器介绍

之前我们进行的MybatisPlus的操作，没有涉及到条件查询，实际上在开发需求中条件查询是非常普遍的。接下来我们就来讲解如何使用MybatisPlus完成条件查询。

首先，想要使用MybatisPlus完成条件查询，基于面向对象的思想，万物皆对象，那么查询条件也需要使用对象来完成封装。我们先看一下，在MybatisPlus中，和条件有关的类有哪些，他们之间有什么关系，理清楚了这个，我们在传递条件对象的时候，就很清晰了。

2.1.1  Wrapper

抽象类，条件类的顶层，提供了一些获取和判断相关的方法

2.1.2 AbstractWrapper

抽象类，Wrapper的子类，提供了所有的条件相关方法

2.1.3  AbstractLambdaWrapper

抽象类，AbstractWrapper的子类，确定字段参数为方法引用类型

2.1.4 QueryWrapper

类，AbstractWrapper的子类，如果我们需要传递String类型的字段信息，创建该对象

2.1.5  LambdaQueryWrapper

类，AbstractLambdaWrapper的子类，如果我们需要传递方法引用方式的字段信息，创建该对象

该图为以上各类的关系，我们在编写代码的时候，只需要关注QueryWrapper和LambdaQueryWrapper

2.2  等值查询  37

2.2.1  eq  单条件 37-40

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

QueryTest

package com.powernode;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.powernode.domain.User;
import com.powernode.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

//条件查询  37
@SpringBootTest
public class QueryTest {

    @Autowired
    private UserMapper userMapper;

    //等值查询eq  37
    @Test
    void eq(){
        //1.创建条件查询对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2.设置查询条件，指定查询的字段和匹配的值
        queryWrapper.eq("name","Jack");
        //3.进行条件查询
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }

}

测试效果

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

代码如下：

QueryTest

//LambdaQueryWrapper的等值查询  38
    @Test
    void eq2(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName,"Jack");
        User user = userMapper.selectOne(lambdaQueryWrapper);
        System.out.println(user);
    }

还要考虑一种情况，我们构建的条件是从哪里来的？应该是从客户端通过请求发送过来的，由服务端接收的。在网站中一般都会有多个条件入口，用户可以选择一个或多个条件进行查询，那这个时候在请求时，我们不能确定所有的条件都是有值的，部分条件可能用户没有传值，那该条件就为null。

比如在电商网站中，可以选择多个查询条件。

那为null的条件，我们是不需要进行查询条件拼接的，否则就会出现如下情况，将为null的条件进行拼接，筛选后无法查询出结果

QueryTest

//当查询条件为null时  39
    @Test
    void isNull(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName,null);
        User user = userMapper.selectOne(lambdaQueryWrapper);
        System.out.println(user);
    }

当然我们要解决这个问题，可以先判断是否为空，根据判断结果选择是否拼接该字段，这个功能其实不需要我们写，由MybatisPlus的方法已经提供好了。

QueryTest

 //优化当查询条件为null时  40
    @Test
    void isNull2(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        String name = null;
        //name != null是空时将不作为查询条件  40
        lambdaQueryWrapper.eq(name != null,User::getName,name);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

2.2.2 allEq  多条件 41

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

QueryTest

//多条件查询  41
    @Test
    void allEq1(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName,"Tom");
        lambdaQueryWrapper.eq(User::getAge,28);
        User user = userMapper.selectOne(lambdaQueryWrapper);
        System.out.println(user);
    }

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

QueryTest

//多条件查询2 41
    //一次通过map封装多个查询条件
    @Test
    void allEq2(){
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("name","Tom");
        hashMap.put("age",28);

        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.allEq(hashMap,false);//为true或者false，就是判断是否作为查询字段

        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }

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

参数params:表示传递的Map集合

参数null2IsNull:表示对于为null的条件是否判断isNull

2.2.3 ne  不等查询   43

//不等查询  43
    @Test
    void ne(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.ne(User::getName,"Tom");//名字不是tom的
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.3 范围查询  44

2.3.1  gt 大于

//范围查询
    //大于
    @Test
    void gt(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        Integer age = 18;
        lambdaQueryWrapper.gt(User::getAge,age);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.3.2 ge  大于等于   45

//大于等于  45
    @Test
    void ge(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        Integer age = 18;
        lambdaQueryWrapper.ge(User::getAge,age);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.3.3 lt  小于  46

//小于  46
    @Test
    void lt(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        Integer age = 30;
        lambdaQueryWrapper.lt(User::getAge,age);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.3.4 le  小于等于  47

//小于等于  47
    @Test
    void le(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        Integer age = 30;
        lambdaQueryWrapper.le(User::getAge,age);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.3.5 between    48

//范围查询
    //在区间内  48
    @Test
    void between(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.between(User::getAge,18,30);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.3.6 notBetween   49

//不在区间范围  49
    @Test
    void notBetween(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.notBetween(User::getAge,18,30);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.4  模糊查询  50

2.4.1   like 匹配的模糊查询  50

//模糊查询  50
    //like 模糊查询
    @Test
    void like(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.like(User::getName,"J");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.4.2 notLike 不匹配的模糊查询   51

//不匹配的模糊查询  51
    @Test
    void notLike(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.notLike(User::getName,"J");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.4.3 likeLeft 左模糊匹配  52

//左模糊匹配  52
    //本方法的意思是，它左边是啥都行，最有表必须是e
    @Test
    void likeLeft(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.likeLeft(User::getName,"e");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.4.4 likeRight  右模糊匹配  53

//右模糊匹配  53
    @Test
    void likeRight(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.likeRight(User::getName,"J");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.5 判空查询  54

2.5.1  isNull   54

如果为空就获取，否则不获取

//判空查询  54
    @Test
    void isNull3(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.isNull(User::getName);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

因为我们数据库中的name字段没有为空的，所以获取为0

2.5.2 isNotNull   54

如果为空就不获取，否则获取

//如果为空就不获取，否则获取   54
    @Test
    void isNotNull(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.isNotNull(User::getName);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.6 包含查询  55

2.6.1   in

//包含查询   55
    //字段=值 or 字段=值  -> in  55
    @Test
    void in(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        ArrayList<Integer> arrayList = new ArrayList<>();
        Collections.addAll(arrayList,18,20,22);
        lambdaQueryWrapper.in(User::getAge,arrayList);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.6.2 notIn   56

//字段!=值 and 字段!=值   -> notIn   56
    @Test
    void notIn(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        ArrayList<Integer> arrayList = new ArrayList<>();
        Collections.addAll(arrayList,18,20,22);
        lambdaQueryWrapper.notIn(User::getAge,arrayList);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.6.3 inSql   57

//包含查询
    //inSql支持sql语句  58
    @Test
    void inSql(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.inSql(User::getAge,"18,20,22");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

@Test
    void inSql2(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.inSql(User::getAge,"select age from powershop_user where age > 20");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

2.6.4 notInSql   58

@Test
    void notInSql(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.notInSql(User::getAge,"18,20,22");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

@Test
    void notInSql2(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.notInSql(User::getAge,"select age from powershop_user where age > 20");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

2.7  分组查询  60

2.7.1 groupBy

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

拼接的SQL如下

2.8 聚合查询   61

2.8.1  having

//聚合查询  61
    @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如下

2.9 排序查询   62

2.9.1  orderByAsc  升序

//排序查询  62
    //升序
    @Test
    void orderByAsc(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.orderByAsc(User::getAge,User::getId);//先按照年龄排序，如果年龄一样再按照id排序
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.9.2 orderByDesc  降序   63

//降序
    @Test
    void orderByDesc(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.orderByDesc(User::getAge,User::getId);//先按照年龄排序，如果年龄一样再按照id排序
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.9.3 orderBy  自定义排序方式 64

//自定义排序降序   64
    @Test
    void orderBy(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //设置排序字段和排序的方式  参数1:如果排序字段的值为null的时候，是否还要作为排序字段参与排序  参数2:是否是升序排序  参数3:排序字段
        //线按照年龄升序，年龄一样按照id降序   64
        lambdaQueryWrapper.orderBy(true,true,User::getAge);
        lambdaQueryWrapper.orderBy(true,false,User::getId);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.10 func查询   65

可以根据不同的情况来选择拼接不同的查询条件

2.10.1   func

//func查询   65
    @Test
    void func(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //可能会根据不同的情况来选择拼接不同的查询条件
        lambdaQueryWrapper.func(userLambdaQueryWrapper -> {
            if (false){
                userLambdaQueryWrapper.eq(User::getId,1);
            }else {
                userLambdaQueryWrapper.ne(User::getId,1);
            }
        });
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.11 逻辑查询   66

2.11.1   and   66

// 逻辑查询  66
    @Test
    void and(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //年龄大于22小于30
        lambdaQueryWrapper.gt(User::getAge,22).lt(User::getAge,30); //and(条件)
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

and也可以进行嵌套   67

//and的嵌套操作   67
    @Test
    void and2(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName,"wang")
                .and(i -> i.gt(User::getAge,26).or().lt(User::getAge,22));

        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.11.2  or   68

@Test
    void or(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.lt(User::getAge,20).or().gt(User::getAge,23);  //age < 20 || age > 23
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

OR嵌套   69

//or的嵌套  69
    @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如下

2.11.3 nested  70

直接将条件拼接在where后面

//70
    @Test
    void nested(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //名字是tom且年龄不是22
        lambdaQueryWrapper.nested(i -> i.eq(User::getName,"Tom").ne(User::getAge,22));
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.12  自定义条件查询   71

可以将我们所写的条件直接拼接在where后面

2.12.1  apply

//自定义条件查询   71
    @Test
    void apply(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.apply("id = 1");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.13 last查询  72

将传递一个字符串，可以将字符串拼接在sql语句的最后面

2.13.1 last  72

//将传递一个字符串，可以将字符串拼接在sql语句的最后面  72
    @Test
    void last(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.last("limit 0,2");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.14 exists查询   73

2.14.1   exists   73

//exists会根据子查询的结果来判断主查询是否保留  73
    @Test
    void exists(){
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建查询条件
        //age没有等于188的，主查询数据不会保留
        lambdaQueryWrapper.exists("select id from powershop_user where age = 188");
        //3.查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.14.2 notExists   74

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

拼接的SQL如下

2.15 字段查询   75

2.15.1 select   75

//查询字段  75
    @Test
    void select(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //查询时只有这两个字段会被查询出来
        lambdaQueryWrapper.select(User::getId,User::getName);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

拼接的SQL如下

2.16 小结  75

本章节讲解了条件查询中的各种查询操作，我们可以通过面向对象的形式，直接调用方法来完成mysql中的条件查询