JAVA通用單表AND查詢操作

JAVA通用單表AND查詢操作,先記錄下來,以後有時間完善。

1、註解


@Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Condition {

    /**
     * 默認爲 等於
     *
     * @return 等於
     */
    ConditionEnum conditionEnum() default ConditionEnum.Equals;

    /**
     * 數據類型 默認 字符串
     *
     * @return 字符串
     */
    DataTypeEnum dataTypeEnum() default DataTypeEnum.STRING;

    /**
     * DO的屬性名,默認和屬性值一致
     *
     * @return DO的屬性名
     */
    String fieldName() default "";

    /**
     * 格式
     *
     * @return 格式
     */
    String format() default "";
}

 

2、基本查詢的通用AND查詢類


@Slf4j
public class BaseForQuery<T> extends BaseMapper<T> {

    /**
     * DESC
     */
    private final static String DESC = "desc";

    /**
     * 獲取沒有特殊操作的查詢條件
     *
     * @param queryParams 查詢的參數
     * @param entityObj   實體對象
     * @return 返回查詢的對象
     */
    protected static <K extends BaseQuery, V> Example getExample(final K queryParams, final Class<V> entityObj) {
        final Example example = new Example(entityObj, false);
        if (queryParams == null) {
            return example;
        }
        // 數據庫對象的字段
        final Map<String, Annotation[]> hashMapDb = FieldUtil.getFieldsAnnotations(entityObj);
        if (hashMapDb == null || CollectionUtils.isEmpty(hashMapDb.entrySet())) {
            return example;
        }
        // 排序
        if (!StringUtils.isEmpty(queryParams.getSort())) {
            if (DESC.equalsIgnoreCase(queryParams.getDirection())) {
                example.orderBy(queryParams.getSort()).desc();
            } else {
                example.orderBy(queryParams.getSort()).asc();
            }
        }
        // 條件
        BaseForQuery.getCondition(example, queryParams, hashMapDb);
        return example;
    }

    /**
     * 設置 條件
     *
     * @param example     條件
     * @param queryParams 請求參數
     * @param hashMapDb   數據庫
     */
    private static <K extends BaseQuery> void getCondition(final Example example, final K queryParams,
                                                           final Map<String, Annotation[]> hashMapDb) {
        final Example.Criteria criteria = example.createCriteria();
        BaseForQuery.getCondition(criteria, queryParams, hashMapDb);
    }

    /**
     * 獲取條件
     *
     * @param criteria  查詢條件
     * @param hashMapDb 數據庫字段
     */
    private static <K> void getCondition(final Example.Criteria criteria, final K queryParams
            , final Map<String, Annotation[]> hashMapDb) {
        final Field[] fields = queryParams.getClass().getDeclaredFields();
        if (Object.class.equals(queryParams) || Object.class.equals(queryParams.getClass())) {
            return;
        }
        Object superInstance = null;
        try {
            superInstance = queryParams.getClass().getSuperclass().newInstance();
        } catch (final InstantiationException e) {
            log.error("{}", e);
        } catch (final IllegalAccessException e) {
            log.error("{}", e);
        }
        BeanUtils.copyProperties(queryParams, superInstance);
        if (fields == null || fields.length == 0) {
            // 遞歸調用
            BaseForQuery.getCondition(criteria, superInstance, hashMapDb);
            return;
        }
        for (final Field field : fields) {
            // 獲取字段對應的值
            Object value;
            try {
                field.setAccessible(true);
                value = field.get(queryParams);
            } catch (final IllegalAccessException e) {
                continue;
            }
            if (StringUtils.isEmpty(value)) {
                continue;
            }
            final Condition condition = field.getAnnotation(Condition.class);
            if (condition == null) {
                continue;
            }
            // 用數據庫生成的字段名稱,避免異常
            String fieldName = condition.fieldName();
            if (StringUtils.isEmpty(fieldName)) {
                fieldName = field.getName();
            }
            final String finalFieldName = fieldName;
            final Optional<String> optionalField = hashMapDb.keySet().stream()
                    .filter(n -> n.equalsIgnoreCase(finalFieldName)).findAny();
            if (!optionalField.isPresent()) {
                continue;
            }
            if (!StringUtils.isEmpty(condition.format()) && condition.dataTypeEnum().getKey() == Date.class) {
                value = Date.from(LocalDateTime.parse(value.toString(), DateTimeFormatter
                        .ofPattern(condition.format())).atZone(ZoneId.systemDefault()).toInstant());
            }
            switch (condition.conditionEnum().getKey()) {
                case "Equals":
                    criteria.andEqualTo(fieldName, value);
                    break;
                case "Like":
                    criteria.andLike(fieldName, String.format("%s%", value));
                    break;
                case "GreaterThan":
                    criteria.andGreaterThan(fieldName, value);
                    break;
                case "GreaterThanOrEqualTo":
                    criteria.andGreaterThanOrEqualTo(fieldName, value);
                    break;
                case "LessThan":
                    criteria.andLessThan(fieldName, value);
                    break;
                case "LessThanOrEqualTo":
                    criteria.andLessThanOrEqualTo(fieldName, value);
                    break;
                case "IsNotNull":
                    criteria.andIsNotNull(fieldName);
                    break;
                case "IsNull":
                    criteria.andIsNull(fieldName);
                    break;
                default:
                    break;
            }
        }
        // 遞歸調用
        BaseForQuery.getCondition(criteria, superInstance, hashMapDb);
    }

