自定義註解,實現jpa查詢，使用起來很方便，記錄一下

自定義註解: @Query

/**
 * @author Lee
 * @description
 * @date 2019/12/25 11:36
 **/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Query {
    String propName() default "";
    
    Type type() default Type.EQUAL;

    /**
     * 連接查詢的屬性名，如User類中的dept
     */
    String joinName() default "";

    /**
     * 默認左連接
     */
    Join join() default Join.LEFT;

    /**
     * 多字段模糊搜索，僅支持String類型字段，多個用逗號隔開, 如@Query(blurry = "email,username")
     */
    String blurry() default "";

    enum Type {
        //等於
        EQUAL
        //大於
        , GREATER_THAN
        //小於
        , LESS_THAN
        //模糊查詢
        , INNER_LIKE
        //左模糊查詢
        , LEFT_LIKE
        //  右模糊查詢
        , RIGHT_LIKE
        // 小於
        , LESS_THAN_NQ
        // 包含
        , IN
        // 不等於
        ,NOT_EQUAL
        // between
        ,BETWEEN
        // 不爲空
        ,NOT_NULL
    }

    /**
     * @author lee
     * 適用於簡單連接查詢，複雜的請自定義該註解，或者使用sql查詢
     */
    enum Join {
        /** 左右連接 */
        LEFT, RIGHT,INNER
    }

}

定義註解處理工具

/**
 * @author Lee
 * @date 2019-12-15 14:59:48
 */
@Slf4j
@SuppressWarnings({"unchecked","all"})
public class QueryHelp {

