MongoDB 多层级查询

多层级查询

注意：要注意代码顺序 查询层级数据代码放前面，查询条件放后面

    if (StringUtils.isBlank(params.getDocType())) {
params.setDocType(DOC_TDCTYPE);
}
String docName = mapper.findByDocInfo(params.getDocType());
List<ExpertApprovalOpinionsVO> expertApprovalOpinionsVOS = new ArrayList<>();
String opinion = params.getApprovalOpinions();
String chapterName = params.getChapterName();
String approvalPerson = params.getApprovalPerson();
Criteria criteria = new Criteria();
Criteria[] criteriaArray = new Criteria[0];
List<AggregationOperation> operations = new ArrayList<>();
//分页条件
int skip = (page - 1) * pageSize;
AggregationOperation skipOperation = Aggregation.skip((long) skip);
AggregationOperation limitOperation = Aggregation.limit((long) pageSize);
//多层级查询条件
// 展开第一层级数组commentThreads
AggregationOperation unwind1 = Aggregation.unwind(COMMENTTHREADS);
// 展开第二层级数组commentThreads.comments
AggregationOperation unwind2 = Aggregation.unwind(COMMENTTHREADS_COMMENTS);
operations.add(unwind1);
operations.add(unwind2);
//添加条件查询 ，单个查询条件和 多个 查询值
if (StringUtils.isNotBlank(chapterName)) {
//查詢出 章节key 用于根据章节key查询 MongoDB 的章节批注意见
List<Map<String, Object>> modelKeyList = mapper.findByModelKey(params);
if (!modelKeyList.isEmpty()) {
// 匹配满足单次正则表达式的文档
if (modelKeyList.size() == 1) {
Pattern pattern = Pattern.compile(ObjectUtils.toString(modelKeyList.get(0).get(MODEL_KEY)), Pattern.CASE_INSENSITIVE); // 根据您的需要指定模糊匹配的正则表达式和匹配选项
MatchOperation match = Aggregation.match(Criteria.where(KEY).regex(pattern));
operations.add(match);
} else {
// 匹配满足批量正则表达式的文档
// 章节key集合
List<String> threadId = modelKeyList.stream()
.map(map -> map.get(MODEL_KEY) != null ? String.valueOf(map.get(MODEL_KEY)) : null)
.filter(Objects::nonNull)
.collect(Collectors.toList());
// 构建匹配条件列表
List<Criteria> criteriaList = new ArrayList<>();
for (String pattern : threadId) {
// 构造正则表达式匹配条件
String regexPattern = ".*" + Pattern.compile(pattern) + ".*";
criteriaList.add(Criteria.where(KEY).regex(regexPattern));
}
// 使用$or操作符组合多个条件
Criteria orCriteria = new Criteria().orOperator(criteriaList.toArray(new Criteria[criteriaList.size()]));
AggregationOperation match2 = Aggregation.match(orCriteria);
operations.add(match2);
}
} else {
return expertApprovalOpinionsVOS;
}
}
if (StringUtils.isNotBlank(approvalPerson)) {
//模糊查询出用户
List<Map<String, Object>> userList = mapper.findByUser(params);
if (!userList.isEmpty()) {
//用户集合
List<String> authorId = userList.stream()
.map(map -> map.get(USER_ID) != null ? String.valueOf(map.get(USER_ID)) : null)
.filter(Objects::nonNull)
.collect(Collectors.toList());
criteria = Criteria.where(COMMENTTHREADS_COMMENTS_AUTHORID).in(authorId);
AggregationOperation match = Aggregation.match(new Criteria().andOperator(criteria));
operations.add(match);
} else {
return expertApprovalOpinionsVOS;
}
}
if (StringUtils.isNotBlank(opinion)) {
Pattern pattern1 = Pattern.compile(opinion, Pattern.CASE_INSENSITIVE);
criteria = Criteria.where(COMMENTTHREADS_COMMENTS_CONTENT).regex(pattern1);
AggregationOperation match2 = Aggregation.match(criteria);
operations.add(match2);
}
/**
* project 新的 数据 包含 "crt_time", "nodeId", "processInstanceId", "nodeCrtTime"
* andExclude 排除 "_id"
* andExpression 执行 表达式 ，取出对应的 数据值
* as 生成的 新数据的 名称
*/
operations.add(Aggregation.project("crt_time", "nodeId", "processInstanceId", "nodeCrtTime").andExclude("_id").andExpression(COMMENTTHREADS_COMMENTS).as(COMMENTS)
);
operations.add(Aggregation.sort(Sort.Direction.DESC, "crt_time"));
operations.add(skipOperation);
operations.add(limitOperation);
Aggregation aggregation = Aggregation.newAggregation(operations);
//查询
AggregationResults<Map> result = template.aggregate(aggregation, params.getDocType() + ".approvals", Map.class);
//获取结果
List<Map> mappedResults = result.getMappedResults();