04，SpringBoot整合es

最新推荐文章于 2024-05-15 15:31:11 发布

李乃龙1

最新推荐文章于 2024-05-15 15:31:11 发布

阅读量461

点赞数

分类专栏： ElasticSearch 文章标签： elasticsearch spring boot java

本文链接：https://blog.csdn.net/w7635122886/article/details/128572087

版权

ElasticSearch 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1，添加MAVEN

<!--springboot整合es-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

2，修改配置文件

server.port=8080
#自定义es连接地址
es.host=192.168.40.131:9200

3，添加config

在这里插入图片描述

4，elasticsearchOperations

4.1 什么是elasticsearchOperations

以面向对象的特点与es进行交互
索引：用来存放相似文档的集合
映射：用来决定放入文档的每个字段以什么样的方式录入到es中，可以指定字段类型和指定分词器
文档：可以被索引的最小单元json数据格式

4.2 新建实体类

package com.study.springbootes.elasticsearchOperations.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

//@Document 用在类上，作用：代表一个对象为一个文档
//      -- indexName属性：创建索引的名称
//      -- createIndex属性 是否创建索引，如果索引名称不存在则创建索引
@Document(indexName = "products",createIndex = true)
public class Product {
    //@id用在属性上   作用：将对象的id字段与es中文档的_id对应
    @Id
    private String id;

    //@Field 用在属性上  作用：用来定义es中的存储类型以及分词情况
    @Field(type = FieldType.Keyword)
    private String title;

    @Field(type = FieldType.Float)
    private Double price;

    @Field(type = FieldType.Text ,analyzer = "ik_smart")
    private String description;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

4.3 sava

当文档id不存在则保存文档，当文档id存在则更新文档
在这里插入图片描述

4.4 查询所有

在这里插入图片描述

4.5 根据id查询es中的数据

在这里插入图片描述

4.6 根据id删除es中的数据

在这里插入图片描述

4.7 删除所有

5，restHighLevelClient

5.1 新建实体类

package com.study.springbootes.restHighLevelClient.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

import java.sql.Date;


public class Demo {
    private String id;
    private String title;
    private double price;
    private String created_at;
    private String description;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getCreated_at() {
        return created_at;
    }

    public void setCreated_at(String created_at) {
        this.created_at = created_at;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }


}

package com.study.springbootes.restHighLevelClient.entity;

public class Search {
    private String id;
    private String title;
    private double startPrice;
    private double endPrice;
    private String created_at;
    private String description;
    private Integer from;
    private Integer size;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getStartPrice() {
        return startPrice;
    }

    public void setStartPrice(double startPrice) {
        this.startPrice = startPrice;
    }

    public double getEndPrice() {
        return endPrice;
    }

    public void setEndPrice(double endPrice) {
        this.endPrice = endPrice;
    }

    public String getCreated_at() {
        return created_at;
    }

    public void setCreated_at(String created_at) {
        this.created_at = created_at;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Integer getFrom() {
        return from;
    }

    public void setFrom(Integer from) {
        this.from = from;
    }

    public Integer getSize() {
        return size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }
}

5.2 基本使用

package com.study.springbootes.restHighLevelClient;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.study.springbootes.restHighLevelClient.entity.Demo;
import com.study.springbootes.utils.IDutils;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.common.xcontent.XContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


@RestController
@RequestMapping("/resthighlevelclienttest")
public class RestHighLevelClientBaseTest {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 创建索引和映射
     * @return
     * @throws Exception
     */
    @GetMapping("createIndexMapping")
    private CreateIndexResponse createIndexMapping()throws Exception{
        //product为索引名称
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("products");
        createIndexRequest.mapping("{\n" +
                "    \"properties\": {\n" +
                "      \"id\":{\n" +
                "        \"type\":\"text\"\n" +
                "      },\n" +
                "      \"title\":{\n" +
                "        \"type\":\"keyword\"\n" +
                "      },\n" +
                "      \"price\":{\n" +
                "        \"type\": \"double\"\n" +
                "      },\n" +
                "      \"created_at\":{\n" +
                "        \"type\": \"date\"\n" +
                "      },\n" +
                "      \"description\":{\n" +
                "        \"type\": \"text\",\n" +
                "        \"analyzer\": \"ik_max_word\"\n" +
                "      }\n" +
                "    }\n" +
                "  }", XContentType.JSON);//参数1：指定映射  参数2：指定参数类型
        //参数1：创建索引的请求对象
        //参数2：请求配置对象
        CreateIndexResponse createIndexResponse =
                restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
//        restHighLevelClient.close(); //关闭资源
        return createIndexResponse;
    }

