Mybatis-Plus基础之Mapper查询

2023-12-25 13:18:19

一、简单查询

// 根据 ID 查询。执行的 SQL 条件是 id = ...
T selectById(Serializable id);

// 根据 ID 批量查询。执行的 SQL 条件是 id in (...)
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

// 根据指定字段查询。执行 SQL 条件是 xxx=... and yyy=... and zzz=...
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

二、 分页查询

分压查询的接口(即,方法参数中要求传入 IPage 对象的)不能直接使用,需要配置后才可用。如果你没有配置就直接使用,你会发现执行的仍然是 select all 的效果。

  • 配置:

    @Bean // 确保 Spring IoC 容器中存在一个分页拦截器的 JavaBean 。
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
    
  • 使用和验证:

    Page<Employee> page = new Page<>(1, 2);
    Page<Employee> employeePage = employeeDao.selectPage(page, null);
    
    log.info("    当前页码: {}", employeePage.getCurrent());
    log.info("每页数据总量: {}", employeePage.getSize());
    log.info("      总页数: {}", employeePage.getPages());
    log.info("    总数据量: {}", employeePage.getTotal());
    
    log.info("当前页数据据如下:");
    employeePage.getRecords().forEach(item -> log.info("{}", item));
    

三、条件查询:Wrapper

在 Dao/Mapper “点”出来的 select 方法中,你会发现有大量的要求你传入 Wrapper 对象的查询方法,这些方法就是用来实现复杂的条件查询功能的,而 Wrapper 对象就是所谓的条件构造器。

Wrapper 查询所有

对于这些要求传入 Wrapper 对象的 select 方法,如果你故意在 Wrapper 参数位置传入一个 null ,那么就是『无条件查询所有』的功能。

Wrapper 查询的 3 种写法

# 写法一:常规写法(不推荐)
QueryWrapper<EmployeePo> qw = new QueryWrapper<>();
qw.lt("salary", 2000);

List<EmployeePo> pos = employeeDao.selectList(qw);

如果有多条件的话,除了独立式赋值,还可以用链式调用写法串在一起

// qw.lt("salary", 2000);
// qw.gt("commission", 500);
qw.lt("salary", 2000).gt("commission", 500);

缺点:查询条件中的列名是以字符串的形式给出的,万一写错了,debug 时找这种错十分费劲。

# 写法二:lambda 写法
QueryWrapper<EmployeePo> qw = new QueryWrapper<>();
qw.lambda().lt(EmployeePo::getSalary, 2000).gt(EmployeePo::getCommission, 500);

List<EmployeePo> pos = employeeDao.selectList(qw);

缺点:这个写法每次都要手动调用一次 .lambda() 方法。

#  写法三:另一种 lambda 写法(推荐)
LambdaQueryWrapper<EmployeePo> qw = new LambdaQueryWrapper<>();
qw.lt(EmployeePo::getSalary, 2000).gt(EmployeePo::getCommission, 500);
List<EmployeePo> pos = employeeDao.selectList(qw);

一个复杂一点的例子

按用户名和状态查询后台用户并按创建时间降序排列为例。预期执行的 SQL 应该如下:

SELECT 
  *
FROM 
  employee
WHERE 
  department_id = 2
AND 
  salary BETWEEN 500 AND 3000
ORDER BY 
  salary DESC;

在 mybatis-plus 中创建 Wrapper 对象,并调用对象的方法,例如,eq()between() 等方法来表达你所想的查询条件。这些条件之间是 AND 的关系:

构造 Wrapper 对象来表达你心里所想的查询条件和排序规则。

LambdaQueryWrapper<EmployeePo> lqw = new LambdaQueryWrapper<>();
lqw.eq(EmployeePo::getDepartmentId, 2L)
   .between(EmployeePo::getSalary, 500, 3000)
   .orderByDesc(EmployeePo::getSalary);

List<EmployeePo> pos = employeeDao.selectList(lqw);

四、逻辑条件的组合

逻辑条件的组合大体分为 2 种:

  • 单纯的 ...与...与... / ...或...或...

  • 与或 混用,由于 的优先级更高,因此可以改造成 (... and ...) or (... and ...) or ... 这样的统一形式。

与与和或或

  • ...与...与... 情况:

    如上例所示,QueryWrapper 的链式调用中,所表达的逻辑关系就是 and 的关系。

  • ...或...或... 情况:

    这种关系中,在 Wrapper 对象的链式调用中穿插调用 or() 方法即可。or() 方法前后的条件就是或的关系。

    Wrapper<Employee> wp1 = new QueryWrapper<Employee>()
            .lt("salary", 1000)
            .or()
            .isNotNull("commission");
    
    employeeDao.selectList(wp1).forEach(System.out::println);
    

与或混用

与或 混用的情况下,先要把你「心里」的 SQL 语句改造成通用形式:(... and ...) or (... and ...) or ...

Wrapper<Employee> wrapper = new QueryWrapper<Employee>()
        .eq("department_id", 2L)
        .lt("salary", 1500)
        .or()
        .eq("department_id", 3L)
        .gt("salary", 1300);

