ES-Client-api-easy es

官方文档:

https://www.easy-es.cn/pages/ce1922/#常规聚合

 

目前感觉不错,简单CRUD支持 复杂的也可以混合模式支持

 例子一

DSL

{
    "size": 1,
    "query": {
        "bool": {
            "must": [
                {
                    "term": {
                        "awardPunishmentType": {
                            "value": 1,
                            "boost": 1.0
                        }
                    }
                },
                {
                    "term": {
                        "formType": {
                            "value": 1,
                            "boost": 1.0
                        }
                    }
                },
                {
                    "range": {
                        "createdTime": {
                            "from": "2024-11-11 16:00:00",
                            "to": null,
                            "include_lower": true,
                            "include_upper": true,
                            "boost": 1.0
                        }
                    }
                },
                {
                    "range": {
                        "createdTime": {
                            "from": null,
                            "to": "2024-11-12 15:59:59",
                            "include_lower": true,
                            "include_upper": true,
                            "boost": 1.0
                        }
                    }
                }
            ],
            "adjust_pure_negative": true,
            "boost": 1.0
        }
    },
    "track_total_hits": 2147483647,
    "aggs": {
        "billingOrgCodeTerms": {
            "terms": {
                "field": "billingOrgCodeL1",
                "size": 10,
                "min_doc_count": 1,
                "shard_min_doc_count": 0,
                "show_term_doc_count_error": false
            },
            "aggregations": {
                "orgCodeCount": {
                    "value_count": {
                        "field": "billingOrgCodeL1"
                    }
                },
                "auditStatus_10": {
                    "filter": {
                        "term": {
                            "auditStatus": "10"
                        }
                    }
                },
                "auditStatus_20": {
                    "filter": {
                        "term": {
                            "auditStatus": "20"
                        }
                    }
                },
                "auditStatus_30": {
                    "filter": {
                        "term": {
                            "auditStatus": "30"
                        }
                    }
                },
                "auditStatusPassPercentage": {
                    "bucket_script": {
                        "buckets_path": {
                            "auditStatusCount": "auditStatus_30._count", // 引用 auditStatus_30 的 doc_count
                            "orgCodeCount": "orgCodeCount"
                        },
                        "script": "params.auditStatusCount / params.orgCodeCount * 100"
                    }
                }
                
            }
        }
    }
}
View Code

 

    @Override
    public List<QueryAuditStatusStatsResDTO> queryAuditStatusStatsByCondition(
        QueryAuditStatusStatsByCondition queryDTO) {
        if (Objects.isNull(queryDTO.getStartCreatedTime()) || Objects.isNull(queryDTO.getEndCreatedTime())) {
            return Lists.newArrayList();
        }
        LambdaEsQueryWrapper<AwardPunishmentDocument> wrapper = new LambdaEsQueryWrapper<>();
        wrapper.ge(AwardPunishmentDocument::getCreatedTime,
            DateHelper.format(queryDTO.getStartCreatedTime(), DateHelper.DATETIME_FORMAT));
        wrapper.le(AwardPunishmentDocument::getCreatedTime,
            DateHelper.format(queryDTO.getEndCreatedTime(), DateHelper.DATETIME_FORMAT));
        if (CollectionUtils.isNotEmpty(queryDTO.getCascadeBillingOrgCodeList())) {
            //利用分词匹配
            String fullOrgPathStr = String.join(AwardPunishmentElasticsearchConstants.ORG_PATH_SPIT_CHAR,
                queryDTO.getCascadeBillingOrgCodeList());
            wrapper.match(AwardPunishmentDocument::getBillingOrgCodePath, fullOrgPathStr);
        }
        if (CollectionUtils.isNotEmpty(queryDTO.getBillingOrgCodePathQueryCodeList())) {
            //利用分词匹配
            String fullOrgPathStr = String.join(AwardPunishmentElasticsearchConstants.ORG_PATH_SPIT_CHAR,
                queryDTO.getBillingOrgCodePathQueryCodeList());
            wrapper.match(AwardPunishmentDocument::getQueryBillingPath, fullOrgPathStr);
        }
        if (Objects.nonNull(queryDTO.getAwardPunishmentType())) {
            wrapper.eq(AwardPunishmentDocument::getAwardPunishmentType, queryDTO.getAwardPunishmentType().value());
        }
        wrapper.groupBy(
            AwardPunishmentDocument::getAuditStatus);
        SearchResponse response = awardPunishmentDocumentMapper.search(wrapper);
        return convert2QueryAuditStatusStatsByCondition(response);

    }