    public static <R, Q> Predicate getPredicate(Root<R> root, Q query, CriteriaBuilder cb) {
        List<Predicate> list = new ArrayList<>();

        if(query == null){
            return cb.and(list.toArray(new Predicate[0]));
        }
        try {
            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
            for (Field field : fields) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                Query q = field.getAnnotation(Query.class);
                if (q != null) {
                    String propName = q.propName();
                    String joinName = q.joinName();
                    String blurry = q.blurry();
                    String attributeName = isBlank(propName) ? field.getName() : propName;
                    Class<?> fieldType = field.getType();
                    Object val = field.get(query);
                    if (ObjectUtil.isNull(val) || "".equals(val) || "null".equals(val) || "undefined".equals(val) ) {
                        continue;
                    }
                    Join join = null;
                    // 模糊多字段
                    if (ObjectUtil.isNotEmpty(blurry)) {
                        String[] blurrys = blurry.split(",");
                        List<Predicate> orPredicate = new ArrayList<>();
                        for (String s : blurrys) {
                            orPredicate.add(cb.like(root.get(s)
                                    .as(String.class), "%" + val.toString() + "%"));
                        }
                        Predicate[] p = new Predicate[orPredicate.size()];
                        list.add(cb.or(orPredicate.toArray(p)));
                        continue;
                    }
                    if (ObjectUtil.isNotEmpty(joinName)) {
                        String[] joinNames = joinName.split(">");
                        for (String name : joinNames) {
                            switch (q.join()) {
                                case LEFT:
                                    if(ObjectUtil.isNotNull(join)){
                                        join = join.join(name, JoinType.LEFT);
                                    } else {
                                        join = root.join(name, JoinType.LEFT);
                                    }
                                    break;
                                case RIGHT:
                                    if(ObjectUtil.isNotNull(join)){
                                        join = join.join(name, JoinType.RIGHT);
                                    } else {
                                        join = root.join(name, JoinType.RIGHT);
                                    }
                                    break;
                                case INNER:
                                    if(ObjectUtil.isNotNull(join)){
                                        join = join.join(name, JoinType.INNER);
                                    } else {
                                        join = root.join(name, JoinType.INNER);
                                    }
                                    break;
                                default: break;
                            }
                        }
                    }
                    switch (q.type()) {
                        case EQUAL:
                            list.add(cb.equal(getExpression(attributeName,join,root)
                                    .as((Class<? extends Comparable>) fieldType),val));
                            break;
                        case GREATER_THAN:
                            list.add(cb.greaterThanOrEqualTo(getExpression(attributeName,join,root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case LESS_THAN:
                            list.add(cb.lessThanOrEqualTo(getExpression(attributeName,join,root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case LESS_THAN_NQ:
                            list.add(cb.lessThan(getExpression(attributeName,join,root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case INNER_LIKE:
                            list.add(cb.like(getExpression(attributeName,join,root)
                                    .as(String.class), "%" + val.toString() + "%"));
                            break;
                        case LEFT_LIKE:
                            list.add(cb.like(getExpression(attributeName,join,root)
                                    .as(String.class), "%" + val.toString()));
                            break;
                        case RIGHT_LIKE:
                            list.add(cb.like(getExpression(attributeName,join,root)
                                    .as(String.class), val.toString() + "%"));
                            break;
                        case IN:
                            if (CollUtil.isNotEmpty((Collection<Long>)val)) {
                                list.add(getExpression(attributeName,join,root).in((Collection<Long>) val));
                            }
                            break;
                        case NOT_EQUAL:
                            list.add(cb.notEqual(getExpression(attributeName,join,root), val));
                            break;
                        case NOT_NULL:
                            list.add(cb.isNotNull(getExpression(attributeName,join,root)));
                            break;
                        case BETWEEN:
                            List<Object> between = new ArrayList<>((List<Object>)val);
                            list.add(cb.between(getExpression(attributeName, join, root).as((Class<? extends Comparable>) between.get(0).getClass()),
                                    (Comparable) between.get(0), (Comparable) between.get(1)));
                            break;
                        default: break;
                    }
                }
                field.setAccessible(accessible);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        int size = list.size();
        return cb.and(list.toArray(new Predicate[size]));
    }

    @SuppressWarnings("unchecked")
    private static <T, R> Expression<T> getExpression(String attributeName, Join join, Root<R> root) {
        if (ObjectUtil.isNotEmpty(join)) {
            return join.get(attributeName);
        } else {
            return root.get(attributeName);
        }
    }

    private static boolean isBlank(final CharSequence cs) {
        int strLen;
        if (cs == null || (strLen = cs.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(cs.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    private static List<Field> getAllFields(Class clazz, List<Field> fields) {
        if (clazz != null) {
            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
            getAllFields(clazz.getSuperclass(), fields);
        }
        return fields;
    }
}

使用說明:

@Query 註解實現簡單的查詢與複雜查詢

簡單查詢：等於(默認)、大於等於、小於等於、左模糊、右模糊、中模糊、多字段模糊、NOT_EQUAL 、BETWEEN 、NOT_NULL。

複雜查詢：包含（IN）查詢、左連接、右連接

參數說明

字段名稱	字段描述	默認值
propName	對象的屬性名，如果字段名稱與實體字段一致，則可以省略	“”
type	查詢方式，默認爲	EQUAL
blurry	多字段模糊查詢，值爲實體字段名稱	“”
joinName	關聯實體的名稱	“”
join	連接查詢方式，左連接或者右連接	LEFT

使用方式

1. 創建一個查詢類 QueryCriteria

@Data
public class QueryCriteria {

    // 等於
    @Query
    private String a;

    // 左模糊
    @Query(type = Query.Type.LEFT_LIKE)
    private String b;

    // 右模糊
    @Query(type = Query.Type.RIGHT_LIKE)
    private String c;

    // 大於等於
    @Query(type = Query.Type.GREATER_THAN, propName = "createTime")
    private Timestamp startTime;

    // 小於等於
    @Query(type = Query.Type.LESS_THAN, propName = "createTime")
    private Timestamp endTime;

    // BETWEEN
    @Query(type = Query.Type.BETWEEN)
    private List<Timestamp> startTime;

    // 多字段模糊查詢，blurry 爲字段名稱
    @Query(blurry = "a,b,c")
    private String blurry;

    // IN 查詢
    @Query(type = Query.Type.IN)
    private List<String> d;

    // 左關聯查詢，left Join ， joinName爲關聯實體名稱
    @Query(joinName = "")
    private String e;

    // 右關聯查詢，right Join ， joinName爲關聯實體名稱
    @Query(joinName = "", join = Query.Join.RIGHT)
    private String f;

    // NOT_EQUAL 不等於
    @Query(type = Query.Type.NOT_EQUAL)
    private String g;

    // NOT_NULL 不爲空
    @Query(type = Query.Type.NOT_NULL)
    private String g;
}

2. 在控制器中使用

// Pageable 分頁查詢
public ResponseEntity query(QueryCriteria criteria, Pageable pageable){
    return new ResponseEntity(service.queryAll(criteria,pageable), HttpStatus.OK);
}

3. Service 中查詢

@Override
public Object queryAll(QueryCriteria criteria, Pageable pageable){
    Page<實體> page = repository.findAll(((root, criteriaQuery, cb) -> QueryHelp.getPredicate(root, criteria, cb)),pageable);
    return page;
}

使用例子

使用註解編寫請求類

@Data
@ApiModel("油費記錄查詢dto")
public class QueryOilReqDto implements Serializable {

    @ApiModelProperty("車牌號")
    @Query(type = Query.Type.INNER_LIKE)
    private String brandNumber;

    @Query(type = Query.Type.BETWEEN)
    private List<Timestamp> createTime;

}

查詢方法:

 public Map queryOilCost(QueryOilReqDto reqDto, Pageable pageable) {
        final Page<CarCost> all = carCostRepository.findAll((root, criteriaQuery, criteriaBuilder)
                -> QueryHelp.getPredicate(root, reqDto, criteriaBuilder), pageable);
        Page<OilRespDto> map = all.map(oilRespDtoMapper::toDto);
        return PageUtil.toPage(map);
    }