在使用MyBatis-Plus进行数据库查询时，构建查询条件是一项常见但重要的任务。本文将介绍如何通过优化代码来生成更高效和简洁的查询条件，以提高代码质量和开发效率。

背景

在许多Java应用程序中，我们使用MyBatis-Plus框架来处理数据库查询。通常，我们需要构建查询条件，并使用QueryWrapper对象来表示这些条件。下面是一种常见的方法，用于根据查询对象和其字段的注解来生成查询条件：

public QueryWrapper<T> queryWrapperHandler(Q q) {
    try {
        // 获取查询对象的类和字段
        Class<? extends EntityQuery> qClass = q.getClass();
        Field[] fields = qClass.getDeclaredFields();

        QueryWrapper<T> queryWrapper = new QueryWrapper<>();
        Map<String, Field[]> betweenFieldMap = new HashMap<>();

        // 处理@SelectColumn
        SelectColumn selectColumn = qClass.getAnnotation(SelectColumn.class);
        if (selectColumn != null && selectColumn.value() != null && selectColumn.value().length > 0) {
            // 转换字段名为下划线风格并设置为选择字段
            String[] strings = selectColumn.value();
            for (int i = 0; i < strings.length; i++) {
                strings[i] = StrUtil.toUnderlineCase(strings[i]);
            }
            queryWrapper.select(strings);
        }

        // 处理排序字段
        String sortColumn = "";
        String sortOrder = "";

        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(q);

            // 判断属性是否存在值
            if (Objects.isNull(value) || String.valueOf(value).equals("null") || value.equals("")) {
                continue;
            }

            // 处理@QuerySort注解
            QuerySort querySort = field.getDeclaredAnnotation(QuerySort.class);
            String paramValue = (String) field.get(q);
            sortColumn = paramValue.isEmpty() ? (querySort != null ? querySort.value() : "") : paramValue;

            // 处理@QueryOrder注解
            QueryOrder queryOrder = field.getDeclaredAnnotation(QueryOrder.class);
            paramValue = (String) field.get(q);
            sortOrder = paramValue.isEmpty() ? (queryOrder != null ? queryOrder.value() : "") : paramValue;

            // 处理@Query注解
            Query query = field.getDeclaredAnnotation(Query.class);
            if (query == null) {
                continue;
            }

            // 获取列名
            String columnName = StrUtil.isBlank(query.column()) ? StrUtil.toUnderlineCase(field.getName()) : query.column();

            // 根据注解生成查询条件
            switch (query.expression()) {
                case EQ:
                    queryWrapper.eq(columnName, value);
                    break;
                case NE:
                    queryWrapper.ne(columnName, value);
                    break;
                case LIKE:
                    queryWrapper.like(columnName, value);
                    break;
                case GT:
                    queryWrapper.gt(columnName, value);
                    break;
                case GE:
                    queryWrapper.ge(columnName, value);
                    break;
                case LT:
                    queryWrapper.lt(columnName, value);
                    break;
                case LE:
                    queryWrapper.le(columnName, value);
                    break;
                case IN:
                    queryWrapper.in(columnName, value);
                    break;
                case NOT_IN:
                    queryWrapper.notIn(columnName, value);
                    break;
                case IS_NULL:
                    queryWrapper.isNull(columnName);
                    break;
                case NOT_NULL:
                    queryWrapper.isNotNull(columnName);
                    break;
                case BETWEEN:
                    // 处理BETWEEN注解
                    if (betweenFieldMap.containsKey(columnName)) {
                        Field[] f = betweenFieldMap.get(columnName);
                        Field[] tempList = new Field[2];
                        tempList[0] = f[0];
                        tempList[1] = field;
                        betweenFieldMap.put(columnName, tempList);
                    } else {
                        betweenFieldMap.put(columnName, new Field[]{field});
                    }
                    break;
            }
        }

        // 处理BETWEEN注解
        Set<String> keySet = betweenFieldMap.keySet();
        for (String key : keySet) {
            Field[] itemFieldList = betweenFieldMap.get(key);
            if (itemFieldList.length != 2){
                throw new IllegalArgumentException("查询参数数量对应异常");
            }

            Field field1 = itemFieldList[0];
            Field field2 = itemFieldList[1];

            Query query1 = field1.getDeclaredAnnotation(Query.class);

            if (field1.get(q) instanceof Date) {
                // 处理日期类型
                if (query1.left()) {
                    queryWrapper.apply("date_format(" + key + ",'%y%m%d') >= date_format({0},'%y%m%d')", field1.get(q));
                    queryWrapper.apply("date_format(" + key + ",'%y%m%d') <= date_format({0},'%y%m%d')", field2.get(q));
                } else {
                    queryWrapper.apply("date_format(" + key + ",'%y%m%d') <= date_format({0},'%y%m%d')", field1.get(q));
                    queryWrapper.apply("date_format(" + key + ",'%y%m%d') >= date_format({0},'%y%m%d')", field2.get(q));
                }
            } else {
                // 处理非日期类型
                if (query1.left()) {
                    queryWrapper.between(key, field1.get(q), field2.get(q));
                } else {
                    queryWrapper.between(key, field2.get(q), field1.get(q));
                }
            }
        }

        // 处理排序字段
        if (sortOrder.equalsIgnoreCase("desc")) {
            queryWrapper.orderByDesc(StrUtil.isNotBlank(sortColumn), StrUtil.toUnderlineCase(sortColumn));
        } else {
            queryWrapper.orderByAsc(StrUtil.isNotBlank(sortColumn), StrUtil.toUnderlineCase(sortColumn));
        }

        return queryWrapper;
    } catch (Exception e) {
        e.printStackTrace();
        throw a RuntimeException(e.getMessage());
    }
}

结论

通过对MyBatis-Plus查询条件生成方法的优化，我们可以生成更高效、可维护和易读的代码。这有助于提高开发效率，并减少潜在的bug。