spring data jpa Specification构建

最新推荐文章于 2024-04-03 10:13:54 发布
最新推荐文章于 2024-04-03 10:13:54 发布
阅读量509 收藏 1
点赞数
分类专栏： java 文章标签： spring hibernate java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59306128/article/details/124829424
版权

介绍：

        一款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("sort", -1, "DESC"));
        }

//        MsLog.info("query: " + JSON.toJSONString(mQueryList));
//        MsLog.info("sort: " + JSON.toJSONString(mSortList));

        // 解析查询规则
        this.mSpec = new Specification<T>() {
            private final List<QueryParams> mSearchList = mQueryList;

            @Override
            public Predicate toPredicate(Root<T> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                // 应用查询规则
                List<Predicate> ps = new ArrayList<>();

                // 逐个处理查询参数
                for (QueryParams qp : mSearchList) {
                    String key = qp.getName();

                    for (Field fd : fds) {
                        if (!fd.getName().equals(key) && !key.contains(".")) {
                            continue;
                        }

                        String exp = qp.getExp();
                        Object val = qp.getVal();

                        // 等于
                        if (exp.equalsIgnoreCase("EQ")) {
                            ps.add(criteriaBuilder.equal(getPath(root, key), val));
                            break;
                        }

                        // 不等于
                        if (exp.equalsIgnoreCase("NEQ")) {
                            ps.add(criteriaBuilder.notEqual(getPath(root, key), val));
                            break;
                        }

                        // 模糊匹配字符串，相似则命中
                        if (exp.equalsIgnoreCase("LIKE")) {
                            ps.add(criteriaBuilder.like((Expression<String>) getPath(root, key), "%" + val + "%"));
                            break;
                        }

                        // 模糊匹配字符串，不相似则命中
                        if (exp.equalsIgnoreCase("NLIKE")) {
                            ps.add(criteriaBuilder.notLike((Expression<String>) getPath(root, key), "%" + val + "%"));
                            break;
                        }

                        // 向左模糊匹配字符串，相似则命中
                        if (exp.equalsIgnoreCase("LLIKE")) {
                            ps.add(criteriaBuilder.like((Expression<String>) getPath(root, key), val + "%"));
                            break;
                        }

                        // 向左模糊匹配字符串，不相似则命中
                        if (exp.equalsIgnoreCase("NLLIKE")) {
                            ps.add(criteriaBuilder.notLike((Expression<String>) getPath(root, key), val + "%"));
                            break;
                        }

                        // 向右模糊匹配字符串，相似则命中
                        if (exp.equalsIgnoreCase("RLIKE")) {
                            ps.add(criteriaBuilder.like((Expression<String>) getPath(root, key), "%" + val));
                            break;
                        }

                        // 向右模糊匹配字符串，不相似则命中
                        if (exp.equalsIgnoreCase("NRLIKE")) {
                            ps.add(criteriaBuilder.notLike((Expression<String>) getPath(root, key), "%" + val));
                            break;
                        }

                        // 小于
                        if (exp.equalsIgnoreCase("LT")) {
                            ps.add(criteriaBuilder.lessThan((Expression<Comparable>) getPath(root, key), (Comparable) val));
                            break;
                        }

                        // 小于等于
                        if (exp.equalsIgnoreCase("ELT")) {
                            ps.add(criteriaBuilder.lessThanOrEqualTo((Expression<Comparable>) getPath(root, key), (Comparable) val));
                            break;
                        }

                        // 大于
                        if (exp.equalsIgnoreCase("GT")) {
                            ps.add(criteriaBuilder.greaterThan((Expression<Comparable>) getPath(root, key), (Comparable) val));
                            break;
                        }

                        // 大于等于
                        if (exp.equalsIgnoreCase("EGT")) {
                            ps.add(criteriaBuilder.greaterThanOrEqualTo((Expression<Comparable>) getPath(root, key), (Comparable) val));
                            break;
                        }

                        // 日期相等
                        if (exp.equalsIgnoreCase("DATEEQ")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    Expression<Date> dateFunc = criteriaBuilder.function("FORMAT", Date.class, getPath(root, key), criteriaBuilder.literal("yyyy-MM-dd"));
                                    ps.add(criteriaBuilder.equal(dateFunc, dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期大于
                        if (exp.equalsIgnoreCase("DATEGT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    Expression<Date> dateFunc = criteriaBuilder.function("FORMAT", Date.class, getPath(root, key), criteriaBuilder.literal("yyyy-MM-dd"));
                                    ps.add(criteriaBuilder.greaterThan(dateFunc, dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期大于等于
                        if (exp.equalsIgnoreCase("DATEEGT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    Expression<Date> dateFunc = criteriaBuilder.function("FORMAT", Date.class, getPath(root, key), criteriaBuilder.literal("yyyy-MM-dd"));
                                    ps.add(criteriaBuilder.greaterThanOrEqualTo(dateFunc, dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期小于
                        if (exp.equalsIgnoreCase("DATELT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    Expression<Date> dateFunc = criteriaBuilder.function("FORMAT", Date.class, getPath(root, key), criteriaBuilder.literal("yyyy-MM-dd"));
                                    ps.add(criteriaBuilder.lessThan(dateFunc, dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期小于等于
                        if (exp.equalsIgnoreCase("DATEELT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    Expression<Date> dateFunc = criteriaBuilder.function("FORMAT", Date.class, getPath(root, key), criteriaBuilder.literal("yyyy-MM-dd"));
                                    ps.add(criteriaBuilder.lessThanOrEqualTo(dateFunc, dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期时间相等
                        if (exp.equalsIgnoreCase("DATETIMEEQ")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    ps.add(criteriaBuilder.equal((Expression<Comparable>) getPath(root, key), (Comparable) dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期时间大于
                        if (exp.equalsIgnoreCase("DATETIMEGT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    ps.add(criteriaBuilder.greaterThan((Expression<Comparable>) getPath(root, key), (Comparable) dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期时间大于等于
                        if (exp.equalsIgnoreCase("DATETIMEEGT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    ps.add(criteriaBuilder.greaterThanOrEqualTo((Expression<Comparable>) getPath(root, key), (Comparable) dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期时间小于
                        if (exp.equalsIgnoreCase("DATETIMELT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    ps.add(criteriaBuilder.lessThan((Expression<Comparable>) getPath(root, key), (Comparable) dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }

                        // 日期时间小于等于
                        if (exp.equalsIgnoreCase("DATETIMEELT")) {
                            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            try {
                                Date dt = fmt.parse((String) val);
                                if (dt != null) {
//                                    Expression<Date> dateFunc = criteriaBuilder.function("DATE", Date.class, getPath(root, key));
                                    ps.add(criteriaBuilder.lessThanOrEqualTo((Expression<Comparable>) getPath(root, key), (Comparable) dt));
                                }
                            } catch (Exception e) {
                                MsLog.error(e);
                            }
                            break;
                        }


                        // find_in_set
                        if (exp.equalsIgnoreCase("INSET")) {
                            Expression<Integer> findInSetFunc = criteriaBuilder.function("FIND_IN_SET", Integer.class, criteriaBuilder.literal(val), getPath(root, key));
                            ps.add(criteriaBuilder.greaterThan(findInSetFunc, 0));
                            break;
                        }

                        // 在给定集合中
                        if (exp.equalsIgnoreCase("IN")) {
                            Collection c = (Collection) val;
                            if (c.size() > 0) {
                                ps.add(getPath(root, key).in((Collection) val));
                            }
                            break;
                        }

                        // 不在给定集合中
                        if (exp.equalsIgnoreCase("NOTIN")) {
                            Collection c = (Collection) val;
                            if (c.size() > 0) {
                                ps.add(criteriaBuilder.not(getPath(root, key).in((Collection) val)));
                            }
                            break;
                        }

                        // 空值判断
                        if (exp.equalsIgnoreCase("EMPTY")) {
                            String type = (String) val;
                            if (type.equalsIgnoreCase("NULL")) {
                                ps.add(criteriaBuilder.isNull(getPath(root, key)));
                            } else if (type.equalsIgnoreCase("NOTNULL")) {
                                ps.add(criteriaBuilder.isNotNull(getPath(root, key)));
                            }
                            break;
                        }

                        break;
                    }
                }

                if (ps.size() == 0) {
                    return null;
                }

                Predicate[] pre = new Predicate[ps.size()];
                if (isOr) {
                    criteriaQuery.where(criteriaBuilder.or(ps.toArray(pre)));
                } else {
                    criteriaQuery.where(criteriaBuilder.and(ps.toArray(pre)));
                }
                return criteriaQuery.getRestriction();
            }
        };

        return this;
    }

    private Path<?> getPath(Root<T> root, String key) {
        if (!key.contains(".")) {
            return root.get(key);
        }

        String[] arr = key.split("\\.");
        Path<?> ret = root.get(arr[0]);
        for (int i = 1; i < arr.length; i++) {
            ret = ret.get(arr[i]);
        }
        return ret;
    }

    public long count(JpaSpecificationExecutor<T> dao, Map<String, Object> params) {
        this.build(params);
        return dao.count(mSpec);
    }

    public Specification<T> getSpecification() {
        return this.mSpec;
    }

    public Pageable getPageable() {
        return PageRequest.of(this.getPageNum(), this.getPageSize());
    }

    public Pageable getSortPageable() {
        return PageRequest.of(this.getPageNum(), this.getPageSize(), this.getSort());
    }

    public Sort getSort() {
        List<Sort.Order> ls = new ArrayList<>();
        for (SortParams sp : mSortList) {
            String key = sp.getName();
            String ord = sp.getDirection();
            if (ord.toUpperCase().equals("DESC")) {
                ls.add(new Sort.Order(Sort.Direction.DESC, key));
            } else {
                ls.add(new Sort.Order(Sort.Direction.ASC, key));
            }
        }

        return Sort.by(ls);
    }

    public List<T> findAll(JpaSpecificationExecutor<T> dao, Map<String, Object> params) {
        this.build(params);
        return dao.findAll(mSpec);
    }

    public Page<T> findPage(JpaSpecificationExecutor<T> dao, Map<String, Object> params) {
        this.build(params);
        return dao.findAll(mSpec, this.getSortPageable());
    }

    public T findOne(JpaSpecificationExecutor<T> dao, Map<String, Object> params) {
        if (params == null) {
            params = new HashMap<>();
        }
        params.put("pageNum", 1);
        params.put("pageSize", 1);

        this.build(params);
        if (this.mQueryList.size() == 0) {
            return null;
        }

        Page<T> res = dao.findAll(mSpec, this.getSortPageable());
        if (res == null) {
            return null;
        }

        List<T> data = res.getContent();
        if (data.size() == 0) {
            return null;
        }

        return data.get(0);
    }

    private int getPageNum() {
        Object val = mParams.get("pageNum");
        if (val == null) return 0;

        Integer pageNum = Integer.parseInt(val.toString());
        int num = 0;
        if (pageNum != null) {
            num = pageNum.intValue() - 1;
            if (num < 0) {
                num = 0;
            }
        }

        return num;
    }

    private int getPageSize() {
        Object val = mParams.get("pageSize");
        if (val == null) return 10;

        Integer pageSize = Integer.parseInt(val.toString());
        int size = 10;
        if (pageSize != null) {
            size = pageSize.intValue();
            if (size <= 0) {
                size = 10;
            }
        }

        return size;
    }

    private boolean isInteger(String s) {
        if (StringUtils.isBlank(s)) return false;

        int len = s.length();
        for (int i = 0; i < len; i++) {
            char ch = s.charAt(i);
            if (ch == '.') {
                return false;
            }
            if (!Character.isDigit(ch)) {
                return false;
            }
        }

        return true;
    }

    private class QueryParams implements Serializable {
        private String name;
        private String exp;
        private Object val;

        public QueryParams(String name, String exp, Object val) {
            this.name = name;
            this.exp = exp;
            this.val = val;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getExp() {
            return exp;
        }

        public void setExp(String exp) {
            this.exp = exp;
        }

        public Object getVal() {
            return val;
        }

        public void setVal(Object val) {
            this.val = val;
        }
    }

    private class SortParams implements Serializable {
        private int index;
        private String name;
        private String direction;

        public SortParams(String name, int index, String direction) {
            this.name = name;
            this.index = index;
            this.direction = direction;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }

        public String getDirection() {
            return direction;
        }

        public void setDirection(String direction) {
            this.direction = direction;
        }
    }
}

自定义注解：

package com.ms.annotations;

import java.lang.annotation.*;

/**
 * @author xiezc
 * @since 2022/5/15
 */
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface QueryName {
    String value();
}

package com.ms.annotations;

import com.ms.enums.QueryType;

import java.lang.annotation.*;

/**
 * @author xiezc
 * @since 2022/5/15
 */
@Documented
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface QueryColumn {
    QueryType type() default QueryType.EQ;
}

枚举类：

package com.ms.enums;

/**
 * @author xiezc
 * @since 2022/5/15
 */
public enum QueryType {
    EQ("EQ"),
    NEQ("NEQ"),
    LIKE("LIKE"),
    NLIKE("NLIKE"),
    LLIKE("LLIKE"),
    NLLIKE("NLLIKE"),
    RLIKE("RLIKE"),
    NRLIKE("NRLIKE"),
    LT("LT"),
    ELT("ELT"),
    GT("GT"),
    EGT("EGT"),
    DATEEQ("DATEEQ"),
    DATEGT("DATEGT"),
    DATEEGT("DATEEGT"),
    DATELT("DATELT"),
    DATEELT("DATEELT"),
    DATETIMEEQ("DATETIMEEQ"),
    DATETIMEGT("DATETIMEGT"),
    DATETIMEEGT("DATETIMEEGT"),
    DATETIMELT("DATETIMELT"),
    DATETIMEELT("DATETIMEELT"),
    INSET("INSET"),
    IN("IN"),
    NOTIN("NOTIN"),
    EMPTY("EMPTY"),
    ASC("ASC"),
    DESC("DESC");

    private final String name;

    private QueryType(String name) {
        this.name = name;
    }

    private String GetName() {
        return this.name;
    }
}

dto：

package com.ms.dto;

import com.ms.annotations.QueryColumn;
import com.ms.annotations.QueryName;
import com.ms.annotations.QueryPojo;
import com.ms.entity.TAdmin;
import com.ms.enums.QueryType;
import lombok.Data;

/**
 * @author xiezc
 * @since 2022/5/14
 */
@Data
@QueryPojo(queryFor = TAdmin.class)
public class PageAdminDto {
    @QueryColumn(type = QueryType.LIKE)
    @QueryName("username")
    private String username;

    private Integer pageNum;
    private Integer pageSize;
}

 查询：

public Page<PageAdminVo> pageAdmin(PageAdminDto dto) throws Exception {
        if (dto == null) dto = new PageAdminDto();
        MySpec<TAdmin> spec = new SpecBuilder<>(TAdmin.class).build(dto).getParams();

        return _dao.findAll(spec.getSpecification(), spec.getSortPageable());
    }

弥散749
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
specification-arg-resolver:使用Spring MVC和Spring Data JPA过滤数据的替代API
05-09
规格arg解析器 使用Spring MVC和Spring Data JPA过滤数据的替代API。 可以在我的博客中找到该组件的完整介绍和原始原理： : 。 在此文件中，您可以找到所有当前功能的摘要以及一些API示例。 您还可以查看使用此库的可运行的Spring Boot应用程序： : 。 目录 -lib的快速 -基本规格，例如Equal ， Like ， GreaterThan等。 将简单的规范与and关键字结合 将简单的规范与or关键字组合 -按联接实体的属性过滤 -初始化惰性关联 处理不存在的HTTP参数 将HTTP参数名称映射到实体的属性路径 查询的静态部分-添加静态（不绑定到HTTP参数）谓词，例如deleted = false 查询的默认值-当不存在HTTP参数时提供回退值 带注释的规范接口-从带注释的接口解析规范接口继承树 处理不同的字段类型-处理提供的参数与字
kotlin-jpa-specification-dsl：该库提供了流利的DSL，用于使用spring数据规范（即JPA Criteria API）查询spring数据JPA存储库，而无需样板代码或生成的元模型
02-03
kotlin-jpa-specification-dsl：该库提供了流利的DSL，用于使用spring数据规范（即JPA Criteria API）查询spring数据JPA存储库，而无需样板代码或生成的元模型
SpringDataJPA之JpaRepository和JpaSpecificationExecutor接口
最新发布
2401_83704036的博客
04-03 306
JpaRepository2.单元测试JpaSpecificationExecutor2.具体功能2.2 多条件查询2.3 分页2.4 排序2.5 分页排序本文我们来介绍下SpringDataJPA继承结构中剩下的两个接口JpaRepository===========================================================================JpaRepository 接口是我们开发时使用的最多的接口。其特点是可以帮助我们将其他接口的方法的返回值做适配处
specification-with-projection:使用Spring Data JPA的JpaSpecificationExecutor.findAll（Specification，Pageable）支持投影
05-15
投影规格 使用Spring Data JPA的JpaSpecificationExecutor.findAll(Specification,Pageable)支持投影 适用于Spring Data JPA 2.x（Spring Boot 2.x）的2.xx版本 版本1.xx Spring Data JPA 1.x 如何使用 添加对pom的依赖 <!-- for Spring Data 2.x --> < dependency> < groupId>th.co.geniustree.springdata.jpa</ groupId> < artifactId>specification-with-projections</ artifactId> < version>2.0.1</ version> </ dependency> <!-- for
Spring data jpa Specification查询关于日期的范围搜索
weixin_34128501的博客
11-02 4734
代码： 时间格式化类型： SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdfmat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");     try { if (StringUtils.isNotEmpty(s...
SpringDataJPA之Specification复杂查询
热门推荐
★【World Of Moshow 郑锴】★
05-14 5万+
前言 继上次SpringData-JPA之ExampleMatcher实例查询使用一会之后发现ExampleMatcher对日期的查询特别糟糕，所以才有了Specification查询的研究。 实现 对应的Repository需要实现JpaSpecificationExecutor接口 public interface EventRepository extends JpaReposito...
Spring Data JPA进阶（三）：Specification查询
程铭程铭你快成名的博客
06-24 1万+
Spring Data JPA支持非常丰富的查询方式，本文主要介绍Specification查询。 JPA 2 规范引进了criteria查询API。Spring Data JPA对此提供了支持。如果你想使用这个功能，只需要继承JpaSpecificationExecutor接口。这个接口已经实现了基本的查询方法（findOne，findAll，count等）。 public interface ...
【自我提升】Spring Data JPA之Specification动态查询详解
習習君的博客
07-12 4413
刷完Spring Data JPA的课后，发现Specification动态查询还挺有意思的，还应用到了规约设计模式，在此记录下学习过程和见解。Specification是一个设计模式，常常用于企业级应用开发中，其主要目的是将业务规则从业务逻辑中分离出来。在数据查询方面，Specification可以定义复杂的查询，使其更易于重用和测试。
Spring Data JPA Specification（规范）实现复杂查询(H2数据库)
蚩尤后裔-汪茂雄
04-28 2万+
目录 持久化 API 接口概述 JpaSpecificationExecutor 常用 API 编码示例 持久化 API 接口概述 1、JPA 持久化 API 接口主要如下： public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> public inte......
SpringDataJPA笔记(7)-Specification
yingziisme的博客
05-11 668
SpringDataJPA-Specification 使用Specification可以构建动态查询 原生的使用起来有点复杂，这里推介一个别人封装好的工具包 这里是github的地址 https://github.com/wenhao/jpa-spec/blob/master/README_CN.md <!-- https://mvnrepository.com/artifact/com....
Spring Data Jpa 动态查询Specification的基本用法
Rookie_cc的博客
03-01 2713
在平常的使用中，我们往往要根据前端传过来的参数(参数个数不确定)动态查询一些数据。 下文就介绍一下在Spring Data Jpa中动态查询的基本用法。 一、dao层的Repository继承JpaRepository 例： public interface UserInfoRepository extends JpaRepository<T, Long>, JpaSpecificationExecutor<T> { } 二、在需要查询的service类中注入Reposi
spring data jpa 的Specifications动态查询
02-07
spring data jpa 的Specifications动态查询 单条件查询 多条件查询 分页查询
rsql-jpa-specification:Java库将RSQL转换为Spring Data JPA规范和QueryDSL谓词
04-08
将RSQL查询转换为org.springframework.data.jpa.domain.Specification或com.querydsl.core.types.Predicate和support实体关联查询。 Maven仓库 将RSQL的rsql-jpa-spring-boot-starter添加到Spring JPA转换 Maven对r...
spring.jpa.data Specification使用
08-01
只是刚接触spring boot的时候自己整合的非常复杂的查询条件的组合使用，作为初学者接触这种and 嵌套各种or或者in的问题还是有可借鉴的
SpringDataJpa详解（四）
qq_29164145的博客
06-11 602
1.配置多数据源 在application.properties中定义两个DataSource 定义两个DataSourceConfigJava类 可以在不同的package下创建各自的实体和数据访问接口，也可以通过@Transactional(transactionManager="transactionManagerOne") Naming命名策略详解及实践...
72、Spring Data JPA 的 Specification 动态查询
Java 领域技术分享
09-17 468
Spring Data JPA 的 Specification 动态查询
JPA--SpringDataJpa之Specifications动态查询
吴声子夜歌的博客
12-17 1594
Specifications动态查询 JpaSpecificationExecutor 方法列表 T findOne(Specification spec)：查询单个对象 List findAll(Specification spec)：查询列表 Page findAll(Specification spec, Pageable pageable)：分页查询 pageable：分页参...
SpringDataJpa Specification
weixin_44240370的博客
11-05 402
Specification是在JPA进行查询动态拼接查询条件的，需要重写其中的Predicate方法来达到我们自己需要的功能。 @Override public Predicate toPredicate(Root<Label> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) { } ...
Spring Data JPA之JpaSpecificationExecutor复杂动态查询实例
小小默：进无止境
11-28 1万+
本文接SpringDataJPA查询方法那些事继续学习JpaSpecificationExecutor复杂动态查询。 【1】回顾简单查询 简单动态查询实例如下： public Page&amp;amp;amp;amp;amp;amp;amp;lt;User&amp;amp;amp;amp;amp;amp;amp;gt; test(){ Sort sort = new Sort(Sort.Direction.DESC,&amp;amp;amp;amp;amp;amp;
springdatajpa多条件组合条件查询
08-30
在使用Spring Data JPA进行多条件组合条件查询时，可以通过使用Specification来实现。Specification是一个接口，我们可以自定义一个实现该接口的类，然后在查询方法中传入该Specification对象来指定查询条件。 首先，我们需要在仓库接口中定义一个方法，该方法接收一个Specification参数，并返回查询结果。如下所示： ```java @Repository public interface UserRepository extends JpaRepository<User, Long> { List<User> findAll(Specification<User> spec); } ``` 接下来，我们在Specification实现类中重写toPredicate方法，在该方法中使用CriteriaBuilder构建查询条件，并返回一个Predicate对象表示查询条件。例如，我们可以按用户名和年龄进行查询，如下所示： ```java public class UserSpecification implements Specification<User> { private String username; private int age; public UserSpecification(String username, int age) { this.username = username; this.age = age; } @Override public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) { List<Predicate> predicates = new ArrayList<>(); if (username != null) { predicates.add(criteriaBuilder.equal(root.get("username"), username)); } if (age != 0) { predicates.add(criteriaBuilder.equal(root.get("age"), age)); } return criteriaBuilder.and(predicates.toArray(new Predicate[0])); } } ``` 最后，我们可以在服务类中调用仓库方法并传入自定义的Specification对象来进行查询。例如： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public List<User> getUsers(String username, int age) { UserSpecification spec = new UserSpecification(username, age); return userRepository.findAll(spec); } } ``` 这样，我们就可以根据传入的条件来进行组合条件查询了。当传入的条件为空时，不会加入到查询中。当传入的条件有值时，则会根据该条件进行查询。这样，就实现了多条件组合条件查询。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值