spring data jpa 动态查询Specification（包括各个In、like、Between等等各种工具类，及完整（分页查询）用法步骤（到返回给前端的结果））

目录

一、

二、工具类

1、AbstractSpecification（抽象动态查询条件）

2、各属性查询条件（IsNull、In、Number、String、Like等）

      （1）字符串属性查询条件StringSpecification

      （2）、Between动态查询条件BetweenSpecification

      （3）相等动态查询条件EqualSpecification

      （4）In动态查询条件InSpecification

      （5）判空查询条件IsNullSpecification

      （6）Like动态查询条件LikeSpecification

      （7）不为空动态查询条件NotNullSpecification

      （8）数字属性查询条件NumberSpecification

      （9）SpecificationGroup

      （10）SpecificationHelper

      （11）分组查询

      （12）2019-06-17补充 or 用法

三、用法

---

适用于多条件动态查询的业务场景。

刚毕业技术比较差，所以记录的比较详细。

一、

repository继承JpaSpecificationExecutor

public interface VehRepository extends JpaRepository, JpaSpecificationExecutor
{
}

二、工具类

1、AbstractSpecification（抽象动态查询条件）

import org.springframework.data.jpa.domain.Specification;

/**
 * 抽象动态查询条件
 *
 */
public abstract class AbstractSpecification implements Specification
{
	/**
	 * 逻辑运算：等于
	 */
	public static final int LOGICAL_OPERATOR_EQUAL = 1;
	/**
	 * 逻辑运算：小于
	 */
	public static final int LOGICAL_OPERATOR_LESS = 2;
	/**
	 * 逻辑运算：大于
	 */
	public static final int LOGICAL_OPERATOR_GREATER = 3;
	/**
	 * 逻辑运算：小于等于
	 */
	public static final int LOGICAL_OPERATOR_LESS_EQUAL = 4;
	/**
	 * 逻辑运算：大于等于
	 */
	public static final int LOGICAL_OPERATOR_GREATER_EQUAL = 5;
	/**
	 * 逻辑运算：不等于
	 */
	public static final int LOGICAL_OPERATOR_NOT_EQUAL = 6;
	/**
	 * 逻辑运算：包含
	 */
	public static final int LOGICAL_OPERATOR_LIKE = 7;
	/**
	 * 逻辑运算：左包含
	 */
	public static final int LOGICAL_OPERATOR_STARTWITH = 8;
	/**
	 * 逻辑运算：右包含
	 */
	public static final int LOGICAL_OPERATOR_ENDWITH = 9;

	/**
	 * 逻辑运算：非空
	 */
	public static final int LOGICAL_OPERATOR_NOT_NULL = 10;
	/**
	 * 逻辑运算：In
	 */
	public static final int LOGICAL_OPERATOR_IN = 11;
    /**
     * 逻辑运算：包含（自定义）
     */
	public static final int LOGICAL_OPERATOR_LIKE_CUSTOM = 99;
	public static final int LOGICAL_OPERATOR_CUSTOM = 100;
	protected String attrName;
	protected ATTR attrValue;
	protected ATTR[] attrValues;
	protected int logicalOperator;
	/**
	 * 构造方法
	 * @param attrName			属性名称
	 * @param attrValue			属性值
	 * @param logicalOperator	逻辑运算符
	 */
	public AbstractSpecification(String attrName, ATTR attrValue, int logicalOperator) {
		super();
		this.attrName = attrName;
		this.attrValue = attrValue;
		this.logicalOperator = logicalOperator;
	}

	public AbstractSpecification(String attrName, int logicalOperator, ATTR ... attrValues) {
		super();
		this.attrName = attrName;
		this.attrValues = attrValues;
		if (this.attrValues.length > 0) {
			this.attrValue = this.attrValues[0];
		}
		this.logicalOperator = logicalOperator;
	}
}

2、各属性查询条件（IsNull、In、Number、String、Like等）

      （1）字符串属性查询条件StringSpecification

               

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.persistence.criteria.*;

/**
 * 字符串属性查询条件
 */
public class StringSpecification extends AbstractSpecification {
    private static Logger log = LoggerFactory
            .getLogger(StringSpecification.class);

    private int start, len;

    /**
     * 构造方法
     *
     * @param attrName        属性名称
     * @param attrValue       属性值
     * @param logicalOperator 逻辑运算符
     */
    public StringSpecification(String attrName, String attrValue, int logicalOperator) {
        this(attrName, logicalOperator, attrValue);
    }

    public StringSpecification(String attrName, int logicalOperator, String... attrValues) {
        super(attrName, logicalOperator, attrValues);
        this.start = 0;
        this.len = 0;
    }

