ES聚合嵌套参数拼接

最新推荐文章于 2023-07-13 16:14:19 发布
最新推荐文章于 2023-07-13 16:14:19 发布
阅读量1.6k 收藏
点赞数
分类专栏： es java 文章标签： elasticsearch java 嵌套聚合 参数拼接
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35461948/article/details/120064343
版权
java 同时被 2 个专栏收录
80 篇文章 3 订阅
订阅专栏
es
14 篇文章 1 订阅
订阅专栏

ES java 请求ES聚合嵌套参数拼接

目录

请求的参数：

代码：

1，StrTermNextScript：

2，模拟数据

3，测试：

总结：

 ​    使用Java请求es聚合查询，这时候使用RestHighLevelClient 进行请求查询，无论是拼接参数，还是处理值都是麻烦些的。如果使用Commons-httpclient里面的 HttpClient进行请求，这时候拼接参数查询就直接是es的语法了，处理值也方便些，没有那么多的类型。

使用 RestHighLevelClient 处理的时候，该如何处理参数呢？

查询query的时候，可以使用 

QueryBuilder queryBuilder = QueryBuilders.wrapperQuery(sourceExpr);
 searchSourceBuilder.query(queryBuilder);

处理aggs参数的时候，就没了，得手动一个个拼接。

过程：

请求的参数：

 

{
	"size": 0,
	"aggs": {
		"colors": {
			"terms": {
				"field": "color.keyword"
			},
			"aggs": {
				"gap_price": {
					"bucket_script": {
						"buckets_path": {
							"deal0": "max_price",
							"deal1": "min_price"
						},
						"script": "params.deal0 - params.deal1"
					}
				},
				"max_price": {
					"sum": {
						"field": "price"
					}
				},
				"min_price": {
					"value_count": {
						"field": "material.keyword"
					}
				}
			}
		}
	}
}

代码：

引用部分参考《es 聚合查询 语法和例子》

1，StrTermNextScript：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.collections4.ListUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.elasticsearch.script.Script;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
import org.elasticsearch.search.aggregations.bucket.range.DateRangeAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.range.RangeAggregationBuilder;
import org.elasticsearch.search.aggregations.pipeline.PipelineAggregatorBuilders;
import org.elasticsearch.search.aggregations.pipeline.bucketscript.BucketScriptPipelineAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.joda.time.DateTimeZone;

import java.util.List;
import java.util.Map;

public class StrTermNextScript {

    /**
     *  字符型的拼接
     *   第一层用 searchSourceBuilder 加
     */
    private static void joinEsStrAggs(Map<String,Object> aggsMap, SearchSourceBuilder searchSourceBuilder) {
        Map<String,Object> aggsNameMap = (Map<String, Object>) aggsMap.get("aggs");
        AggregationBuilder aggregationBuilder;

        for (Map.Entry name : aggsNameMap.entrySet()) {
            String aggName = name.getKey().toString();

            Map<String,Object> valueMap = (Map<String, Object>) name.getValue();
            for (Map.Entry value : valueMap.entrySet()) {
                String aggType = value.getKey().toString();
                Map<String,Object> fieldMap = (Map<String, Object>) value.getValue();
                aggregationBuilder = setAggsBuilders(aggName,aggType,fieldMap);
                if("terms".equals(aggType)){
                    Map<String,Object> innerAggsMap = (Map<String, Object>) valueMap.get("aggs");
                    if(MapUtils.isNotEmpty(innerAggsMap)){
                        joinSecEsStrAggs(innerAggsMap, aggregationBuilder);
                    }
                }
                if(aggregationBuilder != null){
                    searchSourceBuilder.aggregation(aggregationBuilder);
                }
            }
        }

    }


