import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.RestClients;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;

@Configuration
public class RestClientConfig extends AbstractElasticsearchConfiguration {

    @Override
    @Bean
    public RestHighLevelClient elasticsearchClient() {

        final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
            //修改成ES服务的地址，当然这边的配置可以转移到配置文件里面
                .connectedTo("localhost:9200")
                .build();

        return RestClients.create(clientConfiguration).rest();
    }
}

/**
 * @Document 作用在类上，将这个类对象转为es中一条文档进行录入
 *      indexName：用来指定文档的索引名称
 *      createIndex：用来指定是否创建索引
 */
@Document(indexName = "products",createIndex = true)
public class Product {
    //@Id作用在属性上，将对象id字段与ES中文档的_id对应
    @Id	
    private Integer id;
  	/**@Field作用在属性上，用来描述属性在ES中存储类型以及分词情况
  	*	--type用来指定字段类型
   	*/
    @Field(type = FieldType.Keyword)
    private String title;
    @Field(type = FieldType.Double)
    private Double price;
    @Field(type = FieldType.Text)
    private String description;
    //生成set/get
}

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    private ElasticsearchOperations elasticsearchOperations;
    @Test
    public void testInsert() {
        Product product = new Product();
        product.setId(1);
        product.setTitle("小浣熊干脆面");
        product.setPrice(1.5);
        product.setDescription("小浣熊干脆面很好吃");
        elasticsearchOperations.save(product);
    }
}

通过这种方式添加的文档会有_class字段，记录文档的类型，用于后面反序列化时，反序列化何种类型

//save方法当文档id不存在时添加文档，当文档id存在时更新文档
@Test
public void testUpdate() {
    Product product = new Product();
    product.setId(1);
    product.setTitle("小浣熊");
    product.setPrice(1.5);
    product.setDescription("小浣熊干脆面很好吃");
    elasticsearchOperations.save(product);
}

//查询一条文档
@Test
public void testQuery() {
    Product product = elasticsearchOperations.get("1", Product.class);
    System.out.println(product.getId()+product.getTitle());
}

//查询所有
@Test
public void testQueryAll() throws JsonProcessingException {
    SearchHits<Product> productSearchHits = elasticsearchOperations.search(Query.findAll(), Product.class);
    System.out.println("最高分数:"+productSearchHits.getMaxScore());
    System.out.println("总条数:"+productSearchHits.getTotalHits());
    for (SearchHit<Product> productSearchHit:productSearchHits){
        //将查询出来的内容转换成json格式
        System.out.println(new ObjectMapper().writeValueAsString(productSearchHit.getContent()));
    }
}

//删除一条
@Test
public void testDelete() {
    Product product = new Product();
    product.setId(1);
    elasticsearchOperations.delete(product);
}

//删除所有
@Test
public void testDeleteAll() {
    elasticsearchOperations.delete(Query.findAll(),Product.class);
}

/**
* 因为我们上面配置完成，和ES建立连接之后会自动生成ElasticSearchOperations和RestHighLevelClient两个对象，所以这里我们直接
*注入使用就可以
*/
@Autowired
private RestHighLevelClient restHighLevelClient;


