动力节点MybatisPlus学习笔记（三）进阶篇

最新推荐文章于 2024-07-19 15:16:23 发布

农夫山泉有点甜ye

最新推荐文章于 2024-07-19 15:16:23 发布

阅读量134

点赞数

文章标签：学习笔记 mybatis

本文链接：https://blog.csdn.net/buhytbji/article/details/130217010

版权

3 【进阶篇】

3.1 映射

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

3.1.1 自动映射规则

【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

3.1.2 表映射

通过@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_

3.1.3 字段映射

什么场景下会改变字段映射呢？
【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

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

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

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

3.1.4 字段失效

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

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

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

3.1.5 视图属性

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

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

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

3.1.6 小结

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

3.2 条件构造器

3.2.1 条件构造器介绍

之前我们进行的MybatisPlus的操作，没有涉及到条件查询，实际上在开发需求中条件查询是非常普遍的。接下来我们就来讲解如何使用MybatisPlus完成条件查询。
首先，想要使用MybatisPlus完成条件查询，基于面向对象的思想，万物皆对象，那么查询条件也需要使用对象来完成封装。我们先看一下，在MybatisPlus中，和条件有关的类有哪些，他们之间有什么关系，理清楚了这个，我们在传递条件对象的时候，就很清晰了。

3.2.2 Wrapper

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

3.2.3 AbstractWrapper

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

3.2.4 AbstractLambdaWrapper

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

3.2.5 QueryWrapper

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

3.2.6 LambdaQueryWrapper

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

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

3.2.7 小结

通过学习类的继承体系，我们知道，我们需要重点掌握QueryWrapper和LambdaQueryWrapper这两个类，在一般情况下，我们大多选择LambdaQueryWrapper，因为选择这种方式传递参数，不用担心拼写错误问题。

3.3 等值查询

3.3.1 eq

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

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

测试效果

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

@Testvoid 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的条件进行拼接，筛选后无法查询出结果

@Testvoid isNull(){
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    lambdaQueryWrapper.eq(User::getName,null);
    User user = userMapper.selectOne(lambdaQueryWrapper);
    System._out_.println(user);
}

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

@Testvoid 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);
}

3.3.2 allEq

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

@Testvoid 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集合中，更加的方便

@Testvoid 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

3.3.3 ne

@Testvoid 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如下

3.4 范围查询

3.4.1 gt

@Testvoid 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如下

3.4.2 ge

@Testvoid gt(){
    **//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如下

3.4.3 lt

@Testvoid 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如下

3.4.4 le

@Testvoid 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如下

3.4.5 between

@Testvoid 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如下

3.4.6 notBetween

@Testvoid 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如下

3.5 模糊查询

3.5.1 like

@Testvoid 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如下

3.5.2 notLike

@Testvoid 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如下

3.5.3 likeLeft

@Testvoid 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如下

3.5.4 likeRight

@Testvoid likeLeft(){
    **//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如下

3.6 判空查询

3.6.1 isNull

@Testvoid 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如下

3.6.2 isNotNull

@Testvoid 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如下

3.7 包含查询

3.7.1 in

@Testvoid 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);
}

@Testvoid 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如下

3.7.2 notIn

@Testvoid 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);
}

@Testvoid 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如下

3.7.3 inSql

@Testvoid 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如下

@Testvoid 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如下

3.7.4 notInSql

@Testvoid 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如下

@Testvoid 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如下

3.8 分组查询

3.8.1 groupBy

@Testvoid 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如下

实际查询结果

封装结果

3.9 聚合查询

3.9.1 having

@Testvoid 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如下

3.10 排序查询

3.10.1 orderByAsc

@Testvoid 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如下

3.10.2 orderByDesc

@Testvoid 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如下

3.10.3 orderBy

@Testvoid 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如下

3.11 func查询

3.11.1 func

@Testvoid 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如下

3.12 逻辑查询

3.12.1 and

正常拼接默认就是and,例如

@Testvoid 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如下

and也可以进行嵌套

@Testvoid 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如下

3.12.2 or

@Testvoid 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如下

OR嵌套

@Testvoid 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如下

3.12.3 nested

@Testvoid 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如下

3.13 自定义条件查询

3.13.1 apply

@Testvoid 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如下

3.14 last查询

3.14.1 last

@Testvoid 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如下

3.15 exists查询

3.15.1 exists

@Testvoid 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如下

3.15.2 notExists

@Testvoid 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如下

3.16 字段查询

3.16.1 select

@Testvoid 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如下

3.17 小结

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

农夫山泉有点甜ye

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
动力节点MybatisPlus学习笔记（三）进阶篇

之前我们进行的MybatisPlus的操作，没有涉及到条件查询，实际上在开发需求中条件查询是非常普遍的。接下来我们就来讲解如何使用MybatisPlus完成条件查询。首先，想要使用MybatisPlus完成条件查询，基于面向对象的思想，万物皆对象，那么查询条件也需要使用对象来完成封装。我们先看一下，在MybatisPlus中，和条件有关的类有哪些，他们之间有什么关系，理清楚了这个，我们在传递条件对象的时候，就很清晰了。抽象类，Wrapper的子类，提供了所有的条件相关方法。
复制链接

扫一扫