    /**
     * 删除索引
     * @return
     * @throws Exception
     */
    @GetMapping("deleteIndexMapping")
    private AcknowledgedResponse deleteIndexMapping()throws Exception{
        //参数1：创建索引的请求对象
        //参数2：请求配置对象
        AcknowledgedResponse delete =
                restHighLevelClient.indices().delete(new DeleteIndexRequest("products"), RequestOptions.DEFAULT);
//        restHighLevelClient.close(); //关闭资源
        return delete;
    }

    /**
     * 添加一条文档
     * @param demo
     * @return
     * @throws Exception
     */
    @PostMapping("addDocment")
    private IndexResponse addDocment(@RequestBody Demo demo)throws Exception{
        String uuid = IDutils.getuuId();
        JSONObject jsonObject = new JSONObject();
        demo.setId(uuid);
        String data = jsonObject.toJSONString(demo);

        IndexRequest indexRequest = new IndexRequest("products");
        indexRequest.id(uuid).source(data,XContentType.JSON);
        //参数1：创建索引的请求对象
        //参数2：请求配置对象
        IndexResponse response = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        return response;
    }

    /**
     * 修改一条文档
     * @param demo
     * @return
     * @throws Exception
     */
    @PostMapping("updateDocment")
    private UpdateResponse updateDocment(@RequestBody Demo demo)throws Exception{
        JSONObject jsonObject = new JSONObject();
        //获取id
        String id = demo.getId();
        String data = jsonObject.toJSONString(demo);

        UpdateRequest updateRequest = new UpdateRequest("products", id);
        updateRequest.doc(data,XContentType.JSON);
        //参数1：创建索引的请求对象
        //参数2：请求配置对象
        UpdateResponse response = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        return response;
    }

    /**
     * 根据id删除文档
     * @param id
     * @return
     * @throws Exception
     */
    @GetMapping("/deleteDocmentById/{id}")
    public DeleteResponse deleteDocment(@PathVariable("id")String id)throws Exception{
        DeleteResponse products =
                restHighLevelClient.delete(new DeleteRequest("products", id), RequestOptions.DEFAULT);
        return products;
    }

    /**
     * 根据id查询文档
     * @param id
     * @return
     * @throws Exception
     */
    @GetMapping("/getDocmentById/{id}")
    public Demo getDocmentById(@PathVariable("id")String id)throws Exception{
        GetRequest products = new GetRequest("products", id);
        GetResponse response = restHighLevelClient.get(products, RequestOptions.DEFAULT);
        String sourceAsString = response.getSourceAsString();
        Demo result = JSON.parseObject(sourceAsString,Demo.class);
        return result;
    }
}

5.3 复杂查询

package com.study.springbootes.restHighLevelClient;

import com.alibaba.fastjson.JSON;
import com.study.springbootes.restHighLevelClient.entity.Demo;
import com.study.springbootes.restHighLevelClient.entity.Search;
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.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/resthighlevelclientseniortest")
public class RestHighLevelClientSeniorTest {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 查询所有
     * @return
     * @throws Exception
     */
    @GetMapping("/getAllDocment")
    public Map<String,Object> getAllDocment()throws Exception{
        Map<String, Object> map = query(QueryBuilders.matchAllQuery());
        return map;
//        //指定搜索条件
//        SearchRequest searchRequest = new SearchRequest("products");
//        //指定条件对象
//        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();//指定查询条件对象
//        sourceBuilder.equals(QueryBuilders.matchAllQuery());//查询所有
//        searchRequest.source(sourceBuilder);//指定查询条件
//
//        //参数1：创建索引的请求对象
//        //参数2：请求配置对象
//        SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
//        Map <String,Object> map = new HashMap<>();
//        map.put("总条数",search.getHits().getTotalHits().value);
//        map.put("最大得分",search.getHits().getMaxScore());
//        List<Demo> list = new ArrayList<>();
//        //获取结果
//        SearchHit[] hits = search.getHits().getHits();
//        for (SearchHit hit : hits) {
//            String sourceAsString = hit.getSourceAsString();
//            Demo demo = JSON.parseObject(sourceAsString,Demo.class);
//            list.add(demo);
//        }
//        map.put("数据",list);
//        return map;
    }