//在kibana中
PUT products
{
  "mappings": {
    "properties": {
      "title":{
        "type": "keyword"
      },
      "price":{
        "type": "double"
      },
      "create_at":{
        "type": "date"
      },
      "description":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}


//在java中
@Test
public void testRestInsert() throws IOException {
    //指定创建索引的名称
    CreateIndexRequest createIndexRequest = new CreateIndexRequest("product");
    /**
    * 这里的索引结构可以直接从kibana中写好复制过来，
    * 当然如果只是创建索引及映射完全可以在kibana中操作,这里也是为了测试
    * mapping方法创建索引，参数1：指定映射的JSON结构    参数2：指定数据类型
    */
    createIndexRequest.mapping("{\n" +
    "    \"properties\": {\n" +
    "      \"title\":{\n" +
    "        \"type\": \"keyword\"\n" +
    "      },\n" +
    "      \"price\":{\n" +
    "        \"type\": \"double\"\n" +
    "      },\n" +
    "      \"create_at\":{\n" +
    "        \"type\": \"date\"\n" +
    "      },\n" +
    "      \"description\":{\n" +
    "        \"type\": \"text\",\n" +
    "        \"analyzer\": \"ik_max_word\"\n" +
    "      }\n" +
    "    }\n" +
    "  }", XContentType.JSON);
    //create方法，参数1：创建索引请求对象   参数2：请求配置对象
    CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
    System.out.println("索引创建状态："+createIndexResponse.isAcknowledged());
    restHighLevelClient.close();
}

//在kibana中
DELETE /products

//在java中
@Test
public void testRestDelete() throws IOException {
    DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("product");
    AcknowledgedResponse delete = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
    System.out.println("删除状态：" + delete.isAcknowledged());
}

//在kibana中
PUT /product/_doc/1
{
  "title":"小浣熊",
  "price":"1.5",
  "create_at":"2022-01-01",
  "description":"小浣熊很好吃"
}

//在java中
@Test
public void testRestInsertDoc() throws IOException {
    //指定操作那个索引
    IndexRequest indexRequest = new IndexRequest("product");
    indexRequest.id("1");//手动指定文档id，不指定会自动生成UUID形式的
    //source方法，参数1：索引请求对象   参数2：请求配置对象
    indexRequest.source("{\"tittle\":\"小浣熊\",\"price\":\"1.5\",\"create_at\":\"2022-01-01\",\"description\":\"小浣熊很好吃\"}",XContentType.JSON);
    IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
    System.out.println("文档创建状态："+indexResponse.status());
}

//在kibana中
POST /product/_doc/1/_update
{
  "doc":{
    "title":"小浣熊干脆面"
  }
}

//在java中
@Test
public void testRestUpdateDoc() throws IOException {
    UpdateRequest updateRequest = new UpdateRequest("product","1");
    updateRequest.doc("{\"title\":\"小浣熊干脆面\"}",XContentType.JSON);
    UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
    System.out.println("更新文档状态:"+updateResponse.status());
}

//在kibana中
DELETE /product/_doc/1

//在java中
@Test
public void testRestDeleteDoc() throws IOException {
    DeleteRequest deleteRequest = new DeleteRequest("product", "1");
    DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
    System.out.println("删除文档状态："+deleteResponse.status());
}

//在kibana中
GET /product/_doc/1

//在java中
@Test
public void testRestFindByIdDoc() throws IOException {
    GetRequest getRequest = new GetRequest("product", "1");
    GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
    System.out.println("id:"+getResponse.getId());
    System.out.println("source的String形式:"+getResponse.getSourceAsString());
    Map<String, Object> source = getResponse.getSource();
    System.out.println(source.get("title"));
}

//在kibana中
GET /product/_search
{
  "query": {
    "match_all": {}
  }
}

//在java中
@Test
public void testMatchAll() throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");//指定搜索的索引
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.matchAllQuery());//查询所有
    searchRequest.source(searchSourceBuilder);//指定查询条件

    //这里返回的响应对象就是对下面图片中结果的封装，取值的时候可以对照着下面图片
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    //这块取值可以对照着下面的图片，在返回结果中有一个hits数组，hits数组中还有一个hits数组，在下面才是每一个hit对象
    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
    }
}

@Test
public void testTerm() throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //和上面的查询相比，只需要更换查询条件，其他不需要变
    searchSourceBuilder.query(QueryBuilders.termQuery("description","浣熊"));
    
    searchRequest.source(searchSourceBuilder);

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

    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
    }
}

//抽象出一个方法，将查询条件作为参数传递
public void query(QueryBuilder queryBuilder) throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");//指定搜索的索引
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(queryBuilder);//查询所有
    searchRequest.source(searchSourceBuilder);//指定查询条件

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

    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
    }
}

