封装hibernate查询方式（JPA）

封装采用标准查询方式，传值使用数组形式传值，同时对对象字段类型进行判断，避免字段类型不一致导致报错
查询条件生成点击下载java文件

/**
 * 查询条件生成,支持生成=,<,>,<=,>=五种查询条件
 * @param param 参数:数组
 * @param clz
 * @param builder
 * @param root 
 * @return
 * @throws Exception
*/
protected List createPredicate(String[] param, CriteriaBuilder builder, Root root, Class clz) throws Exception{
	List predicates = new ArrayList<>();
	for (int i = 0; i < param.length; i++) {
		String[] keyValue = null;
		try {
			keyValue = param[i].split("\\=|\\>|\\>=|\\<|\\<=|\\!=");
		}catch (Exception e) {
			throw new Exception("请确认格式为{a=1,b>=2}的数组格式") ;
		}
		Class type = null;
		try {
			type = clz.getDeclaredField(keyValue[0]).getType();
		}catch (Exception e) {
			throw new Exception("请确认传入字段是否正确") ;
		}
		if(type == String.class) {
			if(param[i].contains("=")) {
				predicates.add(builder.equal(root.get(keyValue[0]), keyValue[1]));
			}else if(param[i].contains("!=")) {
				predicates.add(builder.notEqual(root.get(keyValue[0]), keyValue[1]));
			}else {
				throw new Exception("String类型不支持比较大小");
			}
		} else if(type == Integer.class) {
			if(param[i].contains("=")) {
				predicates.add(builder.equal(root.get(keyValue[0]), Integer.parseInt(keyValue[1])));
			}else if(param[i].contains(">")) {
				predicates.add(builder.gt(root.get(keyValue[0]), Integer.parseInt(keyValue[1])));
			}else if(param[i].contains("<")) {
				predicates.add(builder.lt(root.get(keyValue[0]), Integer.parseInt(keyValue[1])));
			}else if(param[i].contains(">=")) {
				predicates.add(builder.ge(root.get(keyValue[0]), Integer.parseInt(keyValue[1])));
			}else if(param[i].contains("<=")) {
				predicates.add(builder.le(root.get(keyValue[0]), Integer.parseInt(keyValue[1])));
			}else if(param[i].contains("!=")) {
				predicates.add(builder.notEqual(root.get(keyValue[0]), Integer.parseInt(keyValue[1])));
			}
		} else if(type == Date.class) {
			if(param[i].contains("=")) {
				predicates.add(builder.equal(root.get(keyValue[0]), DateUtils.parse(keyValue[1])));
			}else if(param[i].contains(">")) {
				predicates.add(builder.greaterThan(root.get(keyValue[0]), DateUtils.parse(keyValue[1])));
			}else if(param[i].contains("<")) {
				predicates.add(builder.lessThan(root.get(keyValue[0]), DateUtils.parse(keyValue[1])));
			}else if(param[i].contains(">=")) {
				predicates.add(builder.greaterThanOrEqualTo(root.get(keyValue[0]), DateUtils.parse(keyValue[1])));
			}else if(param[i].contains("<=")) {
				predicates.add(builder.lessThanOrEqualTo(root.get(keyValue[0]), DateUtils.parse(keyValue[1])));
			}else if(param[i].contains("!=")) {
				predicates.add(builder.notEqual(root.get(keyValue[0]), DateUtils.parse(keyValue[1])));
			}
		}else {
			throw new Exception("查询失败，不支持当前类型");
		}
	}
	return predicates;
}

具体查询方法封装

/**
 * 通过code查询单条数据
 * @param clz 查询对象
 * @param code
 * @return
*/
@Override
public Object queryByCode(String code, Class clz){
	CriteriaBuilder builder = entityManager.getCriteriaBuilder();
	CriteriaQuery query = builder.createQuery(clz);
	Root root = query.from(clz);
	List predicates = new ArrayList<>();
	predicates.add(builder.equal(root.get("code"), code));
	predicates.add(builder.equal(root.get("status"), StatusEnum.NORMAL.getId()));
	query.where(predicates.toArray(new Predicate[predicates.size()]));
	query.orderBy(builder.desc(root.get("createTime")));
	List list = entityManager.createQuery(query).getResultList();
	if(list != null && list.size() != 0) {
		return list.get(0);
	}else {
		return null;
	}
}
/**
 * 查询单个对象	 
 *  @param clz 查询对象
 * @param id
 * @return
*/
@Override
public Object queryById(String id, Class clz) {
	return entityManager.find(clz, id);
}	
/**
 * 根据条件查询单条记录(查询到多条记录时，返回最近一条记录)
 * @param param 形如{a=1,b>=2}的数组形式
 * @param clz 查询对象
 * @return
 * @throws Exception 
*/
@Override
public Object queryOne(String[] param, Class clz) throws Exception{
	CriteriaBuilder builder = entityManager.getCriteriaBuilder();
	CriteriaQuery query = builder.createQuery(clz);
	Root root = query.from(clz);	
	List predicates;
	try {
		predicates = createPredicate(param, builder, root, clz);
	} catch (Exception e) {
		throw new Exception("生成查询条件失败,原因:" + e.getMessage());
	}
	query.where(predicates.toArray(new Predicate[predicates.size()]));
	query.orderBy(builder.desc(root.get("createTime")));
	List list = entityManager.createQuery(query).getResultList();
	if(list != null && list.size() != 0) {
		return list.get(0);
	}else {
		return null;
	}
}
	
/**
 * 查询无序List
 * @param param 形如{a=1,b>=2}的数组形式
 * @param clz 查询对象
 * @return
 * @throws Exception
 */
@Override
public List queryList(String[] param, Class clz) throws Exception{
	CriteriaBuilder builder = entityManager.getCriteriaBuilder();
	CriteriaQuery query = builder.createQuery(clz);
	Root root = query.from(clz);
	
	List predicates;
	try {
		predicates = createPredicate(param, builder, root, clz);
	} catch (Exception e) {
		throw new Exception("生成查询条件失败,原因:" + e.getMessage());
	}
	query.where(predicates.toArray(new Predicate[predicates.size()]));
	
	return entityManager.createQuery(query).getResultList();
}

/**
 * 查询有序List
 * @param param 形如{a=1,b>=2}的数组形式
 * @param clz 查询对象
 * @param sort 排序字段
 * @param order 正序倒序
 * @return
 * @throws Exception
 */
@Override
public List queryList(String[] param, String sort, OrderEnum order, Class clz) throws Exception{
	CriteriaBuilder builder = entityManager.getCriteriaBuilder();
	CriteriaQuery query = builder.createQuery(clz);
	Root root = query.from(clz);
	
	List predicates = createPredicate(param, builder, root, clz);
	
	query.where(predicates.toArray(new Predicate[predicates.size()]));
	if(order == OrderEnum.DESC) {
		query.orderBy(builder.desc(root.get(sort)));
	}else if(order == OrderEnum.ASC) {
		query.orderBy(builder.asc(root.get(sort)));
	}
	return entityManager.createQuery(query).getResultList();
}