    /**
     * 关键字查询
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getTermDocment")
    private Map<String, Object> getTermDocment(@RequestBody Search search)throws Exception{
        Map<String, Object> map = query(QueryBuilders.termQuery("description", search.getDescription()));
        return map;
    }

    /**
     * 范围查询
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getRangeDocment")
    private Map<String, Object> getRangeDocment(@RequestBody Search search)throws Exception{
        Map<String, Object> map =
                query(QueryBuilders.rangeQuery("price").gt(search.getStartPrice()).lte(search.getEndPrice()));
        return map;
    }

    /**
     * 前缀查询
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getPrefixDocment")
    private Map<String, Object> getPrefixDocment(@RequestBody Search search)throws Exception{
        Map<String, Object> map =
                query(QueryBuilders.prefixQuery("description",search.getDescription()));
        return map;
    }

    /**
     * 通配符查询
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getWildCardDocment")
    private Map<String, Object> getWildCardDocment(@RequestBody Search search)throws Exception{
        Map<String, Object> map =
                query(QueryBuilders.wildcardQuery("description",search.getDescription()));
        return map;
    }

    /**
     * 多字段查询
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getMultiMatchDocment")
    private Map<String, Object> getMultiMatchDocment(@RequestBody Search search)throws Exception{
        Map<String, Object> map =
                query(QueryBuilders.multiMatchQuery(search.getDescription(),"description","title"));
        return map;
    }

    private Map<String,Object> query(QueryBuilder queryBuilder)throws Exception{
        SearchRequest searchRequest = new SearchRequest("products"); //指定查询文档
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(queryBuilder); //指定查询条件
        searchRequest.source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Map <String,Object> map = new HashMap<>();
        map.put("总条数",response.getHits().getTotalHits().value);
        map.put("最大得分",response.getHits().getMaxScore());

        List<Demo> list = new ArrayList<>();
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            Demo demo = JSON.parseObject(sourceAsString,Demo.class);
            list.add(demo);
        }
        map.put("数据",list);
        return map;
    }
}

5.4 分页和高亮查询

package com.study.springbootes.restHighLevelClient;

import com.alibaba.fastjson.JSON;
import com.study.springbootes.restHighLevelClient.entity.Demo;
import com.study.springbootes.restHighLevelClient.entity.Search;
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.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/resthighlevelclientpagelisttest")
public class RestHighLevelClientPageListTest {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 分页查询所有 from 起始位置  size每页展示条数
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getPageListDocment")
    private Map<String, Object> getMultiMatchDocment(@RequestBody Search search)throws Exception{
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery())
                .from(search.getFrom())
                .size(search.getSize())
                .sort("price", SortOrder.DESC) //排序
                .fetchSource(new String[]{},new String[]{"created_at"}); //指定返回字段  参数1：包含字段数组，  参数2：排查字段数组
        Map<String, Object> map = query(sourceBuilder);
        return map;
    }

    /**
     * 高亮字段显示不能再查询所有时生效
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getPageListHighlightDocment")
    private Map<String, Object> getPageListHighlightDocment(@RequestBody Search search)throws Exception{
        SearchRequest searchRequest = new SearchRequest("products"); //指定查询文档
        //高亮设置器
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.requireFieldMatch(false) //关闭高亮匹配字段
                .field("description") //设置高亮字段
                .field("title")
                .preTags("<span style='color:red;'>")
                .postTags("</span>");

        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.termQuery("description",search.getDescription()))
                .from(search.getFrom())
                .size(search.getSize())
                .sort("price", SortOrder.DESC) //排序
                .fetchSource(new String[]{},new String[]{"created_at"}) //指定返回字段  参数1：包含字段数组，  参数2：排查字段数组
                .highlighter(highlightBuilder); //设置高亮
        searchRequest.source(sourceBuilder);
        Map<String, Object> map = query(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        map.put("总条数",response.getHits().getTotalHits().value);
        map.put("最大得分",response.getHits().getMaxScore());

        List<Demo> list = new ArrayList<>();
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            Demo demo = JSON.parseObject(sourceAsString,Demo.class);
            //获取高亮字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if(highlightFields.containsKey("description")){
                String description = highlightFields.get("description").fragments()[0].toString();
                demo.setDescription(description);
            }
            if(highlightFields.containsKey("title")){
                String title = highlightFields.get("title").fragments()[0].toString();
                demo.setTitle(title);
            }
            list.add(demo);
        }
        map.put("数据",list);
        return map;
    }

    private Map<String,Object> query(SearchSourceBuilder sourceBuilder)throws Exception{
        SearchRequest searchRequest = new SearchRequest("products"); //指定查询文档
        searchRequest.source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Map <String,Object> map = new HashMap<>();
        map.put("总条数",response.getHits().getTotalHits().value);
        map.put("最大得分",response.getHits().getMaxScore());

        List<Demo> list = new ArrayList<>();
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            Demo demo = JSON.parseObject(sourceAsString,Demo.class);
            list.add(demo);
        }
        map.put("数据",list);
        return map;
    }
}

5.5 过滤查询

package com.study.springbootes.restHighLevelClient;

import com.alibaba.fastjson.JSON;
import com.study.springbootes.restHighLevelClient.entity.Demo;
import com.study.springbootes.restHighLevelClient.entity.Search;
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.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 在大量的数据在筛选出相关数据，会对经常使用的filter query进行缓存
 * 注意：一旦使用query和filter query es 优先执行 filter query 然后在执行 query
 */
@RestController
@RequestMapping("/resthighlevelclientfiltertest")
public class RestHighLevelClientFilterTest {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 过滤查询
     * @param search
     * @return
     * @throws Exception
     */
    @PostMapping("getFileterDocment")
    private Map<String, Object> getFileterDocment(@RequestBody Search search)throws Exception{
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.termQuery("description",search.getDescription()))
                .postFilter(QueryBuilders.rangeQuery("price")
                        .gt(search.getStartPrice()).lte(search.getEndPrice())); //指定过滤条件
        Map<String, Object> query = query(sourceBuilder);
        return query;
    }


