JPA uses criterion simple query tool class

I used jpa to write a conditional filter query data as follows, only then did I know that the slag is a table, and the data is filtered according to the front end, which is written as follows

The first is to judge that the parameters from the front end have been written so much, and now I found out that it is the slag in the slag, and it is also time-consuming. It can be solved quickly with the criterion.

First create a class and implement the Specification<T> interface

import java.util.ArrayList;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

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

public class ExpandCriteria<T> implements Specification<T>{  
    private List<ExpandCriterion> criterions = new ArrayList<ExpandCriterion>();  
  
    public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,  
            CriteriaBuilder builder) {  
        if (!criterions.isEmpty()) {  
            List<Predicate> predicates = new ArrayList<Predicate>();  
            for(ExpandCriterion c : criterions){  
                predicates.add(c.toPredicate(root, query,builder));  
            }  
            // combine all conditions with and  
            if (predicates.size() > 0) {  
                return builder.and(predicates.toArray(new Predicate[predicates.size()]));  
            }  
        }  
        return builder.conjunction();  
    }  
    /**
     * Add simple conditional expressions
     * @Methods Name add
     * @Create In 2012-2-8 By lee
     * @param expression0 void
     */  
    public void add(ExpandCriterion criterion){  
        if(criterion!=null){  
            criterions.add(criterion);  
        }  
    }  
    
    public static void main(String[] args) {
    	//Use the example Demo
//    	Criteria<Entity> c = new Criteria<Entity>();
//    	c.add(Restrictions.like("code", searchParam.getCode(), true));  
//    	        c.add(Restrictions.eq("level", searchParam.getLevel(), false));  
//    	        c.add(Restrictions.eq("mainStatus", searchParam.getMainStatus(), true));  
//    	        c.add(Restrictions.eq("flowStatus", searchParam.getFlowStatus(), true));  
//    	        c.add(Restrictions.eq("createUser.userName", searchParam.getCreateUser(), true));  
//    	        c.add(Restrictions.lte("submitTime", searchParam.getStartSubmitTime(), true));  
//    	        c.add(Restrictions.gte("submitTime", searchParam.getEndSubmitTime(), true));  
//    	        c.add(Restrictions.eq("needFollow", searchParam.getIsfollow(), true));  
//    	        c.add(Restrictions.ne("flowStatus", searchParam.getMainStatus() true));  
//    	        c.add(Restrictions.in("solveTeam.code",teamCodes, true));  
//    	repository.findAll(c);  
	}
}  

Create a new ExpandCriterion interface

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

public interface ExpandCriterion {
	 public enum Operator {  
	        EQ, NE, LIKE, GT, LT, GTE, LTE, AND, OR  
	    }  
	    public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,  
	            CriteriaBuilder builder);  
}

New Restrictions.java

import java.util.Collection;

import org.springframework.util.StringUtils;

import com.sll.iot.dao.base.criteria.ExpandCriterion.Operator;


public class Restrictions {  
	  
    /**
     * is equal to
     * @param fieldName
     * @param value
     * @param ignoreNull
     * @return
     */  
    public static SimpleExpression eq(String fieldName, Object value, boolean ignoreNull) {  
        if(StringUtils.isEmpty(value))return null;  
        return new SimpleExpression (fieldName, value, Operator.EQ);  
    }  
      
    /**
     * not equal to
     * @param fieldName
     * @param value
     * @param ignoreNull
     * @return
     */  
    public static SimpleExpression ne(String fieldName, Object value, boolean ignoreNull) {  
        if(StringUtils.isEmpty(value))return null;  
        return new SimpleExpression (fieldName, value, Operator.NE);  
    }  
  
    /**
     * Fuzzy match
     * @param fieldName
     * @param value
     * @param ignoreNull
     * @return
     */  
    public static SimpleExpression like(String fieldName, String value, boolean ignoreNull) {  
        if(StringUtils.isEmpty(value))return null;  
        return new SimpleExpression (fieldName, value, Operator.LIKE);  
    }  
  
  
    /**
     * more than the
     * @param fieldName
     * @param value
     * @param ignoreNull
     * @return
     */  
    public static SimpleExpression gt(String fieldName, Object value, boolean ignoreNull) {  
        if(StringUtils.isEmpty(value))return null;  
        return new SimpleExpression (fieldName, value, Operator.GT);  
    }  
  
    /**
     * less than
     * @param fieldName
     * @param value
     * @param ignoreNull
     * @return
     */  
    public static SimpleExpression lt(String fieldName, Object value, boolean ignoreNull) {  
        if(StringUtils.isEmpty(value))return null;  
        return new SimpleExpression (fieldName, value, Operator.LT);  
    }  
  
    /**
     * greater or equal to
     * @param fieldName
     * @param value
     * @param ignoreNull
     * @return
     */  
    public static SimpleExpression lte(String fieldName, Object value, boolean ignoreNull) {  
        if(StringUtils.isEmpty(value))return null;  
        return new SimpleExpression (fieldName, value, Operator.GTE);  
    }  
  
    /**
     * less than or equal to
     * @param fieldName
     * @param value
     * @param ignoreNull
     * @return
     */  
    public static SimpleExpression gte(String fieldName, Object value, boolean ignoreNull) {  
        if(StringUtils.isEmpty(value))return null;  
        return new SimpleExpression (fieldName, value, Operator.LTE);  
    }  
  
