Mybatis—Weekend、WeekendCriteria用法

Weekend是Mybatis-Plus中提供的一个查询封装工具，它主要用于复杂的条件查询和动态SQL查询。Weekend通常由两部分组成：Wrapper和WeekendCriteria。

Wrapper是条件包装器，可以添加多个条件，支持and和or关系，如：equal、not equal、greater than、less than、like、in等。

WeekendCriteria是条件构造器，它是对Wrapper的封装，可以将多个Wrapper进行整合，支持Exists、NotExists、In、NotIn、Between等，同时还支持分组查询、聚合查询等。

需要导入的依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.4.3</version>
</dependency>

假设我们有一个实体类User，其中包含id、name、age、gender等属性，现在要查询age大于20或者gender为1的记录。

创建LambdaQueryWrapper对象，设置查询条件：

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gt(User::getAge, 20)
                 .or()
                 .eq(User::getGender, 1);

这里的LambdaQueryWrapper用于封装查询条件，其中gt方法表示大于，or方法表示或，eq方法表示等于。

创建Weekend对象，指定查询的实体类：

Weekend<User> weekend = Weekend.of(User.class);

获取WeekendCriteria对象：

WeekendCriteria<User, Object> weekendCriteria = weekend.weekendCriteria();

将LambdaQueryWrapper对象的查询条件添加到WeekendCriteria对象中：

weekendCriteria.and(lambdaQueryWrapper);

执行查询操作：

List<User> userList = userMapper.selectByExample(weekend);

上述代码中，我们使用LambdaQueryWrapper对象设置查询条件，通过or方法表示条件之间的是或者关系，再将查询条件添加到WeekendCriteria对象中，最后执行selectByExample方法执行查询操作，获取符合条件的User对象的集合。

LambdaQueryWrapper是Mybatis-Plus中提供用于构建查询条件的Wrapper之一。该Wrapper基于Lambda表达式实现，使得查询条件不仅简洁易懂，还可以避免硬编码的问题。以下是LambdaQueryWrapper中的方法：

//eq：等于
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "张三");

//ne：不等于
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.ne(User::getName, "张三");

//gt：大于
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.gt(User::getAge, 18);

//ge：大于等于
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.ge(User::getAge, 18);

//lt：小于
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.lt(User::getAge, 18);

//le：小于等于
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.le(User::getAge, 18);

//like：模糊查询
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.like(User::getName, "张%");

//in：IN查询
List<Integer> ids = Arrays.asList(1, 2, 3);
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.in(User::getId, ids);

//notIn：NOT IN查询
List<Integer> ids = Arrays.asList(1, 2, 3);
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.notIn(User::getId, ids);

//isNull：NULL查询
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.isNull(User::getEmail);

//isNotNull：NOT NULL查询
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.isNotNull(User::getEmail);

//orderByAsc：升序排序
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.orderByAsc(User::getAge);

//orderByDesc：降序排序
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.orderByDesc(User::getAge);

可以根据需要动态组合这些方法，构建复杂的查询条件。

也可以用WeekendCriteria对象设置查询条件

// 创建 Weekend 对象，并指定需要进行条件构造的实体类 FunctionEntity
Weekend<FunctionEntity> weekend = Weekend.of(FunctionEntity.class);

// 获取 WeekendCriteria 对象，用于设置条件
WeekendCriteria<FunctionEntity, Object> weekendCriteria = weekend.weekendCriteria();

// 在 WeekendCriteria对象中设置查询条件，可以使用链式编程的方式
// 例如：.andLike(FunctionEntity::getName, "函数名称")
weekendCriteria.andXXX(...);
List<User> userList = userMapper.selectByExample(weekend);

WeekendCriteria中定义的查询方法如下：

//andEqualTo：设置等于条件。
weekendCriteria.andEqualTo(FunctionEntity::getName, "函数名称");

//andNotEqualTo：设置不等于条件。
weekendCriteria.andNotEqualTo(FunctionEntity::getName, "函数名称");