    /**
     *  字符型的拼接
     * 第二层用 aggregationBuilder 的 subAggregation 方法添加后面的内容
     */
    private static void joinSecEsStrAggs(Map<String,Object> aggsNameMap, AggregationBuilder allAggregationBuilder) {

        AggregationBuilder aggregationBuilder;
        for (Map.Entry name : aggsNameMap.entrySet()) {
            String aggName = name.getKey().toString();

            Map<String,Object> valueMap = (Map<String, Object>) name.getValue();
            for (Map.Entry value : valueMap.entrySet()) {
                String aggType = value.getKey().toString();
                Map<String,Object> fieldMap = (Map<String, Object>) value.getValue();
                aggregationBuilder = setAggsBuilders(aggName,aggType,fieldMap);
                if("terms".equals(aggType)){
                    Map<String,Object> innerAggsMap = (Map<String, Object>) valueMap.get("aggs");
                    if(MapUtils.isNotEmpty(innerAggsMap)){
                        joinSecEsStrAggs(innerAggsMap, aggregationBuilder);
                    }
                }
                if("bucket_script".equals(aggType)){
                    BucketScriptPipelineAggregationBuilder bucketScript = getBucketScript(aggName,fieldMap);
                    if(aggregationBuilder != null){
                        aggregationBuilder.subAggregation(bucketScript);
                    }else{
                        allAggregationBuilder.subAggregation(bucketScript);
                    }
                }
                if(aggregationBuilder != null){
                    allAggregationBuilder.subAggregation(aggregationBuilder);
                }

            }

        }


    }

    private static BucketScriptPipelineAggregationBuilder getBucketScript(String aggName, Map<String, Object> aggParam){
        Map<String, String> bucketsPathHashMap = (Map<String, String>) aggParam.get("buckets_path");
        return PipelineAggregatorBuilders.bucketScript(aggName, bucketsPathHashMap,
                new Script(MapUtils.getString(aggParam,"script")));
    }

	/**
     *  根据聚合类型 获取对应的聚合builder
     * @param aggName  聚合名称
     * @param aggType  聚合类型
     * @param aggParam  聚合参数
     * @return AggregationBuilder
     */
    private static AggregationBuilder setAggsBuilders(String aggName, String aggType,  Map<String, Object> aggParam){

        String fieldValue = MapUtils.getString(aggParam, "field");

        AggregationBuilder aggregationBuilder = null;
        if("terms".equals(aggType)){
            int size = MapUtils.getIntValue(aggParam, "size");
            if(size == NumberUtils.INTEGER_ZERO){
                size = 10;
            }
            aggregationBuilder = AggregationBuilders.terms(aggName).field(fieldValue).size(size);
        }else if("sum".equals(aggType)){
            aggregationBuilder = AggregationBuilders.sum(aggName).field(fieldValue);
        }else if("avg".equals(aggType)){
            aggregationBuilder = AggregationBuilders.avg(aggName).field(fieldValue);
        }else if("max".equals(aggType)){
            aggregationBuilder = AggregationBuilders.max(aggName).field(fieldValue);
        }else if("min".equals(aggType)){
            aggregationBuilder = AggregationBuilders.min(aggName).field(fieldValue);
        }else if("value_count".equals(aggType)){
            aggregationBuilder = AggregationBuilders.count(aggName).field(fieldValue);
        }else if ("cardinality".equals(aggType)) {// 去重之后总数
            aggregationBuilder = AggregationBuilders.cardinality(aggName).field(fieldValue);
        } else if ("histogram".equals(aggType)) {// 直方图
            Double interval = MapUtils.getDouble(aggParam, "interval");
            Long minDocCount = MapUtils.getLong(aggParam, "min_doc_count");
            aggregationBuilder = AggregationBuilders.histogram(aggName).field(fieldValue).interval(interval)
                    .minDocCount(minDocCount);
        } else if ("date_histogram".equals(aggType)) {// 日期直方图
            String interval = MapUtils.getString(aggParam, "interval");
            String format = MapUtils.getString(aggParam, "format");
            Long minDocCount = MapUtils.getLong(aggParam, "min_doc_count");
            DateHistogramAggregationBuilder dateHistogramAggregationBuilder = AggregationBuilders.dateHistogram(aggName)
                    .field(fieldValue).dateHistogramInterval(new DateHistogramInterval(interval))
                    .minDocCount(minDocCount).timeZone(DateTimeZone.forOffsetHours(8));
            if (StringUtils.isNotEmpty(format)) {
                dateHistogramAggregationBuilder.format(format);
            }
            aggregationBuilder = dateHistogramAggregationBuilder;
        } else if ("range".equals(aggType)) {// 范围
            String fieleName = MapUtils.getString(aggParam, "field");
            List<Map<String, Object>> ranges = (List<Map<String, Object>>) aggParam.get("ranges");
            RangeAggregationBuilder rangeAggregationBuilder = AggregationBuilders.range(aggName).field(fieleName);
            ListUtils.emptyIfNull(ranges).forEach(e -> {
                Double from = MapUtils.getDouble(e, "from");
                Double to = MapUtils.getDouble(e, "to");
                rangeAggregationBuilder.addRange(from, to);
            });

            aggregationBuilder = rangeAggregationBuilder;
        } else if ("date_range".equals(aggType)) {// 日期范围
            String fieleName = MapUtils.getString(aggParam, "field");
            String format = MapUtils.getString(aggParam, "format");
            List<Map<String, Object>> ranges = (List<Map<String, Object>>) aggParam.get("ranges");
            DateRangeAggregationBuilder dateRangeAggregationBuilder = AggregationBuilders.dateRange(aggName)
                    .field(fieleName).timeZone(DateTimeZone.forOffsetHours(8));

            if (StringUtils.isNotEmpty(format)) {
                dateRangeAggregationBuilder.format(format);
            }
            ListUtils.emptyIfNull(ranges).forEach(e -> {
                String from = MapUtils.getString(e, "from");
                String to = MapUtils.getString(e, "to");
                dateRangeAggregationBuilder.addRange(from, to);
            });
            aggregationBuilder = dateRangeAggregationBuilder;
        }
        return aggregationBuilder;
    }


}