employeeDao.selectList(wrapper).forEach(System.out::println);

五、条件为 null 的处理技巧

我们经常会遇到这样的场景:当查询条件值为非 null 时,就使用它作为查询条件;如果查询条件值为 null 时,就忽略这个条件。例如,当 department_id 有值时,就查询指定部门的员工信息,如果 department_id 值为 null ,那就忽略 department_id 条件,查询所有。

笨办法就是自己在拼接 Wrapper 查询条件时,加个 if 判断:

Long department_id = ...;

LambdaQueryWrapper<EmployeePo> lqw = new LambdaQueryWrapper<>();
if (department_id != null) {
    lqw.eq(EmployeePo::getDepartmentId, department_id);
}
lqw.between(EmployeePo::getSalary, 500, 3000);
lqw.orderByDesc(EmployeePo::getSalary);
List<EmployeePo> pos = employeeDao.selectList(lqw);

对于这种情况,Mybatis Plus 提供了一个简单一点的写法:

Long department_id = ...;
LambdaQueryWrapper<EmployeePo> lqw = new LambdaQueryWrapper<>();
//下面这句
lqw.eq(department_id != null, EmployeePo::getDepartmentId, department_id); 
lqw.between(EmployeePo::getSalary, 500, 3000);
lqw.orderByDesc(EmployeePo::getSalary);
List<EmployeePo> pos = employeeDao.selectList(lqw);

当判断条件(即,第一个参数)成立时,这个查询条件才存在。


六、设置查询列

之前的查询执行的都是 select * 查询所有列/字段,有时,我们需要指定查询特的那个字段。这种情况下就要调用 QueryWrapper 的 .select() 方法来指定带查询字段。

注意
对于没有指定的列/字段,查询结果 PO 类的对象中相应的属性值就是 null

  • LambdaQueryWrapper 的 select 用法

    LambdaQueryWrapper<EmployeePo> lqw = new LambdaQueryWrapper<>();
    lqw.select(EmployeePo::getId, EmployeePo::getName, EmployeePo::getSalary, EmployeePo::getCommission, EmployeePo::getDepartmentId);
    lqw.eq(EmployeePo::getDepartmentId, 2)
      .between(EmployeePo::getSalary, 500, 3000).
      orderByDesc(EmployeePo::getSalary);
    List<EmployeePo> pos = employeeDao.selectList(lqw);
    
  • QueryWrapper 的 select 用法

    QueryWrapper<EmployeePo> lqw = new QueryWrapper<>();
    lqw.select("id", "name", "salary", "commission", "department_id");
    lqw.lambda().eq(EmployeePo::getDepartmentId, 2)
                .between(EmployeePo::getSalary, 500, 3000)
                .orderByDesc(EmployeePo::getSalary);
    List<EmployeePo> pos = employeeDao.selectList(lqw);
    

    还是因为字符串容易“写错”,不好找 bug 的,建议使用 lambda 写法。


七、使用 SQL 聚合函数

在 Mybatis Plus 中使用聚合函数,类似于上面的指定特定列,使用 QueryWrapper 在 select 方法中指定聚合函数。例如:

QueryWrapper<EmployeePo> lqw = new QueryWrapper<>();
lqw.select("count(*) as total"); // 你还能起别名

但是接下来的 2 点就和上面的指定特定列有所不动了:

  1. 调用的是 mapper/dao 的 .selectMaps() 方法;
  2. 这个方法的返回值是一个 map 的 list 。
qw.select("count(*) as total");
qw.lambda().between(EmployeePo::getSalary, 500, 3000);
List<Map<String, Object>> maps = employeeDao.selectMaps(qw);

maps.forEach(map -> System.out.println(map.get("total")));

为什么结果会是一个 map 的 list ?原因在于在你所执行的 SQL 语句的聚合函数可能不止一个,另外,结合分组,你所得到的聚合数据也不止一行。例如:

qw.select("count(*) as total", "avg(salary) as avgSalary", "avg(commission) as avgCommission");
qw.lambda().between(EmployeePo::getSalary, 500, 3000)
           .groupBy(EmployeePo::getDepartmentId);
List<Map<String, Object>> maps = employeeDao.selectMaps(qw);

maps.forEach(map -> System.out.printf("%s %s %s\n",
                map.get("total"),
                map.get("avgSalary"),
                map.get("avgCommission"))
);

八、模糊查询

Mybatis Plus 的 QueryWrapper 有一套专门的 like 方法用于模糊查询。如下:

LambdaQueryWrapper<EmployeePo> qw = new LambdaQueryWrapper<>();
qw.select(EmployeePo::getId, EmployeePo::getName, EmployeePo::getSalary);
qw.like(EmployeePo::getName, "A");        // like "%A%"
//qw.likeRight(EmployeePo::getName, "A"); // like "%A%"
//qw.likeLeft(EmployeePo::getName, "A");  // like "%A"
employeeDao.selectMaps(qw);

关于条件构造器 Wrapper 的更多使用,见官网

文章来源:https://blog.csdn.net/m0_73393501/article/details/135192076
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。