【Elasticsearch】 05-桶聚合查询详解及示例_java代码实现es分桶查询

1. 引言

Elasticsearch 是一款强大的分布式搜索和分析引擎，提供了丰富的聚合查询功能。桶聚合（Bucket Aggregations）是其中一种重要的聚合查询方式。本文将详细介绍 Elasticsearch 的桶聚合查询，并提供示例演示和 Java 代码实现。

2. 什么是桶聚合查询？

桶聚合查询是一种将文档分组到不同的桶（buckets）中的方式。每个桶代表一个特定的条件或者属性。桶聚合查询通常用于统计、分析和聚合数据。

3. 桶聚合查询的组成部分

桶聚合查询由两个主要部分组成：桶聚合类型和子聚合。

3.1 桶聚合类型

Elasticsearch 提供了多种桶聚合类型，用于不同的聚合需求。常见的桶聚合类型包括：

• Terms Aggregation：按照字段的值进行分组。
• Date Histogram Aggregation：按照日期字段的值进行时间间隔划分。
• Range Aggregation：按照字段的值范围进行分组。
• Histogram Aggregation：按照数值字段的值范围进行划分。

3.2 子聚合

子聚合是对每个桶内的文档进行进一步的聚合和分析。子聚合可以是任意类型的聚合查询，用于计算各个桶内的统计指标。

4. 示例演示

假设我们有一个存储了商品销售数据的索引，其中包含了商品名称和销售数量。我们希望按照商品名称进行分组，并统计每个商品的销售总数量和平均销售数量。

示例数据：

[
  {
    "product": "iPhone",
    "quantity": 10
  },
  {
    "product": "iPad",
    "quantity": 20
  },
  {
    "product": "MacBook",
    "quantity": 15
  },
  {
    "product": "Apple Watch",
    "quantity": 5
  }
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

示例查询：

GET /sales/_search
{
  "size": 0,
  "aggs": {
    "product_buckets": {
      "terms": {
        "field": "product",
        "size": 10
      },
      "aggs": {
        "total_quantity": {
          "sum": {
            "field": "

quantity"
          }
        },
        "avg_quantity": {
          "avg": {
            "field": "quantity"
          }
        }
      }
    }
  }
}
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

返回结果：

{
  "aggregations": {
    "product_buckets": {
      "buckets": [
        {
          "key": "iPhone",
          "doc_count": 1,
          "total_quantity": {
            "value": 10.0
          },
          "avg_quantity": {
            "value": 10.0
          }
        },
        {
          "key": "iPad",
          "doc_count": 1,
          "total_quantity": {
            "value": 20.0
          },
          "avg_quantity": {
            "value": 20.0
          }
        },
        {
          "key": "MacBook",
          "doc_count": 1,
          "total_quantity": {
            "value": 15.0
          },
          "avg_quantity": {
            "value": 15.0
          }
        },
        {
          "key": "Apple Watch",
          "doc_count": 1,
          "total_quantity": {
            "value": 5.0
          },
          "avg_quantity": {
            "value": 5.0
          }
        }
      ]
    }
  }
}
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

解释：
通过使用桶聚合类型 Terms Aggregation，我们按照商品名称将文档分组到不同的桶中。在每个桶内，我们使用求和聚合（sum）计算每个商品的销售总数量，并使用平均聚合（avg）计算平均销售数量。返回结果显示了每个商品的销售总数量和平均销售数量。

5. Java 代码实现

除了通过 Elasticsearch REST API 进行查询外，我们还可以通过 Java 客户端来实现桶聚合查询。

以下是使用 Elasticsearch Java 客户端进行桶聚合查询的示例代码：

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.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

public class BucketAggregationExample {

    public static void main(String[] args) {
        try (RestHighLevelClient client = createClient()) {
            SearchRequest request = new SearchRequest("sales");
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

            // 设置查询条件
            sourceBuilder.query(QueryBuilders.matchAllQuery());

            // 添加桶聚合查询
            TermsAggregationBuilder aggregation = AggregationBuilders.terms("product_buckets")
                    .field("product")
                    .size(10)
                    .subAggregation(AggregationBuilders.sum("total_quantity")
                            .field("quantity"))
                    .subAggregation(AggregationBuilders.avg("avg_quantity")
                            .field("quantity"));

            sourceBuilder.aggregation(aggregation);

            // 设置返回结果大小和超时时间
            sourceBuilder.size(0);
            sourceBuilder.timeout(TimeValue.timeValueSeconds(5));

            request.source(sourceBuilder);

            // 执行查询
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);

            // 处理结果
            // TODO: 处

理桶聚合查询结果

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static RestHighLevelClient createClient() {
        // 创建并返回 Elasticsearch 客户端
    }
}
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

6. 结论

本文详细介绍了 Elasticsearch 的桶聚合查询，解释了桶聚合查询的概念和组成部分。通过示例数据和查询语句演示，我们了解了如何使用桶聚合查询对数据进行分组和统计。此外，还提供了 Java 代码实现的示例，帮助开发者在实际项目中应用桶聚合查询。