ElasticSearch（十）【聚合查询】

十、聚合查询

---

上一篇文章《ElasticSearch - SpringBoot整合》

简介

聚合：英文为Aggregation Aggs，是ES除搜索功能外提供的针对ES数据做统计分析的功能。聚合有助于根据搜索查询提供聚合数据。聚合查询是数据库中重要的功能特性，ES作为搜索引擎兼数据库，同样提供了强大的聚合分析能力。它基于查询条件来对数据进行分桶、计算的方法。有点类似于SQL中的group by再加一些函数方法的操作

【注意】text类型是不支持聚合的

10.1 Kibana操作聚合查询

下面使用size省略查询结果的输出

terms基于某个字段分组

# 非组名字可以自定义price_group
GET /products/_search
{
  "query": {
    "match_all": {}
  },
  "size": 0, 
  "aggs": {
    "price_group": {      
      "terms": {
        "field": "price"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

最大值、最小值

# 最大值
GET /products/_search
{
  "query": {
    "match_all": {}
  },
  "size": 0, 
  "aggs": {
    "max_price": {      
      "max": {
        "field": "price"
      }
    }
  }
}

# 最小值
GET /products/_search
{
  "query": {
    "match_all": {}
  },
  "size": 0, 
  "aggs": {
    "min_price": {      
      "min": {
        "field": "price"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

sum求和、avg平均值

# 求和
GET /products/_search
{
  "query": {
    "match_all": {}
  },
  "size": 0, 
  "aggs": {
    "sum_price": {      
      "sum": {
        "field": "price"
      }
    }
  }
}

# 平均值
GET /products/_search
{
  "query": {
    "match_all": {}
  },
  "size": 0, 
  "aggs": {
    "avg_price": {      
      "avg": {
        "field": "price"
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

10.2 RestHighLevelClient 操作聚合查询

package com.vinjcent;

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedDoubleTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.metrics.ParsedSum;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.List;

@SpringBootTest
public class RestHighLevelClientAggregationTests {

    private final RestHighLevelClient restHighLevelClient;

    @Autowired
    public RestHighLevelClientAggregationTests(@Qualifier("elasticsearchClient") RestHighLevelClient restHighLevelClient) {
        this.restHighLevelClient = restHighLevelClient;
    }



    /**
     * 基于 term 类型进行聚合,并且基于字段进行分组聚合
     * @throws IOException
     */
    @Test
    public void testAggs() throws IOException {

        // 1.创建请求对象
        SearchRequest searchRequest = new SearchRequest("products");
        // 2.创建查询对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder
                .query(QueryBuilders.matchAllQuery())
                .aggregation(AggregationBuilders.terms("price_group").field("price"))   // 用于设置聚合处理
                .size(0);
        // 3.为请求对象配置查询对象
        searchRequest.source(searchSourceBuilder);
        // 4.接收响应对象
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        // 5.处理聚合结果
        Aggregations aggregations = searchResponse.getAggregations();
        // 根据字段类型,转移
        ParsedDoubleTerms price_group = aggregations.get("price_group");
        // 解析桶里的内容
        List<? extends Terms.Bucket> buckets = price_group.getBuckets();
        for (Terms.Bucket bucket : buckets) {
            System.out.println(bucket.getKey() + "  " + bucket.getDocCount());
        }
    }


    /**
     * 基于 sum(ParsedSum)、avg(ParsedAvg)、max(ParsedMax)、min(ParsedMin) 函数聚合,
     * @throws IOException
     */
    @Test
    public void testAggsFunction() throws IOException {
        // 1.创建请求对象
        SearchRequest searchRequest = new SearchRequest("products");
        // 2.创建查询对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder
                .query(QueryBuilders.matchAllQuery())
                .aggregation(AggregationBuilders.sum("sum_price").field("price"))   // 用于设置聚合处理,sum、avg、max、min
                .size(0);
        // 3.为请求对象配置查询对象
        searchRequest.source(searchSourceBuilder);
        // 4.接收响应对象
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        // 5.处理聚合结果
        Aggregations aggregations = searchResponse.getAggregations();
        // 根据字段类型,转移    ParsedSum、ParsedAvg、ParsedMax、ParsedMin
        ParsedSum sum_price = aggregations.get("sum_price");
        // 解析桶里的内容
        System.out.println(sum_price.getValue());
    }
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

下一篇文章《ElasticSearch - 集群搭建》