    /**
     * 排序
     *
     * @param queryParams 請求參數
     * @param example     查詢條件
     * @param hashMapDb   數據庫的字段
     * @param <K>         泛型
     */
    private static <K extends BaseQuery> void setOrderBy(final K queryParams, final Example example, final Map<String, Annotation[]> hashMapDb) {
        if (!StringUtils.isEmpty(queryParams.getSort())) {
            String sort = queryParams.getSort();
            final Optional<String> optionalField = hashMapDb.keySet().stream().filter(n ->
                    n.equalsIgnoreCase(queryParams.getSort())).findAny();
            if (optionalField.isPresent()) {
                // 獲取屬性對應的字段
                sort = optionalField.get();
                final Optional<Annotation> annotation = Arrays.stream(hashMapDb
                        .get(sort)).filter(n -> n instanceof Column).findAny();
                if (annotation.isPresent()) {
                    final Column column = (Column) annotation.get();
                    sort = column.name();
                }
            }
            if (StringUtils.isEmpty(queryParams.getDirection())) {
                example.setOrderByClause(sort);
            } else {
                example.setOrderByClause(sort.concat(" ").concat(queryParams.getDirection()));
            }
        }
    }

    /**
     * 獲取總行數和查詢的條件
     *
     * @param queryParams 查詢的請求參數
     * @param entityObj   實體對象
     * @param <K>         查詢的請求參數 泛型對象
     * @param <V>         實體對象 泛型對象
     * @return 返回總的行數
     */
    protected <K extends BaseQuery, V> ResultInfo<List<T>, BaseSummary> getPagerData(final K queryParams, final Class<V> entityObj) {
        final Example example = BaseForQuery.getExample(queryParams, entityObj);
        return this.getPagerData(queryParams, example);
    }

    /**
     * 獲取總行數和查詢的條件
     *
     * @param queryParams 查詢的請求參數
     * @param example     查詢條件Example
     * @param <K>         查詢的請求參數 泛型對象
     * @return 返回總的行數
     */
    protected <K extends BaseQuery> ResultInfo<List<T>, BaseSummary> getPagerData(final K queryParams, final Example example) {
        final ResultInfo resultInfo = new ResultInfo();
        final int count = this.mapper.selectCountByExample(example);
        final BaseSummary baseSummary = new BaseSummary();
        baseSummary.setTotalRows(count);
        // 總條數
        resultInfo.setSummary(baseSummary);
        List<T> list = new ArrayList<>();
        if (baseSummary.getTotalRows() != 0) {
            // 明細數據
            final int pageNo = queryParams.getPageNo();
            final int pageSize = queryParams.getPageSize();
            final int offset = (pageNo - 1) * pageSize;
            final RowBounds rowBounds = new RowBounds(offset, pageSize);
            // 查詢數據
            list = super.mapper.selectByExampleAndRowBounds(example, rowBounds);
        }
        resultInfo.setDetail(list);

        return resultInfo;
    }

    /**
     * 返回分頁之後的數據
     *
     * @param k   帶有分頁的信息
     * @param lst 列表
     * @param <K> 泛型
     * @return 返回分頁之後的數據
     */
    protected static <K extends BaseQuery, V> List<V> getLists(final K k, final List<V> lst) {
        final int beginIndex = (k.getPageNo() - 1) * k.getPageSize();
        int endIndex = k.getPageNo() * k.getPageSize();
        if (lst.size() < endIndex) {
            endIndex = lst.size();
        }
        return lst.subList(beginIndex, endIndex);
    }

    /**
     * 排序
     *
     * @param forQuery 查詢條件
     * @param example  example
     */
    protected <T extends BaseQuery> void setExampleOrderBy(final T forQuery, final Example example) {
        if (!StringUtils.isEmpty(forQuery.getSort())) {
            if (!StringUtils.isEmpty(forQuery.getDirection()) && DESC.equalsIgnoreCase(forQuery.getDirection())) {
                example.orderBy(forQuery.getSort()).desc();
            } else {
                example.orderBy(forQuery.getSort()).asc();
            }
        }
    }
}

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章