    private Map<String,Object> query(SearchSourceBuilder sourceBuilder)throws Exception{
        SearchRequest searchRequest = new SearchRequest("products"); //指定查询文档
        searchRequest.source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Map <String,Object> map = new HashMap<>();
        map.put("总条数",response.getHits().getTotalHits().value);
        map.put("最大得分",response.getHits().getMaxScore());

        List<Demo> list = new ArrayList<>();
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            Demo demo = JSON.parseObject(sourceAsString,Demo.class);
            list.add(demo);
        }
        map.put("数据",list);
        return map;
    }
}

5.6 聚合查询

package com.study.springbootes.restHighLevelClient;

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.QueryBuilders;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedDoubleTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.metrics.ParsedAvg;
import org.elasticsearch.search.aggregations.metrics.ParsedMax;
import org.elasticsearch.search.aggregations.metrics.ParsedMin;
import org.elasticsearch.search.aggregations.metrics.ParsedSum;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/resthighlevelclientaggstest")
public class RestHighLevelClientAggsTest {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 分组聚合
     * @return
     * @throws Exception
     */
    @GetMapping("/getGroup")
    public Map<String,Object> getGroup()throws Exception{
        SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery()) //查询条件
                     .aggregation(AggregationBuilders.terms("price_group").field("price")) //设置聚合处理
                     .size(0);
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        //处理聚合结果
        Aggregations aggregations = searchResponse.getAggregations();
        ParsedDoubleTerms parsedDoubleTerms = aggregations.get("price_group");
        List<? extends Terms.Bucket> buckets = parsedDoubleTerms.getBuckets();
        Map<String,Object> map = new HashMap<>();
        for (Terms.Bucket bucket : buckets) {
            map.put(bucket.getKey().toString(),bucket.getDocCount());
        }
        return map;
    }

    /**
     * 求和
     * @return
     * @throws Exception
     */
    @GetMapping("/getSum")
    public Map<String,Object> getSum()throws Exception{
        Map<String,Object> map =new HashMap<>();
        SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery()) //查询条件
                .aggregation(AggregationBuilders.sum("sum_group").field("price")) //设置聚合处理
                .size(0);
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();
        ParsedSum parsedSum = aggregations.get("sum_group");
        double value = parsedSum.getValue();
        map.put("total",value);
        return map;
    }

    /**
     * 求平均值
     * @return
     * @throws Exception
     */
    @GetMapping("/getAvg")
    public Map<String,Object> getAvg()throws Exception{
        Map<String,Object> map =new HashMap<>();
        SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery()) //查询条件
                .aggregation(AggregationBuilders.avg("avg_group").field("price")) //设置聚合处理
                .size(0);
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();
        ParsedAvg parsedAvg = aggregations.get("avg_group");
        double value = parsedAvg.getValue();
        map.put("total",value);
        return map;
    }

    /**
     * 求最小值
     * @return
     * @throws Exception
     */
    @GetMapping("/getMin")
    public Map<String,Object> getMin()throws Exception{
        Map<String,Object> map =new HashMap<>();
        SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery()) //查询条件
                .aggregation(AggregationBuilders.min("min_group").field("price")) //设置聚合处理
                .size(0);
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();
        ParsedMin parsedMin = aggregations.get("min_group");
        double value = parsedMin.getValue();
        map.put("total",value);
        return map;
    }

    /**
     * 最大值
     * @return
     * @throws Exception
     */
    @GetMapping("/getMax")
    public Map<String,Object> getMax()throws Exception{
        Map<String,Object> map =new HashMap<>();
        SearchRequest searchRequest = new SearchRequest("products");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchAllQuery()) //查询条件
                .aggregation(AggregationBuilders.max("max_group").field("price")) //设置聚合处理
                .size(0);
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        Aggregations aggregations = searchResponse.getAggregations();
        ParsedMax parsedMax = aggregations.get("max_group");
        double value = parsedMax.getValue();
        map.put("total",value);
        return map;
    }
}