@Test
public void testQuery() throws IOException {
    //1、查询所有
    //query(QueryBuilders.matchAllQuery());
    //2、term 关键词查询
    //query(QueryBuilders.termQuery("description","辣条"));
    //3、range 范围查询 1<price<=3
    //query(QueryBuilders.rangeQuery("price").gt(1).lte(3));
    //4、prefix 前缀查询
    //query(QueryBuilders.prefixQuery("title","小浣熊"));
    //5、wildcard 通配符查询 ？代表一个字符 *代表任意多个字符
    //query(QueryBuilders.wildcardQuery("title","小*"));
    //6、ids 多个指定id查询
    //query(QueryBuilders.idsQuery().addIds("1","2","3"));
    //或者可以这样写
    //query(QueryBuilders.idsQuery().addIds("1").addIds("2").addIds("3"));
    //7、multi_match 多字段查询
    query(QueryBuilders.multiMatchQuery("非常好吃小浣熊","title","description"));
}

//在kibana中，from指定从第几页开始，size指每页显示条数
GET /product/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 1
}

//在java中 from size
@Test
public void testSearch() throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    sourceBuilder.from(0);//起始位置
    sourceBuilder.size(1);//每页显示条数
    //也可以链式调用
    //        sourceBuilder.query(QueryBuilders.matchAllQuery()).from(0).size(1);
    searchRequest.source(sourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
    }
}

//在kibana中，使用sort实现，这里在上个分页例子的基础上排序
GET /product/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 10,
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    }
  ]
}

//在java中，sort
@Test
public void testSearch() throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    sourceBuilder.from(0);//起始位置
    sourceBuilder.size(10);//每页显示条数
    sourceBuilder.sort("price", SortOrder.ASC);//排序，参数1：按哪个字段排序 参数2：排序方式
    //        也可以链式调用
    //        sourceBuilder.query(QueryBuilders.matchAllQuery()).from(0).size(10).sort("price", SortOrder.ASC);
    searchRequest.source(sourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
    }
}

//在kibana中，使用_source实现，这里在上个例子的基础上实现
GET /product/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 10,
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    }
  ],
  "_source": ["title","description"]
}

//在java中 fetchSource
@Test
public void testSearch() throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    sourceBuilder.from(0);//起始位置
    sourceBuilder.size(10);//每页显示条数
    //排序，参数1：按哪个字段排序 参数2：排序方式
    sourceBuilder.sort("price", SortOrder.ASC);
    //fetchSource 参数1：指定显示字段数组  参数2：指定排除字段数组
    //        sourceBuilder.fetchSource(new String[]{"title","description"},new String[]{});//只显示title、description两个字段
    sourceBuilder.fetchSource(new String[]{},new String[]{"create_at"});//不显示create_at字段
    //        也可以链式调用
    //        sourceBuilder.query(QueryBuilders.matchAllQuery())
    //                .from(0)
    //                .size(10)
    //                .sort("price", SortOrder.ASC)
    //                .fetchSource(new String[]{},new String[]{"create_at"});
    searchRequest.source(sourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
    }
}

//这里我们重新创建索引，并将title字段设置成分词类型的text
//删除索引
DELETE /product
//重新创建    
PUT product
{
  "mappings": {
    "properties": {
      "title":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "price":{
        "type": "double"
      },
      "create_at":{
        "type": "date"
      },
      "description":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}
//插入数据
PUT /product/_doc/1
{
  "title":"小浣熊",
  "price":"1.5",
  "create_at":"2022-01-01",
  "description":"小浣熊很好吃"
}
PUT /product/_doc/2
{
  "title":"豆腐",
  "price":"3.5",
  "create_at":"2022-01-01",
  "description":"豆腐很好吃"
}

PUT /product/_doc/3
{
  "title":"辣条",
  "price":"2.5",
  "create_at":"2022-01-01",
  "description":"辣条很好吃"
}


//在kibana中使用highlight指定
GET /product/_search
{
  "query": {
    "term": {
      "description": {
        "value": "好吃"
      }
    }
  },
  "from": 0,
  "size": 10,
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    }
  ],
  "highlight": {
    "require_field_match": "false",
    "pre_tags": ["<span style='color:red'>"],
    "post_tags": ["</span>"],
    "fields": {"description": {},"title": {}}
  }
}