View Code

 

  @Override
    public IPage<PageAuditStatusStatsOrgResDTO> pageAuditStatusStatsOrgByCondition(
        PageAuditStatusStatsOrgByConditionQueryDTO queryDTO) {
        if (Objects.isNull(queryDTO.getStartCreatedTime()) || Objects.isNull(queryDTO.getEndCreatedTime())) {
            return new Page<>(queryDTO.getCurrentPage(), queryDTO.getPageSize());
        }
        LambdaEsQueryWrapper<AwardPunishmentDocument> wrapper = buildQueryWrapper(
            queryDTO);
        wrapper.size(0);
        long form = (queryDTO.getCurrentPage() - 1) * queryDTO.getPageSize();
        String level = "billingOrgCodeL%s";
        if (CollectionUtils.isEmpty(queryDTO.getBillingOrgCodePathQueryCodeList())) {
            level = String.format(level, 1);
        } else {
            level = String.format(level, queryDTO.getBillingOrgCodePathQueryCodeList().size());
        }
        //前端滚动到最后没有数据表示最后一页
        Page<PageAuditStatusStatsOrgResDTO> pageResult = new Page<>();
        pageResult.setPages(Integer.MAX_VALUE);
        pageResult.setSize(queryDTO.getPageSize());
        pageResult.setCurrent(queryDTO.getCurrentPage());
        pageResult.setRecords(Lists.newArrayList());
        try {
            //复杂聚合查询使用ES原生客户端
            SearchSourceBuilder searchSourceBuilder = awardPunishmentDocumentMapper.getSearchSourceBuilder(wrapper);
            TermsAggregationBuilder termsAggregation = AggregationBuilders.terms("billingOrgCodeTerms").field(level);
            // 在每个 billingOrgCodeL1 的桶下,进行进一步的聚合
            termsAggregation.subAggregation(
                AggregationBuilders.count("orgCodeCount").field(level));
            termsAggregation.subAggregation(
                AggregationBuilders.filter(
                    AwardPunishmentElasticsearchConstants.WAIT_AUDIT_KEY,
                    QueryBuilders.termQuery("auditStatus", AwardPunishmentAuditStatusEnum.WAIT_AUDIT.value())));
            termsAggregation.subAggregation(
                AggregationBuilders.filter(
                    AwardPunishmentElasticsearchConstants.AUDIT_PASS_KEY,
                    QueryBuilders.termQuery("auditStatus", AwardPunishmentAuditStatusEnum.AUDIT_PASS.value())));
            termsAggregation.subAggregation(
                AggregationBuilders.filter(
                    AwardPunishmentElasticsearchConstants.AUDIT_FAIL_KEY,
                    QueryBuilders.termQuery("auditStatus", AwardPunishmentAuditStatusEnum.AUDIT_FAIL.value())));
            termsAggregation.subAggregation(
                AggregationBuilders.filter(
                    AwardPunishmentElasticsearchConstants.CANCEL_KEY,
                    QueryBuilders.termQuery("auditStatus", AwardPunishmentAuditStatusEnum.CANCEL.value())));
            //计算通过率
            BucketScriptPipelineAggregationBuilder bucketScriptPipelineAggregationBuilder = new BucketScriptPipelineAggregationBuilder(
                "auditStatusPassPercentage",
                new Script("params._value0/ params._value1"),
                String.format("auditStatus_%s._count", AwardPunishmentAuditStatusEnum.AUDIT_PASS.value()),
                "orgCodeCount");
            // 使用 bucket_script 聚合计算 审核通过的 的百分比
            termsAggregation.subAggregation(bucketScriptPipelineAggregationBuilder);

            //进行排序
            FieldSortBuilder sortBuilder = new FieldSortBuilder("auditStatusPassPercentage").order(
                SortOrder.DESC);
            termsAggregation.subAggregation(
                new BucketSortPipelineAggregationBuilder("order_by_percentage",
                    Collections.singletonList(sortBuilder)).from((int) form)
                    .size(10));
            searchSourceBuilder.aggregation(termsAggregation);
            wrapper.setSearchSourceBuilder(searchSourceBuilder);
            SearchResponse response = awardPunishmentDocumentMapper.search(wrapper);
            List<PageAuditStatusStatsOrgResDTO> resDTOList = convert2PageAuditStatusStatsOrgResDTO(
                response);
            pageResult.setRecords(resDTOList);
        } catch (Exception e) {
            log.error("B端组织下钻统计 pageAuditStatusStatsOrgListByCondition 异常", e);
            return pageResult;
        }
        return pageResult;
    }
View Code

 例子2

dsl