2，模拟数据

 private static Map<String,Object> initFirstData(){
        String data ="{\n" +
                "\t\"size\": 0,\n" +
                "\t\"aggs\": {\n" +
                "\t\t\"colors\": {\n" +
                "\t\t\t\"terms\": {\n" +
                "\t\t\t\t\"field\": \"color.keyword\"\n" +
                "\t\t\t},\n" +
                "\t\t\t\"aggs\": {\n" +
                "\t\t\t\t\"min_price\": {\n" +
                "\t\t\t\t\t\"value_count\": {\n" +
                "\t\t\t\t\t\t\"field\": \"material.keyword\"\n" +
                "\t\t\t\t\t}\n" +
                "\t\t\t\t},\n" +
                "\t\t\t\t\"max_price\": {\n" +
                "\t\t\t\t\t\"sum\": {\n" +
                "\t\t\t\t\t\t\"field\": \"price\"\n" +
                "\t\t\t\t\t}\n" +
                "\t\t\t\t},\n" +
                "\t\t\t\t\"gap_price\": {\n" +
                "\t\t\t\t\t\"bucket_script\": {\n" +
                "\t\t\t\t\t\t\"buckets_path\": {\n" +
                "\t\t\t\t\t\t\t\"deal0\": \"max_price\",\n" +
                "\t\t\t\t\t\t\t\"deal1\": \"min_price\"\n" +
                "\t\t\t\t\t\t},\n" +
                "\t\t\t\t\t\t\"script\": \"params.deal0 - params.deal1\"\n" +
                "\t\t\t\t\t}\n" +
                "\t\t\t\t}\n" +
                "\t\t\t}\n" +
                "\t\t}\n" +
                "\t}\n" +
                "}";
        System.out.println(JSONObject.parseObject(data).toJSONString());
        Map<String,Object> parse = (Map<String, Object>) JSON.parse(data);
        return parse;
    }

 

