基于jpa的specification实现动态查询

快来打我* 2024-02-19 18:38 27阅读 0赞

spring data jpa为我们实现简单的crud操作提供了极大的方便。但大部分情况下，系统中都存在大量的动态查询操作，这个时候就可以借助spring data jpa的 Specification动态查询操作。但这个动态查询操作的大部分的代码都是重复的，因此可以考虑将Specification进一步封装.**一个查询条件的构成，需要知道是查询的是那个字段(field)，用的是什么类型的操作符(op)，以及是什么数据类型的(dataType)，**如果我们前台封装好，传递到后台，后台在进行解析就知道如何进行查询了。

思路：

1、前台提交查询条件时，提交的 key： **为h\_后台实体类中的字段\_操作符\_数据类型** value: **为实际的值**

**eg: 用户名:<input type="text" name="h\_name\_eq\_s" />**

2、后台从request中获取到所有的参数，然后判断参数是否是构成查询条件的。

判断依据: 必须以 **h\_** 开头，中间以 **\_** 分割 ，且分割后的数组是 **4**.

3、检测上一步的操作符是否是我们系统中支持的，检测 数据类型是否是系统中支持的。

4、构成查询条件

就是根据上一步得到的值，根据不同的数据类型和不同的操作符构成不同的Predicate，最终组合这些Predicate

**代码如下：**

一、写一个类实现Specification接口，在此接口中构造查询条件 (**这个类主要是用于构造动态查询条件**)

package com.huan.dubbo.bookshop.repositoy.ext;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    import java.util.Optional;
    import java.util.concurrent.ConcurrentHashMap;
    
    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;
    
    import lombok.Getter;
    import lombok.extern.slf4j.Slf4j;
    
    /**
     * 基于jpa specification动态查询条件的封装
     * 
     * @描述
     * @作者 huan
     * @时间 2017年10月29日 - 上午11:41:30
     * 
     *     <pre>
     * 使用方式：外部传递进来一个map->
     * 			key: h_实体类中的字段_操作符_数据类型  value: 实际的值
     *          eg:  h_name_eq_s             value: 12   ===> name=12
     *     </pre>
     */
    @Slf4j
    public class JpaSpecificationWrapper<T> implements Specification<T> {
    
    	@Getter
    	private Map<String, Object> params;
    
    	public JpaSpecificationWrapper(Map<String, Object> params) {
    		this.params = params;
    	}
    
    	private static final ConcurrentHashMap<String, String> DATE_TYPE_FORMATTER = new ConcurrentHashMap<>();
    
    	private static final String PREFIX = "h_";
    	private static final String SPLIT = "_";
    
    	static {
    		DATE_TYPE_FORMATTER.put("d", "yyyy-MM-dd HH:mm:ss");
    	}
    
    	@Override
    	public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
    		if (null == params) {
    			return null;
    		}
    		List<Predicate> predicates = new ArrayList<>();
    		for (Map.Entry<String, Object> entry : params.entrySet()) {
    			String key = entry.getKey();
    			Object value = entry.getValue();
    			if (!key.startsWith(PREFIX)) {
    				continue;
    			}
    			String[] conditions = key.split(SPLIT);
    			if (conditions.length != 4) {
    				log.warn("非法的查询条件:{}", key);
    				continue;
    			}
    			String field = conditions[1];
    			String op = conditions[2];
    			String dataType = conditions[3];
    			Predicate predicate = convertPredicate(root, cb, field, op, dataType, value);
    			Optional.ofNullable(predicate).ifPresent(predicates::add);
    		}
    		return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
    	}
    
    	private Predicate convertPredicate(Root<T> root, CriteriaBuilder cb, String field, String op, String dataType, Object value) {
    		if (field == null || value == null || value.toString().equals("")) {
    			return null;
    		}
    		Predicate predicate;
    		switch (op) {
    		case "eq":
    			predicate = cb.equal(root.get(field), wrapValue(dataType, op, value));
    			break;
    		case "lt":
    			predicate = convertLtPredicate(root, cb, field, op, dataType, value);
    			break;
    		case "lte":
    			predicate = convertLtePredicate(root, cb, field, op, dataType, value);
    			break;
    		case "gt":
    			predicate = convertGtPredicate(root, cb, field, op, dataType, value);
    			break;
    		case "gte":
    			predicate = convertGtePredicate(root, cb, field, op, dataType, value);
    			break;
    		case "l":
    		case "ll":
    		case "rl":
    			predicate = cb.like(root.get(field), (String) wrapValue(dataType, op, value));
    			break;
    		default:
    			throw new RuntimeException("暂不支持的sql操作符" + op);
    		}
    		return predicate;
    	}
    
    	private Predicate convertGtePredicate(Root<T> root, CriteriaBuilder cb, String field, String op, String dataType, Object value) {
    		switch (dataType) {
    		case "s":
    			return cb.greaterThanOrEqualTo(root.get(field), (String) wrapValue(dataType, op, value));
    		case "i":
    			return cb.greaterThanOrEqualTo(root.get(field), (Double) wrapValue(dataType, op, value));
    		case "d":
    			return cb.greaterThanOrEqualTo(root.get(field), (Date) wrapValue(dataType, op, value));
    		default:
    			throw new RuntimeException("非法的数据类型." + dataType);
    		}
    	}
    
    	private Predicate convertGtPredicate(Root<T> root, CriteriaBuilder cb, String field, String op, String dataType, Object value) {
    		switch (dataType) {
    		case "s":
    			return cb.greaterThan(root.get(field), (String) wrapValue(dataType, op, value));
    		case "i":
    			return cb.greaterThan(root.get(field), (Double) wrapValue(dataType, op, value));
    		case "d":
    			return cb.greaterThan(root.get(field), (Date) wrapValue(dataType, op, value));
    		default:
    			throw new RuntimeException("非法的数据类型." + dataType);
    		}
    	}
    
    	private Predicate convertLtePredicate(Root<T> root, CriteriaBuilder cb, String field, String op, String dataType, Object value) {
    		switch (dataType) {
    		case "s":
    			return cb.lessThanOrEqualTo(root.get(field), (String) wrapValue(dataType, op, value));
    		case "i":
    			return cb.lessThanOrEqualTo(root.get(field), (Double) wrapValue(dataType, op, value));
    		case "d":
    			return cb.lessThanOrEqualTo(root.get(field), (Date) wrapValue(dataType, op, value));
    		default:
    			throw new RuntimeException("非法的数据类型." + dataType);
    		}
    	}
    
    	private Predicate convertLtPredicate(Root<T> root, CriteriaBuilder cb, String field, String op, String dataType, Object value) {
    		switch (dataType) {
    		case "s":
    			return cb.lessThan(root.get(field), (String) wrapValue(dataType, op, value));
    		case "i":
    			return cb.lessThan(root.get(field), (Double) wrapValue(dataType, op, value));
    		case "d":
    			return cb.lessThan(root.get(field), (Date) wrapValue(dataType, op, value));
    		default:
    			throw new RuntimeException("非法的数据类型." + dataType);
    		}
    	}
    
    	private Object wrapValue(String dataType, String op, Object value) {
    		switch (dataType) {
    		case "s":
    			String newValue = (String) value;
    			if ("l".equals(op)) {
    				newValue = "%" + value + "%";
    			} else if ("ll".equals(op)) {
    				newValue = "%" + value;
    			} else if ("rl".equals(op)) {
    				newValue = value + "%";
    			}
    			return newValue;
    		case "i":
    			return Integer.parseInt((String) value);
    		case "d":
    			try {
    				return new SimpleDateFormat(DATE_TYPE_FORMATTER.get(dataType)).parse((String) value);
    			} catch (ParseException e) {
    				throw new RuntimeException("不合法的日期." + value);
    			}
    		default:
    			throw new RuntimeException("非法的数据类型" + dataType);
    		}
    	}
    }