//andIsNotNull：设置字段非空条件。
weekendCriteria.andIsNotNull(FunctionEntity::getName);

//andIsNull：设置字段为空条件。
weekendCriteria.andIsNull(FunctionEntity::getName);

//andLike：设置like条件。
weekendCriteria.andLike(FunctionEntity::getName, "%函数名称%");

//andNotLike：设置not like条件。
weekendCriteria.andNotLike(FunctionEntity::getName, "%函数名称%");

//andIn：设置in条件。
List<String> names = Arrays.asList("函数名称1", "函数名称2");
weekendCriteria.andIn(FunctionEntity::getName, names);

//andNotIn：设置not in条件。
List<String> names = Arrays.asList("函数名称1", "函数名称2");
weekendCriteria.andNotIn(FunctionEntity::getName, names);

//andBetween：设置between条件。
weekendCriteria.andBetween(FunctionEntity::getCreateTime, startTime, endTime);

//andNotBetween：设置not between条件。
weekendCriteria.andNotBetween(FunctionEntity::getCreateTime, startTime, endTime);

//andGreaterThan：大于条件。
weekendCriteria.andGreaterThan(FunctionEntity::getCreateTime, "2021-06-20");

//andGreaterThanOrEqualTo：大于等于条件。
weekendCriteria.andGreaterThanOrEqualTo(FunctionEntity::getCreateTime, "2021-06-20");

//andLessThan：小于条件。
weekendCriteria.andLessThan(FunctionEntity::getCreateTime, "2021-06-20");

//andLessThanOrEqualTo：小于等于条件。
weekendCriteria.andLessThanOrEqualTo(FunctionEntity::getCreateTime, "2021-06-20");

//andEqualToWithFunc：支持自定义条件，例如SQL函数。
weekendCriteria.andEqualToWithFunc(entity -> "`function_code` = " + funcCode);

//andIsNullWithFunc：支持自定义条件，查询条件字段为 null。
weekendCriteria.andIsNullWithFunc(entity -> "`function_code`");

//andIsNotNullWithFunc：支持自定义条件，查询条件字段不为 null。
weekendCriteria.andIsNotNullWithFunc(entity -> "`function_code`");

//andLikeWithFunc：支持自定义条件，查询条件为 Like。
weekendCriteria.andLikeWithFunc(entity -> "`function_name` LIKE '" + keyword + "%'");

//andNotLikeWithFunc：支持自定义条件，查询条件为 not like。
weekendCriteria.andNotLikeWithFunc(entity -> "`function_name` NOT LIKE '%" + keyword + "%'");

//andInWithFunc：支持自定义条件，查询条件为 In。
weekendCriteria.andInWithFunc(entity -> "`id`", ids);

//andNotInWithFunc：支持自定义条件，查询条件为 Not in。
weekendCriteria.andNotInWithFunc(entity -> "`id`", ids);

//andBetweenWithFunc：支持自定义条件，查询条件为 Between。
weekendCriteria.andBetweenWithFunc(entity -> "`create_time`", startTime, endTime);

//andNotBetweenWithFunc：支持自定义条件，查询条件为 Not between。
weekendCriteria.andNotBetweenWithFunc(entity -> "`create_time`", startTime, endTime);

//andGreaterThanWithFunc：支持自定义条件，大于查询。
weekendCriteria.andGreaterThanWithFunc(entity -> "`create_time`", "2021-06-20");

//andGreaterThanOrEqualToWithFunc：支持自定义条件，大于等于查询。
weekendCriteria.andGreaterThanOrEqualToWithFunc(entity -> "`create_time`", "2021-06-20");

//andLessThanWithFunc：支持自定义条件，小于查询。
weekendCriteria.andLessThanWithFunc(entity -> "`create_time`", "2021-06-20");

//andLessThanOrEqualToWithFunc：支持自定义条件，小于等于查询。
weekendCriteria.andLessThanOrEqualToWithFunc(entity -> "`create_time`", "2021-06-20");

上述的查询方法都可以进行链式调用，以组合出更复杂的查询条件。