    public StringSpecification(String attrName, int start, int length, int logicalOperator, String... attrValues) {
        super(attrName, logicalOperator, attrValues);
        this.start = start;
        this.len = length;
    }

    private Class getFieldClass(String attr) {
        // TODO
        return null;
    }

    /* (non-Javadoc)
     * @see org.springframework.data.jpa.domain.Specification#toPredicate(javax.persistence.criteria.Root, javax.persistence.criteria.CriteriaQuery, javax.persistence.criteria.CriteriaBuilder)
     */
    @Override
    public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
        Path path = SpecificationHelper.getPath(root, attrName);
        Expression expr = path;
        if (0 < start && 0 < len) {
            expr = cb.substring(path, start, len);
        } else {

        }
        switch (logicalOperator) {
            case StringSpecification.LOGICAL_OPERATOR_EQUAL: {
                return cb.equal(expr, attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_GREATER: {
                return cb.greaterThan(expr, attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_GREATER_EQUAL: {
                return cb.greaterThanOrEqualTo(expr, attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_LESS: {
                return cb.lessThan(expr, attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_LESS_EQUAL: {
                return cb.lessThanOrEqualTo(expr, attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_NOT_EQUAL: {
                return cb.notEqual(expr, attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_LIKE: {
                return cb.like(expr, "%" + attrValue + "%");
            }
            case StringSpecification.LOGICAL_OPERATOR_STARTWITH: {
                return cb.like(expr, attrValue + "%");
            }
            case StringSpecification.LOGICAL_OPERATOR_ENDWITH: {
                return cb.like(expr, "%" + attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_NOT_NULL: {
                return cb.isNotNull(path);
            }
            case StringSpecification.LOGICAL_OPERATOR_LIKE_CUSTOM: {
                return cb.like(expr, attrValue);
            }
            case StringSpecification.LOGICAL_OPERATOR_IN: {
                CriteriaBuilder.In predicate = cb.in(expr);
                for (String item : attrValues) {
                    predicate.value(item);
                }
                return predicate;
            }
            default:
                return null;
        }
    }
}

      （2）、Between动态查询条件BetweenSpecification

import org.springframework.data.jpa.domain.Specification;

import javax.persistence.criteria.*;

/**
 * Between动态查询条件
 */
public class BetweenSpecification> implements Specification
{
	private String attrName;
	private ATTR lowerBound, upperBound;

	/**
	 * 构造方法
	 * @param attrName		属性名称
	 * @param lowerBound	属性值下界
	 * @param upperBound	属性值上界
	 */
	public BetweenSpecification(String attrName, ATTR lowerBound, ATTR upperBound) {
		super();
		this.attrName = attrName;
		this.lowerBound = lowerBound;
		this.upperBound = upperBound;
	}

	/* (non-Javadoc)
	 * @see org.springframework.data.jpa.domain.Specification#toPredicate(javax.persistence.criteria.Root, javax.persistence.criteria.CriteriaQuery, javax.persistence.criteria.CriteriaBuilder)
	 */
	@Override
	public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
		Path path = SpecificationHelper.getPath(root, attrName);
		return cb.between(path, lowerBound, upperBound);
	}

}

      （3）相等动态查询条件EqualSpecification

import org.springframework.data.jpa.domain.Specification;

import javax.persistence.criteria.*;

/**
 * 相等动态查询条件
 *
 */
public class EqualSpecification implements Specification
{
	private String fieldName;
	private ATTR fieldValue;

	public EqualSpecification(String fieldName, ATTR fieldValue) {
		super();
		this.fieldName = fieldName;
		this.fieldValue = fieldValue;
	}

	@Override
	public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
		Path path = SpecificationHelper.getPath(root, fieldName);
		return cb.equal(path, fieldValue);
	}

}

      （4）In动态查询条件InSpecification

import org.springframework.data.jpa.domain.Specification;

import javax.persistence.criteria.*;

/**
 *
 */
public class InSpecification implements Specification
{
    private String attrName;
    private ATTR[] values;
    public InSpecification(String attrName, ATTR[] values) {
        this.attrName = attrName;
        this.values = values;
    }

    @Override
    public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
        Path path = SpecificationHelper.getPath(root, attrName);
        CriteriaBuilder.In predicate = cb.in(path);
        for(ATTR item : values) {
            predicate.value(item);
        }
        return predicate;
    }
}

      （5）判空查询条件IsNullSpecification

import javax.persistence.criteria.*;

/**
 * 
 */
public class IsNullSpecification extends AbstractSpecification {
    public IsNullSpecification(String attrName) {
        super(attrName, null, AbstractSpecification.LOGICAL_OPERATOR_CUSTOM);
    }

    @Override
    public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
        Path