import lombok.Getter;
import lombok.Setter;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* @Author: Ma Chi
* @Date: 2019-05-22
* @Time: 16:05
* @ClassName: McSpecification
* @Description: 扩展Specification
*/
public class McSpecification<T> implements Specification<T> {
/**
* 属性分隔符
*/
private static final String PROPERTY_SEPARATOR = ".";
/**
* and条件组
*/
List<Cnd> andConditions = new ArrayList<>();
/**
* or条件组
*/
List<Cnd> orConditions = new ArrayList<>();
/**
* 排序条件组
*/
List<Order> orders = new ArrayList<>();
@Override
public Predicate toPredicate(Root<T> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
Predicate restrictions = cb.and(getAndPredicates(root, cb));
restrictions = cb.and(restrictions, getOrPredicates(root, cb));
cq.orderBy(getOrders(root, cb));
return restrictions;
}
/**
* 给里面传参，用Cnd里面得静态方法，可以传多个值
*
* @param conditions
* @return
*/
public McSpecification and(Cnd... conditions) {
for (Cnd condition : conditions) {
//循环全部添加到and条件组
andConditions.add(condition);
}
return this;
}
public McSpecification or(Collection<Cnd> conditions) {
//全添加到or条件组
orConditions.addAll(conditions);
return this;
}
public McSpecification desc(String property) {
this.orders.add(Order.desc(property));
return this;
}
public McSpecification asc(String property) {
this.orders.add(Order.asc(property));
return this;
}
/**
* 把and条件组得拼到一起
*
* @param root
* @param cb
* @return
*/
private Predicate getAndPredicates(Root<T> root, CriteriaBuilder cb) {
//过滤条件用Predicate方法拼接
Predicate restrictions = cb.conjunction();
for (Cnd condition : andConditions) {
if (condition == null) {
continue;
}
Path<?> path = this.getPath(root, condition.property);
if (path == null) {
continue;
}
switch (condition.operator) {
case eq://等于
if (condition.value != null) {
/**
* isAssignableFrom()方法是判断是否为某个类的父类,父类.class.isAssignableFrom(子类.class)
* instanceof关键字是判断是否某个类的子类。子类实例 instanceof 父类类型
*/
if (String.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof String) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.and(restrictions, cb.equal(path, condition.value));
}
} else {
restrictions = cb.and(restrictions, cb.equal(path, condition.value));
}
}
break;
case ge://大于等于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.and(restrictions, cb.ge((Path<Number>) path, (Number) condition.value));
}
}
break;
case gt://大于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.and(restrictions, cb.gt((Path<Number>) path, (Number) condition.value));
}
}
break;
case le://小于等于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.and(restrictions, cb.le((Path<Number>) path, (Number) condition.value));
}
}
break;
case lt://小于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.and(restrictions, cb.lt((Path<Number>) path, (Number) condition.value));
}
}
break;
case ne://不等于
if (condition.value != null) {
if (String.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof String && !((String) condition.value).isEmpty()) {
restrictions = cb.and(restrictions, cb.notEqual(path, condition.value));
}
}
break;
case isNotNull:
restrictions = cb.and(restrictions, path.isNotNull());
break;
}
}
return restrictions;
}
private Predicate getOrPredicates(Root<T> root, CriteriaBuilder cb) {
Predicate restrictions = cb.conjunction();
for (Cnd condition : orConditions) {
if (condition == null) {
continue;
}
Path<?> path = this.getPath(root, condition.property);
if (path == null) {
continue;
}
switch (condition.operator) {
case eq://等于
if (condition.value != null) {
/**
* isAssignableFrom()方法是判断是否为某个类的父类,父类.class.isAssignableFrom(子类.class)
* instanceof关键字是判断是否某个类的子类。子类实例 instanceof 父类类型
*/
if (String.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof String) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.or(restrictions, cb.equal(path, condition.value));
}
} else {
restrictions = cb.or(restrictions, cb.equal(path, condition.value));
}
}
break;
case ge://大于等于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.or(restrictions, cb.ge((Path<Number>) path, (Number) condition.value));
}
}
break;
case gt://大于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.or(restrictions, cb.gt((Path<Number>) path, (Number) condition.value));
}
}
break;
case le://小于等于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.or(restrictions, cb.le((Path<Number>) path, (Number) condition.value));
}
}
break;
case lt://小于
if (Number.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof Number) {
if (!((String) condition.value).isEmpty()) {//判断condition.value 是否有元素
restrictions = cb.or(restrictions, cb.lt((Path<Number>) path, (Number) condition.value));
}
}
break;
case ne://不等于
if (condition.value != null) {
if (String.class.isAssignableFrom(path.getJavaType()) && condition.value instanceof String && !((String) condition.value).isEmpty()) {
restrictions = cb.or(restrictions, cb.notEqual(path, condition.value));
}
}
break;
case isNotNull:
restrictions = cb.or(restrictions, path.isNotNull());
break;
}
}
return restrictions;
}
/**
* 排序
*
* @param root
* @param cb
* @return
*/
private List<javax.persistence.criteria.Order> getOrders(Root<T> root, CriteriaBuilder cb) {
List<javax.persistence.criteria.Order> orderList = new ArrayList<>();
//CollectionUtils.isEmpty判断集合是否为空
if (orderList == null || CollectionUtils.isEmpty(orders)) {
return orderList;
}
for (Order order : orders) {
if (order == null) {
continue;
}
//获取属性
String property = order.getProperty();
//获取排序规则
Sort.Direction direction = order.getDirection();
Path<?> path = this.getPath(root, property);
if (path == null || direction == null) {
continue;
}
switch (direction) {
case ASC:
orderList.add(cb.asc(path));
break;
case DESC:
orderList.add(cb.desc(path));
break;
}
}
return orderList;
}
/**
* 获取path
*
* @param path
* @param propertyPath 属性路径
* @param <X>
* @return Path
*/
private <X> Path<X> getPath(Path<X> path, String propertyPath) {
if (path == null || StringUtils.isEmpty(propertyPath)) {
return (Path<X>) path;
}
//StringUtils.substringBefore 截取指定字符串（PROPERTY_SEPARATOR）之前的内容
String property = StringUtils.substringBefore(propertyPath, PROPERTY_SEPARATOR);
//StringUtils.substringAfter 截取指定字符串（PROPERTY_SEPARATOR）之后的内容
return getPath(path.get(property), StringUtils.substringAfter(propertyPath, PROPERTY_SEPARATOR));
}
/**
* 条件
*/
public static class Cnd {
Operator operator;//运算符
String property;//属性
Object value;//值
public Cnd(Operator operator, String property, Object value) {
this.operator = operator;
this.property = property;
this.value = value;
}
/**
* 相等
*
* @param property 属性
* @param value 值
* @return
*/
public static Cnd eq(String property, Object value) {
return new Cnd(Operator.eq, property, value);
}
/**
* 不相等
*
* @param property 属性
* @param value 值
* @return
*/
public static Cnd ne(String property, Object value) {
return new Cnd(Operator.ne, property, value);
}
/**
* 大于
*
* @param property 属性
* @param value 值
* @return
*/
public static Cnd gt(String property, Object value) {
return new Cnd(Operator.gt, property, value);
}
/**
* 小于
*
* @param property 属性
* @param value 值
* @return
*/
public static Cnd lt(String property, Object value) {
return new Cnd(Operator.lt, property, value);
}
/**
* 大于等于
*
* @param property 属性
* @param value 值
* @return
*/
public static Cnd ge(String property, Object value) {
return new Cnd(Operator.ge, property, value);
}
/**
* 小于等于
*
* @param property 属性
* @param value 值
* @return
*/
public static Cnd le(String property, Object value) {
return new Cnd(Operator.le, property, value);
}
/**
* 不为null
*
* @param property 属性
* @param value 值
* @return
*/
public static Cnd isNotNull(String property, Object value) {
return new Cnd(Operator.isNotNull, property, value);
}
}
/**
* 运算符
*/
public enum Operator {
/**
* 等于
*/
eq("="),
/**
* 不等于
*/
ne(" != "),
/**
* 大于
*/
gt(">"),
/**
* 小于
*/
lt("<"),
/**
* 大于等于
*/
ge(">="),
/**
* 小于等于
*/
le("<="),
/**
* 不为null
*/
isNotNull(" is not Null");
@Getter
@Setter
private String operator;
Operator(String operator) {
this.operator = operator;
}
}
/**
* 排序
*/
@Getter
@Setter
public static class Order {
private String property;//属性
private Sort.Direction direction = Sort.Direction.ASC;//方向
public Order(String property, Sort.Direction direction) {
this.property = property;
this.direction = direction;
}
/**
* @param property
* @return 递增序列，升序
*/
public static Order asc(String property) {
return new Order(property, Sort.Direction.ASC);
}
/**
* @param property
* @return 递减序列，逆序
*/
public static Order desc(String property) {
return new Order(property, Sort.Direction.DESC);
}
}
}