{
    "size": 0,
    "query": {
        "bool": {
            "must": [
                {
                    "exists": {
                        "field": "rectifyNo",
                        "boost": 1.0
                    }
                },
                {
                    "match": {
                        "orgPath": {
                            "query": "10010000",
                            "operator": "OR",
                            "prefix_length": 0,
                            "max_expansions": 50,
                            "fuzzy_transpositions": true,
                            "lenient": false,
                            "zero_terms_query": "NONE",
                            "auto_generate_synonyms_phrase_query": true,
                            "boost": 1.0
                        }
                    }
                },
                {
                    "term": {
                        "month": {
                            "value": "2024-11",
                            "boost": 1.0
                        }
                    }
                }
            ],
            "adjust_pure_negative": true,
            "boost": 1.0
        }
    },
    "track_total_hits": 2147483647,
    "aggregations": {
        "rectify_order_count": {
            "cardinality": {
                "field": "rectifyNo"
            }
        },
        "rectify_item_count": {
            "cardinality": {
                "field": "rectifyItemNo"
            }
        },
        "store_code_count": {
            "cardinality": {
                "field": "storeCode"
            }
        },
        "rectified_count": {
            "filter": {
                "term": {
                    "rectifyItemStatus": {
                        "value": 20,
                        "boost": 1.0
                    }
                }
            }
        }
    }
}

 

常量定义

/**
 * @Author liqiang
 * @Description 巡检整改es相关常量
 * @Date 2024/11/28/16:06
 */
public class PatrolRectifyElasticSearchConstants {

    private PatrolRectifyElasticSearchConstants() {

    }

    /**
     * 整改单编号
     */
    public final static String RECTIFY_NO_FIELD_NAME = "rectifyNo";

    /**
     * 整改项编号
     */
    public final static String RECTIFY_ITEM_NO_FIELD_NAME = "rectifyItemNo";

    /**
     * 整改门店编号
     */
    public final static String STORE_CODE_FIELD_NAME = "storeCode";


    /**
     * 整改项状态
     */
    public final static String RECTIFY_ITEM_STATUS_FIELD_NAME = "rectifyItemStatus";


    /**
     * 整改单编号聚合
     */
    public static final String RECTIFY_ORDER_COUNT_CARDINALITY_AGG_NAME = "rectify_order_count";

    /**
     * 整改项编号聚合
     */
    public static final String RECTIFY_ITEM_COUNT_CARDINALITY_AGG_NAME = "rectify_item_count";

    /**
     * 整改门店编号聚合
     */
    public static final String STORE_CODE_COUNT_CARDINALITY_AGG_NAME = "store_code_count";

    /**
     * 已整改聚合
     */
    public static final String RECTIFIED_FILTER_AGG_NAME = "rectified_count";
}

查询条件构建

 private LambdaEsUpdateWrapper<PatrolRecordDetailDocument> buildWrapper(
        GetRectifyStatsQueryDTO queryDTO) {
        LambdaEsUpdateWrapper<PatrolRecordDetailDocument> wrapper = new LambdaEsUpdateWrapper<>();
        wrapper.exists(PatrolRectifyElasticSearchConstants.RECTIFY_NO_FIELD_NAME);
        if (CollectionUtils.isNotEmpty(queryDTO.getCascadeOrgCodeList())) {
            //利用分词匹配
            String fullOrgPathStr = String.join(ElasticsearchConstants.PATTERN_HYPHEN,
                queryDTO.getCascadeOrgCodeList());
            wrapper.match(PatrolRecordDetailDocument::getOrgPath, fullOrgPathStr);
        }
        if (StringUtils.isNotBlank(queryDTO.getCascadeOrgCode())) {
            wrapper.match(PatrolRecordDetailDocument::getOrgPath, queryDTO.getCascadeOrgCode());
        }
        if (StringUtils.isNotBlank(queryDTO.getOriginFormNo())) {
            wrapper.eq(PatrolRecordDetailDocument::getOriginFormNo, queryDTO.getOriginFormNo());
        }
        if (StringUtils.isNotBlank(queryDTO.getOrgClass())) {
            wrapper.eq(PatrolRecordDetailDocument::getStoreType, queryDTO.getOrgClass());
        }
        if (StringUtils.isNotBlank(queryDTO.getYearMonth())) {
            wrapper.eq(PatrolRecordDetailDocument::getMonth, queryDTO.getYearMonth());
        }
        if (StringUtils.isNotBlank(queryDTO.getYear())) {
            wrapper.eq(PatrolRecordDetailDocument::getYear, queryDTO.getYear());
        }
        return wrapper;
    }

