elasticsearch-聚合查询

- 依赖引入
- 目录结构
- 代码详情
- - DemoApplication.java
  - ElasticsearchRestClient.java
  - BucketAggregationTest.java
  - MetricAggregationTest.java
- 完整工程地址

本篇目将写一个案例来介绍, java 集成 elasticsearch 并且实现常见的聚合查询

依赖引入

我们使用 springboot快速创建一个项目, pom.xml如下



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.5.4
         
    
    com.elastic
    demo
    0.0.1-SNAPSHOT
    demo
    Demo project for Spring Boot
    
        1.8
    
    
        
        
            org.springframework.boot
            spring-boot-starter
        

        
        
            org.elasticsearch.client
            elasticsearch-rest-high-level-client
            6.6.2
        

        
            org.elasticsearch
            elasticsearch
            6.6.2
        

        
            org.elasticsearch.client
            transport
            6.6.2
        

        
            org.springframework.boot
            spring-boot-starter-test
            test

目录结构

代码详情

在这里我们做案例的话, 仅仅需要4个类. 分别如下

DemoApplication: 启动入口类
ElasticsearchRestClient: elasticsearch 配置类
BucketAggregationTest: Bucket aggregations 桶分聚合
MetricAggregationTest: 计算度量聚合

DemoApplication.java

package com.elastic.demo;

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(DemoApplication.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.run(args);
    }
}

ElasticsearchRestClient.java

package com.elastic.demo;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Arrays;
import java.util.Objects;


@Configuration
public class ElasticsearchRestClient {
    private static final Logger log = LoggerFactory.getLogger(ElasticsearchRestClient.class);
    private static final int ADDRESS_LENGTH = 2;
    private static final String HTTP_SCHEME = "http";

    String[] ipAddress = new String[]{"192.168.1.186:9200"};

    @Bean
    public RestClientBuilder restClientBuilder() {
        HttpHost[] hosts = Arrays.stream(ipAddress)
                .map(this::makeHttpHost)
                .filter(Objects::nonNull)
                .toArray(HttpHost[]::new);
        log.debug("hosts:{}", Arrays.toString(hosts));
        return RestClient.builder(hosts);
    }


    @Bean(name = "highLevelClient")
    public RestHighLevelClient highLevelClient(@Autowired RestClientBuilder restClientBuilder) {
        return new RestHighLevelClient(restClientBuilder);
    }


    private HttpHost makeHttpHost(String s) {
        String[] address = s.split(":");
        if (address.length == ADDRESS_LENGTH) {
            String ip = address[0];
            int port = Integer.parseInt(address[1]);
            return new HttpHost(ip, port, HTTP_SCHEME);
        } else {
            return null;
        }
    }
}

BucketAggregationTest.java

package com.elastic.demo;

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.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.BucketOrder;
import org.elasticsearch.search.aggregations.bucket.filter.*;
import org.elasticsearch.search.aggregations.bucket.global.Global;
import org.elasticsearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.missing.Missing;
import org.elasticsearch.search.aggregations.bucket.missing.MissingAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.nested.Nested;
import org.elasticsearch.search.aggregations.bucket.nested.NestedAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.nested.ReverseNested;
import org.elasticsearch.search.aggregations.bucket.range.Range;
import org.elasticsearch.search.aggregations.bucket.significant.SignificantTerms;
import org.elasticsearch.search.aggregations.bucket.significant.SignificantTermsAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.joda.time.DateTime;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;


