SpringDataJpa多条件查询代码封装

 package com.pantech.cloud.mlogistics.util;

 import com.mysql.jdbc.StringUtils;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;

 import java.util.Map;

 /**
  * @author xzy
  * @date 2019-11-25 10:15
  * 说明：用于生成sort、pageable
  */
 public class PageableUtils {
     /**
      * Meta = {"sortColumn":"","sortDirection":"","pageNumber","","pageSize":""}
      * 排序字段、排序方向、页码、分页大小
      */
     private Map<String, Object> meta = null;
     private String sortColumn = null;
     private String sortDirection = null;
     private Integer pageNumber = null;
     private Integer pageSize = null;

     public Map<String, Object> getMeta() {
         return meta;
     }

     public void setMeta(Map<String, Object> meta) {
         this.meta = meta;
         //排序字段和排序方向必须同时指定，且值不能为null
         if (meta.containsKey("sortColumn") && meta.get("sortColumn") != null
                 && meta.containsKey("sortDirection") && meta.get("sortDirection") != null) {
             sortColumn = String.valueOf(meta.get("sortColumn"));
             sortDirection = String.valueOf(meta.get("sortDirection"));
         }
         if (meta.containsKey("pageNumber") && !"".equals(meta.get("pageNumber"))
                 && meta.containsKey("pageSize") && !"".equals(meta.get("pageSize"))) {
             pageNumber = Integer.parseInt(meta.get("pageNumber").toString());
             pageSize = Integer.parseInt(meta.get("pageSize").toString());
         }
     }

     public PageableUtils(Map<String, Object> meta) {
         setMeta(meta);
     }

     /**
      * 获取排序条件
      */
     public Sort getSort() {
         Sort sort = null;
         //确保排序字段有效,确保排序方向有效
         if (StringUtils.isNullOrEmpty(sortColumn)) {
             return null;
         } else if ("ASC".equals(sortDirection) || "asc".equals(sortDirection)) {
             sort = new Sort(Sort.Direction.ASC, sortColumn);
         } else if ("DESC".equals(sortDirection) || "desc".equals(sortDirection)) {
             sort = new Sort(Sort.Direction.DESC, sortColumn);
         }
         return sort;
     }

     /**
      * 获取分页条件
      *
      * @param sort - 排序条件
      */
     public Pageable getPageable(Sort sort) {
         Pageable pageable;
         if (pageNumber == null || pageSize == null) {
             pageable = null;
         } else if (sort != null) {
             pageable = PageRequest.of(pageNumber, pageSize, sort);
         } else {
             pageable = PageRequest.of(pageNumber, pageSize);
         }
         return pageable;
     }

     public Pageable getPageable() {
         Sort sort = getSort();
         return getPageable(sort);
     }
 }

PageableUtils.java工具类负责从参数中提取排序、分页条件

 package com.pantech.cloud.mlogistics.util;

 import com.pantech.cloud.common.msg.Message;
 import com.pantech.cloud.common.msg.MessageBox;
 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.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
 import org.springframework.data.repository.Repository;

 import java.util.Map;

 /**
  * @author xzy
  * @date 2019-11-25 10:26
  * 说明：条件查询
  */
 public class ConditionalQueryUtils<T extends JpaRepository & JpaSpecificationExecutor> {

     private T repository = null;

     public T getRepository() {
         return repository;
     }

     public void setRepository(T repository) {
         this.repository = repository;
     }

     public ConditionalQueryUtils(T repository) {
         this.repository = repository;
     }

     /**
      * 条件查询：多条件查询||排序查询||分页查询
      *
      * @param specification - 多条件查询条件
      * @param meta          - 包含条件查询、分页查询条件
      */
     public Message findByConditions(Specification specification, Map<String, Object> meta) {
         PageableUtils pageableUtils = new PageableUtils(meta);
         //排序条件
         Sort sort = pageableUtils.getSort();
         //分页条件
         Pageable pageable = pageableUtils.getPageable();
         /**
          * 查询
          */
         if (specification != null) {
             //1、多条件查询
             if (pageable != null) {
                 //1.1多条件查询+排序查询+分页查询
                 return new MessageBox<>(repository.findAll(specification, pageable));
             } else {
                 if (sort != null) {
                     //1.2.1多条件查询+排序查询
                     return new MessageBox<>(repository.findAll(specification, sort));
                 } else {
                     //1.2.2多条件查询
                     return new MessageBox<>(repository.findAll(specification));
                 }
             }
         } else {
             //2、查询所有数据
             if (pageable != null) {
                 //2.1查询所有数据+排序查询+分页查询
                 return new MessageBox<>(repository.findAll(pageable));
             } else {
                 if (sort != null) {
                     //2.2.1查询所有数据+排序查询
                     return new MessageBox<>(sort);
                 } else {
                     //2.2.2查询所有数据
                     return new MessageBox<>(repository.findAll());
                 }
             }
         }
     }
 }