查询定义

 @Override
    public GetRectifyStatsDBResDTO getRectifyStatsByCondition(GetRectifyStatsQueryDTO queryDTO) {
        LambdaEsUpdateWrapper<PatrolRecordDetailDocument> wrapper = buildWrapper(
            queryDTO);
        wrapper.size(0);
        try {
            //复杂聚合查询使用ES原生客户端
            SearchSourceBuilder searchSourceBuilder = patrolRecordDetailDocumentEsMapper.getSearchSourceBuilder(
                wrapper);

            CardinalityAggregationBuilder rectifyNoCardinalityAgg = AggregationBuilders
                .cardinality(PatrolRectifyElasticSearchConstants.RECTIFY_ORDER_COUNT_CARDINALITY_AGG_NAME)
                .field(PatrolRectifyElasticSearchConstants.RECTIFY_NO_FIELD_NAME);
            searchSourceBuilder.aggregation(rectifyNoCardinalityAgg);

            CardinalityAggregationBuilder rectifyItemCardinalityAgg = AggregationBuilders
                .cardinality(PatrolRectifyElasticSearchConstants.RECTIFY_ITEM_COUNT_CARDINALITY_AGG_NAME)
                .field(PatrolRectifyElasticSearchConstants.RECTIFY_ITEM_NO_FIELD_NAME);
            searchSourceBuilder.aggregation(rectifyItemCardinalityAgg);

            CardinalityAggregationBuilder storeCodeCardinalityAgg = AggregationBuilders
                .cardinality(PatrolRectifyElasticSearchConstants.STORE_CODE_COUNT_CARDINALITY_AGG_NAME)
                .field(PatrolRectifyElasticSearchConstants.STORE_CODE_FIELD_NAME);
            searchSourceBuilder.aggregation(storeCodeCardinalityAgg);

            FilterAggregationBuilder rectifiedFilterAgg = AggregationBuilders
                .filter(PatrolRectifyElasticSearchConstants.RECTIFIED_FILTER_AGG_NAME,
                    QueryBuilders.termQuery(PatrolRectifyElasticSearchConstants.RECTIFY_ITEM_STATUS_FIELD_NAME,
                        PatrolRectifyItemStatusEnum.RECTIFIED.value()));
            searchSourceBuilder.aggregation(rectifiedFilterAgg);

            wrapper.setSearchSourceBuilder(searchSourceBuilder);
            SearchResponse search = patrolRecordDetailDocumentEsMapper.search(wrapper);
            return convert2GetRectifyStatsDBResDTO(search);
        } catch (Exception e) {
            log.error("getRectifyStatsByCondition error", e);
            return new GetRectifyStatsDBResDTO();
        }
    }

响应参数解析

private GetRectifyStatsDBResDTO convert2GetRectifyStatsDBResDTO(SearchResponse response) {
        GetRectifyStatsDBResDTO getRectifyStatsDBResDTO = new GetRectifyStatsDBResDTO();
        if (Objects.isNull(response.getAggregations()) && CollectionUtils.isEmpty(
            response.getAggregations().asList())) {
            return getRectifyStatsDBResDTO;
        }
        Map<String, Aggregation> aggNameMap = response.getAggregations().getAsMap();
        if (MapUtils.isEmpty(aggNameMap)) {
            return getRectifyStatsDBResDTO;
        }
        Aggregation orderCountaggregation = aggNameMap.get(
            PatrolRectifyElasticSearchConstants.RECTIFY_ORDER_COUNT_CARDINALITY_AGG_NAME);
        if (orderCountaggregation instanceof ParsedCardinality) {
            long orderCount = ((ParsedCardinality) orderCountaggregation).getValue();
            getRectifyStatsDBResDTO.setRectifyNumber(Long.valueOf(orderCount).intValue());
        }

        Aggregation itemAggregation = aggNameMap.get(
            PatrolRectifyElasticSearchConstants.RECTIFY_ITEM_COUNT_CARDINALITY_AGG_NAME);
        if (itemAggregation instanceof ParsedCardinality) {
            long itemCount = ((ParsedCardinality) itemAggregation).getValue();
            getRectifyStatsDBResDTO.setRectifyItemNumber(Long.valueOf(itemCount).intValue());
        }

        Aggregation storeAggregation = aggNameMap.get(
            PatrolRectifyElasticSearchConstants.STORE_CODE_COUNT_CARDINALITY_AGG_NAME);
        if (storeAggregation instanceof ParsedCardinality) {
            long itemCount = ((ParsedCardinality) storeAggregation).getValue();
            getRectifyStatsDBResDTO.setRectifyStoreNumber(Long.valueOf(itemCount).intValue());
        }
        Aggregation rectifiedAggregation = aggNameMap.get(
            PatrolRectifyElasticSearchConstants.RECTIFIED_FILTER_AGG_NAME);
        if (rectifiedAggregation instanceof ParsedFilter) {
            long itemCount = ((ParsedFilter) rectifiedAggregation).getDocCount();
            getRectifyStatsDBResDTO.setRectifiedCount(Long.valueOf(itemCount).intValue());
        }
        return getRectifyStatsDBResDTO;

    }

 

posted @ 2024-11-12 11:55  意犹未尽  阅读(21)  评论(0编辑  收藏  举报