3，测试：

 

 public static void main(String[] args) {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        Map<String,Object> aggsMap = initFirstData();
        joinEsStrAggs(aggsMap, searchSourceBuilder);
        System.out.println("aggs "+searchSourceBuilder.toString());

    }

结果：

aggs  {
	"aggregations": {
		"colors": {
			"terms": {
				"field": "color.keyword",
				"size": 10,
				"min_doc_count": 1,
				"shard_min_doc_count": 0,
				"show_term_doc_count_error": false,
				"order": [{
					"_count": "desc"
				}, {
					"_key": "asc"
				}]
			},
			"aggregations": {
				"max_price": {
					"sum": {
						"field": "price"
					}
				},
				"min_price": {
					"value_count": {
						"field": "material.keyword"
					}
				},
				"gap_price": {
					"bucket_script": {
						"buckets_path": {
							"deal0": "max_price",
							"deal1": "min_price"
						},
						"script": {
							"source": "params.deal0 - params.deal1",
							"lang": "painless"
						},
						"gap_policy": "skip"
					}
				}
			}
		}
	}
}

总结：

    使用RestHighLevelClient 查询es聚合数据，处理参数会麻烦些，需要拼接对应的AggregationBuilder的内容，嵌套的，要逐层处理。复杂的东西，先从简单的入手，逐层解析，到后面就会发现规律的，有时候初看，知道有规律，但是又说不出来，那就动手实践。

