spring data jpa Specification构建

介绍：

        一款jpa的动态查询Specification构建思路，利用自定义注解在查询参数上设置查询规则，已实现表在一对一关联的查询，SpecBuilder与MySpec分离，可单独使用MySpec，MySpec中已实现排序规则。

数据表：

package com.ms.entity;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import java.io.Serializable;

/**
 * @author xiezc
 * @since 2022/3/31
 */
@Entity
@DynamicInsert
@DynamicUpdate
@EntityListeners(AuditingEntityListener.class)
@Table(name = "t_admin")
@Data
public class TAdmin implements Serializable {
    @Id
    @Basic
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Basic
    @Column(name = "username")
    private String username;

    @Basic
    @Column(name = "email")
    private String email;

    @Basic
    @Column(name = "mobile")
    private String mobile;
}

Specification构建类 ：

package com.ms.utils;

import org.apache.commons.lang.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import javax.persistence.criteria.*;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author xiezc
 * @since 2022/3/29
 */
public class MySpec<T> {
    private Specification<T> mSpec;
    private Map<String, Object> mParams = new HashMap<>();
    private List<SortParams> mSortList = new ArrayList<>();
    private List<QueryParams> mQueryList = new ArrayList<>();
    private Class<T> clazz = null;

    public MySpec() {
    }

    public MySpec(Class<T> clazz) {
        this.clazz = clazz;
    }

    public Class<T> getTClass() {
        if (this.clazz != null) {
            return this.clazz;
        }

        return (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public MySpec<T> build(Map<String, Object> params) {
        this.build(params, false);
        return this;
    }

    public MySpec<T> build(Map<String, Object> params, boolean isOr) {
        if (params == null) {
            params = new HashMap<>();
        }
        this.mParams = params;

        // 默认查询参数设置
        if (mParams.get("deleted") == null && !isOr) {
            mParams.put("deleted", 0);
        }

        mSortList = new ArrayList<>();
        mQueryList = new ArrayList<>();

        // 解析参数和比较关系
        for (Map.Entry<String, Object> entry : mParams.entrySet()) {
            String key = entry.getKey();
            Object val = entry.getValue();

//            MsLog.info("key = " + key);

            // 空值均不处理
            if (val == null) {
                continue;
            }
            if (val instanceof String) {
                String s = (String) val;
                if (s.isEmpty() || s.trim().isEmpty()) {
                    continue;
                }
            }

            String[] arr = key.split("_");
            int len = arr.length;
            if (len == 1) {
                mQueryList.add(new QueryParams(key, "EQ", entry.getValue()));
                continue;
            }

            if (len != 2) {
                continue;
            }

//            MsLog.info("arr = " + JSON.toJSONString(arr));

            // 排序列表
            if (isInteger(arr[1])) {
                SortParams param = new SortParams(arr[0], Integer.parseInt(arr[1]), (String) entry.getValue());
                int i = 0;
                boolean added = false;
                for (SortParams sp : mSortList) {
                    if (sp.getIndex() > param.getIndex()) {
                        mSortList.add(i, param);
                        added = true;
                        break;
                    }
                    i++;
                }
                if (!added) {
                    mSortList.add(param);
                }
                continue;
            }
//            MsLog.info("sort = " + JSON.toJSONString(mSortList));

            // 保存
            mQueryList.add(new QueryParams(arr[0], arr[1], entry.getValue()));
        }

        // 删除不必要的排序字段
        final Class<T> clazz = getTClass();
        final Field[] fds = clazz.getDeclaredFields();
        boolean hasSortField = false;
        boolean hasSortReq = false;
        for (SortParams sp : mSortList) {
            if (!hasSortReq) {
                if (sp.getName().equals("sort")) {
                    hasSortReq = true;
                }
            }

            boolean isValid = false;
            for (Field fd : fds) {
                // 判断是否有sort字段
                if (!hasSortField) {
                    if (fd.getName().equals("sort")) {
                        hasSortField = true;
                    }
                }

                // 字段比较
                if (fd.getName().equals(sp.getName())) {
                    isValid = true;
                    break;
                }
            }

            if (!isValid) {
                mSortList.remove(sp);
            }
        }

        // 设置默认排序
        if (hasSortField && !hasSortReq) {
            mSortList.add(0, new SortParams("