**注意事项:**

1、params 这个map中保存的是前台传递过来的查询条件和值

2、PREFIX 这个用于判断查询条件是否是以这个开头，如果不是则说明不是查询条件

3、SPLIT 这个用于进行查询条件的分割，看长度是否是4

4、DATE\_TYPE\_FORMATTER 当数据类型是日期类型时，需要格式化日期操作。

5、wrapValue 这个方法是根据不同的数据类型，将参数中的值进行包装。

6、convertPredicate 这个方法是根据不同的操作符，封装不同的Predicate

二、编写一个实体类User

/**
     * 用户实体类映射
     * 
     * @描述
     * @作者 huan
     * @时间 2017年10月29日 - 上午11:35:14
     */
    @Table(name = "t_user")
    @Entity
    @Data
    public class User {
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	@Column(name = "id")
    	private String id;
    	@Column(name = "name")
    	private String name;
    	@Column(name = "age")
    	private Integer age;
    }

三、编写UserRepository接口，这个接口需要继承**JpaSpecificationExecutor**这个接口，这个接口是spring data jpa中实现动态查询所必须的

/**
     * 用户查询repository
     * 
     * @描述
     * @作者 huan
     * @时间 2017年10月29日 - 上午11:45:31
     */
    public interface UserRepository extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User> {
    
    }

四、测试  
![aHR0cDovL2RsMi5pdGV5ZS5jb20vdXBsb2FkL2F0dGFjaG1lbnQvMDEyNy81OTY5LzQxYTQwMTAzLWE1NWQtM2FkNi1iMjQxLTcwZDlhOTYwMzg1Zi5wbmc][]

[aHR0cDovL2RsMi5pdGV5ZS5jb20vdXBsb2FkL2F0dGFjaG1lbnQvMDEyNy81OTY5LzQxYTQwMTAzLWE1NWQtM2FkNi1iMjQxLTcwZDlhOTYwMzg1Zi5wbmc]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/04350cab890a4144a867994f69c9a115.png