Mybatis-Plus 实现任意字段多条件查询

查询条件构造对象

条件构造对象

/**
 * 查询条件构造对象
 */
@Data
@Schema(description = "查询条件构造对象")
public class QueryCondition {
    @Schema(description = "精确匹配")
    private Map<String, String> eq;

    @Schema(description = "不等于")
    private Map<String, String> ne;

    @Schema(description = "大于")
    private Map<String, Object> gt;

    @Schema(description = "大于等于")
    private Map<String, Object> ge;

    @Schema(description = "小于")
    private Map<String, Object> lt;

    @Schema(description = "小于等于")
    private Map<String, Object> le;

    @Schema(description = "模糊匹配")
    private Map<String, String> like;

    @Schema(description = "非模糊匹配")
    private Map<String, String> notLike;

    @Schema(description = "在某个集合中")
    private Map<String, Collection<Object>> in;

    @Schema(description = "不在某个集合中")
    private Map<String, Collection<Object>> notIn;

    @Schema(description = "在某个范围内")
    private Map<String, Object[]> between;

    @Schema(description = "不在某个范围内")
    private Map<String, Object[]> notBetween;

    @Schema(description = "是否为空")
    private Map<String, Boolean> isNull;

    @Schema(description = "是否非空")
    private Map<String, Boolean> isNotNull;

    @Schema(description = "排序")
    private Map<String, String> orderBy;  
}

分页构造对象

/**
 * 分页查询条件构造对象
 */
@EqualsAndHashCode(callSuper = true)
@Data
@Schema(description = "分页查询条件构造对象")
public class PageQueryCondition extends QueryCondition {
    @Schema(description = "当前页码")
    private Integer page;

    @Schema(description = "每页记录数")
    private Integer pageSize;
}

条件解析工具类

public class DynamicQueryUtil {

    public static <T> QueryWrapper<T> buildQueryWrapper(QueryCondition queryCondition) {
        QueryWrapper<T> wrapper = new QueryWrapper<>();

        // 处理精确匹配
        if (queryCondition.getEq() != null) {
            queryCondition.getEq().forEach((field, value) -> wrapper.eq(value != null, field, value));
        }

        // 处理不等于
        if (queryCondition.getNe() != null) {
            queryCondition.getNe().forEach((field, value) -> wrapper.ne(value != null, field, value));
        }

        // 处理大于
        if (queryCondition.getGt() != null) {
            queryCondition.getGt().forEach((field, value) -> wrapper.gt(value != null, field, value));
        }

        // 处理大于等于
        if (queryCondition.getGe() != null) {
            queryCondition.getGe().forEach((field, value) -> wrapper.ge(value != null, field, value));
        }

        // 处理小于
        if (queryCondition.getLt() != null) {
            queryCondition.getLt().forEach((field, value) -> wrapper.lt(value != null, field, value));
        }

        // 处理小于等于
        if (queryCondition.getLe() != null) {
            queryCondition.getLe().forEach((field, value) -> wrapper.le(value != null, field, value));
        }

        // 处理模糊匹配
        if (queryCondition.getLike() != null) {
            queryCondition.getLike().forEach((field, value) -> wrapper.like(StringUtils.isNotBlank(value), field, value));
        }

        // 处理非模糊匹配
        if (queryCondition.getNotLike() != null) {
            queryCondition.getNotLike().forEach((field, value) -> wrapper.notLike(StringUtils.isNotBlank(value), field, value));
        }

        // 处理在某个集合中
        if (queryCondition.getIn() != null && !queryCondition.getIn().isEmpty()) {
            queryCondition.getIn().forEach((field, value) -> wrapper.in(value != null, field, value));
        }

        // 处理不在某个集合中
        if (queryCondition.getNotIn() != null && !queryCondition.getNotIn().isEmpty()) {
            queryCondition.getNotIn().forEach((field, value) -> wrapper.notIn(value != null, field, value));
        }

        // 处理在某个范围内
        if (queryCondition.getBetween() != null) {
            queryCondition.getBetween().forEach((field, values) -> {
                if (values != null && values.length == 2) {
                    wrapper.between(field, values[0], values[1]);
                }
            });
        }

        // 处理不在某个范围内
        if (queryCondition.getNotBetween() != null) {
            queryCondition.getNotBetween().forEach((field, values) -> {
                if (values != null && values.length == 2) {
                    wrapper.notBetween(field, values[0], values[1]);
                }
            });
        }

        // 处理是否为空
        if (queryCondition.getIsNull() != null) {
            queryCondition.getIsNull().forEach((field, value) -> wrapper.isNull(value, field));
        }

        // 处理是否非空
        if (queryCondition.getIsNotNull() != null) {
            queryCondition.getIsNotNull().forEach((field, value) -> wrapper.isNotNull(value, field));
        }

        // 处理排序
        if (queryCondition.getOrderBy() != null) {
            queryCondition.getOrderBy().forEach((field, order) -> {
                if ("asc".equalsIgnoreCase(order)) {
                    wrapper.orderByAsc(field);
                } else if ("desc".equalsIgnoreCase(order)) {
                    wrapper.orderByDesc(field);
                }
            });
        }

        return wrapper;
    }

}

在 Controller中使用

@Operation(summary = "获取权限列表", description = "根据查询条件获取权限列表")
@Parameter(name = "condition", description = "查询条件对象", required = true)
@PostMapping("/list")
public ResponseData<List<Permission>> getPermissions(@RequestBody @Parameter(description = "查询条件") QueryCondition condition) {
    QueryWrapper<Permission> wrapper = DynamicQueryUtil.buildQueryWrapper(condition);
    return ResponseData.ok(permissionService.list(wrapper));
}

@Operation(summary = "分页获取权限列表")
@PostMapping("/page")
public ResponseData<Page<Permission>> getUsersPage(@RequestBody @Parameter(description = "分页查询条件") PageQueryCondition condition) {
    QueryWrapper<Permission> wrapper = DynamicQueryUtil.buildQueryWrapper(condition);
    return ResponseData.ok(permissionService.page(new Page<>(condition.getPage(), condition.getPageSize()), wrapper));
}

前端调用