// 根据 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));
在 Dao/Mapper “点”出来的 select 方法中，你会发现有大量的要求你传入 Wrapper 对象的查询方法，这些方法就是用来实现复杂的条件查询功能的，而 Wrapper 对象就是所谓的条件构造器。
对于这些要求传入 Wrapper 对象的 select 方法，如果你故意在 Wrapper 参数位置传入一个 null ，那么就是『无条件查询所有』的功能。
# 写法一：常规写法（不推荐）
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 时，就忽略这个条件。例如，当 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 写法。
在 Mybatis Plus 中使用聚合函数，类似于上面的指定特定列，使用 QueryWrapper 在 select 方法中指定聚合函数。例如：
QueryWrapper<EmployeePo> lqw = new QueryWrapper<>();
lqw.select("count(*) as total"); // 你还能起别名
但是接下来的 2 点就和上面的指定特定列有所不动了：
.selectMaps() 方法；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 的更多使用，见官网