聚合查询不是直接查询文档数据，而是对文档数据按照某些维度进行统计，如果你熟悉 MySql 的聚合查询，这个也就好理解了。之前我们已经学习了使用 RESTful API 聚合查询，现在学 Java High Level REST Client 的聚合查询也就很简单了，

我们还是使用上一篇的文档数据学习聚合查询：

我们一般可以使用AggregationBuilders类的静态方法来构建需要的聚合方式。它会返回一个 Builder 类，当然你也可以直接new一个指定聚合方式的 Builder 类。

1、avg

public void avg() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 统计文档中age字段的平均值，avgAge相当于统计结果的名称
    AvgAggregationBuilder avgBuilder = AggregationBuilders.avg("avgAge").field("age");
    // 设置聚合查询
    searchSourceBuilder.aggregation(avgBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    Avg avg = response.getAggregations().get("avgAge");
    double value = avg.getValue();
    System.out.println(value);
}

上边是统计age的平均值，注意，由于没有添加其它查询条件，则会统计索引中所有文档。

2、max

统计age的最大值：

public void max() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 统计文档中age字段的最大值
    MaxAggregationBuilder maxBuilder = AggregationBuilders.max("maxAge").field("age");
    searchSourceBuilder.aggregation(maxBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    Max max = response.getAggregations().get("maxAge");
    double value = max.getValue();
    System.out.println(value);
}

3、min、sum

统计最小值以及求和的实现上边的类似，就不详细说了：

MinAggregationBuilder minBuilder = AggregationBuilders.min("minAge").field("age");

SumAggregationBuilder sumBuilder = AggregationBuilders.sum("sumAge").field("age");

4、range

range表示按区间统计，比如指定时间范围，指定大小区间等。如下统计age在(-∞, 30)、[30,40]、(40,+∞)三个区间的人数：

public void range() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 统计文档中age字段的最大值
    RangeAggregationBuilder rangeBuilder = AggregationBuilders.range("rangeAge")
            .field("age")
            .addUnboundedTo(30)
            .addRange(30, 40)
            .addUnboundedFrom(40);
    searchSourceBuilder.aggregation(rangeBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    Range range = response.getAggregations().get("rangeAge");
    for (Range.Bucket bucket : range.getBuckets()) {
        // 打印每个区间的人数
        System.out.println("age区间 " + bucket.getKeyAsString() + " 的人数：" + bucket.getDocCount());
    }

统计的结果如下：

5、filter

filter可以按指定的查询条件过滤数据，如下统计姓school是北大的人数：

public void filter() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 统计文档中school是北大的人数
    // 先构建查询条件
    TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("school.keyword", "北大");
    // 设置过滤统计的查询条件
    FilterAggregationBuilder filterBuilder = AggregationBuilders.filter("count", termQueryBuilder);
    searchSourceBuilder.aggregation(filterBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    Filter filter = response.getAggregations().get("count");
    double value = filter.getDocCount();
    System.out.println(value);
}

6、count

count是统计数量的，如下根据文档 id 统计索引中的文档数：

public void valueCount() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 根据文档id统计索引的文档数
    ValueCountAggregationBuilder valueCountBuilder = AggregationBuilders.count("count").field("_id");
    searchSourceBuilder.aggregation(valueCountBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    ValueCount valueCount = response.getAggregations().get("count");
    double value = valueCount.getValue();
    System.out.println(value);
}

7、terms

terms是按指定字段对文档数据进行分组，如下按school字段进行分组，统计出前20组（默认10组），并按每组的数据量升序排列（默认降序）：

public void terms() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 按照school分组
    TermsAggregationBuilder termsBuilder = AggregationBuilders.terms("schoolGroup")
            .field("school.keyword")
            // 按每组的数据量升序排列
            .order(BucketOrder.aggregation("_count", true))
            // 最多统计出20组数据
            .size(20);
    searchSourceBuilder.aggregation(termsBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    Terms terms = response.getAggregations().get("schoolGroup");
    for (Terms.Bucket bucket : terms.getBuckets()) {
        System.out.println(bucket.getKeyAsString() + " 的人数：" + bucket.getDocCount());
    }
}

8、子统计

上边我们使用terms对文档数据按照school字段进行了分组，我们还可以对组内的数据进行其它统计，例如统计age的最小值，这就是子统计。代码如下：

public void sub() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 按照school分组
    TermsAggregationBuilder termsBuilder = AggregationBuilders.terms("schoolGroup")
            .field("school.keyword")
            // 按每组的数据量升序排列
            .order(BucketOrder.aggregation("_count", true))
            // 最多统计出20组数据
            .size(20)
            // 添加子统计
            .subAggregation(AggregationBuilders.min("minAge").field("age"));
    searchSourceBuilder.aggregation(termsBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    Terms terms = response.getAggregations().get("schoolGroup");
    for (Terms.Bucket bucket : terms.getBuckets()) {
        // 取出子统计的结果
        Min min = bucket.getAggregations().get("minAge");
        System.out.println(bucket.getKeyAsString() + " 的人数：" + bucket.getDocCount() + "，age的最小值：" + min.getValue());
    }
}

9、topHits

前边的各种聚合查询只能统计出最终的结果，我们并不能知道那些文档数据参与了统计，topHits可以用来跟踪正在参与分组聚合统计的文档数据，我在前边terms例子的基础上继续修改，来跟踪每组内的前20条数据（默认10条数据），并按age升序排列：

public void topHits() throws IOException {
    SearchRequest request = new SearchRequest("user");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 跟踪正在参与分组聚合统计的文档数据
    TopHitsAggregationBuilder topHitsBuilder = AggregationBuilders.topHits("groupData")
            // 跟踪前20条数据
            .size(20)
            // 按age升序排列
            .sort("age", SortOrder.ASC);
    // 按照school分组
    TermsAggregationBuilder termsBuilder = AggregationBuilders.terms("schoolGroup")
            .field("school.keyword")
            // 按每组的数据量升序排列
            .order(BucketOrder.aggregation("_count", true))
            // 最多统计出20组数据
            .size(20)
            // 添加文档数据跟踪
            .subAggregation(topHitsBuilder);
    searchSourceBuilder.aggregation(termsBuilder);
    request.source(searchSourceBuilder);
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 取出统计结果
    Terms terms = response.getAggregations().get("schoolGroup");
    for (Terms.Bucket bucket : terms.getBuckets()) {
        System.out.println(bucket.getKeyAsString() + " 的人数：" + bucket.getDocCount());
        // 取出topHits跟踪的文档数据
        TopHits groupData = bucket.getAggregations().get("groupData");
        for (SearchHit hit : groupData.getHits()) {
            System.out.println(hit.getSourceAsString());
        }
        System.out.println("---------------------------------------------------------------------------");
    }
}

聚合查询的相关内容就介绍这么多了，更多的可以查看官方文档。