当用户使用搜索引擎完成搜索后，在展示结果中需要进行进一步的筛选，而筛选的维度需要根据当前的搜索结果进行汇总，这就用到了聚合技术。聚合的需求在很多应用程序中都有所体现，例如在京东App中搜索“咸鸭蛋”，然后单击搜索界面中的“筛选”按钮，在弹出的界面中可以对当前的搜索结果进行进一步的过滤。例如，可以从价格区间、品牌、分类、枚数等维度分别进行筛选，如图7.1所示。
ES支持丰富的聚合操作，不仅可以使用聚合功能对文档进行计数，还可以计算文档字段的平均值、最大值和最小值等。ES还提供了桶聚合的功能，以便于对多维度数据进行聚合。本章将结合实例介绍这些内容。另外，如果希望搜索结果和聚合结果一起返回，其中绕不开的一个主题就是分页和排序，本章也会对这两部内容进行介绍。
为方便介绍，下面重新定义酒店的索引。
PUT /hotel
{
"settings": {
"number_of_shards": 1
},
"mappings": {
"properties": {
"title": {
"type": "text"
},
"city": {
"type": "keyword"
},
"price": {
"type": "double"
},
"create_time": {
"type": "keyword"
},
"full_room": {
"type": "boolean"
},
"tags": {
"type": "keyword"
}
}
}
}
接着向索引中写入示例数据，具体如下：
POST /_bulk
{"index":{"_index":"hotel","_id":"001"}}
{"title": "文雅酒假日酒店","city":"北京","price": 556.00,"create_time": "20200418120000","full_room":true, "tags":["wifi","小型电影院"],"comment_info":{"favourable_comment":20, "negative_comment":10}}
{"index":{"_index":"hotel","_id":"002"}}
{"title": "金都嘉怡假日酒店","city":"北京","create_time":"20210315200000", "full_room":false,"tags": ["wifi","免费早餐"],"comment_info":{"favourable_comment":20,"negative_ comment":10}}
{"index":{"_index":"hotel","_id":"003"}}
{"title": "金都假日酒店","city":"北京","price": 200.00,"create_time": "20210509160000","full_room":true,"comment_info":{"favourable_comment":20,"negative_comment":10}}
{"index":{"_index":"hotel","_id":"004"}}
{"title": "金都假日酒店","city":"天津","price": 500.00,"create_time": "20210218080000","full_room":false,"tags":["wifi","免费车位"]}
{"index":{"_index":"hotel","_id":"005"}}
{"title": "文雅精选酒店","city":"天津","price": 800.00,"create_time": "20210101080000","full_room":true,"tags":["wifi","充电车位"],"comment_info":{"favourable_comment" :20,"negative_comment":10}}
1 聚合指标
在进行聚合搜索时，聚合的指标业务需求不仅是文档数量。例如，在酒店搜索场景中，我们希望能看到以当前位置为中心点，周边各个区域酒店的平均价格。本节将对ES支持的聚合指标进行介绍。
在搜索聚合时，用户可能会关注字段的相关统计信息，例如平均值、最大值、最小值及加和值等。例如，用户在使用一个二手房交易搜索引擎进行搜索时，可能会关注当前城市各个区域的房产平均价格。再例如，用户在搜索酒店时，也可能会关注附近各个区域酒店的最低价格。如图7.2所示，左图为在链家App的地图模式，可以搜索到当前位置附近的二手房平均交易价格；右图为携程App的地图模式，可以搜索到当前位置附近最低价格的酒店。
ES聚合请求的地址也是索引的搜索地址，可以使用aggs子句封装聚合请求。
当使用avg子句进行平均值的聚合时，可以在avg子句中指定聚合的字段。在默认情况下，查询将匹配所有文档，如果不需要返回匹配的文档信息，最好将返回的文档个数设置为0。这样既可以让结果看起来更整洁，又可以提高查询速度。下面的DSL将查询所有酒店的平均价格并且不返回匹配的文档信息。
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": { //聚合名称
"avg": {
"field": "price" //计算文档的平均价格
}
}
}
}
在上面的DSL中，设定avg聚合的字段为price字段，并设置size参数的值为0。该DSL被执行后，ES的返回结果如下：
{
…
"hits" : { //命中的文档列表
"total" : {
"value" : 5,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : { //聚合结果
"my_agg" : { //聚合名称
"value" : 514.0 //聚合指标值
}
}
}
在上面的搜索结果中，索引中的5个文档全部命中，由于DSL设置size为0，所以命中文档的信息没有显示。在搜索结果的aggregations子句中存储着聚合结果，其中my_agg是聚合的名称，其对应的value值就是具体聚合结果，即酒店的平均价格。
如果聚合的指标字段不是ES的基本类型，例如object类型，则可以使用点运算符进行引用。下面的DSL演示了该用法：
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"avg": {
//使用点运算符引用object类型字段的数据
"field": "comment_info.favourable_comment"
}
}
}
}
与平均值类似，最大值、最小值及加和值分别使用max、min和sum子句进行聚合，这里不再赘述。
以下代码演示了在Java中使用聚合计算平均值的逻辑。
public void getAvgAggSearch() throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String aggName="my_agg"; //聚合的名称
//定义avg聚合，指定字段为price
AvgAggregationBuilder aggregationBuilder = AggregationBuilders.avg
(aggName).field("price");
searchSourceBuilder.aggregation(aggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Avg avg = aggregations.get(aggName); //获取avg聚合返回的对象
String key=avg.getName(); //获取聚合名称
double avgValue = avg.getValue(); //获取聚合值
System.out.println("key="+key+",avgValue="+avgValue); //打印结果
}
为了避免多次请求，ES还提供了stats聚合。stats聚合可以将对应字段的最大值、最小值、平均值及加和值一起计算并返回计算结果。下面的DSL展示了stats的用法。
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"stats": { //使用stats运算符计算多个指标
"field": "price"
}
}
}
}
在上面的DSL中，对所有酒店进行了常用统计指标的聚合，查询结果如下：
{
"…
"hits" : {
"total" : {
"value" : 5,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"my_agg" : {
"count" : 4, //文档数量
"min" : 200.0, //聚合的价格最小值
"max" : 800.0, //聚合的价格最大值
"avg" : 514.0, //聚合的价格平均值
"sum" : 2056.0 //聚合的价格加和值
}
}
}
以下代码演示了在Java中使用stats聚合的逻辑。
public void getStatsAggSearch () throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String aggName="my_agg"; //聚合的名称
//定义stats聚合，指定字段为price
StatsAggregationBuilder aggregationBuilder = AggregationBuilders.stats
(aggName).field("price");
searchSourceBuilder.aggregation(aggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Stats stats = aggregations.get(aggName); //获取stats聚合返回的对象
String key=stats.getName(); //获取聚合名称
double sumVal =stats.getSum() ; //获取聚合加和值
double avgVal =stats.getAvg() ; //获取聚合平均值
long countVal =stats.getCount() ; //获取聚合文档数量值
double maxVal =stats.getMax() ; //获取聚合最大值
double minVal =stats.getMin() ; //获取聚合最小值
System.out.println("key="+key); //打印聚合名称
System.out.println("sumVal="+sumVal+",avgVal="+avgVal+",countVal=
"+countVal+",maxVal="+maxVal+",minVal="+minVal); //打印结果
}
2 空值处理
在索引中的一部分文档很可能其某些字段是缺失的，在介绍空值处理之前，首先介绍ES聚合查询提供的value_count聚合，该聚合用于统计字段非空值的个数。以下示例使用value_count聚合统计了price字段中非空值的个数。
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"value_count": { //统计price字段中非空值的个数
"field": "price"
}
}
}
}
执行上述DSL后，ES返回的结果如下：
{
..
"hits" : {
"total" : {
"value" : 5,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"my_agg" : { //price字段中非空值的个数
"value" : 4
}
}
}
通过上述结果可以看到，当前索引中price字段中的非空值有4个。
下面的代码演示了在Java中使用value_count对price字段进行聚合的逻辑。
public void getValueCountAggSearch () throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String aggName="my_agg"; //聚合的名称
//定义value_count聚合，指定字段为price
ValueCountAggregationBuilder aggregationBuilder = AggregationBuilders.
count(aggName).field("price");
aggregationBuilder.missing("200");
searchSourceBuilder.aggregation(aggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse =client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
//获取value_count聚合返回的对象
ValueCount valueCount = aggregations.get(aggName);
String key=valueCount.getName(); //获取聚合名称
long count = valueCount.getValue(); //获取聚合值
System.out.println("key="+key+",count="+count); //打印结果
}
需要指出的是，如果判断的字段是数组类型，则value_count统计的是符合条件的所有文档中该字段数组中非空元素个数的总和，而不是数组的个数总和。下面的DSL用于统计tags字段数组中非空元素个数的总和。
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"value_count": { //统计tags字段数组中非空元素的个数
"field": "tags"
}
}
}
}
在索引的5个文档中，除去文档003没有tags字段外，其他4个文档的tags字段数组中各有两个元素，因此聚合的值为2×4=8个。下面来看一下ES返回的内容：
{
….
"hits" : {
"total" : {
"value" : 5,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"my_agg" : {
"value" : 8 //tags字段数组中非空元素的个数
}
}
}
上面的结果中，aggregations.my_agg.value的值为8，这和前面计算的数值相等，验证了使用value_count对数组字段进行聚合时，ES返回的结果是所有数组元素的个数总和这一结论。
如果需要以空值字段的数据作为聚合指标对其进行聚合，可以在指标统计中通过missing参数指定填充值对空值进行填充。以下示例演示了对price字段进行聚合，并设定了当字段值为空值时使用100进行替代的查询请求。
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"sum": {
"field": "price",
"missing":100 //计算加和值时将price字段中的空值用100代替
}
}
}
}
在索引中，文档002的price字段为空，因此被填充为100，文档001、003、004和005的price字段分别为556、200、500和800，因此符合聚合的值应该是556+100+200+500+800=2156。ES返回的结果如下：
{
…
"hits" : {
"total" : {
"value" : 5,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"my_agg" : {
"value" : 2156.0 //将price字段中的空值用100代替后的加和结果
}
}
}
以下代码演示了在Java中当聚合指标为空值时指定填充值的逻辑。
public void getSumAggSearch () throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String aggName="my_agg"; //聚合的名称
//定义sum聚合，指定字段为price
SumAggregationBuilder aggregationBuilder = AggregationBuilders.sum
(aggName).field("price");
aggregationBuilder.missing("100");
searchSourceBuilder.aggregation(aggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Sum sum = aggregations.get(aggName); //获取sum聚合返回的对象
String key=sum.getName(); //获取聚合名称
double sumVal = sum.getValue(); //获取聚合值
System.out.println("key="+key+",count="+sumVal); //打印结果
}
3 桶聚合
前面介绍的聚合指标是指符合条件的文档字段的聚合，有时还需要根据某些维度进行聚合。例如在搜索酒店时，按照城市、是否满房、标签和创建时间等维度统计酒店的平均价格。这些字段统称为“桶”，在同一维度内有一个或者多个桶。例如城市桶，有“北京”“天津”等，是否满房桶，有“满房”“非满房”。
1 单维度桶聚合
最简单的桶聚合是单维度桶聚合，指的是按照一个维度对文档进行分组聚合。在桶聚合时，聚合的桶也需要匹配，匹配的方式有terms、filter和ranges等。本节只介绍比较有代表性的terms查询和ranges查询，对其他匹配方式感兴趣读者可以阅读相关文档进行学习，这里不再赘述。
terms聚合是按照字段的实际完整值进行匹配和分组的，它使用的维度字段必须是keyword、bool、keyword数组等适合精确匹配的数据类型，因此不能对text字段直接使用terms聚合，如果对text字段有terms聚合的需求，则需要在创建索引时为该字段增加多字段功能。
以下的DSL描述的是按照城市进行聚合的查询：
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"terms": { //按照城市进行聚合
"field": "city"
}
}
}
}
因为ES支持多桶聚合，所以每个桶聚合需要定义一个名字，此处定义了一个桶聚合，名字为my_agg。在这个桶聚合中使用了一个terms聚合，聚合字段选择了城市，目的是统计各个城市的酒店的文档个数。在聚合外面，因为不希望返回任何文档，所以指定查询返回的文档为0。执行该DSL后，ES返回的结果如下：
{
…
"hits" : {
…
"hits" : [ ]
},
"aggregations" : {
"my_agg" : { //单维度聚合的名称
"doc_count_error_upper_bound" : 0, //可能被遗漏的文档数量的最大值
"sum_other_doc_count" : 0, //除了返回给用户的文档外剩下的文档总数
"buckets" : [ //聚合桶
{
"key" : "北京",
"doc_count" : 3 //该聚合桶下的文档数量
},
{
"key" : "天津",
"doc_count" : 2 //该聚合桶下的文档数量
}
]
}
}
}
在默认情况下，进行桶聚合时如果不指定指标，则ES默认聚合的是文档计数，该值以doc_count为key存储在每一个bucket子句中。在聚合结果的buckets的两个bucket中，key字段的值分别为“北京”“天津”，表示两个bucket的唯一标识；doc_count字段的值分别为3和2，表示两个bucket的文档计数。返回的doc_count是近似值，并不是一个准确数，因此在聚合外围，ES给出了两个参考值doc_count_error_upper_bound和sum_other__doc_count，doc_count_error_upper表示被遗漏的文档数量可能存在的最大值，sum_other_doc_count表示除了返回给用户的文档外剩下的文档总数。
以下DSL是按照满房状态进行聚合的查询，注意该字段是bool型：
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"terms": {
"field": "full_room" //按照满房状态进行聚合
}
}
}
}
执行DSL后，ES返回的结果如下：
{
…
"hits" : {
"total" : {
"value" : 5,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"my_agg" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [
{
"key" : 1,
"key_as_string" : "true", //聚合桶的字符串形式
"doc_count" : 3
},
{
"key" : 0,
"key_as_string" : "false", //聚合桶的字符串形式
"doc_count" : 2
}
]
}
}
}
从上述结果中可以看到，在满房和非满房的bucket结果中多出了一个字段，名称为key_as_string，其值分别是true和false。另外，这两个bucket的key值分别为1和0。这是因为，如果桶字段类型不是keyword类型，ES在聚合时会将桶字段转换为Lucene存储的实际值进行识别。true在Lucene中存储为1，false在Lucene中存储为0，这就是为什么满房和非满房的key字段分别为1和0的原因。这种情况给用户的使用带来了一些困惑，因为和原始值的差别比较大。针对这个问题，我们可以使用ES提供的key_as_string桶识别字段，它是原始值的字符串形式，和原始值的差别比较小。
以下代码演示了在Java中使用terms聚合进行单维度桶聚合的逻辑：
public void getBucketDocCountAggSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName = "my_terms"; //指定聚合的名称
//定义terms聚合，指定字段为城市
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.
terms(termsAggName).field("full_room");
searchSourceBuilder.aggregation(termsAggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get(termsAggName); //获取聚合返回的对象
for (Terms.Bucket bucket : terms.getBuckets()) {
String bucketKey = bucket.getKeyAsString(); //获取桶名称
long docCount = bucket.getDocCount(); //获取文档个数
System.out.println("termsKey=" + bucketKey + ",docCount=" + docCount);
}
}
除了terms聚合，ranges聚合也是经常使用的一种聚合。它匹配的是数值字段，表示按照数值范围进行分组。用户可以在ranges中添加分组，每个分组用from和to表示分组的起止数值。注意该分组包含起始数值，不包含终止数值。以下DSL演示了使用ranges进行聚合的方法：
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": {
"range": {
"field": "price",
"ranges": [ //多个范围桶
{
"to": 200 //不指定from，默认from为0
},
{
"from": 200,
"to": 500
},
{
"from": 500 //不指定to，默认to为该字段最大值
}
]
}
}
}
}
执行上述DSL后，ES返回的结果如下：
{
…
"hits" : {
…
"hits" : [ ]
},
"aggregations" : {
"my_agg" : { //range聚合名称
"buckets" : [ //范围聚合桶
{
"key" : "*-200.0",
"to" : 200.0,
"doc_count" : 0
},
{
"key" : "200.0-500.0",
"from" : 200.0,
"to" : 500.0,
"doc_count" : 1
},
{
"key" : "500.0-*",
"from" : 500.0,
"doc_count" : 3
}
]
}
}
}
在上面的分组划分中，第一个分组规则为price<200，没有文档与其匹配，因此其doc_count为0；第二个分组规则为200≤price<500，文档003与其匹配，因此其doc_count为1；第三个分组规则为price>500，文档001、004和005与其匹配，因此其doc_count值为3。
以下代码演示了在Java中使用ranges聚合的逻辑：
public void getRangeDocCountAggSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String rangeAggName = "my_range"; //聚合的名称
//定义ranges聚合，指定字段为price
RangeAggregationBuilder rangeAgg = AggregationBuilders.range(rangeAggName).
field("price");
rangeAgg.addRange(new RangeAggregator.Range(null,null,200d));
rangeAgg.addRange(new RangeAggregator.Range(null,200d,500d));
rangeAgg.addRange(new RangeAggregator.Range(null,500d,null));
searchSourceBuilder.aggregation(rangeAgg); //添加ranges聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Range range = aggregations.get(rangeAggName);//获取range聚合返回的对象
for (Range.Bucket bucket : range.getBuckets()) {
String bucketKey = bucket.getKeyAsString(); //获取桶名称
long docCount = bucket.getDocCount(); //获取聚合文档个数
System.out.println("bucketKey=" + bucketKey + ",docCount=" + docCount);
}
}
有时还需要对单维度桶指定聚合指标，聚合指标单独使用子aggs进行封装，该aggs子句的使用方式和上一节介绍的聚合指标相同。以下请求表示按照城市维度进行聚合，统计各个城市的平均酒店价格：
GET /hotel/_search
{
"size": 0,
"aggs": {
"my_agg": { //单维度聚合名称
"terms": { //定义单维度桶
"field": "city"
},
"aggs": { //用于封装单维度桶下的聚合指标
"my_sum": { //聚合指标名称
"sum": { //对price字段进行加和
"field": "price",
"missing": 200
}
}
}
}
}
}
执行上述DSL后，ES返回的结果如下：
{
…
"hits" : {
…
},
"aggregations" : {
"my_agg" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [ //单维度桶列表
{ //具体的单维度桶
"key" : "北京",
"doc_count" : 3,
"my_sum" : { //聚合指标
"value" : 956.0
}
},
{ //具体的单维度桶
"key" : "天津",
"doc_count" : 2,
"my_sum" : { //聚合指标
"value" : 1300.0
}
}
]
}
}
}
在上面的结果中，聚合桶的维度是城市，当前索引中城市为“北京”的文档个数为3，城市为“天津”的文档个数为2。将这两组文档的聚合结果在buckets子句中进行了封装，可以根据key字段进行聚合桶的识别，每个聚合的组中既有文档个数又有价格的加和值。
以下代码演示了在Java中使用桶聚合和指标聚合的逻辑：
public void getBucketAggSearch () throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName="my_terms"; //聚合的名称
//定义terms聚合，指定字段为城市
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.
terms(termsAggName).field("city");
String sumAggName="my_sum"; //sum聚合的名称
//定义sum聚合，指定字段为价格
SumAggregationBuilder sumAggregationBuilder = AggregationBuilders.
sum(sumAggName).field("price");
//定义聚合的父子关系
termsAggregationBuilder.subAggregation(sumAggregationBuilder);
searchSourceBuilder.aggregation(termsAggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get(termsAggName); //获取聚合返回的对象
for(Terms.Bucket bucket:terms.getBuckets()){
String termsKey=bucket.getKey().toString();
System.out.println("termsKey="+termsKey);
Sum sum =bucket.getAggregations().get(sumAggName);
String key=sum.getName(); //获取聚合名称
double sumVal = sum.getValue(); //获取聚合值
System.out.println("key="+key+",count="+sumVal); //打印结果
}
}
2 多维度桶嵌套聚合
在某些业务需求中，不仅需要一个维度的桶聚合，而且还可能有多维度桶嵌套聚合的需求。例如在搜索酒店时，可能需要统计各个城市的满房和非满房状态下的酒店平均价格。ES支持嵌套桶聚合，进行嵌套时，可以使用aggs子句进行子桶的继续嵌套，指标放在最里面的子桶内。以下DSL演示了多维度桶的使用方法：
GET /hotel/_search
{
"size": 0,
"aggs": {
"group_city": { //多维度桶名称
"terms": {
"field": "city"
},
"aggs": { //单维度桶
"group_full_room": {
"terms": {
"field": "full_room"
},
"aggs": { //聚合指标
"my_sum": {
"avg": {
"field": "price",
"missing": 200
}
}
}
}
}
}
}
}
上述DSL被执行后，ES返回的结果如下：
{
…
"hits" : {…},
"aggregations" : {
"group_city" : { //多维度聚合名称
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [ //第一层桶聚合列表
{
"key" : "北京", //第一层桶的key
"doc_count" : 3,
"group_full_room" : { //第二层桶聚合
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [ //单维度聚合列表
{
"key" : 1,
"key_as_string" : "true",
"doc_count" : 2,
"my_sum" : { //聚合指标
"value" : 378.0
}
},
{
"key" : 0,
"key_as_string" : "false",
"doc_count" : 1,
"my_sum" : {
"value" : 200.0
}
}
]
}
},
{
"key" : "天津",
"doc_count" : 2,
"group_full_room" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [
{
"key" : 0,
"key_as_string" : "false",
"doc_count" : 1,
"my_sum" : {
"value" : 500.0
}
},
{
"key" : 1,
"key_as_string" : "true",
"doc_count" : 1,
"my_sum" : {
"value" : 800.0
}
}
]
}
}
]
}
}
}
结果中可以看到，第一层的分桶先按照城市分组分为“北京”“天津”；第二层在“北京”“天津”桶下面继续分桶，分为“满房”“非满房”桶，对应的聚合指标即价格的加和值存储在内部的my_sum字段中。
以下代码演示了在Java中使用多维度桶进行聚合的逻辑：
public void getExternalBucketAggSearch () throws IOException{
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String aggNameCity="my_terms_city"; //按城市聚合的名称
//定义terms聚合，指定字段为城市
TermsAggregationBuilder termsAggCity = AggregationBuilders.terms
(aggNameCity).field("city");
String aggNameFullRoom="my_terms_full_room"; //按满房状态聚合的名称
//定义terms聚合，指定字段为满房状态
TermsAggregationBuilder termsArrFullRoom = AggregationBuilders.terms
(aggNameCity).field("full_room");
String sumAggName="my_sum"; //sum聚合的名称
//定义sum聚合，指定字段为价格
SumAggregationBuilder sumAgg = AggregationBuilders.sum(sumAggName).
field("price");
//定义聚合的父子关系
termsArrFullRoom.subAggregation(sumAgg);
termsAggCity.subAggregation(termsArrFullRoom);
searchSourceBuilder.aggregation(termsAggCity); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
//执行查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT);
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get(aggNameCity); //获取聚合返回的对象
for(Terms.Bucket bucket:terms.getBuckets()){ //遍历第一层bucket
//获取第一层bucket名称
String termsKeyCity=bucket.getKey().toString();
System.out.println("--------"+"termsKeyCity="+termsKeyCity+
"--------");
Terms termsFullRom =bucket.getAggregations().get(aggNameCity);
//遍历第二层bucket
for(Terms.Bucket bucketFullRoom:termsFullRom.getBuckets()){
//获取第二层bucket名称
String termsKeyFullRoom=bucketFullRoom.getKeyAsString();
System.out.println("termsKeyFullRoom="+termsKeyFullRoom);
//获取聚合指标
Sum sum =bucketFullRoom.getAggregations().get(sumAggName);
String key=sum.getName(); //获取聚合指标名称
double sumVal = sum.getValue(); //获取聚合指标值
System.out.println("key="+key+",count="+sumVal); //打印结果
}
}
}
4 聚合方式
ES支持灵活的聚合方式，它不仅支持聚合和查询相结合，而且还可以使聚合的过滤条件不影响搜索条件，并且还支持在聚合后的结果中进行过滤筛选。本节将介绍这些聚合方式。
1 直接聚合
直接聚合指的是聚合时的DSL没有query子句，是直接对索引内的所有文档进行聚合。前面介绍的示例都属于直接聚合，这里不再进行演示。
2 先查询再聚合
与直接聚合相对应，这种查询方式需要增加query子句，query子句和普通的query查询没有区别，参加聚合的文档必须匹配query查询。下面的DSL演示了这种用法：
GET /hotel/_search
{
"size": 0,
"query": { //指定查询query逻辑
"term": {
"city": {
"value": "北京"
}
}
},
"aggs": { //指定聚合逻辑
"my_agg": {
"avg": {
"field": "price"
}
}
}
}
以下代码演示了在Java中先查询再聚合的逻辑：
public void getQueryAggSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String avgAggName = "my_avg"; //avg聚合的名称
//定义sum聚合，指定字段为价格
AvgAggregationBuilder avgAgg = AggregationBuilders.avg(avgAggName).
field("price");
searchSourceBuilder.aggregation(avgAgg); //添加聚合
//构建query查询
searchSourceBuilder.query(QueryBuilders.termQuery("city", "北京"));
searchRequest.source(searchSourceBuilder); //设置查询请求
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
SearchHits searchHits = searchResponse.getHits(); //获取搜索结果集
System.out.println("---------------hit--------------");
for (SearchHit searchHit : searchHits) { //遍历搜索结果集
String index = searchHit.getIndex(); //获取索引名称
String id = searchHit.getId(); //获取文档_id
Float score = searchHit.getScore(); //获取得分
String source = searchHit.getSourceAsString(); //获取文档内容
System.out.println("index=" + index + ",id=" + id + ",source=" +
source); //打印数据
}
System.out.println("---------------agg--------------");
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
ParsedAvg avg = aggregations.get(avgAggName); //获取聚合返回的对象
String avgName = avg.getName(); //获取聚合名称
double avgVal = avg.getValue(); //获取聚合值
//打印结果
System.out.println("avgName=" + avgName + ",avgVal=" + avgVal);
}
3 前过滤器
有时需要对聚合条件进一步地过滤，但是又不能影响当前的查询条件。例如用户进行酒店搜索时的搜索条件是天津的酒店，但是聚合时需要将非满房的酒店平均价格进行聚合并展示给用户。此时不能变更用户的查询条件，需要在聚合子句中添加过滤条件。下面的DSL展示了在聚合时使用过滤条件的用法：
GET /hotel/_search
{
"size": 0,
"query": { //指定查询的query逻辑
"term": {
"city": {
"value": "天津"
}
}
},
"aggs": {
"my_agg": {
"filter": { //指定过滤器逻辑
"term": {
"full_room": false
}
},
"aggs": { //指定聚合逻辑
"my_avg": {
"avg": {
"field": "price"
}
}
}
}
}
}
执行上述DSL后，ES返回的结果如下：
{
…
"hits" : {
"total" : {
"value" : 2,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"my_agg" : {
"doc_count" : 1, //只有文档004没有被过滤
"my_avg" : {
"value" : 500.0
}
}
}
}
通过上述结果可以知道，满足查询条件的文档个数为2，命中的文档为004和005，但是在聚合时要求匹配非满房的酒店，只有文档004满足聚合条件，因此酒店的平均值为文档004的price字段值。
以下代码演示了在Java中使用前过滤器的逻辑：
public void getFilterAggSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String filterAggName = "my_terms"; //聚合的名称
TermQueryBuilder termQueryBuilder=QueryBuilders.termQuery("full_room",
true);
FilterAggregationBuilder filterAggregationBuilder=AggregationBuilders.
filter(filterAggName,termQueryBuilder);
String avgAggName = "my_avg"; //avg聚合的名称
//定义聚合，指定字段为价格
AvgAggregationBuilder avgAgg= AggregationBuilders.avg(avgAggName).
field("price");
//为filter聚合添加子聚合
filterAggregationBuilder.subAggregation(avgAgg);
searchSourceBuilder.aggregation(filterAggregationBuilder); //添加聚合
//构建term查询
searchSourceBuilder.query(QueryBuilders.termQuery("city", "天津"));
searchRequest.source(searchSourceBuilder); //设置查询请求
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
//获取sum聚合返回的对象
ParsedFilter filter = aggregations.get(filterAggName);
Avg avg =filter.getAggregations().get(avgAggName);
String key = avg.getName(); //获取聚合名称
double avgVal = avg.getValue(); //获取聚合值
System.out.println("key=" + key + ",avgVal=" + avgVal); //打印结果
}
4 后过滤器
在有些场景中，需要根据条件进行数据查询，但是聚合的结果集不受影响。例如在酒店搜索场景中，用户的查询词为“假日”，此时应该展现标题中带有“假日”的酒店。但是在该页面中，如果还希望给用户呈现出全国各个城市的酒店的平均价格，这时可以使用ES提供的后过滤器功能。该过滤器是在查询和聚合之后进行过滤的，因此它的过滤条件对聚合没有影响。以下的DSL展示了后过滤器的使用：
GET /hotel/_search
{
"size": 0,
"query": { //指定查询的query逻辑
"match": {
"title": "假日"
}
},
"post_filter": { //指定后过滤器逻辑
"term": {
"city": "北京"
}
},
"aggs": { //指定聚合逻辑
"my_agg": {
"avg": {
"field": "price",
"missing":200
}
}
}
}
在上面的查询中，使用match匹配title中包含“假日”的酒店，并且查询出这些酒店的平均价格，最后使用post_filter设置后过滤器的条件，将酒店的城市锁定为“北京”，执行该DSL后，ES返回的结果如下：
{
…
"hits" : {
"total" : {
"value" : 3,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"my_agg" : { //聚合时酒店的城市锁定为“北京”
"value" : 364.0
}
}
}
根据查询结果可知，match查询命中了4个文档，对这4个文档的price字段取平均值为364，最后通过post_filter将其中的文档004过滤掉，因此hits子句中的total数量为3。
以下代码演示了在Java中使用后过滤器的逻辑：
public void getPostFilterAggSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String avgAggName = "my_avg"; //avg聚合的名称
//定义sum聚合，指定字段为价格
AvgAggregationBuilder avgAgg= AggregationBuilders.avg(avgAggName).
field("price");
avgAgg.missing(200); //设置默认值为200
searchSourceBuilder.aggregation(avgAgg); //添加聚合
//构建term查询
searchSourceBuilder.query(QueryBuilders.matchQuery("title", "假日"));
TermQueryBuilder termQueryBuilder=QueryBuilders.termQuery("city","北京");
searchSourceBuilder.postFilter(termQueryBuilder);
searchRequest.source(searchSourceBuilder); //设置查询请求
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Avg avg =aggregations.get(avgAggName);
String key = avg.getName(); //获取聚合名称
double avgVal = avg.getValue(); //获取聚合值
System.out.println("key=" + key + ",avgVal=" + avgVal); //打印结果
}
5 聚合排序
根据前面的介绍可知，ES对于聚合结果的默认排序规则有时并非是我们期望的。可以使用ES提供的sort子句进行自定义排序，有多种排序方式供用户选择：可以按照聚合后的文档计数的大小进行排序；可以按照聚合后的某个指标进行排序；还可以按照每个组的名称进行排序。下面将介绍以上3种排序功能。
1 按文档计数排序
在聚合排序时，业务需求可能有按照每个组聚合后的文档数量进行排序的场景。此时可以使用_count来引用每组聚合的文档计数进行排序。以下DSL演示了按照城市的酒店平均价格进行聚合，并按照聚合后的文档计数进行升序排列的请求：
GET /hotel/_search
{
"size": 0,
"aggs": {
"group_city": {
"terms": {
"field": "city",
"order": { //按照文档计数进行升序排列
"_count": "asc"
}
},
"aggs": {
"my_avg": {
"avg": { //使用价格平均值作为聚合指标
"field": "price",
"missing": 200
}
}
}
}
}
}
执行上述DSL后，ES返回的结果如下：
{
…
"hits" : {…},
"aggregations" : {
"group_city" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [ //按照文档计数对桶聚合进行排序
{
"key" : "天津",
"doc_count" : 2,
"my_avg" : {
"value" : 650.0
}
},
{
"key" : "北京",
"doc_count" : 3,
"my_avg" : {
"value" : 318.6666666666667
}
}
]
}
}
}
以下代码演示了在Java中使用文档计数进行聚合排序的逻辑：
public void getAggDocCountOrderSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName = "my_terms"; //聚合的名称
//定义terms聚合，指定字段为城市
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.
terms(termsAggName).field("city");
BucketOrder bucketOrder=BucketOrder.count(true);
termsAggregationBuilder.order(bucketOrder);
String avgAggName = "my_avg"; //avg聚合的名称
//定义sum聚合，指定字段为价格
SumAggregationBuilder avgAgg = AggregationBuilders.sum(avgAggName).
field("price");
//定义聚合的父子关系
termsAggregationBuilder.subAggregation(avgAgg);
searchSourceBuilder.aggregation(termsAggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
SearchHits searchHits = searchResponse.getHits(); //获取搜索结果集
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get(termsAggName); //获取聚合返回的对象
for (Terms.Bucket bucket : terms.getBuckets()) {
String bucketKey = bucket.getKey().toString();
System.out.println("termsKey=" + bucketKey);
Sum sum = bucket.getAggregations().get(avgAggName);
String key = sum.getName(); //获取聚合名称
double sumVal = sum.getValue(); //获取聚合值
System.out.println("key=" + key + ",count=" + sumVal); //打印结果
}
}
2 按聚合指标排序
在聚合排序时，业务需求可能有按照每个组聚合后的指标值进行排序的场景。此时可以使用指标的聚合名称来引用每组聚合的文档计数。以下DSL演示了按照城市的酒店平均价格进行聚合，并按照聚合后的平均价格进行升序排列的请求：
GET /hotel/_search
{
"size": 0,
"aggs": {
"group_city": {
"terms": {
"field": "city",
"order": { //按照聚合指标进行升序排列
"my_avg": "asc"
}
},
"aggs": {
"my_avg": { //定义聚合指标
"avg": {
"field": "price",
"missing": 200
}
}
}
}
}
}
执行上述DSL后，ES返回的结果如下：
…
"hits" : {…},
"aggregations" : {
"group_city" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [ //按照价格平均值对桶聚合升序排列
{
"key" : "北京",
"doc_count" : 3,
"my_avg" : {
"value" : 318.6666666666667
}
},
{
"key" : "天津",
"doc_count" : 2,
"my_avg" : {
"value" : 650.0
}
}
]
}
}
}
以下代码演示了在Java中按照聚合指标进行聚合排序的逻辑：
public void getAggMetricsOrderSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName = "my_terms"; //聚合的名称
//定义terms聚合，指定字段为城市
String avgAggName = "my_avg"; //avg聚合的名称
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.
terms(termsAggName).field("city");
BucketOrder bucketOrder=BucketOrder.aggregation(avgAggName,true);
termsAggregationBuilder.order(bucketOrder);
//定义sum聚合，指定字段为价格
AvgAggregationBuilder avgAgg = AggregationBuilders.avg(avgAggName).
field("price");
//定义聚合的父子关系
termsAggregationBuilder.subAggregation(avgAgg);
searchSourceBuilder.aggregation(termsAggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get(termsAggName); //获取聚合返回的对象
for (Terms.Bucket bucket : terms.getBuckets()) {
String bucketKey = bucket.getKey().toString();
System.out.println("termsKey=" + bucketKey);
Avg avg = bucket.getAggregations().get(avgAggName);
String key = avg.getName(); //获取聚合名称
double avgVal = avg.getValue(); //获取聚合值
System.out.println("key=" + key + ",avgVal=" + avgVal);//打印结果
}
}
3按分组key排序
在聚合排序时，业务需求可能有按照每个分组的组名称排序的场景。此时可以使用_key来引用分组名称。以下DSL演示了按照城市的酒店平均价格进行聚合，并按照聚合后的分组名称进行升序排列的请求：
GET /hotel/_search
{
"size": 0,
"aggs": {
"group_city": {
"terms": {
"field": "city",
"order": { //按照分组key的自然顺序升序排列
"_key": "asc"
}
},
"aggs": {
"my_avg": { //定义聚合指标
"avg": {
"field": "price",
"missing": 200
}
}
}
}
}
}
执行上述DSL后，ES返回的结果如下：
{
…
"hits" : {…},
"aggregations" : {
"group_city" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [ //按照分组key的自然顺序对桶聚合升序排列
{
"key" : "北京",
"doc_count" : 3,
"my_avg" : {
"value" : 318.6666666666667
}
},
{
"key" : "天津",
"doc_count" : 2,
"my_avg" : {
"value" : 650.0
}
}
]
}
}
}
以下代码演示了在Java中按照分组key进行聚合排序的逻辑：
public void getAggKeyOrderSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName = "my_terms"; //聚合的名称
//定义terms聚合，指定字段为城市
String avgAggName = "my_avg"; //avg聚合的名称
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.
terms(termsAggName).field("city");
BucketOrder bucketOrder=BucketOrder.key(true);
termsAggregationBuilder.order(bucketOrder);
//定义sum聚合，指定字段为价格
SumAggregationBuilder avgAgg = AggregationBuilders.sum(avgAggName).
field("price");
//定义聚合的父子关系
termsAggregationBuilder.subAggregation(avgAgg);
searchSourceBuilder.aggregation(termsAggregationBuilder); //添加聚合
searchRequest.source(searchSourceBuilder); //设置查询请求
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
SearchHits searchHits = searchResponse.getHits(); //获取搜索结果集
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
Terms terms = aggregations.get(termsAggName); //获取sum聚合返回的对象
for (Terms.Bucket bucket : terms.getBuckets()) {
String bucketKey = bucket.getKey().toString();
System.out.println("termsKey=" + bucketKey);
Sum sum = bucket.getAggregations().get(avgAggName);
String key = sum.getName(); //获取聚合名称
double sumVal = sum.getValue(); //获取聚合值
System.out.println("key=" + key + ",count=" + sumVal);//打印结果
}
}
4 聚合分页
ES支持同时返回查询结果和聚合结果，前面介绍聚合查询时，查询结果和聚合结果各自封装在不同的子句中。但有时我们希望聚合的结果按照每组选出前N个文档的方式进行呈现，最常见的一个场景就是电商搜索，如搜索苹果手机6S，搜索结果应该展示苹果手机6S型号中的一款手机即可，而不论该型号手机的颜色有多少种。另外，当聚合结果和查询结果封装在一起时，还需要考虑对结果分页的问题，此时前面介绍的聚合查询就不能解决这些问题了。ES提供的Top hits聚合和Collapse聚合可以满足上述需求，但是这两种查询的分页方案是不同的。本节将介绍Top hits聚合和Collapse聚合，并分别给出这两种查询的分页方案。
1 Top hits聚合
顾名思义，Top hits聚合指的是聚合时在每个分组内部按照某个规则选出前N个文档进行展示。例如，搜索“金都”时，如果希望按照城市分组，每组按照匹配分数降序展示3条文档数据，DSL如下：
GET /hotel/_search
{
"size": 0,
"query": {
"match": {
"title": "金都"
}
},
"aggs": {
"group_city": { //按照城市进行桶聚合
"terms": {
"field": "city"
},
"aggs": {
"my_avg": {
"top_hits": { //指定返回每个桶的前3个文档
"size": 3
}
}
}
}
}
}
执行上述查询后，ES返回的结果如下：
{
…
"hits" : {
…
"hits" : [ ]
},
"aggregations" : {
"group_city" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [ //每个桶聚合中返回前3个文档
{
"key" : "北京",
"doc_count" : 2,
"my_avg" : {
"hits" : {
…
"hits" : [
{
"_index" : "hotel",
"_type" : "_doc",
"_id" : "003",
"_score" : 1.0928286,
"_source" : {
…
}
},
{
"_index" : "hotel",
"_type" : "_doc",
"_id" : "002",
"_score" : 0.96817136,
"_source" : {
…
}
]
}
}
},
{
"key" : "天津",
"doc_count" : 1,
"my_avg" : {
"hits" : {
"total" : {
"value" : 1,
"relation" : "eq"
},
"max_score" : 1.0928286,
"hits" : [
{
"_index" : "hotel",
"_type" : "_doc",
"_id" : "004",
"_score" : 1.0928286,
"_source" : {
…
}
}
]
}
}
}
]
}
}
}
可以看到，在索引中一共有3个文档命中match查询条件，在聚合结果中按照城市分成了两个组“北京”“天津”，在“北京”下面有两个文档命中，并且按照得分将展示文档进行了降序排列，“天津”只有一个文档命中。
以下代码演示了在Java中使用Top hits聚合的逻辑：
public void getAggTopHitsSearch() throws IOException {
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("hotel");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
String termsAggName = "my_terms"; //聚合的名称
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.
terms(termsAggName).field("city");
BucketOrder bucketOrder=BucketOrder.key(true);
termsAggregationBuilder.order(bucketOrder);
String topHitsAggName = "my_top"; //聚合的名称
TopHitsAggregationBuilder topHitsAgg=AggregationBuilders.topHits
(topHitsAggName);
topHitsAgg.size(3);
//定义聚合的父子关系
termsAggregationBuilder.subAggregation(topHitsAgg);
//添加聚合
searchSourceBuilder.aggregation(termsAggregationBuilder);
searchSourceBuilder.query(QueryBuilders.matchQuery("title","金都"));
searchRequest.source(searchSourceBuilder); //设置查询请求
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
//获取聚合结果
Aggregations aggregations = searchResponse.getAggregations();
//获取sum聚合返回的对象
Terms terms = aggregations.get(termsAggName);
for (Terms.Bucket bucket : terms.getBuckets()) {
String bucketKey = bucket.getKey().toString();
System.out.println("termsKey=" + bucketKey);
TopHits topHits = bucket.getAggregations().get(topHitsAggName);
SearchHit[] searchHits=topHits.getHits().getHits();
for(SearchHit searchHit:searchHits){
System.out.println(searchHit.getSourceAsString());
}
}
}
Top hits聚合能满足“聚合的结果按照每组选出N个文档的方式进行呈现”的需求，但是很遗憾，它不能完成自动分页功能。如果在聚合中使用Top hits聚合并期望对数据进行分页，则要求聚合的结果一定不能太多，因为需要由客户端自行进行分页，此时对分页内存的存储能力是一个挑战。可以一次性获取聚合结果并将其存放在内存中或者Redis中，然后自行实现翻页逻辑，完成翻页。假设数据一次性存储到Redis的list结构中，以下示例代码演示了从Redis分页取数据的逻辑：
import org.springframework.stereotype.Service;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.List;
@Service
public class CacheServiceImpl {
@Resource
private StringRedisTemplate stringRedisTemplate; //Redis客户端
public List<String> getRecommendData(String key, Integer pageNo,
Integer pageSize) {
long start = (pageNo - 1) * pageSize; //计算分页的起始位置
long end = pageNo * pageSize - 1; //计算分页的终止位置
//从Redis中取数据并将数据返回
return stringRedisTemplate.opsForList().range(key, start, end);
}
}
2 Collapse聚合
如前面所述，当在索引中有大量数据命中时，Top hits聚合存在效率问题，并且需要用户自行排序。针对上述问题，ES推出了Collapse聚合，即用户可以在collapse子句中指定分组字段，匹配query的结果按照该字段进行分组，并在每个分组中按照得分高低展示组内的文档。当用户在query子句外指定from和size时，将作用在Collapse聚合之后，即此时的分页是作用在分组之后的。以下DSL展示了Collapse聚合的用法：
GET /hotel/_search
{
"from": 0, //指定分页的起始位置
"size": 5, //指定每页返回的数量
"query": { //指定查询的query逻辑
"match": {
"title": "金都"
}
},
"collapse": { //指定按照城市进行Collapse聚合
"field": "city"
}
}
执行上述DSL后，ES返回的结果如下：
{
…
"hits" : {
…
"hits" : [
{
…
"_id" : "003",
"_score" : 1.0928286,
"_source" : {
…
},
"fields" : { //按照城市进行Collapse聚合
"city" : [
"北京"
]
}
},
{
…
"_id" : "004",
"_score" : 1.0928286,
"_source" : {
…
},
"fields" : { //按照城市进行Collapse聚合
"city" : [
"天津"
]
}
}
]
}
}
从结果中可以看到，与Top hits聚合不同，Collapse聚合的结果是封装在hit中的。在索引中一共有3个文档命中match查询条件，在聚合结果中已经按照城市分成了两个组，即“北京”“天津”，在“北京”下面有两个文档命中，其中得分最高的文档为003，“天津”只有一个文档命中。上述结果不仅能按照得分进行排序，并且具备分页功能。
以下代码演示了在Java中使用Collapse聚合的逻辑：
public void getCollapseAggSearch() throws IOException{
//按照spu进行分组
//按照城市进行分组
CollapseBuilder collapseBuilder = new CollapseBuilder("city");
SearchRequest searchRequest = new SearchRequest(); //新建搜索请求
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//新建match查询
searchSourceBuilder.query(QueryBuilders.matchQuery("title", "金都"));
searchSourceBuilder.collapse(collapseBuilder); //设置Collapse聚合
searchRequest.source(searchSourceBuilder); //设置查询
SearchResponse searchResponse = client.search(searchRequest,
RequestOptions.DEFAULT); //执行搜索
SearchHits searchHits = searchResponse.getHits(); //获取搜索结果集
for (SearchHit searchHit : searchHits) { //遍历搜索结果集
String index = searchHit.getIndex(); //获取索引名称
String id = searchHit.getId(); //获取文档_id
Float score = searchHit.getScore(); //获取得分
String source = searchHit.getSourceAsString(); //获取文档内容
System.out.println("index=" + index + ",id=" + id + ",score=" + score
+ ",source=" + source); //打印数据
}
}