@SpringBootTest
class BucketAggregationTest {
    private static final Logger log = LoggerFactory.getLogger(BucketAggregationTest.class);
    @Autowired
    private RestHighLevelClient highLevelClient;

    
    @Test
    void globalAggregation() throws IOException {
        GlobalAggregationBuilder aggregation = AggregationBuilders
                .global("agg")
                .subAggregation(AggregationBuilders.terms("classCode.keyword").field("classCode.keyword"));

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Global aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", aggResult.getDocCount());
    }


    
    @Test
    void filterAggregation() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.termQuery("parentId", 5));

        FilterAggregationBuilder aggregation = AggregationBuilders
                .filter("agg", query);

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Filter aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", aggResult.getDocCount());
    }


    
    @Test
    void filtersAggregation() throws IOException {
        FiltersAggregationBuilder aggregation = AggregationBuilders
                .filters("agg",
                        new FiltersAggregator.KeyedFilter("men", QueryBuilders.termQuery("parentId", 5)),
                        new FiltersAggregator.KeyedFilter("women", QueryBuilders.termQuery("parentId", 1)));

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Filters aggResult = response.getAggregations().get("agg");

        for (Filters.Bucket entry : aggResult.getBuckets()) {
            // bucket key
            String key = entry.getKeyAsString();
            // Doc count
            long docCount = entry.getDocCount();
            log.info(">>> key: {}, doc_count: {}", key, docCount);
        }
    }


    
    @Test
    void missingAggregation() throws IOException {
        MissingAggregationBuilder aggregation = AggregationBuilders.missing("agg").field("parentId");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Missing aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", aggResult.getDocCount());
    }


    
    @Test
    void nestedAggregation() throws IOException {
        NestedAggregationBuilder aggregation = AggregationBuilders.nested("agg", "parentId");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Nested aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", aggResult.getDocCount());
    }


    
    @Test
    void reverseNestedAggregation() throws IOException {
        NestedAggregationBuilder aggregation = AggregationBuilders
                .nested("agg", "resellers")
                .subAggregation(
                        AggregationBuilders
                                .terms("type").field("resellers.type")
                                .subAggregation(
                                        AggregationBuilders
                                                .reverseNested("reseller_to_product")
                                )
                );

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Nested aggResult = response.getAggregations().get("agg");
        Terms name = aggResult.getAggregations().get("type");
        for (Terms.Bucket bucket : name.getBuckets()) {
            ReverseNested resellerToProduct = bucket.getAggregations().get("reseller_to_product");
            log.info(">>> {}", resellerToProduct.getDocCount());
        }
    }


    
    @Test
    void termsAggregation() throws IOException {
        TermsAggregationBuilder aggregation = AggregationBuilders
                .terms("agg")
                .field("parentId");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Terms aggResult = response.getAggregations().get("agg");
        for (Terms.Bucket entry : aggResult.getBuckets()) {
            log.info(">>> key: {}, docCount: {}", entry.getKey(), entry.getDocCount());
        }
    }


    
    @Test
    void orderAggregation() throws IOException {
        // 通过 doc_count 按升序排列
        // TermsAggregationBuilder aggregation = AggregationBuilders
        //         .terms("agg")
        //         .field("parentId")
        //         .order(BucketOrder.count(true));

        // 通过 key 按升序排列
        // TermsAggregationBuilder aggregation = AggregationBuilders
        //         .terms("agg")
        //         .field("parentId")
        //         .order(BucketOrder.key(true));

        // 按 metrics 子聚合排列（标示为聚合名）
        TermsAggregationBuilder aggregation = AggregationBuilders
                .terms("agg")
                .field("parentId")
                .order(BucketOrder.aggregation("avg_parentId", false))
                .subAggregation(
                        AggregationBuilders.avg("avg_parentId").field("avg_parentId")
                );

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Terms aggResult = response.getAggregations().get("agg");
        for (Terms.Bucket entry : aggResult.getBuckets()) {
            log.info(">>> key: {}, docCount: {}", entry.getKey(), entry.getDocCount());
        }
    }


    
    @Test
    void significantTermsAggregation() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.termQuery("parentId", 5));

        SignificantTermsAggregationBuilder aggregation = AggregationBuilders
                .significantTerms("agg")
                .field("parentId");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        sourceBuilder.query(query);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SignificantTerms aggResult = response.getAggregations().get("agg");
        for (SignificantTerms.Bucket entry : aggResult.getBuckets()) {
            log.info(">>> key: {}, docCount: {}", entry.getKey(), entry.getDocCount());
        }
    }


    
    @Test
    void dateRangeAggregation() throws IOException {
        AggregationBuilder aggregation =
                AggregationBuilders
                        .dateRange("agg")
                        .field("createTime")
                        .format("yyyyMMddHHmmss")
                        .addUnboundedTo("20160522161616")     // Less than 20160522161616
                        .addRange("20160522161616", "20210522161616")  // 20160522161616 --- 20210522161616
                        .addUnboundedFrom("20210522161616"); // more than 20210522161616

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Range aggResult = response.getAggregations().get("agg");

        for (Range.Bucket entry : aggResult.getBuckets()) {
            String key = entry.getKeyAsString();                // Date range as key
            DateTime fromAsDate = (DateTime) entry.getFrom();   // Date bucket from as a Date
            DateTime toAsDate = (DateTime) entry.getTo();       // Date bucket to as a Date
            long docCount = entry.getDocCount();                // Doc count
            log.info("key [{}], from [{}], to [{}], doc_count [{}]", key, fromAsDate, toAsDate, docCount);
        }
    }


    
    @Test
    void histogramAggregation() throws IOException {
        AggregationBuilder aggregation = AggregationBuilders
                        .histogram("agg")
                        .field("parentId")
                        .interval(1);

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);
        SearchRequest searchRequest = new SearchRequest("dcvciclass");

        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Range aggResult = response.getAggregations().get("agg");

        for (Range.Bucket entry : aggResult.getBuckets()) {
            String key = entry.getKeyAsString();                // Date range as key
            DateTime fromAsDate = (DateTime) entry.getFrom();   // Date bucket from as a Date
            DateTime toAsDate = (DateTime) entry.getTo();       // Date bucket to as a Date
            long docCount = entry.getDocCount();                // Doc count
            log.info("key [{}], from [{}], to [{}], doc_count [{}]", key, fromAsDate, toAsDate, docCount);
        }
    }
}