    /**
     * and
     * @param criterions
     * @return
     */  
    public static LogicalExpression and(ExpandCriterion... criterions){  
        return new LogicalExpression(criterions, Operator.AND);  
    }  
    /**
     * or
     * @param criterions
     * @return
     */  
    public static LogicalExpression or(ExpandCriterion... criterions){  
        return new LogicalExpression(criterions, Operator.OR);  
    }  
    /**
     * included in
     * @param fieldName
     * @param value
     * @return
     */  
    @SuppressWarnings("rawtypes")  
    public static LogicalExpression in(String fieldName, Collection value, boolean ignoreNull) {  
        if(ignoreNull&&(value==null||value.isEmpty())){  
            return null;  
        }  
        SimpleExpression[] ses = new SimpleExpression[value.size()];  
        int i=0;  
        for(Object obj : value){  
            ses[i]=new SimpleExpression(fieldName,obj,Operator.EQ);  
            i++;  
        }  
        return new LogicalExpression(ses,Operator.OR);  
    }  

New SimpleExpression.java

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;


public class SimpleExpression implements ExpandCriterion{  
    
    private String fieldName; //Property name  
    private Object value; //corresponding value  
    private Operator operator; //Calculator  
  
    protected SimpleExpression(String fieldName, Object value, Operator operator) {  
        this.fieldName = fieldName;  
        this.value = value;  
        this.operator = operator;  
    }  
  
    public String getFieldName() {  
        return fieldName;  
    }  
    public Object getValue() {  
        return value;  
    }  
    public Operator getOperator() {  
        return operator;  
    }  
    @SuppressWarnings({ "rawtypes", "unchecked" })  
    public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,  
            CriteriaBuilder builder) {  
        Path expression = null;  
        if(fieldName.contains(".")){  
            String[] names = fieldName.split(".");  
            expression = root.get(names[0]);  
            for (int i = 1; i < names.length; i++) {  
                expression = expression.get(names[i]);  
            }  
        }else{  
            expression = root.get(fieldName);  
        }  
          
        switch (operator) {  
        case EQ:  
            return builder.equal(expression, value);  
        NE case:  
            return builder.notEqual(expression, value);  
        case LIKE:  
            return builder.like((Expression<String>) expression, "%" + value + "%");  
        case LT:  
            return builder.lessThan(expression, (Comparable) value);  
        case GT:  
            return builder.greaterThan(expression, (Comparable) value);  
        case LTE:  
            return builder.lessThanOrEqualTo(expression, (Comparable) value);  
        case GTE:  
            return builder.greaterThanOrEqualTo(expression, (Comparable) value);  
        default:  
            return null;  
        }  
    }  
      
}  

LogicalExpression.java

import java.util.ArrayList;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

public class LogicalExpression implements ExpandCriterion {  
    private ExpandCriterion[] criterion; // expressions contained in logical expressions  
    private Operator operator; //Calculator  
  
    public LogicalExpression(ExpandCriterion[] criterions, Operator operator) {  
        this.criterion = criterions;  
        this.operator = operator;  
    }  
  
    public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,  
            CriteriaBuilder builder) {  
        List<Predicate> predicates = new ArrayList<Predicate>();  
        for(int i=0;i<this.criterion.length;i++){  
            predicates.add(this.criterion[i].toPredicate(root, query, builder));  
        }  
        switch (operator) {  
        case OR:  
            return builder.or(predicates.toArray(new Predicate[predicates.size()]));  
        default:  
            return null;  
        }  
    }  
  
}

The premise of using criteria is that the dao interface must implement the JpaSpecificationExecutor<T> interface

The transformation is as follows

//Conditional query
	@Override
	public Paging<Channel> query(Paging<Channel> paging,String channelName,String operator) {
		Pageable pageReq = new PageRequest(paging.getCurrentPage()-1, paging.getPageSize());
		Page<Channel> pageChanel=null;
		ExpandCriteria<Channel> criteria = new ExpandCriteria<Channel>();
		if(StringUtil.isNotEmpty(channelName)){
			criteria.add(Restrictions.like("name", channelName, false));
		}
		if(StringUtil.isNotEmpty(operator)){
			criteria.add(Restrictions.eq("operator",Operator.valueOf(operator), false));
		}
		pageChanel=channelRepository.findAll(criteria, pageReq);
		
		if(pageChanel!=null){
			paging.setTotalCount((int)pageChanel.getTotalElements());
			paging.setData(pageChanel.getContent());
			paging.setTotalPage(pageChanel.getTotalPages());
		}
		return paging;
	}

No need to write anything in the dao interface

How to use is demo 

public static void main(String[] args) {
    	//Use the example Demo
//    	Criteria<Entity> c = new Criteria<Entity>();
//    	c.add(Restrictions.like("code", searchParam.getCode(), true));  
//    	        c.add(Restrictions.eq("level", searchParam.getLevel(), false));  
//    	        c.add(Restrictions.eq("mainStatus", searchParam.getMainStatus(), true));  
//    	        c.add(Restrictions.eq("flowStatus", searchParam.getFlowStatus(), true));  
//    	        c.add(Restrictions.eq("createUser.userName", searchParam.getCreateUser(), true));  
//    	        c.add(Restrictions.lte("submitTime", searchParam.getStartSubmitTime(), true));  
//    	        c.add(Restrictions.gte("submitTime", searchParam.getEndSubmitTime(), true));  
//    	        c.add(Restrictions.eq("needFollow", searchParam.getIsfollow(), true));  
//    	        c.add(Restrictions.ne("flowStatus", searchParam.getMainStatus() true));  
//    	        c.add(Restrictions.in("solveTeam.code",teamCodes, true));  
//    	repository.findAll(c);  
	}