Mybatis-plug 实体查询类封装

小灬疯

已于 2022-04-25 11:52:49 修改

阅读量729

点赞数

文章标签： java

于 2022-04-25 11:50:18 首次发布

本文链接：https://blog.youkuaiyun.com/u011748936/article/details/124401588

版权

该博客介绍了一种通过定义注解和反射机制来构建查询条件的方法，从而避免大量手动编写查询条件。SearchHelper类帮助根据实体类和QueryBaseSO对象自动生成QueryWrapper，忽略Ignore注解的字段，并根据Column、Like、Equal等注解处理不同类型的查询操作，如模糊匹配、等于或不等于等。此外，还支持自定义扩展和排序功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给大家分享一个通过实体不用写太多的查询条件去实现数据查询。

方法：定义注解类，通过获取注解的字段类型去赋值查询，如果有些未用处理到字段用 Igorn 排除即可，后续可以自已在增加拓展


import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.BiConsumer;

public class SearchHelper {

    private SearchHelper() {
        throw new IllegalStateException("Utility class");
    }

    public static QueryWrapper build(Class<?> entityClass, QueryBaseSO so) {

        QueryWrapper<?> queryWrapper = new QueryWrapper<>();

        Arrays.stream(so.getClass().getDeclaredFields()).forEach(field -> {
            if (!field.isAnnotationPresent(Ignore.class)) {
                ReflectionUtils.makeAccessible(field);
                Optional.ofNullable(ReflectionUtils.getField(field, so))
                        .ifPresent(value -> andSqls(entityClass, queryWrapper, field, value));
            }
        });

        so.structureQueryOrderBy(queryWrapper, entityClass, so.getSidx());
        return queryWrapper;

    }

    public static <T> QueryWrapper build(Class<T> entityClass, QueryBaseSO so, BiConsumer<QueryWrapper<T>, LambdaQueryWrapper<T>> fn) {
        QueryWrapper<T> queryWrapper = new QueryWrapper<>();
        LambdaQueryWrapper<T> query = queryWrapper.lambda();

        Arrays.stream(so.getClass().getDeclaredFields()).forEach(field -> {
            if (!field.isAnnotationPresent(Ignore.class)) {
                ReflectionUtils.makeAccessible(field);
                Optional.ofNullable(ReflectionUtils.getField(field, so))
                        .ifPresent(value -> andSqls(entityClass, queryWrapper, field, value));
            }
        });
        fn.accept(queryWrapper, query);

        so.structureQueryOrderBy(queryWrapper, entityClass, so.getSidx());
        return queryWrapper;
    }

    private static void andSqls(Class<?> entityClass, QueryWrapper<?> sqls, Field field, Object value) {
        Optional<Field> eField = Optional.ofNullable(ReflectionUtils.findField(entityClass, field.getName()));
        if (eField.isPresent() && eField.get().isAnnotationPresent(Column.class)) {
            // TK 框架只需要获取实体属性名 eField.get().getAnnotation(Column.class).name()
            String columnName = eField.get().getName();
            if (field.isAnnotationPresent(Like.class)) {
                andLike(sqls, field, value, columnName);
            } else if (field.isAnnotationPresent(Equal.class)) {
                andEqual(sqls, field, value, columnName);
            } else if (value instanceof String) {
                sqls.like(columnName , "%" + value + "%");
            } else if (value instanceof List) {
                sqls.in(columnName ,value);
            } else {
                sqls.eq(columnName, value);
            }

        }
    }

    private static void andLike(QueryWrapper<?> sqls, Field field, Object value, String columnName) {
        Like like = field.getAnnotation(Like.class);
        String left = like.left() ? "%" : "";
        String right = like.right() ? "%" : "";
        if (like.value()) {
            sqls.like(columnName, left + value + right);
        } else {
            sqls.notLike(columnName, left + value + right);
        }
    }

    private static void andEqual(QueryWrapper<?> sqls, Field field, Object value, String columnName) {
        Equal equal = field.getAnnotation(Equal.class);
        if (equal.value()) {
            sqls.eq(columnName, value);
        } else {
            sqls.ne(columnName, value);
        }
    }

}