MetricAggregationTest.java

package com.elastic.demo;

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.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.metrics.avg.Avg;
import org.elasticsearch.search.aggregations.metrics.avg.AvgAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.max.Max;
import org.elasticsearch.search.aggregations.metrics.max.MaxAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.min.Min;
import org.elasticsearch.search.aggregations.metrics.min.MinAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.percentiles.PercentileRanks;
import org.elasticsearch.search.aggregations.metrics.percentiles.Percentiles;
import org.elasticsearch.search.aggregations.metrics.percentiles.PercentilesAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.stats.Stats;
import org.elasticsearch.search.aggregations.metrics.stats.StatsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.stats.extended.ExtendedStats;
import org.elasticsearch.search.aggregations.metrics.stats.extended.ExtendedStatsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.sum.Sum;
import org.elasticsearch.search.aggregations.metrics.sum.SumAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.tophits.TopHits;
import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCount;
import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCountAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.math.BigDecimal;


@SpringBootTest
class MetricAggregationTest {
    private static final Logger log = LoggerFactory.getLogger(MetricAggregationTest.class);
    @Autowired
    private RestHighLevelClient highLevelClient;

    
    @Test
    void metricsMin() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.rangeQuery("classLvl").gte(2));

        MinAggregationBuilder aggregation =
                AggregationBuilders
                        .min("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(query);
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Min aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", BigDecimal.valueOf(aggResult.getValue()));
    }

    
    @Test
    void metricsMax() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.rangeQuery("classLvl").gte(2));

        MaxAggregationBuilder aggregation =
                AggregationBuilders
                        .max("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(query);
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Max aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", BigDecimal.valueOf(aggResult.getValue()));
    }


    
    @Test
    void metricsSum() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.rangeQuery("classLvl").gte(2));

        SumAggregationBuilder aggregation =
                AggregationBuilders
                        .sum("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(query);
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Sum aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", BigDecimal.valueOf(aggResult.getValue()));
    }


    
    @Test
    void metricsAvg() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.rangeQuery("classLvl").gte(2));

        AvgAggregationBuilder aggregation =
                AggregationBuilders
                        .avg("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(query);
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Avg aggResult = response.getAggregations().get("agg");
        log.info(">>> {}", BigDecimal.valueOf(aggResult.getValue()));
    }


    
    @Test
    void metricsStats() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.rangeQuery("classLvl").gte(2));

        StatsAggregationBuilder aggregation =
                AggregationBuilders
                        .stats("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(query);
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Stats aggResult = response.getAggregations().get("agg");

        log.info("Min >>> {}", BigDecimal.valueOf(aggResult.getMin()));
        log.info("Max >>> {}", BigDecimal.valueOf(aggResult.getMax()));
        log.info("Avg >>> {}", BigDecimal.valueOf(aggResult.getAvg()));
        log.info("Sum >>> {}", BigDecimal.valueOf(aggResult.getSum()));
        log.info("Count >>> {}", aggResult.getCount());
    }


    
    @Test
    void metricsExtendedStats() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.rangeQuery("classLvl").gte(20));

        ExtendedStatsAggregationBuilder aggregation =
                AggregationBuilders
                        .extendedStats("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(query);
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        ExtendedStats aggResult = response.getAggregations().get("agg");

        log.info("Min >>> {}", BigDecimal.valueOf(aggResult.getMin()));
        log.info("Max >>> {}", BigDecimal.valueOf(aggResult.getMax()));
        log.info("Avg >>> {}", BigDecimal.valueOf(aggResult.getAvg()));
        log.info("Sum >>> {}", BigDecimal.valueOf(aggResult.getSum()));
        log.info("Count >>> {}", aggResult.getCount());

        log.info("stdDeviation >>> {}", BigDecimal.valueOf(aggResult.getStdDeviation()));
        log.info("sumOfSquares >>> {}", BigDecimal.valueOf(aggResult.getSumOfSquares()));
        log.info("sumOfSquares >>> {}", BigDecimal.valueOf(aggResult.getVariance()));
    }


    
    @Test
    void metricsValueCount() throws IOException {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        query.must(QueryBuilders.rangeQuery("classLvl").gte(20));

        ValueCountAggregationBuilder aggregation =
                AggregationBuilders
                        .count("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(query);
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        ValueCount aggResult = response.getAggregations().get("agg");
        log.info("Count >>> {}", BigDecimal.valueOf(aggResult.getValue()));
    }


    
    @Test
    void metricsPercentiles() throws IOException {
        PercentilesAggregationBuilder aggregation =
                AggregationBuilders
                        .percentiles("agg")
                        .field("id");
        // 自定义百分数位
        // .percentiles(1.0, 6.0, 10.0, 20.0, 30.0, 75.0, 95.0, 99.0);

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Percentiles aggResult = response.getAggregations().get("agg");
        aggResult.forEach(result -> {
            log.info("percent >>> {}", result.getPercent());
            log.info("value >>> {}", result.getValue());
        });
    }


    
    @Test
    void metricsPercentilesRanks() throws IOException {
        PercentilesAggregationBuilder aggregation =
                AggregationBuilders
                        .percentiles("agg")
                        .field("classLvl");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        PercentileRanks aggResult = response.getAggregations().get("agg");
        aggResult.forEach(result -> {
            log.info("percent >>> {}", result.getPercent());
            log.info("value >>> {}", result.getValue());
        });
    }


    
    @Test
    void metricsTopHits() throws IOException {
        // 大多数标准的搜索选项可以使用 from, size, sort, highlight, explain 等
        AggregationBuilder aggregation = AggregationBuilders
                .terms("agg").field("parentId")
                .subAggregation(
                        AggregationBuilders.topHits("top")
                                // .explain(true)
                                .size(1)
                                .from(10)
                );

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.boolQuery());
        sourceBuilder.aggregation(aggregation);

        SearchRequest searchRequest = new SearchRequest("dcvciclass");
        searchRequest.source(sourceBuilder);
        SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Terms aggResult = response.getAggregations().get("agg");

        for (Terms.Bucket entry : aggResult.getBuckets()) {
            log.info(">>> bucket_key: {}, doc_count: {}", entry.getKey(), entry.getDocCount());

            // We ask for top_hits for each bucket
            TopHits topHits = entry.getAggregations().get("top");
            for (SearchHit hit : topHits.getHits().getHits()) {
                log.info(">>> id [{}], _source [{}]", hit.getId(), hit.getSourceAsString());
            }
        }
    }
}

以上便是关于 elasticsearch-聚合查询示例

完整工程地址

https://github.com/XQfelix/elastic-agg

elasticsearch-聚合查询

大数据相关栏目本月热门文章