MyBatis-Plus——使用查询构造器Wrapper & 简单分页操作

Posted 2021-09-11 张起灵-小哥

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了MyBatis-Plus——使用查询构造器Wrapper & 简单分页操作相关的知识，希望对你有一定的参考价值。

1.查询构造器：Wrapper

QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条
件。 MP3.x开始支持lambda表达式，LambdaQueryWrapper，LambdaUpdateWrapper支持 lambda 表达式的构造查询条件。

我们这里主要使用的是QueryWrapper这个类，它的父类AbstractWrapper实现了一个接口Compare<This, R>，在这个接口中，有大量用来拼接where子句中相关条件的方法。

allEq：基于map的相等
eq 等于 =
ne 不等于 <>
gt 大于 >
ge 大于等于 >=
lt 小于 <
le 小于等于 <=
between BETWEEN 值 1 AND 值 2
notBetween NOT BETWEEN 值 1 AND 值 2
like LIKE '%值%'
notLike NOT LIKE '%值%'
likeLeft LIKE '%值'
likeRight LIKE '值%'
isNull 字段 IS NULL
isNotNull 字段 IS NOT NULL
in 字段 IN (value1, value2, ...)
notIn 字段 NOT IN (value1, value2, ...)
inSql 字段 IN ( sql 语句 )
例: inSql("age", "1,2,3")--->age in (1,2,3,4,5,6)
例: inSql("id", "select id from table where id < 3")--->id
in (select id from table where id < 3)
notInSql 字段 NOT IN ( sql 语句 )
groupBy GROUP BY 字段
orderByAsc 升序 ORDER BY 字段, ... ASC
orderByDesc 降序 ORDER BY 字段, ... DESC
orderBy 自定义字段排序 orderBy(true, true, "id", "name")--->order by id ASC,name ASC
having 条件分组
or OR 语句，拼接 + OR 字段=值
and AND 语句，拼接 + AND 字段=值
apply 拼接 sql
last 在 sql 语句后拼接自定义条件
exists 拼接 EXISTS ( sql 语句 )
例 : exists("select id from table where age =
1")--->exists (select id from table where age = 1)
notExists 拼接 NOT EXISTS ( sql 语句 )
nested 正常嵌套不带 AND 或者 OR

2.案例详解

这篇文章中所用到的数据库表、实体类，mapper接口均和上一篇文章（链接：https://blog.csdn.net/weixin_43823808/article/details/118412431）相同，所以这里不再给出代码了，只是这篇文章中，不再使用xml映射文件了。

我将使用Wrapper这个查询构造器来实现查询操作。

2.1 测试方法

    @Test
    public void testAllEq() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //将查询条件封装到Map集合中，and
        Map<String,Object> map=new HashMap<>();
        map.put("name","张三");
        map.put("age",22);

        qw.allEq(map);
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testAllEq2() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //将查询条件封装到Map集合中
        Map<String,Object> map=new HashMap<>();
        map.put("name","张三");
        map.put("age",null);

        /**
         * 第二个参数为 true：处理null值，where条件中加入 字段 IS NULL
         *         为 false：直接忽略null值，不添加到where子句中
         */
        qw.allEq(map,true);
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

qw.allEq(map,true) 的执行结果

qw.allEq(map,false) 的执行结果

    @Test
    public void testEq() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //eq等于
        qw.eq("name","李四");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testNe() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //ne不等于
        qw.ne("name","李四");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testGt() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //gt大于，ge大于等于
        //lt小于，le小于等于
        qw.gt("age",25);
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testBetween() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //between在两个值的范围之间（闭区间）
        //notBetween不在两个值范围之间（对应上面集合的补集）
        qw.between("age",30,36);
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testLike() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //like 匹配值 "%值%"
        //notLike 不匹配 "%值%"
        qw.like("name","周");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testLikeLeft() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //likeLeft 匹配 like "%值"
        //likeRight 匹配 like "值%"
        qw.likeLeft("name","三");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testIsNull() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //isNull 判断字段值为 null
        //isNotNull 字段值不为 null
        qw.isNull("age");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testIn() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //in 在这个值列表中，在列表中的都是符合条件的。
        //notIn 不在列表中的
//        List<String> list=new ArrayList<>();
//        list.add("张三");
//        list.add("李四");
//        qw.in("name",list);
        //下面这行等价于上面注释掉的四行
        qw.in("name","张三","李四");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testInSql() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //inSql 常用来做子查询 类似 in()
        //notInSql 类似 notIn()
        qw.inSql("age","select age from student where id=2");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testGroupBy() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        qw.select("status,count(*)");
        //groupBy 基于多个字段分组
        qw.groupBy("status");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testOrderByAsc() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //orderByAsc 按字段升序
        //orderByDesc 按字段降序
        //orderBy 每个字段指定排序方向
        qw.orderByAsc("age");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testOr() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //or 连接条件用 or，默认是 and
        //and 连接条件用 and
        qw.eq("name","张三").or().eq("age",24);
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testLast() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //last 拼接 sql 语句
        qw.eq("name","张三").or().eq("age",24).last("limit 1");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

    @Test
    public void testExists() {
        QueryWrapper<Student> qw=new QueryWrapper<>();

        //exists 拼接 exists ( sql 语句 )
        //notExists 是 exists 的相反操作
        qw.exists("select id,name from student where age>36");
        List<Student> students=mapper.selectList(qw);
        students.forEach( student -> System.out.println(student));
    }

1.2 分页操作

首先添加分页插件，在原先的SSM中，我们需要在xml文件中使用<bean>标签进行声明配置；现在升级为了SpringBoot，就告别xml了，我们直接定义一个config包，在其中创建一个类，使用@Configuration注解标记该类为配置类，在其中使用@Bean注解就可以了。

package com.szh.mybatisplus.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 *
 */
@Configuration
public class MyConfig {

    //分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

下面是测试方法。

    @Test
    public void testPage() {
        QueryWrapper<Student> qw=new QueryWrapper<>();
        qw.gt("age",20);
        qw.orderByAsc("id");

        //设置分页的数据
        IPage<Student> page=new Page<>();
        page.setCurrent(1);//第1页
        page.setSize(3);//每页3条记录
        IPage<Student> result = mapper.selectPage(page, qw);

        List<Student> students = result.getRecords();
        System.out.println("总页数：" + result.getPages());
        System.out.println("总记录数：" + result.getTotal());
        System.out.println("当前页码：" + result.getCurrent());
        System.out.println("每页大小：" + result.getSize());
        students.forEach( student -> System.out.println(student));
    }

以上是关于MyBatis-Plus——使用查询构造器Wrapper & 简单分页操作的主要内容，如果未能解决你的问题，请参考以下文章

每天玩转3分钟 MyBatis-Plus - 3. 高级查询（条件构造器）

MyBatis-Plus——使用查询构造器Wrapper & 简单分页操作

Mybatis-Plus：条件构造器（allEq基本比较操作模糊查询排序逻辑查询select）

Mybatis-plus工具学习笔记---[常用注解,条件构造器,插件使用]