//在java中 highlighter
@Test
public void testSearch() throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

    //高亮条件的构造
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.requireFieldMatch(false).field("title").field("description").preTags("<span style='color:red;'>").postTags("</span>");
    
    sourceBuilder.query(QueryBuilders.termQuery("description","豆腐"));
    sourceBuilder.from(0);//起始位置
    sourceBuilder.size(10);//每页显示条数
    sourceBuilder.sort("price", SortOrder.ASC);//排序，参数1：按哪个字段排序 参数2：排序方式
    sourceBuilder.fetchSource(new String[]{},new String[]{"create_at"});//不显示create_at字段

    sourceBuilder.highlighter(highlightBuilder);
    searchRequest.source(sourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
        //在取得高亮的显示时，可以对照下图的JSON结构
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        if(highlightFields.containsKey("description")) {
            System.out.println("description高亮结果："+highlightFields.get("description").fragments()[0]);
        }
        if(highlightFields.containsKey("title")) {
            System.out.println("title高亮结果："+highlightFields.get("title").fragments()[0]);
        }
    }
}

@Test
public void filterQuery() throws IOException {
    SearchRequest searchRequest = new SearchRequest("product");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(QueryBuilders.matchAllQuery());//在过滤的基础上再查询所有
    //sourceBuilder.query(QueryBuilders.termQuery("description","浣熊"));//在过滤的基础上再查询出description中包含“浣熊”的
    //指定过滤条件
    //sourceBuilder.postFilter(QueryBuilders.termQuery("description","豆腐"));//过滤description字段中包含“豆腐”字段的
    //sourceBuilder.postFilter(QueryBuilders.rangeQuery("price").gt(0).lte(3));//过滤出0<price<=3的
    //sourceBuilder.postFilter((QueryBuilders.existsQuery("title")));//过滤出存在title字段的
    sourceBuilder.postFilter(QueryBuilders.idsQuery().addIds("1","2","3"));//过滤出ID为1、2、3的
    //searchRequest.source(sourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

    System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
    System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

    SearchHit[] hits = searchResponse.getHits().getHits();

    for(SearchHit hit:hits) {
        System.out.println("id: "+hit.getId()+"   source:"+hit.getSourceAsString());
    }
}		

public class Goods {
    private Integer id;
    private String title;
    private Double price;
    private String description;
    //生成set/get以及toString
}

@SpringBootTest
public class DemoGoods {
    @Autowired
    private RestHighLevelClient restHighLevelClient;

    //插入数据
    @Test
    public void testInsert() throws IOException {
        Goods goods = new Goods();
        goods.setId(1);
        goods.setTitle("小浣熊干脆面");
        goods.setPrice(1.5);
        goods.setDescription("小浣熊干脆面很好吃");

        IndexRequest indexRequest = new IndexRequest("goods");
        indexRequest.id(goods.getId().toString());
        //这里通过jackson下面的ObjectMapper对象将对象转换成json
       	//这里我们原先直接传递的JSON串，这里可以将对象转成JSON串后传入，便于我们直接操作对象
        indexRequest.source(new ObjectMapper().writeValueAsString(goods), XContentType.JSON);
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);