天狼1222
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ES的嵌套查询和嵌套聚合
qq_33999844的博客
04-29 6300
1.想要实现嵌套查询和嵌套聚合，首先需要在索引里面设置某个属性是嵌套类型（一般是List）-----type=nested 2.API的demo-嵌套查询---（使用场景：需要根据list中的两个字段以and的关系进行查询） // 构造布尔查询 BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder(); ...
Elasticsearch笔记（七）：聚合查询
热门推荐
布道
01-08 4万+
聚合框架有助于根据搜索查询提供聚合数据。聚合查询是数据库中重要的功能特性，ES作为搜索引擎兼数据库，同样提供了强大的聚合分析能力。它基于查询条件来对数据进行分桶、计算的方法。有点类似于 SQL 中的 group by 再加一些函数方法的操作。聚合可以嵌套，由此可以组成复杂的操作（Bucketing聚合可以包含sub-aggregation）。 聚合计算的值可以取字段的值，也可是脚本计算的结果。查...
使用Elasticsearch进行分组聚合统计
ue4的博客
05-18 8434
使用Elasticsearch进行分组聚合统计
【无标题】
u011250186的博客
06-01 518
【原创】ElasticSearch使用Java代码group by多个字段查询统计数量DCTANT已于 2022-05-23 10:44:30 修改1011 收藏 3 分类专栏： java springboot 文章标签： elasticsearch java springboot es 版权java 同时被 2 个专栏收录 26 篇文章1 订阅 订阅专栏springboot 11 篇文章0 订阅 订阅专栏 这篇文章主要介绍group by多个字段查询，这方面的资料在全网都非常少，而我这边的需求需要gro
ES aggregation详解
赵英超的博客
10-12 2万+
aggregation分类 aggregations —— 聚合，提供了一种基于查询条件来对数据进行分桶、计算的方法。有点类似于 SQL 中的 group by 再加一些函数方法的操作。 聚合可以嵌套，由此可以组成复杂的操作（Bucketing聚合可以包含sub-aggregation）。 聚合整体上可以分为 3 类： 1. Bucketing：桶分聚合： 此类聚合执行的是对文档分组的操...
elasticsearch嵌套聚合dsl
最新发布
09-14
elasticsearch嵌套聚合dsl
elasticsearch聚合后分页
12-16
方法如果传总页数了，es就不用查询总页数，直接通过开始位置到结束位置取数即可
java使用elasticsearch分组进行聚合查询过程解析
08-25
Java 使用 Elasticsearch 进行分组聚合查询过程解析 Java 使用 Elasticsearch 进行分组聚合查询是一个常见的需求，特别是在大数据处理和数据分析领域。Elasticsearch 提供了强大的聚合功能，可以对数据进行分组、...
Elasticsearch聚合 之 Terms
06-19
Elasticsearch聚合之Terms Elasticsearch中的Terms聚合是一种常用的聚合方式，用于对文档中的某个字段进行分组统计。Terms聚合可以对文档中的某个字段进行分组，并统计每个组中的文档数量。 在Elasticsearch中，...
elasticsearch聚合值过滤
03-02
在 Elasticsearch（ES）中，聚合（Aggregations）是一种强大的数据汇总工具，允许用户对索引中的数据进行分组和统计分析。而“elasticsearch聚合值过滤”是ES聚合功能的一个高级应用场景，它允许我们根据聚合计算出...
ES agg terms 多个字段
u011250186的博客
07-26 3226
ES agg terms 多个字段
es分组查询多个字段
Z17839192969的博客
11-30 4491
es
es AggregationBuilders 聚合查询
qq_1763467007的博客
02-17 1万+
在项目中遇到一块关于es的多条件聚合的代码，如下： >AggregationBuilders > .terms("agg_name") > .field("name") > .size(Integer.MAX_VALUE) > .subAggregation(AggregationBuilders > .topHits("top") > .sort("time",SortOrade.DESC
SpringBoot集成Elasticsearch7.x（4）|（aggregations之分桶聚合查询）
Oaklkm的博客
07-22 2527
本章节主要介绍SpringBoot项目集成ElasticSearch的一些相关知识，主要介绍的是基于JavaHighLevelRESTClient方式实现ElasticSearch分桶（Buckets）聚合（aggregations）查询操作以及对应kibana控制台JSON格式访问对照。查询每个城市景点数量总价格平均价格。......
ES计算指定索引，按多个字段去重后批量查询count结果
qq_42002616的博客
07-13 760
ES计算指定索引，按多个字段去重后批量查询count结果
ElasticSearch聚合使用实战
StudingStudent的博客
09-07 444
ElasticSearch聚合 数据生成 新建索引 PUT employee { "mappings": { "properties": { "id": { "type": "integer" }, "name": { "type": "keyword" }, "job": { "type": "keyword" }, "age": { "typ
ES 聚合函数的用法
mclongyi的专栏
08-05 1万+
1. ES聚合分析是什么？ 聚合分析是数据库中重要的功能特性，完成对一个查询的数据集中数据的聚合计算，如：找出某字段（或计算表达式的结果）的最大值、最小值，计算和、平均值等。ES作为搜索引擎兼数据库，同样提供了强大的聚合分析能力。 对一个数据集求最大、最小、和、平均值等指标的聚合，在ES中称为指标聚合 metric 而关系型数据库中除了有聚合函数外，还可以对查询出的数据进行分组group by，再在组上进行指标聚合。在 ES 中group by 称为分桶，桶聚合 bucketing ES中还提供..
ElasticSearch--聚合查询
Cloud的专栏
05-16 4331
聚合(aggs) 聚合一般用于数据的统计分析,类似于mysql的group by。 聚合里面有两个基本概念，一个叫桶，一个叫度量。 桶的作用，是按照某种方式对数据进行分组，每一组数据成为一个桶。比如对手机品牌分组，可以得到小米桶，华为桶。 桶的分组方式 Date Histogram Aggregation：根据日期阶梯分组，例如给定阶梯为周，会自动每周分为一组 Histogram Aggregation：根据数值阶梯分组，与日期类似 Terms Aggregation：根据词条内容分组，词条内容完
java实现es嵌套聚合查询
06-07
要实现 Elasticsearch 的嵌套聚合查询，你可以使用 Elasticsearch 的 AggregationBuilders 类来创建嵌套聚合查询。具体实现步骤如下： 1. 创建一个嵌套聚合查询，用于组合多个子聚合查询。 2. 在嵌套聚合查询中添加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天狼1222

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值