使用说明：

1、Entity中包含参数

     /**
      * 附加参数
      */
     @Transient
     @JsonInclude(JsonInclude.Include.NON_DEFAULT)
     private Map<String, Object> meta = new HashMap<>();

2、Repository实现接口

 package com.pantech.cloud.mlogistics.repository.ina;

 import com.pantech.cloud.mlogistics.entity.ina.WaybillReturnViewEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

 /**
  * @author xzy
  * @date 2019-11-25 09:43
  * 说明：
  */
 public interface WaybillReturnViewRepository extends JpaRepository<WaybillReturnViewEntity, String>, JpaSpecificationExecutor<WaybillReturnViewEntity> {
 }

使用例子：

 package com.pantech.cloud.mlogistics.service.impl.ina;

 import com.mysql.jdbc.StringUtils;
 import com.pantech.cloud.common.msg.Message;
 import com.pantech.cloud.mlogistics.entity.ina.WaybillReturnViewEntity;
 import com.pantech.cloud.mlogistics.repository.ina.WaybillReturnViewRepository;
 import com.pantech.cloud.mlogistics.service.ina.WaybillReturnViewService;
 import com.pantech.cloud.mlogistics.util.ConditionalQueryUtils;
 import com.pantech.cloud.mlogistics.util.SpecificationFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Service;

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 /**
  * @author xzy
  * @date 2019-11-25 09:46
  * 说明：
  */
 @Service
 public class WaybillReturnViewServiceImpl implements WaybillReturnViewService {

     private WaybillReturnViewRepository repository;

     @Autowired
     public void dependenceInject(WaybillReturnViewRepository repository) {
         this.repository = repository;
     }

     /**
      * 获取所有数据
      */
     @Override
     public List<WaybillReturnViewEntity> findAll() {
         return repository.findAll();
     }

     /**
      * 多条件查询
      *
      * @param conditions - 查询条件
      * @return - 返回符合条件的数据
      */
     @Override
     public Message findByConditions(WaybillReturnViewEntity conditions) {
         Specification specification = getConditions(conditions);
         ConditionalQueryUtils<WaybillReturnViewRepository> conditionUtils = new ConditionalQueryUtils<>(repository);
         return conditionUtils.findByConditions(specification, conditions.getMeta());
     }

     /**
      * 确认查询条件
      *
      * @param conditions - 包含查询条件的实体
      * @return - 查询条件
      */
     private Specification getConditions(WaybillReturnViewEntity conditions) {
         List<Specification> specificationList = new ArrayList<>();
         Specification specification = null;

         //主单号
         if (!StringUtils.isNullOrEmpty(conditions.getMainBill())) {
             specificationList.add(SpecificationFactory.equal("mainBill", conditions.getMainBill()));
         }
         //分单号
         if (!StringUtils.isNullOrEmpty(conditions.getHawbBill())) {
             specificationList.add(SpecificationFactory.equal("hawbBill", conditions.getHawbBill()));
         }
         //退货客户
         if (!StringUtils.isNullOrEmpty(conditions.getCustomerName())) {
             specificationList.add(SpecificationFactory.equal("customerName", conditions.getCustomerName()));
         }
         if (conditions.getMeta().containsKey("returnDateLeft") && !"".equals(conditions.getMeta().get("returnDateLeft").toString())) {
             Date returnDateLeft = null;
             try {
                 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                 returnDateLeft = dateFormat.parse(conditions.getMeta().get("returnDateLeft").toString());
             } catch (ParseException e) {
                 e.printStackTrace();
             }
             specificationList.add(SpecificationFactory.greaterOrEqual("returnDate", (Date) returnDateLeft));
         }
         if (conditions.getMeta().containsKey("returnDateRight") && !"".equals(conditions.getMeta().get("returnDateRight").toString())) {
             Date returnDateRight = null;
             try {
                 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                 returnDateRight = dateFormat.parse(conditions.getMeta().get("returnDateRight").toString());
             } catch (ParseException e) {
                 e.printStackTrace();
             }
             specificationList.add(SpecificationFactory.smallerOrEqual("returnDate", returnDateRight));
         }

         for (Specification spec : specificationList) {
             if (specification == null) {
                 specification = spec;
             } else {
                 specification = specification.and(spec);
             }
         }
         return specification;
     }
 }

请求参数：