        System.out.println(indexResponse.status());
    }
    
    
    //查询操作
    @Test
    public void testQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        searchSourceBuilder.from(0).size(30);//分页
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
        System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

        SearchHit[] hits = searchResponse.getHits().getHits();
        List<Goods> goods = new ArrayList<>();
        for (SearchHit hit:hits) {
            System.out.println(hit.getSourceAsString());
            //将JSON转换成对象
            Goods good = new ObjectMapper().readValue(hit.getSourceAsString(), Goods.class);
            goods.add(good);
        }

        for (Goods good:goods) {
            System.out.println(good);
        }
    }
    
    //如果查询的数据有高亮字段
    @Test
    public void testHighLighter() throws IOException {
        SearchRequest searchRequest = new SearchRequest("goods");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        searchSourceBuilder.query(QueryBuilders.termQuery("description","浣熊"));
        searchSourceBuilder.from(0).size(30);//分页
        highlightBuilder.requireFieldMatch(false).field("description").preTags("<span style='color:red;'>").postTags("</span>");
        searchSourceBuilder.highlighter(highlightBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        System.out.println("总条数："+searchResponse.getHits().getTotalHits().value);
        System.out.println("最大得分："+searchResponse.getHits().getMaxScore());

        SearchHit[] hits = searchResponse.getHits().getHits();
        List<Goods> goods = new ArrayList<>();
        for (SearchHit hit:hits) {
            System.out.println(hit.getSourceAsString());
            //将JSON转换成对象
            Goods good = new ObjectMapper().readValue(hit.getSourceAsString(), Goods.class);
            //处理高亮
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            //如果存在高亮字段则设置
            if(highlightFields.containsKey("description")) {
                good.setDescription(highlightFields.get("description").fragments()[0].toString());
            }
            goods.add(good);
        }

        for (Goods good:goods) {
            System.out.println(good);
        }
    }
}

package com.example.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.QueryBuilders;
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.ParsedStringTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@SpringBootTest
public class DemoAggs {
    @Autowired
    private RestHighLevelClient restHighLevelClient;


    //基于字段的聚合查询，桶中的值是键值对的形式
    @Test
    public void testAggs() throws IOException {
        SearchRequest searchRequest = new SearchRequest("fruit");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());//查询条件
//        searchSourceBuilder.aggregation(AggregationBuilders.terms("price_group").field("price"));//设置聚合处理
        searchSourceBuilder.aggregation(AggregationBuilders.terms("title_group").field("title"));//设置聚合处理
        searchSourceBuilder.size(0);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        Aggregations aggregations = searchResponse.getAggregations();
        //这里price返回的是double类型，可以直接使用ParsedDoubleTerms接收
//        ParsedDoubleTerms doubleTerms =  aggregations.get("price_group");
//        List<? extends Terms.Bucket> buckets = doubleTerms.getBuckets();

        //这里的title是String类型的，那么就可以使用ParsedStringTerms接收
        ParsedStringTerms stringTerms = aggregations.get("title_group");
        List<? extends Terms.Bucket> buckets = stringTerms.getBuckets();

//        for(Terms.Bucket bucket:buckets) {
        //获取桶中的键值对
//            System.out.println("价格："+bucket.getKey()+"--数量:"+bucket.getDocCount());
//        }

        for(Terms.Bucket bucket:buckets) {
            System.out.println("名称："+bucket.getKey()+"--数量:"+bucket.getDocCount());
        }
    }
}

//max(ParsedMax)  min(ParsedMin) sum(ParsedSum) avg(ParsedAvg)
//桶中只有一个返回值
@Test
public void testAggsFunction() throws IOException {
    SearchRequest searchRequest = new SearchRequest("fruit");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    sourceBuilder.aggregation(AggregationBuilders.max("max_price").field("price"));//max
    sourceBuilder.aggregation(AggregationBuilders.min("min_price").field("price"));//min
    sourceBuilder.aggregation(AggregationBuilders.sum("sum_price").field("price"));//sum
    sourceBuilder.aggregation(AggregationBuilders.avg("avg_price").field("price"));//avg
    sourceBuilder.size(0);
    searchRequest.source(sourceBuilder);
    SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    Aggregations aggregations = searchResponse.getAggregations();
    ParsedMax parsedMax = aggregations.get("max_price");//取得最大值
    ParsedMin parsedMin = aggregations.get("min_price");//取得最小值
    ParsedSum parsedSum = aggregations.get("sum_price");//求和
    ParsedAvg parsedAvg = aggregations.get("avg_price");//平均值
    //桶中只有一个返回值，直接取值即可
    System.out.println("最大值"+parsedMax.getValue());
    System.out.println("最小值"+parsedMin.getValue());
    System.out.println("求和"+parsedSum.getValue());
    System.out.println("平均值"+parsedAvg.getValue());
}