elasticsearch 聚合操作

朱雀 2023-06-27 08:48 45阅读 0赞

--------------------

### elasticsearch 聚合操作 ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**相关类及接口**

**elasticsearchRestTemplate**

public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate implements ElasticsearchOperations, EsClient<Client>, ApplicationContextAware {
    
        public <T> T query(SearchQuery query, ResultsExtractor<T> resultsExtractor) {
    
        public <T> AggregatedPage<T> queryForPage(SearchQuery query, Class<T> clazz) {
        public <T> AggregatedPage<T> queryForPage(SearchQuery query, Class<T> clazz, SearchResultMapper mapper) {

**ResultsExtractor：提取查询结果接口**

public interface ResultsExtractor<T> {
        T extract(SearchResponse var1);
    }

**SearchResultMapper：查询结果映射接口**

public interface SearchResultMapper {
        <T> AggregatedPage<T> mapResults(SearchResponse var1, Class<T> var2, Pageable var3);
    
        @Nullable
        <T> T mapSearchHit(SearchHit var1, Class<T> var2);
    }

**SearchResponse：查询结果返回体**

public class SearchResponse extends ActionResponse implements StatusToXContentObject {
    
        private String scrollId;
        private int totalShards;
        private int successfulShards;
        private int skippedShards;
        private ShardSearchFailure[] shardFailures;
        private SearchResponse.Clusters clusters;
        private long tookInMillis;
    
    ***************
    普通方法
    
        public Aggregations getAggregations() {
    
        public SearchHits getHits() {
        public String getScrollId() {
        public void scrollId(String scrollId) {
    
        public int getTotalShards() {
        public int getSuccessfulShards() {
        public int getSkippedShards() {
        public int getFailedShards() {
        public ShardSearchFailure[] getShardFailures() {
    
        public Suggest getSuggest() {
        public boolean isTimedOut() {
        public Boolean isTerminatedEarly() {
        public int getNumReducePhases() {
        public TimeValue getTook() {

**Aggregations：聚合结果操作类**

public class Aggregations implements Iterable<Aggregation>, ToXContentFragment {
    
        protected Map<String, Aggregation> aggregationsAsMap;
    
    *****************
    普通方法
    
        public final Iterator<Aggregation> iterator() {
        public final List<Aggregation> asList() {
    
        public final Map<String, Aggregation> asMap() {
        public final Map<String, Aggregation> getAsMap() {
    
        public final <A extends Aggregation> A get(String name) {

**AggregatedPage：聚合类page接口**

public interface AggregatedPage<T> extends FacetedPage<T>, ScrolledPage<T>, ScoredPage<T> {
    
        boolean hasAggregations();
    
        Aggregations getAggregations();
        Aggregation getAggregation(String var1);
    }
    
    
    **********************
    ScrolledPage
    
    public interface ScrolledPage<T> extends Page<T> {
        String getScrollId();
    }
    
    
    **********************
    ScoredPage
    
    public interface ScoredPage<T> extends Page<T> {
        float getMaxScore();
    }

## ##

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**示例：****表 fruit：id、name、price**

**查询语句 1：**

select name,sum(price),min(price),max(price),avg(price)

from fruit **where price>=5**;

**查询语句 2：**

select name,sum(price),min(price),max(price),avg(price)

from fruit **where price>=5 group by name**

**having count(\*)>1 and min(price)>5**;

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**pojo 层**

@Data
    @Document(indexName = "fruit2")
    public class Fruit {
    
        @Id
        private Integer id;
    
        @Field(type = FieldType.Keyword)
        private String name;
    
        @Field(type = FieldType.Integer)
        private Integer price;
    }

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**controller 层**

@RestController
    public class FruitController {
    
        @Resource
        private FruitRepository fruitRepository;
    
        @Resource
        private ElasticsearchRestTemplate elasticsearchTemplate;
    
        @RequestMapping("/save2")
        public String save(){
            for(int i=0;i<10;i++){
                Fruit fruit=new Fruit();
                fruit.setId(i);
    
                switch (i%3){
                    case 0: fruit.setName("苹果"); break;
                    case 1: fruit.setName("香蕉"); break;
                    case 2: fruit.setName("栗子");
                }
                fruit.setPrice(i%10+2);
    
                fruitRepository.save(fruit);
            }
    
            return "success";
        }
    
        @RequestMapping("/aggregation")
        public void aggregation(){
            QueryBuilder queryBuilder= QueryBuilders.boolQuery()
                    .must(QueryBuilders.rangeQuery("price").gte(5));
    
            SumAggregationBuilder sumAggregationBuilder= AggregationBuilders.sum("sum_price").field("price");
            MinAggregationBuilder minAggregationBuilder=AggregationBuilders.min("min_price").field("price");
            MaxAggregationBuilder maxAggregationBuilder=AggregationBuilders.max("max_price").field("price");
            AvgAggregationBuilder avgAggregationBuilder=AggregationBuilders.avg("avg_price").field("price");
            StatsAggregationBuilder statsAggregationBuilder=AggregationBuilders.stats("stats_price").field("price");
    
            NativeSearchQuery nativeSearchQuery=new NativeSearchQueryBuilder()
                    .withQuery(queryBuilder)
                    .addAggregation(sumAggregationBuilder)
                    .addAggregation(minAggregationBuilder)
                    .addAggregation(maxAggregationBuilder)
                    .addAggregation(avgAggregationBuilder)
                    .addAggregation(statsAggregationBuilder).build();
    
            AggregatedPage<Fruit> aggregatedPage=elasticsearchTemplate.queryForPage(nativeSearchQuery,Fruit.class);
            Sum sum=(Sum) aggregatedPage.getAggregation("sum_price");
            Min min=(Min) aggregatedPage.getAggregation("min_price");
            Max max=(Max) aggregatedPage.getAggregation("max_price");
            Avg avg=(Avg) aggregatedPage.getAggregation("avg_price");
            Stats stats=(Stats) aggregatedPage.getAggregation("stats_price");
    
            System.out.println("sum："+sum.getValue());
            System.out.println("min："+min.getValue());
            System.out.println("max："+max.getValue());
            System.out.println("avg："+avg.getValue());
            System.out.println("sum："+stats.getSumAsString()+"  "+
                    "min："+stats.getMinAsString()+" "+
                    "max："+stats.getMaxAsString()+" "+
                    "avg："+stats.getAvgAsString()+" "+
                    "count："+stats.getCount());
        }
    
        @RequestMapping("/aggregation2")
        public void aggregation2(){
            QueryBuilder queryBuilder= QueryBuilders.boolQuery()
                    .must(QueryBuilders.rangeQuery("price").gte(5));
    
            TermsAggregationBuilder aggregationBuilder=AggregationBuilders.terms("fruit_name").field("name");
    
            Map<String,String> map=new HashMap<>();
            map.put("count","_count");
            map.put("min","min_price");
            BucketSelectorPipelineAggregationBuilder pipelineAggregationBuilder= PipelineAggregatorBuilders
                    .bucketSelector("having_count",map,new Script("params.count>1&&params.min>5"));
    
            AggregationBuilder minAggregation=AggregationBuilders.min("min_price").field("price");
            AggregationBuilder maxAggregation=AggregationBuilders.max("max_price").field("price");
            AggregationBuilder avgAggregation=AggregationBuilders.avg("avg_price").field("price");
    
            aggregationBuilder.subAggregation(minAggregation)
                    .subAggregation(maxAggregation)
                    .subAggregation(avgAggregation)
                    .subAggregation(pipelineAggregationBuilder);
            NativeSearchQuery nativeSearchQuery=new NativeSearchQueryBuilder().withQuery(queryBuilder)
                    .addAggregation(aggregationBuilder).build();
    
            AggregatedPage<Fruit> aggregatedPage=elasticsearchTemplate.queryForPage(nativeSearchQuery,Fruit.class);
    
            Terms terms =(Terms) aggregatedPage.getAggregation("fruit_name");
            for (Terms.Bucket bucket: terms.getBuckets()){
                Aggregations aggregations=bucket.getAggregations();
                System.out.print("bucket："+bucket.getKeyAsString()+" ");
    
                Min min= aggregations.get("min_price");
                Max max= aggregations.get("max_price");
                Avg avg= aggregations.get("avg_price");
                System.out.println("min："+min.getValue()+" "+"max："+max.getValue()+" "+"avg："+avg.getValue());
            }
    
        }
    }

## ##

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**控制台输出**

**/agregation**

sum：56.0
    min：5.0
    max：11.0
    avg：8.0
    sum：56.0  min：5.0 max：11.0 avg：8.0 count：7

**/aggregation2**

bucket：栗子 min：7.0 max：10.0 avg：8.5
    bucket：香蕉 min：6.0 max：9.0 avg：7.5