【Elasticsearch】 07-指标聚合查询详解及示例

1. 引言

Elasticsearch是一款强大的分布式搜索和分析引擎，广泛应用于各种大规模数据存储和分析场景。在数据分析过程中，我们经常需要对数据进行统计和聚合操作，以获取有意义的指标和结果。本文将重点介绍Elasticsearch的指标聚合查询，深入探讨多种聚合类型，并结合示例和Java代码演示如何使用这些聚合类型来计算数据指标。

2. 什么是指标聚合查询？

在Elasticsearch中，指标聚合查询是一种用于计算数据指标的特殊查询类型。它可以对数据进行汇总、计算平均值、最大值、最小值、求和等操作，从而快速获取数据的统计信息。指标聚合查询通常用于生成报表、绘制图表和进行数据分析等场景。

3. 聚合类型介绍

在Elasticsearch中，有多种聚合类型可供选择，每种类型都有不同的计算方式和用途。以下是常用的聚合类型：

3.1 Sum Aggregation

Sum Aggregation用于计算指定字段的总和。它对字段的值进行累加，得到该字段的总和值。

3.2 Avg Aggregation

Avg Aggregation用于计算指定字段的平均值。它将字段的值累加，并除以文档的数量，得到平均值。

3.3 Max Aggregation

Max Aggregation用于计算指定字段的最大值。它找出字段中的最大值，并返回该值。

3.4 Min Aggregation

Min Aggregation用于计算指定字段的最小值。它找出字段中的最小值，并返回该值。

4. 数据准备

我们先创建一个简单的示例数据，用于演示指标聚合查询。以一个电商网站的订单数据为例，创建数据：

PUT /order/_doc/1
{
  "order_id": "1",
  "user_id": "101",
  "amount": 100
}

PUT /order/_doc/2
{
  "order_id": "2",
  "user_id": "102",
  "amount": 150
}

PUT /order/_doc/3
{
  "order_id": "3",
  "user_id": "101",
  "amount": 200
}

PUT /order/_doc/4
{
  "order_id": "4",
  "user_id": "103",
  "amount": 80
}

以上数据包含了4个订单，每个订单包含订单ID、用户ID和订单金额。

5. 使用示例

5.1 计算订单总金额

计算所有订单的总金额。使用Sum Aggregation来实现这个功能。

POST /order/_search
{
  "size": 0,
  "aggs": {
    "total_amount": {
      "sum": {
        "field": "amount"
      }
    }
  }
}

运行以上查询语句，返回以下结果：

{
  "took": 2,
  "timed_out": false,
  "hits": {
    "total": 4,
    "max_score": 0.0,
    "hits": []
  },
  "aggregations": {
    "total_amount": {
      "value": 530.0
    }
  }
}

从结果中可以看到，所有订单的总金额为530.0。

5.2 计算订单平均金额

计算所有订单的平均金额。使用Avg Aggregation来实现这个功能。

POST /order/_search
{
  "size": 0,
  "aggs": {
    "average_amount": {
      "avg": {
        "field": "amount"
      }
    }
  }
}

运行以上查询语句，返回以下结果：

{
  "took": 1,
  "timed_out": false,
  "hits": {
    "total": 4,
    "max_score": 0.0,
    "hits": []
  },
  "aggregations": {
    "average_amount": {
      "value": 132.5
    }
  }
}

从结果中可以看到，所有订单的平均金额为132.5。

5.3 计算最大订单金额

计算所有订单的最大金额。使用Max Aggregation来实现这个功能。

POST /order/_search
{
  "size": 0,
  "aggs": {
    "max_amount": {
      "max": {
        "field": "amount"
      }
    }
  }
}

运行以上查询语句，返回以下结果：

{
  "took": 1,
  "timed_out": false,
  "hits": {
    "total": 4,
    "max_score": 0.0,
    "hits": []
  },
  "aggregations": {
    "max_amount": {
      "value": 200.0
    }
  }
}

从结果中可以看到，所有订单的最大金额为200.0。

5.4 计算最小订单金额

计算所有订单的最小金额。使用Min Aggregation来实现这个功能。

POST /order/_search
{
  "size": 0,
  "aggs": {
    "min_amount": {
      "min": {
        "field": "amount"
      }
    }
  }
}

运行以上查询语句，返回以下结果：

{
  "took": 1,
  "timed_out": false,
  "hits": {
    "total": 4,
    "max_score": 0.0,
    "hits": []
  },
  "aggregations": {
    "min_amount": {
      "value": 80.0
    }
  }
}

从结果中可以看到，所有订单的最小金额为80.0。

6. Java代码示例

通过Java代码来实现上述的订单指标计算。只需将Java代码稍作修改来实现不同的聚合类型。

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.metrics.sum.Sum;
import org.elasticsearch.search.aggregations.metrics.avg.Avg;
import org.elasticsearch.search.aggregations.metrics.max.Max;
import org.elasticsearch.search.aggregations.metrics.min.Min;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

public class ElasticsearchAggregationExample {
    public static void main(String[] args) {
        try (RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder("localhost:9200"))) {

            SearchRequest searchRequest = new SearchRequest("order");
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.size(0);

            // 计算订单总金额
            searchSourceBuilder.aggregation(AggregationBuilders.sum("total_amount").field("amount"));
            // 计算订单平均金额
            searchSourceBuilder.aggregation(AggregationBuilders.avg("average_amount").field("amount"));
            // 计算最大订单金额
            searchSourceBuilder.aggregation(AggregationBuilders.max("max_amount").field("amount"));
            // 计算最小订单金额
            searchSourceBuilder.aggregation(AggregationBuilders.min("min_amount").field("amount"));

            searchRequest.source(searchSourceBuilder);

            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

            Sum sumAggregation = searchResponse.getAggregations().get("total_amount");
            double totalAmount = sumAggregation.getValue();
            System.out.println("Total amount of all orders: " + totalAmount);

            Avg avgAggregation = searchResponse.getAggregations().get("average_amount");
            double averageAmount = avgAggregation.getValue();
            System.out.println("Average amount of all orders: " + averageAmount);

            Max maxAggregation = searchResponse.getAggregations().get("max_amount");
            double maxAmount = maxAggregation.getValue();
            System.out.println("Max amount of all orders: " + maxAmount);

            Min minAggregation = searchResponse.getAggregations().get("min_amount");
            double minAmount = minAggregation.getValue();
            System.out.println("Min amount of all orders: " + minAmount);

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

希望本文对您在学习Elasticsearch的指标聚合查询时有所帮助。如果您有疑问或需要进一步探讨，欢迎随时与我交流。