io.gitee.mingbaobaba.apijson.querycondition.query.template.ApiJsonQueryTemplate Maven / Gradle / Ivy
The newest version!
package io.gitee.mingbaobaba.apijson.querycondition.query.template;
import com.alibaba.fastjson.*;
import io.gitee.mingbaobaba.apijson.querycondition.query.conditions.ApiJsonPageInfo;
import io.gitee.mingbaobaba.apijson.querycondition.query.conditions.ApiJsonQuery;
import io.gitee.mingbaobaba.apijson.querycondition.query.dao.DwQueryDao;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
/**
* 查询模板工具
*
* @author yingsheng.ye
* @version 1.0.0
* @since 2023/6/20 5:46
*/
@Setter
@Slf4j
public class ApiJsonQueryTemplate {
/**
* 数仓查询接口
*/
private DwQueryDao dao;
/**
* 查询列表服务
*
* @param query 查询条件
* @param tClass 结果转换类
* @param 泛型
* @return List
*/
public List getList(ApiJsonQuery query, Class tClass) {
return queryList(query, tClass, null, null);
}
/**
* 查询列表服务
*
* @param query 查询条件
* @param tClass 结果转换类
* @param covertBefore 转换前操作
* @param List
* @return 泛型
*/
public List getList(ApiJsonQuery query, Class tClass, Consumer covertBefore) {
return queryList(query, tClass, covertBefore, null);
}
/**
* 查询列表服务
*
* @param query 查询条件
* @param tClass 结果转换类
* @param covertBefore 转换前操作
* @param covertAfter 转换后操作
* @param 泛型
* @return List
*/
public List getList(ApiJsonQuery query, Class tClass, Consumer covertBefore, BiConsumer covertAfter) {
return queryList(query, tClass, covertBefore, covertAfter);
}
/**
* 查询列表服务
*
* @param query 查询条件
* @param typeReference 结果转换类
* @param 泛型
* @return List
*/
public List getList(ApiJsonQuery query, TypeReference typeReference) {
return queryList(query, typeReference, null, null);
}
/**
* 查询列表服务
*
* @param query 查询条件
* @param typeReference 结果转换类
* @param covertBefore 转换前操作
* @param 泛型
* @return List
*/
public List getList(ApiJsonQuery query, TypeReference typeReference, Consumer covertBefore) {
return queryList(query, typeReference, covertBefore, null);
}
/**
* 查询列表服务
*
* @param query 查询条件
* @param typeReference 结果转换类
* @param covertBefore 转换前操作
* @param covertAfter 转换后操作
* @param 泛型
* @return List
*/
public List getList(ApiJsonQuery query, TypeReference typeReference, Consumer covertBefore, BiConsumer covertAfter) {
return queryList(query, typeReference, covertBefore, covertAfter);
}
/**
* 查询一条数据
*
* @param query 查询条件
* @param tClass 结果转换类
* @param 泛型
* @return T
*/
public T getOne(ApiJsonQuery query, Class tClass) {
return getOne(query, tClass, null);
}
/**
* 查询一条数据
*
* @param query 查询条件
* @param tClass 结果转换类
* @param covertBefore 转换前操作
* @param 泛型
* @return T
*/
public T getOne(ApiJsonQuery query, Class tClass, Consumer covertBefore) {
return getOne(query, tClass, covertBefore, null);
}
/**
* 查询一条数据
*
* @param query 查询条件
* @param tClass 结果转换类
* @param covertBefore 转换前操作
* @param covertAfter 转换后操作
* @param 泛型
* @return T
*/
public T getOne(ApiJsonQuery query, Class tClass, Consumer covertBefore, BiConsumer covertAfter) {
List list = queryList(query, tClass, covertBefore, covertAfter);
if (CollectionUtils.isEmpty(list)) {
return null;
}
Assert.isTrue(list.size() == 1, "期望返回一条数据，但是结果返回多条数据");
return list.get(0);
}
/**
* 查询一条数据
*
* @param query 查询条件
* @param typeReference 结果转换类
* @param 泛型
* @return T
*/
public T getOne(ApiJsonQuery query, TypeReference typeReference) {
return getOne(query, typeReference, null, null);
}
/**
* 查询一条数据
*
* @param query 查询条件
* @param typeReference 结果转换类
* @param covertBefore 转换前操作
* @param 泛型
* @return T
*/
public T getOne(ApiJsonQuery query, TypeReference typeReference, Consumer covertBefore) {
return getOne(query, typeReference, covertBefore, null);
}
/**
* 查询一条数据
*
* @param query 查询条件
* @param typeReference 结果转换类
* @param covertBefore 转换前操作
* @param covertAfter 转换后操作
* @param 泛型
* @return T
*/
public T getOne(ApiJsonQuery query, TypeReference typeReference, Consumer covertBefore, BiConsumer covertAfter) {
List list = queryList(query, typeReference, covertBefore, covertAfter);
Assert.isTrue(list.size() == 1, "期望返回一条数据，但是结果返回多条数据");
return list.get(0);
}
/**
* 查询统计条数
*
* @param query 查询条件
* @return 条数
*/
public Long count(ApiJsonQuery query) {
Map params = new HashMap<>(16);
params.put("@schema", query.getSchema());
params.put("total@", "/[]/total");
Map modelParams = new HashMap<>(16);
modelParams.put(query.getTable(), query.getApiJsonParam());
//查询表中的所有数据
modelParams.put("query", 1);
params.put("[]", modelParams);
JSONObject data = resultToObject(dao.getData(params, query));
return Objects.nonNull(data) ? data.getLong("total") : 0L;
}
/**
* 分页查询结果
*
* @param query 查询条件
* @param page 当前页
* @param limit 分页条数
* @param tClass 转换类
* @param 泛型
* @return DwPageInfo
*/
public ApiJsonPageInfo getPageList(ApiJsonQuery query, Integer page, Integer limit, Class tClass) {
return queryPageList(query, page, limit, tClass, null, null);
}
/**
* 分页查询结果
*
* @param query 查询条件
* @param page 当前页
* @param limit 分页条数
* @param tClass 转换类
* @param covertBefore 转换前操作
* @param 泛型
* @return DwPageInfo
*/
public ApiJsonPageInfo getPageList(ApiJsonQuery query, Integer page, Integer limit, Class tClass, Consumer covertBefore) {
return queryPageList(query, page, limit, tClass, covertBefore, null);
}
/**
* 分页查询结果
*
* @param query 查询条件
* @param page 当前页
* @param limit 分页条数
* @param tClass 转换类
* @param covertBefore 转换前操作
* @param covertAfter 转换后操作
* @param 泛型
* @return DwPageInfo
*/
public ApiJsonPageInfo getPageList(ApiJsonQuery query, Integer page, Integer limit, Class tClass, Consumer covertBefore, BiConsumer covertAfter) {
return queryPageList(query, page, limit, tClass, covertBefore, covertAfter);
}
/**
* 分页查询结果
*
* @param query 查询条件
* @param page 当前页
* @param limit 分页条数
* @param typeReference 转换类
* @param 泛型
* @return DwPageInfo
*/
public ApiJsonPageInfo getPageList(ApiJsonQuery query, Integer page, Integer limit, TypeReference typeReference) {
return queryPageList(query, page, limit, typeReference, null, null);
}
/**
* 分页查询结果
*
* @param query 查询条件
* @param page 当前页
* @param limit 分页条数
* @param typeReference 转换类
* @param covertBefore 转换前操作
* @param 泛型
* @return DwPageInfo
*/
public ApiJsonPageInfo getPageList(ApiJsonQuery query, Integer page, Integer limit, TypeReference typeReference, Consumer covertBefore) {
return queryPageList(query, page, limit, typeReference, covertBefore, null);
}
/**
* 分页查询结果
*
* @param query 查询条件
* @param page 当前页
* @param limit 分页条数
* @param typeReference 转换类
* @param covertBefore 转换前操作
* @param covertAfter 转换后操作
* @param 泛型
* @return DwPageInfo
*/
public ApiJsonPageInfo getPageList(ApiJsonQuery query, Integer page, Integer limit, TypeReference typeReference, Consumer covertBefore, BiConsumer covertAfter) {
return queryPageList(query, page, limit, typeReference, covertBefore, covertAfter);
}
/**
* 分页查询结果
*
* @param query 查询条件
* @param page 当前页
* @param limit 分页条数
* @param o 转换类
* @param 泛型
* @return DwPageInfo
*/
private ApiJsonPageInfo queryPageList(ApiJsonQuery query, Integer page, Integer limit, Object o, Consumer covertBefore, BiConsumer covertAfter) {
Map params = query.getApiJsonParam();
//如果同时为空取参数构建中的page值
if (null != page || null != limit) {
if (null == page || page < 1) {
page = 1;
}
if (null == limit || limit < 1) {
limit = 10;
}
params.put("total@", "/[]/total");
@SuppressWarnings("unchecked")
Map modelParams = (Map) params.get("[]");
//apiJson分页从0开始
int currentPage = page - 1;
//查询表中的所有数据
modelParams.put("page", currentPage);
modelParams.put("count", limit);
modelParams.put("query", 2);
}
JSONObject data = resultToObject(dao.getData(params, query));
ApiJsonPageInfo dwPageInfo = new ApiJsonPageInfo<>();
dwPageInfo.setData(praseResultToList(query, data, o, covertBefore, covertAfter));
dwPageInfo.setPage(page);
dwPageInfo.setLimit(limit);
dwPageInfo.setTotal(data.containsKey("total") ? data.getLong("total") : 0L);
return dwPageInfo;
}
/**
* 查询列表服务
*
* @param query 查询条件
* @param o 结果转换类
* @param covertBefore 转换前
* @param covertAfter 转换后
* @param 泛型
* @return List
*/
public List queryListLoop(ApiJsonQuery query, Object o, Consumer covertBefore, BiConsumer covertAfter) {
//apiJson返回单次有最大限制，所以需要循环分次获取
List result = new ArrayList<>();
int limit = 2000;
int page = 1;
loopQueryPage(result, page, limit, query, o, covertBefore, covertAfter);
return result;
}
/**
* 查询列表服务
*
* @param query 查询条件
* @param o 结果转换类
* @param covertBefore 转换前
* @param covertAfter 转换后
* @param 泛型
* @return List
*/
public List queryList(ApiJsonQuery query, Object o, Consumer covertBefore, BiConsumer covertAfter) {
Map params = query.getApiJsonParam();
JSONObject data = resultToObject(dao.getData(params, query));
return praseResultToList(query, data, o, covertBefore, covertAfter);
}
/**
* 查询列表
*
* @param result 查询结果
* @param page 当前页
* @param limit 分页大小
* @param query 查询条件
* @param o 返回类型
* @param covertBefore 转换前
* @param covertAfter 转换后
* @param 泛型
*/
private void loopQueryPage(List result, int page, int limit, ApiJsonQuery query, Object o, Consumer covertBefore, BiConsumer covertAfter) {
ApiJsonPageInfo dwPageInfo = queryPageList(query, page, limit, o, covertBefore, covertAfter);
result.addAll(dwPageInfo.getData());
if ((long) page * limit < dwPageInfo.getTotal()) {
//循环调用
loopQueryPage(result, ++page, limit, query, o, covertBefore, covertAfter);
}
}
/**
* 结果转换
*
* @param res 返回结果
* @return JSONObject
*/
private JSONObject resultToObject(String res) {
return JSON.parseObject(res);
}
/**
* 将结果转换为list
*
* @param query 查询条件
* @param data 数据
* @param o 类型
* @param Class
* @return List
*/
private List praseResultToList(ApiJsonQuery query, JSONObject data, Object o, Consumer covertBefore, BiConsumer covertAfter) {
//解析结果转义
JSONArray jsonArray = data.getJSONArray("[]");
List list = new ArrayList<>();
if (!CollectionUtils.isEmpty(jsonArray)) {
for (int i = 0; i < jsonArray.size(); i++) {
JSONObject resultObj = jsonArray.getJSONObject(i).getJSONObject(query.getTable());
if (StringUtils.isNotBlank(query.getJoinTable())) {
//关联结果
JSONObject relResultObj = jsonArray.getJSONObject(i).getJSONObject(query.getJoinTable());
//合并结果
resultObj.keySet().forEach(key -> {
String keyAlias = resultObj.containsKey(key) ? "_" + key : key;
Object value = relResultObj.get(key);
resultObj.put(keyAlias, value);
});
}
if (null != covertBefore) {
covertBefore.accept(resultObj);
}
//结果对象
T covertResultObj = covertObj(o, resultObj);
if (null != covertAfter) {
covertAfter.accept(resultObj, covertResultObj);
}
list.add(covertResultObj);
}
}
return list;
}
/**
* 对象转换
*
* @param o 转换类
* @param resultObj 结果数据
* @param 泛型
* @return T
*/
@SuppressWarnings("unchecked")
private T covertObj(Object o, JSONObject resultObj) {
//结果对象
T covertResultObj;
//将结果转换成对象
if (o instanceof JSONObject) {
covertResultObj = (T) o;
} else if (o instanceof TypeReference) {
TypeReference tTypeReference = (TypeReference) o;
covertResultObj = JSON.parseObject(JSON.toJSONString(resultObj), tTypeReference);
} else {
Class tClass = (Class) o;
covertResultObj = JSON.parseObject(JSON.toJSONString(resultObj), tClass);
}
return covertResultObj;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy