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;
    }
}

请求参数：