• 基于SpringBoot的ElasticSearch操作（超详细教程）

    一、ElasticSearch 简介

    1、简介


    ElasticSearch 是一个基于 Lucene 的搜索服务器。它提供了一个分布式多员工能力的全文搜索引擎，基于 RESTful web 接口。Elasticsearch 是用 Java 语言开发的，并作为 Apache 许可条款下的开放源码发布，是一种流行的企业级搜索引擎。

    ElasticSearch 用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。

    2、特性

    分布式的文档存储引擎
    分布式的搜索引擎和分析引擎
    分布式，支持PB级数据

    3、使用场景


    搜索领域：如百度、谷歌，全文检索等。
    门户网站：访问统计、文章点赞、留言评论等。
    广告推广：记录员工行为数据、消费趋势、员工群体进行定制推广等。
    信息采集：记录应用的埋点数据、访问日志数据等，方便大数据进行分析。

    二、ElasticSearch 基础概念

    1、ElaticSearch 和 DB 的关系

    在 Elasticsearch 中，文档归属于一种类型 type，而这些类型存在于索引 index 中，我们可以列一些简单的不同点，来类比传统关系型数据库：

    Relational DB -> Databases -> Tables -> Rows -> Columns
    Elasticsearch -> Indices -> Types -> Documents -> Fields
    Elasticsearch 集群可以包含多个索引 indices，每一个索引可以包含多个类型 types，每一个类型包含多个文档 documents，然后每个文档包含多个字段 Fields。而在 DB 中可以有多个数据库 Databases，每个库中可以有多张表 Tables，没个表中又包含多行Rows，每行包含多列Columns。

    2、索引

    索引基本概念（indices）：

    索引是含义相同属性的文档集合，是 ElasticSearch 的一个逻辑存储，可以理解为关系型数据库中的数据库，ElasticSearch 可以把索引数据存放到一台服务器上，也可以 sharding 后存到多台服务器上，每个索引有一个或多个分片，每个分片可以有多个副本。

    索引类型（index_type）：

    索引可以定义一个或多个类型，文档必须属于一个类型。在 ElasticSearch 中，一个索引对象可以存储多个不同用途的对象，通过索引类型可以区分单个索引中的不同对象，可以理解为关系型数据库中的表。每个索引类型可以有不同的结构，但是不同的索引类型不能为相同的属性设置不同的类型。

    3、文档

    文档（document）：

    文档是可以被索引的基本数据单位。存储在 ElasticSearch 中的主要实体叫文档 document，可以理解为关系型数据库中表的一行记录。每个文档由多个字段构成，ElasticSearch 是一个非结构化的数据库，每个文档可以有不同的字段，并且有一个唯一的标识符。

    4、映射

    映射（mapping）:

    ElasticSearch 的 Mapping 非常类似于静态语言中的数据类型：声明一个变量为 int 类型的变量，以后这个变量都只能存储 int 类型的数据。同样的，一个 number 类型的 mapping 字段只能存储 number 类型的数据。

    同语言的数据类型相比，Mapping 还有一些其他的含义，Mapping 不仅告诉 ElasticSearch 一个 Field 中是什么类型的值， 它还告诉 ElasticSearch 如何索引数据以及数据是否能被搜索到。

    ElaticSearch 默认是动态创建索引和索引类型的 Mapping 的。这就相当于无需定义 Solr 中的 Schema，无需指定各个字段的索引规则就可以索引文件，很方便。但有时方便就代表着不灵活。比如，ElasticSearch 默认一个字段是要做分词的，但我们有时要搜索匹配整个字段却不行。如有统计工作要记录每个城市出现的次数。对于 name 字段，若记录 new york 文本，ElasticSearch 可能会把它拆分成 new 和 york 这两个词，分别计算这个两个单词的次数，而不是我们期望的 new york。

    三、SpringBoot 项目引入 ElasticSearch 依赖

    下面介绍下 SpringBoot 如何通过 elasticsearch-rest-high-level-client 工具操作 ElasticSearch，这里需要说一下，为什么没有使用 Spring 家族封装的 spring-data-elasticsearch。

    主要原因是灵活性和更新速度，Spring 将 ElasticSearch 过度封装，让开发者很难跟 ES 的 DSL 查询语句进行关联。再者就是更新速度，ES 的更新速度是非常快，但是 spring-data-elasticsearch 更新速度比较缓慢。

    由于上面两点，所以选择了官方推出的 Java 客户端 elasticsearch-rest-high-level-client，它的代码写法跟 DSL 语句很相似，懂 ES 查询的使用其上手很快。

    【注意SpringBoot的版本-es的版本对应】

    1、Maven 引入相关依赖

    • lombok：lombok 工具依赖。
    • fastjson：用于将 JSON 转换对象的依赖。
    • spring-boot-starter-web： SpringBoot 的 Web 依赖。
    • elasticsearch：ElasticSearch：依赖，需要和 ES 版本保持一致。
    • elasticsearch-rest-high-level-client：用于操作 ES 的 Java 客户端。
    1. "1.0" encoding="UTF-8"?>
    2. "http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.     4.0.0
    5.     com.example
    6.     elasticsearch
    7.     0.0.1-SNAPSHOT
    8.     elasticsearch
    9.     Demo project for Spring Boot
    10.     
    11.         1.8
    12.         UTF-8
    13.         UTF-8
    14.         2.3.12.RELEASE
    15.     
    16.     
    17.         
    18.             org.springframework.boot
    19.             spring-boot-starter-web
    20.         
    21.  
    22.         
    23.             org.springframework.boot
    24.             spring-boot-starter-test
    25.             test
    26.             
    27.                 
    28.                     org.junit.vintage
    29.                     junit-vintage-engine
    30.                 
    31.             
    32.         
    33.  
    34.         
    35.             org.projectlombok
    36.             lombok
    37.             true
    38.         
    39.         
    40.         
    41.             com.alibaba
    42.             fastjson
    43.             1.2.61
    44.         
    45.         
    46.         
    47.             org.elasticsearch.client
    48.             elasticsearch-rest-high-level-client
    49.             7.6.1
    50.         
    51.         
    52.             org.elasticsearch
    53.             elasticsearch
    54.             7.6.1
    55.         
    56.     
    57.     
    58.         
    59.             
    60.                 org.springframework.boot
    61.                 spring-boot-dependencies
    62.                 ${spring-boot.version}
    63.                 pom
    64.                 import
    65.             
    66.         
    67.     
    68.  
    69.     
    70.         
    71.             
    72.                 org.apache.maven.plugins
    73.                 maven-compiler-plugin
    74.                 3.8.1
    75.                 
    76.                     1.8
    77.                     1.8
    78.                     UTF-8
    79.                 
    80.             
    81.             
    82.                 org.springframework.boot
    83.                 spring-boot-maven-plugin
    84.                 ${spring-boot.version}
    85.                 
    86.                     com.example.elasticsearch.ElasticsearchApplication
    87.                     true
    88.                 
    89.                 
    90.                     
    91.                         repackage
    92.                         
    93.                             repackage
    94.                         
    95.                     
    96.                 
    97.             
    98.         
    99.     
    100.

    2、ElasticSearch 连接配置

    (1)、application.yml 配置文件

    为了方便更改连接 ES 的连接配置，所以我们将配置信息放置于 application.yml 中：

    1. server:
    2.   port: 8080
    3.   servlet:
    4.     context-path: /search
    5.  
    6. elasticsearch:
    7.   schema: http
    8.   address: 127.0.0.1:9200
    9.   connectTimeout: 10000
    10.   socketTimeout: 10000
    11.   connectionRequestTimeout: 10000
    12.   maxConnectNum: 100
    13.   maxConnectPerRoute: 100
    14.  
    15. myindex: testindex

    (2)、java 连接配置类

    这里需要写一个 Java 配置类读取 application 中的配置信息：

    1. package com.example.elasticsearch.demos.config;
    2.  
    3. import org.apache.http.HttpHost;
    4. import org.elasticsearch.client.RestClient;
    5. import org.elasticsearch.client.RestClientBuilder;
    6. import org.elasticsearch.client.RestHighLevelClient;
    7. import org.springframework.beans.factory.annotation.Value;
    8. import org.springframework.context.annotation.Bean;
    9. import org.springframework.context.annotation.Configuration;
    10.  
    11. import java.util.ArrayList;
    12. import java.util.List;
    13.  
    14. /**
    15.  * ElasticSearch 配置
    16.  */
    17. @Configuration
    18. public class ElasticSearchConfig {
    19.  
    20.     /** 协议 */
    21.     @Value("${elasticsearch.schema:http}")
    22.     private String schema;
    23.  
    24.     /** 集群地址，如果有多个用“,”隔开 */
    25.     @Value("${elasticsearch.address}")
    26.     private String address;
    27.  
    28.     /** 连接超时时间 */
    29.     @Value("${elasticsearch.connectTimeout:5000}")
    30.     private int connectTimeout;
    31.  
    32.     /** Socket 连接超时时间 */
    33.     @Value("${elasticsearch.socketTimeout:10000}")
    34.     private int socketTimeout;
    35.  
    36.     /** 获取连接的超时时间 */
    37.     @Value("${elasticsearch.connectionRequestTimeout:5000}")
    38.     private int connectionRequestTimeout;
    39.  
    40.     /** 最大连接数 */
    41.     @Value("${elasticsearch.maxConnectNum:100}")
    42.     private int maxConnectNum;
    43.  
    44.     /** 最大路由连接数 */
    45.     @Value("${elasticsearch.maxConnectPerRoute:100}")
    46.     private int maxConnectPerRoute;
    47.  
    48.     @Bean
    49.     public RestHighLevelClient restHighLevelClient() {
    50.         // 拆分地址
    51.         List hostLists = new ArrayList<>();
    52.         String[] hostList = address.split(",");
    53.         for (String addr : hostList) {
    54.             String host = addr.split(":")[0];
    55.             String port = addr.split(":")[1];
    56.             hostLists.add(new HttpHost(host, Integer.parseInt(port), schema));
    57.         }
    58.         // 转换成 HttpHost 数组
    59.         HttpHost[] httpHost = hostLists.toArray(new HttpHost[]{});
    60.         // 构建连接对象
    61.         RestClientBuilder builder = RestClient.builder(httpHost);
    62.         // 异步连接延时配置
    63.         builder.setRequestConfigCallback(requestConfigBuilder -> {
    64.             requestConfigBuilder.setConnectTimeout(connectTimeout);
    65.             requestConfigBuilder.setSocketTimeout(socketTimeout);
    66.             requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeout);
    67.             return requestConfigBuilder;
    68.         });
    69.         // 异步连接数配置
    70.         builder.setHttpClientConfigCallback(httpClientBuilder -> {
    71.             httpClientBuilder.setMaxConnTotal(maxConnectNum);
    72.             httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
    73.             return httpClientBuilder;
    74.         });
    75.         return new RestHighLevelClient(builder);
    76.     }
    77.  
    78. }

    四、索引操作示例

    这里示例会指出通过Postman的 ​ ​Restful​​​ 工具操作与对应的 Java 代码操作的两个示例。

    1、Restful 操作示例

    创建索引

    创建名为 testindex 的索引与对应 Mapping。

    1. PUT http://localhost:9200/testindex
    2.  
    3. {
    4.   "mappings": {
    5.     "doc": {
    6.       "dynamic": true,
    7.       "properties": {
    8.         "name": {
    9.           "type": "text",
    10.           "fields": {
    11.             "keyword": {
    12.               "type": "keyword"
    13.             }
    14.           }
    15.         },
    16.         "address": {
    17.           "type": "text",
    18.           "fields": {
    19.             "keyword": {
    20.               "type": "keyword"
    21.             }
    22.           }
    23.         },
    24.         "remark": {
    25.           "type": "text",
    26.           "fields": {
    27.             "keyword": {
    28.               "type": "keyword"
    29.             }
    30.           }
    31.         },
    32.         "age": {
    33.           "type": "integer"
    34.         },
    35.         "salary": {
    36.           "type": "float"
    37.         },
    38.         "birthDate": {
    39.           "type": "date",
    40.           "format": "yyyy-MM-dd"
    41.         },
    42.         "createTime": {
    43.           "type": "date"
    44.         }
    45.       }
    46.     }
    47.   }
    48. }

    删除索引

    删除 mydlq-user 索引。

    DELETE http://localhost:9200/testindex

    2、Java 代码示例

    1. package com.example.elasticsearch.demos.web.service.base;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
    5. import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
    6. import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
    7. import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
    8. import org.elasticsearch.action.support.master.AcknowledgedResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.common.settings.Settings;
    12. import org.elasticsearch.common.xcontent.XContentBuilder;
    13. import org.elasticsearch.common.xcontent.XContentFactory;
    14. import org.springframework.beans.factory.annotation.Autowired;
    15. import org.springframework.stereotype.Service;
    16.  
    17. import java.io.IOException;
    18.  
    19. /**
    20.  * 索引操作
    21.  */
    22. @Slf4j
    23. @Service
    24. public class IndexService {
    25.  
    26.     @Autowired
    27.     private RestHighLevelClient restHighLevelClient;
    28.  
    29.     /**
    30.      * 验证索引是否存在
    31.      */
    32.     public Object existsIndex(String indexName) {
    33.         Object result = "";
    34.         try {
    35.             // 获取索引请求
    36.             GetIndexRequest request = new GetIndexRequest();
    37.             // 设置要查询的索引名称
    38.             request.indices(indexName);
    39.             // 执行请求，验证索引是否存在
    40.             boolean isExist = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
    41.             log.info("是否存在：{}", isExist);
    42.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    43.             result = isExist;
    44.         } catch (IOException e) {
    45.             log.error("", e);
    46.         }
    47.         return result;
    48.     }
    49.  
    50.     /**
    51.      * 创建索引
    52.      */
    53.     public Object createIndex(String indexName) {
    54.         Object result = "";
    55.         try {
    56.             // 创建 Mapping
    57.             XContentBuilder mapping = XContentFactory.jsonBuilder()
    58.                 .startObject()
    59.                     .field("dynamic", true)
    60.                     .startObject("properties")
    61.                         .startObject("name")
    62.                             .field("type","text")
    63.                             .startObject("fields")
    64.                                 .startObject("keyword")
    65.                                     .field("type","keyword")
    66.                                 .endObject()
    67.                             .endObject()
    68.                         .endObject()
    69.                         .startObject("address")
    70.                             .field("type","text")
    71.                             .startObject("fields")
    72.                                 .startObject("keyword")
    73.                                     .field("type","keyword")
    74.                                 .endObject()
    75.                             .endObject()
    76.                         .endObject()
    77.                         .startObject("remark")
    78.                             .field("type","text")
    79.                             .startObject("fields")
    80.                                 .startObject("keyword")
    81.                                     .field("type","keyword")
    82.                                 .endObject()
    83.                             .endObject()
    84.                         .endObject()
    85.                         .startObject("age")
    86.                             .field("type","integer")
    87.                         .endObject()
    88.                         .startObject("salary")
    89.                             .field("type","float")
    90.                         .endObject()
    91.                         .startObject("birthDate")
    92.                             .field("type","date")
    93.                             .field("format", "yyyy-MM-dd")
    94.                         .endObject()
    95.                         .startObject("createTime")
    96.                             .field("type","date")
    97.                         .endObject()
    98.                     .endObject()
    99.                 .endObject();
    100.             // 创建索引配置信息，配置
    101.             Settings settings = Settings.builder()
    102.                     .put("index.number_of_shards", 1)
    103.                     .put("index.number_of_replicas", 0)
    104.                     .build();
    105.             // 新建创建索引请求对象，然后设置索引类型（ES 7.0 将不存在索引类型）和 mapping 与 index 配置
    106.             CreateIndexRequest request = new CreateIndexRequest(indexName, settings);
    107.             request.mapping("doc", mapping);
    108.             // RestHighLevelClient 执行创建索引
    109.             CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);
    110.             // 判断是否创建成功
    111.             boolean isCreated = createIndexResponse.isAcknowledged();
    112.             log.info("是否创建成功：{}", isCreated);
    113.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    114.             result = isCreated;
    115.         } catch (IOException e) {
    116.             log.error("", e);
    117.         }
    118.         return result;
    119.     }
    120.  
    121.     /**
    122.      * 删除索引
    123.      */
    124.     public Object deleteIndex(String indexName) {
    125.         Object result = "";
    126.         try {
    127.             // 新建删除索引请求对象
    128.             DeleteIndexRequest request = new DeleteIndexRequest(indexName);
    129.             // 执行删除索引
    130.             AcknowledgedResponse acknowledgedResponse = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
    131.             // 判断是否删除成功
    132.             boolean siDeleted = acknowledgedResponse.isAcknowledged();
    133.             log.info("是否删除成功：{}", siDeleted);
    134.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    135.             result = siDeleted;
    136.         } catch (IOException e) {
    137.             log.error("", e);
    138.         }
    139.         return result;
    140.     }
    141.  
    142. }

    五、文档操作示例

    1、Restful 操作示例

    增加文档信息

    在索引 mydlq-user 中增加一条文档信息。

    1. POST http://localhost:9200/testindex/doc
    2. {
    3.     "address": "北京市",
    4.     "age": 29,
    5.     "birthDate": "1990-01-10",
    6.     "createTime": 1579530727699,
    7.     "name": "张三",
    8.     "remark": "来自北京市的张先生",
    9.     "salary": 100
    10. }
    11.  
    12. //返回
    13. {
    14.     "_index": "testindex",
    15.     "_type": "doc",
    16.     "_id": "hZo5_4oBFE0BmNy_GMUN", //这个是插入生成的随机id
    17.     "_version": 1,
    18.     "result": "created",
    19.     "_shards": {
    20.         "total": 1,
    21.         "successful": 1,
    22.         "failed": 0
    23.     },
    24.     "_seq_no": 29,
    25.     "_primary_term": 3
    26. }

    获取文档信息

    获取 testindex的索引 id=hZo5_4oBFE0BmNy_GMUN 的文档信息。

    1. GET http://localhost:9200/testindex/doc/hZo5_4oBFE0BmNy_GMUN
    2. //返回
    3. {
    4.     "_index": "testindex",
    5.     "_type": "doc",
    6.     "_id": "hZo5_4oBFE0BmNy_GMUN",
    7.     "_version": 1,
    8.     "_seq_no": 29,
    9.     "_primary_term": 3,
    10.     "found": true,
    11.     "_source": {
    12.         "address": "北京市",
    13.         "age": 29,
    14.         "birthDate": "1990-01-10",
    15.         "createTime": 1579530727699,
    16.         "name": "张三",
    17.         "remark": "来自北京市的张先生",
    18.         "salary": 100
    19.     }
    20. }

    更新文档信息

    更新之前创建的 id=hZo5_4oBFE0BmNy_GMUN 的文档信息。

    1. PUT http://localhost:9200/testindex/doc/hZo5_4oBFE0BmNy_GMUN
    2. //请求
    3. {
    4.     "address": "北京市",
    5.     "age": 29,
    6.     "birthDate": "1990-01-10",
    7.     "createTime": 1579530727699,
    8.     "name": "张三(改名字)",
    9.     "remark": "来自北京市的张先生",
    10.     "salary": 100
    11. }

    删除文档信息

    删除之前创建的 id=hZo5_4oBFE0BmNy_GMUN 的文档信息。

    DELETE http://localhost:9200/testindex/doc/hZo5_4oBFE0BmNy_GMUN

    2、Java 代码示例

    1. package com.example.elasticsearch.demos.web.service.base;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.dto.DocDto;
    5. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.elasticsearch.action.delete.DeleteRequest;
    8. import org.elasticsearch.action.delete.DeleteResponse;
    9. import org.elasticsearch.action.get.GetRequest;
    10. import org.elasticsearch.action.get.GetResponse;
    11. import org.elasticsearch.action.index.IndexRequest;
    12. import org.elasticsearch.action.index.IndexResponse;
    13. import org.elasticsearch.action.update.UpdateRequest;
    14. import org.elasticsearch.action.update.UpdateResponse;
    15. import org.elasticsearch.client.RequestOptions;
    16. import org.elasticsearch.client.RestHighLevelClient;
    17. import org.elasticsearch.common.xcontent.XContentType;
    18. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
    19. import org.springframework.beans.factory.annotation.Autowired;
    20. import org.springframework.stereotype.Service;
    21.  
    22. import java.io.IOException;
    23. import java.util.Date;
    24.  
    25. /**
    26.  * 文档操作
    27.  */
    28. @Slf4j
    29. @Service
    30. public class DocumentService {
    31.  
    32.     @Autowired
    33.     private RestHighLevelClient restHighLevelClient;
    34.  
    35.     public Object existsDocument(DocDto docDto) {
    36.         Object result = "";
    37.         try {
    38.             // 获取请求对象
    39.             GetRequest getRequest = new GetRequest(docDto.getIndexName(), docDto.getDocId());
    40.             // 是否获取源码内容
    41.             getRequest.fetchSourceContext(new FetchSourceContext(false));
    42.             // 执行请求，验证文档是否存在
    43.             boolean isExist = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
    44.             log.info("文档是否存在：{}", isExist);
    45.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    46.             result = isExist;
    47.         } catch (IOException e) {
    48.             log.error("", e);
    49.         }
    50.         return result;
    51.     }
    52.  
    53.     public Object getDocument(DocDto docDto) {
    54.         Object result = "";
    55.         try {
    56.             // 获取请求对象
    57.             GetRequest getRequest = new GetRequest(docDto.getIndexName(), docDto.getDocId());
    58.             // 获取文档信息
    59.             GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
    60.             // 将 JSON 转换成对象
    61.             if (getResponse.isExists()) {
    62.                 UserInfo userInfo = JSON.parseObject(getResponse.getSourceAsBytes(), UserInfo.class);
    63.                 log.info("用户信息：{}", userInfo);
    64.             }
    65.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    66.             result = getResponse;
    67.         } catch (IOException e) {
    68.             log.error("", e);
    69.         }
    70.         return result;
    71.     }
    72.  
    73.     public Object addDocument(DocDto docDto) {
    74.         Object result = "";
    75.         try {
    76.             // 创建索引请求对象
    77.             IndexRequest indexRequest = new IndexRequest(docDto.getIndexName());
    78.             // 创建用户信息
    79.             UserInfo userInfo = new UserInfo();
    80.             userInfo.setName(docDto.getName());
    81.             userInfo.setAge(docDto.getAge());
    82.             userInfo.setSalary(docDto.getSalary());
    83.             userInfo.setAddress(docDto.getAddress());
    84.             userInfo.setRemark(docDto.getRemark());
    85.             userInfo.setCreateTime(new Date());
    86.             userInfo.setBirthDate(docDto.getBirthDate());
    87.             // 将对象转换为 byte 数组
    88.             byte[] json = JSON.toJSONBytes(userInfo);
    89.             // 设置文档内容
    90.             indexRequest.source(json, XContentType.JSON);
    91.             // 执行增加文档
    92.             IndexResponse response = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
    93.             log.info("创建状态：{}", response.status());
    94.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    95.             result = response;
    96.         } catch (Exception e) {
    97.             log.error("", e);
    98.         }
    99.         return result;
    100.     }
    101.  
    102.     public Object updateDocument(DocDto docDto) {
    103.         Object result = "";
    104.         try {
    105.             // 创建索引请求对象
    106.             UpdateRequest updateRequest = new UpdateRequest(docDto.getIndexName(), docDto.getDocId());
    107. //            UpdateRequest updateRequest = new UpdateRequest(docDto.getIndexName(), "doc", docDto.getDocId());
    108.             // 设置用户更新信息
    109.             UserInfo userInfo = new UserInfo();
    110.             userInfo.setSalary(docDto.getSalary());
    111.             userInfo.setAddress(docDto.getAddress());
    112.             // 将对象转换为 byte 数组
    113.             byte[] json = JSON.toJSONBytes(userInfo);
    114.             // 设置更新文档内容
    115.             updateRequest.doc(json, XContentType.JSON);
    116.             // 执行更新文档
    117.             UpdateResponse response = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
    118.             log.info("创建状态：{}", response.status());
    119.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    120.             result = response;
    121.         } catch (Exception e) {
    122.             log.error("", e);
    123.         }
    124.         return result;
    125.     }
    126.  
    127.     public Object deleteDocument(DocDto docDto) {
    128.         Object result = "";
    129.         try {
    130.             // 创建删除请求对象
    131.             DeleteRequest deleteRequest = new DeleteRequest(docDto.getIndexName(), docDto.getDocId());
    132.             // 执行删除文档
    133.             DeleteResponse response = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
    134.             log.info("删除状态：{}", response.status());
    135.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将结果返回
    136.             result = response;
    137.         } catch (IOException e) {
    138.             log.error("", e);
    139.         }
    140.         return result;
    141.     }
    142.  
    143. }

    六、插入初始化数据

    执行查询示例前，先往索引中插入一批数据：

    1、单条插入

    1. POST http://localhost:9200/testindex/doc
    2. //请求
    3. {
    4.     "name": "零零",
    5.     "address": "北京市丰台区",
    6.     "remark": "低层员工",
    7.     "age": 29,
    8.     "salary": 3000,
    9.     "birthDate": "1990-11-11",
    10.     "createTime": "2019-11-11T08:18:00.000Z"
    11. }

    2、批量插入

    1. POST http://localhost:9200/_bulk
    2. //header
    3. Content-Type: application/json
    4. //body
    5. {"index":{"_index":"testindex","_type":"doc"}}
    6. {"name":"刘一","address":"北京市丰台区","remark":"低层员工","age":30,"salary":3000,"birthDate":"1989-11-11","createTime":"2019-03-15T08:18:00.000Z"} 
    7. {"index":{"_index":"testindex","_type":"doc"}}
    8. {"name":"陈二","address":"北京市昌平区","remark":"中层员工","age":27,"salary":7900,"birthDate":"1992-01-25","createTime":"2019-11-08T11:15:00.000Z"} 
    9. {"index":{"_index":"testindex","_type":"doc"}} 
    10. {"name":"张三","address":"北京市房山区","remark":"中层员工","age":28,"salary":8800,"birthDate":"1991-10-05","createTime":"2019-07-22T13:22:00.000Z"} 
    11. {"index":{"_index":"testindex","_type":"doc"}}
    12. {"name":"李四","address":"北京市大兴区","remark":"高层员工","age":26,"salary":9000,"birthDate":"1993-08-18","createTime":"2019-10-17T15:00:00.000Z"} 
    13. {"index":{"_index":"testindex","_type":"doc"}}
    14. {"name":"王五","address":"北京市密云区","remark":"低层员工","age":31,"salary":4800,"birthDate":"1988-07-20","createTime":"2019-05-29T09:00:00.000Z"} 
    15. {"index":{"_index":"testindex","_type":"doc"}}
    16. {"name":"赵六","address":"北京市通州区","remark":"中层员工","age":32,"salary":6500,"birthDate":"1987-06-02","createTime":"2019-12-10T18:00:00.000Z"} 
    17. {"index":{"_index":"testindex","_type":"doc"}}
    18. {"name":"孙七","address":"北京市朝阳区","remark":"中层员工","age":33,"salary":7000,"birthDate":"1986-04-15","createTime":"2019-06-06T13:00:00.000Z"} 
    19. {"index":{"_index":"testindex","_type":"doc"}}
    20. {"name":"周八","address":"北京市西城区","remark":"低层员工","age":32,"salary":5000,"birthDate":"1987-09-26","createTime":"2019-01-26T14:00:00.000Z"} 
    21. {"index":{"_index":"testindex","_type":"doc"}}
    22. {"name":"吴九","address":"北京市海淀区","remark":"高层员工","age":30,"salary":11000,"birthDate":"1989-11-25","createTime":"2019-09-07T13:34:00.000Z"} 
    23. {"index":{"_index":"testindex","_type":"doc"}}
    24. {"name":"郑十","address":"北京市东城区","remark":"低层员工","age":29,"salary":5000,"birthDate":"1990-12-25","createTime":"2019-03-06T12:08:00.000Z"} 
    25. {"index":{"_index":"testindex","_type":"doc"}}
    26. {"name":"萧十一","address":"北京市平谷区","remark":"低层员工","age":29,"salary":3300,"birthDate":"1990-11-11","createTime":"2019-03-10T08:17:00.000Z"} 
    27. {"index":{"_index":"testindex","_type":"doc"}} 
    28. {"name":"曹十二","address":"北京市怀柔区","remark":"中层员工","age":27,"salary":6800,"birthDate":"1992-01-25","createTime":"2019-12-03T11:09:00.000Z"} 
    29. {"index":{"_index":"testindex","_type":"doc"}}
    30. {"name":"吴十三","address":"北京市延庆区","remark":"中层员工","age":25,"salary":7000,"birthDate":"1994-10-05","createTime":"2019-07-27T14:22:00.000Z"} 
    31. {"index":{"_index":"testindex","_type":"doc"}}
    32. {"name":"冯十四","address":"北京市密云区","remark":"低层员工","age":25,"salary":3000,"birthDate":"1994-08-18","createTime":"2019-04-22T15:00:00.000Z"} 
    33. {"index":{"_index":"testindex","_type":"doc"}}
    34. {"name":"蒋十五","address":"北京市通州区","remark":"低层员工","age":31,"salary":2800,"birthDate":"1988-07-20","createTime":"2019-06-13T10:00:00.000Z"} 
    35. {"index":{"_index":"testindex","_type":"doc"}}
    36. {"name":"苗十六","address":"北京市门头沟区","remark":"高层员工","age":32,"salary":11500,"birthDate":"1987-06-02","createTime":"2019-11-11T18:00:00.000Z"} 
    37. {"index":{"_index":"testindex","_type":"doc"}}
    38. {"name":"鲁十七","address":"北京市石景山区","remark":"高员工","age":33,"salary":9500,"birthDate":"1986-04-15","createTime":"2019-06-06T14:00:00.000Z"} 
    39. {"index":{"_index":"testindex","_type":"doc"}}
    40. {"name":"沈十八","address":"北京市朝阳区","remark":"中层员工","age":31,"salary":8300,"birthDate":"1988-09-26","createTime":"2019-09-25T14:00:00.000Z"} 
    41. {"index":{"_index":"testindex","_type":"doc"}}
    42. {"name":"吕十九","address":"北京市西城区","remark":"低层员工","age":31,"salary":4500,"birthDate":"1988-11-25","createTime":"2019-09-22T13:34:00.000Z"} 
    43. {"index":{"_index":"testindex","_type":"doc"}}
    44. {"name":"丁二十","address":"北京市东城区","remark":"低层员工","age":33,"salary":2100,"birthDate":"1986-12-25","createTime":"2019-03-07T12:08:00.000Z"}

    3、查询数据

    插入完成后再查询数据，查看之前插入的数据是否存在：

    1. GET http://localhost:9200/testindex/_search
    2. //返回
    3. {
    4.     "took": 6,
    5.     "timed_out": false,
    6.     "_shards": {
    7.         "total": 1,
    8.         "successful": 1,
    9.         "skipped": 0,
    10.         "failed": 0
    11.     },
    12.     "hits": {
    13.         "total": {
    14.             "value": 2,
    15.             "relation": "eq"
    16.         },
    17.         "max_score": 2.302585,
    18.         "hits": [
    19.             {
    20.                 "_index": "testindex",
    21.                 "_type": "doc",
    22.                 "_id": "3iDh-IoByPOFA_QWinlo",
    23.                 "_score": 2.302585,
    24.                 "_source": {
    25.                     "name": "赵六",
    26.                     "address": "北京市通州区",
    27.                     "remark": "中层员工",
    28.                     "age": 32,
    29.                     "salary": 6500,
    30.                     "birthDate": "1987-06-02",
    31.                     "createTime": "2019-12-10T18:00:00.000Z"
    32.                 }
    33.             },
    34.             {
    35.                 "_index": "testindex",
    36.                 "_type": "doc",
    37.                 "_id": "5yDh-IoByPOFA_QWinlo",
    38.                 "_score": 2.302585,
    39.                 "_source": {
    40.                     "name": "蒋十五",
    41.                     "address": "北京市通州区",
    42.                     "remark": "低层员工",
    43.                     "age": 31,
    44.                     "salary": 2800,
    45.                     "birthDate": "1988-07-20",
    46.                     "createTime": "2019-06-13T10:00:00.000Z"
    47.                 }
    48.             }
    49.             ...
    50.         ]
    51.     }
    52. }

    七、查询操作示例

    1、精确查询(term)

    (1)、Restful 操作示例

    精确查询

    精确查询，查询地址为 北京市通州区 的人员信息：

    查询条件不会进行分词，但是查询内容可能会分词，导致查询不到。之前在创建索引时设置 Mapping 中 address 字段存在 keyword 字段是专门用于不分词查询的子字段。

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "term": {
    6.       "address.keyword": {
    7.         "value": "北京市通州区"
    8.       }
    9.     }
    10.   }
    11. }
    12. //返回
    13. {
    14.     "took": 6,
    15.     "timed_out": false,
    16.     "_shards": {
    17.         "total": 1,
    18.         "successful": 1,
    19.         "skipped": 0,
    20.         "failed": 0
    21.     },
    22.     "hits": {
    23.         "total": {
    24.             "value": 2,
    25.             "relation": "eq"
    26.         },
    27.         "max_score": 2.302585,
    28.         "hits": [
    29.             {
    30.                 "_index": "testindex",
    31.                 "_type": "doc",
    32.                 "_id": "3iDh-IoByPOFA_QWinlo",
    33.                 "_score": 2.302585,
    34.                 "_source": {
    35.                     "name": "赵六",
    36.                     "address": "北京市通州区",
    37.                     "remark": "中层员工",
    38.                     "age": 32,
    39.                     "salary": 6500,
    40.                     "birthDate": "1987-06-02",
    41.                     "createTime": "2019-12-10T18:00:00.000Z"
    42.                 }
    43.             },
    44.             {
    45.                 "_index": "testindex",
    46.                 "_type": "doc",
    47.                 "_id": "5yDh-IoByPOFA_QWinlo",
    48.                 "_score": 2.302585,
    49.                 "_source": {
    50.                     "name": "蒋十五",
    51.                     "address": "北京市通州区",
    52.                     "remark": "低层员工",
    53.                     "age": 31,
    54.                     "salary": 2800,
    55.                     "birthDate": "1988-07-20",
    56.                     "createTime": "2019-06-13T10:00:00.000Z"
    57.                 }
    58.             }
    59.             ...
    60.         ]
    61.     }
    62. }
    精确查询-多内容查询

    精确查询，查询地址为 北京市丰台区、北京市昌平区 或 北京市大兴区 的人员信息：

     

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "terms": {
    6.       "address.keyword": [
    7.         "北京市丰台区",
    8.         "北京市昌平区",
    9.         "北京市大兴区"
    10.       ]
    11.     }
    12.   }
    13. }

    (2)、Java 代码示例 

    1. package com.example.elasticsearch.demos.web.service.query;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.dto.TermsQueryDto;
    5. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.elasticsearch.action.search.SearchRequest;
    8. import org.elasticsearch.action.search.SearchResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.index.query.QueryBuilders;
    12. import org.elasticsearch.rest.RestStatus;
    13. import org.elasticsearch.search.SearchHit;
    14. import org.elasticsearch.search.SearchHits;
    15. import org.elasticsearch.search.builder.SearchSourceBuilder;
    16. import org.springframework.beans.factory.annotation.Autowired;
    17. import org.springframework.stereotype.Service;
    18.  
    19. import java.io.IOException;
    20. import java.util.Arrays;
    21.  
    22. /**
    23.  * 精确查询
    24.  */
    25. @Slf4j
    26. @Service
    27. public class TermQueryService {
    28.  
    29.     @Autowired
    30.     private RestHighLevelClient restHighLevelClient;
    31.  
    32.     /**
    33.      * 精确查询（查询条件不会进行分词，但是查询内容可能会分词，导致查询不到）
    34.      * @param queryDto
    35.      */
    36.     public Object termQuery(TermsQueryDto queryDto) {
    37.         Object result = "";
    38.         try {
    39.             // 构建查询条件（注意：termQuery 支持多种格式查询，如 boolean、int、double、string 等，这里使用的是 string 的查询）
    40.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    41.             searchSourceBuilder.query(QueryBuilders.termQuery(queryDto.getKey() +  ".keyword", queryDto.getValue()));
    42.             // 创建查询请求对象，将查询对象配置到其中
    43.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    44.             searchRequest.source(searchSourceBuilder);
    45.             // 执行查询，然后处理响应结果
    46.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    47.             // 根据状态和数据条数验证是否返回了数据
    48.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    49.                 SearchHits hits = searchResponse.getHits();
    50.                 for (SearchHit hit : hits) {
    51.                     // 将 JSON 转换成对象
    52.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    53.                     // 输出查询信息
    54.                     log.info(userInfo.toString());
    55.                 }
    56.             }
    57.             result = searchResponse.getHits();
    58.         } catch (IOException e) {
    59.             log.error("", e);
    60.         }
    61.         return result;
    62.     }
    63.  
    64.     /**
    65.      * 多个内容在一个字段中进行查询
    66.      * @param queryDto
    67.      */
    68.     public Object termsQuery(TermsQueryDto queryDto) {
    69.         Object result = "";
    70.         try {
    71.             // 构建查询条件（注意：termsQuery 支持多种格式查询，如 boolean、int、double、string 等，这里使用的是 string 的查询）
    72.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    73.             searchSourceBuilder.query(QueryBuilders.termsQuery(queryDto.getKey() +  ".keyword", queryDto.getValues()));
    74.             // 创建查询请求对象，将查询对象配置到其中
    75.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    76.             searchRequest.source(searchSourceBuilder);
    77.             // 执行查询，然后处理响应结果
    78.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    79.             // 根据状态和数据条数验证是否返回了数据
    80.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    81.                 SearchHits hits = searchResponse.getHits();
    82.                 for (SearchHit hit : hits) {
    83.                     // 将 JSON 转换成对象
    84.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    85.                     // 输出查询信息
    86.                     log.info(userInfo.toString());
    87.                 }
    88.             }
    89.             result = searchResponse.getHits();
    90.         } catch (IOException e) {
    91.             log.error("", e);
    92.         }
    93.         return result;
    94.     }
    95.  
    96. }

    2、匹配查询(match)

    (1)、Restful 操作示例

    匹配查询全部数据与分页

    匹配查询符合条件的所有数据，并且设置以 salary 字段升序排序，并设置分页：

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "match_all": {}
    6.   },
    7.   "from": 0,
    8.   "size": 10,
    9.   "sort": [
    10.     {
    11.       "salary": {
    12.         "order": "asc"
    13.       }
    14.     }
    15.   ]
    16. }
    匹配查询数据

    匹配查询地址为 通州区 的数据：

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "match": {
    6.       "address": "通州区"
    7.     }
    8.   }
    9. }
     词语匹配查询

    词语匹配进行查询，匹配 address 中为 北京市通州区 的员工信息：

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "match_phrase": {
    6.       "address": "北京市通州区"
    7.     }
    8.   }
    9. }
    内容多字段查询

    查询在字段 address、remark 中存在 北京 内容的员工信息：

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "multi_match": {
    6.       "query": "北京",
    7.       "fields": ["address","remark"]
    8.     }
    9.   }
    10. }

     (2)、Java 代码示例

    1. package com.example.elasticsearch.demos.web.service.query;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.dto.MatchQueryDto;
    5. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.elasticsearch.action.search.SearchRequest;
    8. import org.elasticsearch.action.search.SearchResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.index.query.MatchAllQueryBuilder;
    12. import org.elasticsearch.index.query.QueryBuilders;
    13. import org.elasticsearch.rest.RestStatus;
    14. import org.elasticsearch.search.SearchHit;
    15. import org.elasticsearch.search.SearchHits;
    16. import org.elasticsearch.search.builder.SearchSourceBuilder;
    17. import org.elasticsearch.search.sort.SortOrder;
    18. import org.springframework.beans.factory.annotation.Autowired;
    19. import org.springframework.stereotype.Service;
    20.  
    21. import java.io.IOException;
    22.  
    23. /**
    24.  * 匹配查询
    25.  */
    26. @Slf4j
    27. @Service
    28. public class MatchQueryService {
    29.  
    30.     @Autowired
    31.     private RestHighLevelClient restHighLevelClient;
    32.  
    33.     /**
    34.      * 匹配查询符合条件的所有数据，并设置分页
    35.      * @param queryDto
    36.      */
    37.     public Object matchAllQuery(MatchQueryDto queryDto) {
    38.         Object result = "";
    39.         try {
    40.             // 构建查询条件
    41.             MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
    42.             // 创建查询源构造器
    43.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    44.             searchSourceBuilder.query(matchAllQueryBuilder);
    45.             // 设置分页
    46.             searchSourceBuilder.from((queryDto.getRows() - 1) * queryDto.getSize());
    47.             searchSourceBuilder.size(queryDto.getSize());
    48.             // 设置排序
    49.             searchSourceBuilder.sort("salary", SortOrder.ASC);
    50.             // 创建查询请求对象，将查询对象配置到其中
    51.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    52.             searchRequest.source(searchSourceBuilder);
    53.             // 执行查询，然后处理响应结果
    54.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    55.             // 根据状态和数据条数验证是否返回了数据
    56.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    57.                 SearchHits hits = searchResponse.getHits();
    58.                 for (SearchHit hit : hits) {
    59.                     // 将 JSON 转换成对象
    60.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    61.                     // 输出查询信息
    62.                     log.info(userInfo.toString());
    63.                 }
    64.             }
    65.             result = searchResponse.getHits();
    66.         } catch (IOException e) {
    67.             log.error("", e);
    68.         }
    69.         return result;
    70.     }
    71.  
    72.     /**
    73.      * 匹配查询数据-or的方式
    74.      * @param queryDto
    75.      */
    76.     public Object matchQuery(MatchQueryDto queryDto) {
    77.         Object result = "";
    78.         try {
    79.             // 构建查询条件
    80.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    81.             searchSourceBuilder.query(QueryBuilders.matchQuery(queryDto.getKey(), queryDto.getValue()));
    82. //            searchSourceBuilder.query(QueryBuilders.matchQuery("address", "通州区"));
    83.             // 创建查询请求对象，将查询对象配置到其中
    84.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    85.             searchRequest.source(searchSourceBuilder);
    86.             // 执行查询，然后处理响应结果
    87.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    88.             // 根据状态和数据条数验证是否返回了数据
    89.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    90.                 SearchHits hits = searchResponse.getHits();
    91.                 for (SearchHit hit : hits) {
    92.                     // 将 JSON 转换成对象
    93.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    94.                     // 输出查询信息
    95.                     log.info(userInfo.toString());
    96.                 }
    97.             }
    98.             result = searchResponse.getHits();
    99.         } catch (IOException e) {
    100.             log.error("", e);
    101.         }
    102.         return result;
    103.     }
    104.  
    105.     /**
    106.      * 词语匹配查询
    107.      * @param queryDto
    108.      */
    109.     public Object matchPhraseQuery(MatchQueryDto queryDto) {
    110.         Object result = "";
    111.         try {
    112.             // 构建查询条件
    113.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    114.             searchSourceBuilder.query(QueryBuilders.matchPhraseQuery(queryDto.getKey(), queryDto.getValue()));
    115. //            searchSourceBuilder.query(QueryBuilders.matchPhraseQuery("address", "北京市通州区"));
    116.             // 创建查询请求对象，将查询对象配置到其中
    117.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    118.             searchRequest.source(searchSourceBuilder);
    119.             // 执行查询，然后处理响应结果
    120.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    121.             // 根据状态和数据条数验证是否返回了数据
    122.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    123.                 SearchHits hits = searchResponse.getHits();
    124.                 for (SearchHit hit : hits) {
    125.                     // 将 JSON 转换成对象
    126.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    127.                     // 输出查询信息
    128.                     log.info(userInfo.toString());
    129.                 }
    130.             }
    131.             result = searchResponse.getHits();
    132.         } catch (IOException e) {
    133.             log.error("", e);
    134.         }
    135.         return result;
    136.     }
    137.  
    138.     /**
    139.      * 内容在多字段中进行查询
    140.      * @param queryDto
    141.      */
    142.     public Object matchMultiQuery(MatchQueryDto queryDto) {
    143.         Object result = "";
    144.         try {
    145.             // 构建查询条件
    146.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    147.             searchSourceBuilder.query(QueryBuilders.multiMatchQuery(queryDto.getKey(), queryDto.getValues()));
    148. //            searchSourceBuilder.query(QueryBuilders.multiMatchQuery("北京市", "address", "remark"));
    149.             // 创建查询请求对象，将查询对象配置到其中
    150.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    151.             searchRequest.source(searchSourceBuilder);
    152.             // 执行查询，然后处理响应结果
    153.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    154.             // 根据状态和数据条数验证是否返回了数据
    155.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    156.                 SearchHits hits = searchResponse.getHits();
    157.                 for (SearchHit hit : hits) {
    158.                     // 将 JSON 转换成对象
    159.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    160.                     // 输出查询信息
    161.                     log.info(userInfo.toString());
    162.                 }
    163.             }
    164.             result = searchResponse.getHits();
    165.         } catch (IOException e) {
    166.             log.error("", e);
    167.         }
    168.         return result;
    169.     }
    170.  
    171. }

    3、模糊查询(fuzzy)

    (1)、Restful 操作示例

    模糊查询所有以 三 结尾的姓名
    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "fuzzy": {
    6.       "name": "三"
    7.     }
    8.   }
    9. }

     (2)、Java 代码示例

    1. package com.example.elasticsearch.demos.web.service.query;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.dto.MatchQueryDto;
    5. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.elasticsearch.action.search.SearchRequest;
    8. import org.elasticsearch.action.search.SearchResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.common.unit.Fuzziness;
    12. import org.elasticsearch.index.query.QueryBuilders;
    13. import org.elasticsearch.rest.RestStatus;
    14. import org.elasticsearch.search.SearchHit;
    15. import org.elasticsearch.search.SearchHits;
    16. import org.elasticsearch.search.builder.SearchSourceBuilder;
    17. import org.springframework.beans.factory.annotation.Autowired;
    18. import org.springframework.stereotype.Service;
    19.  
    20. import java.io.IOException;
    21.  
    22. /**
    23.  * 模糊查询
    24.  */
    25. @Slf4j
    26. @Service
    27. public class FuzzyQueryService {
    28.  
    29.     @Autowired
    30.     private RestHighLevelClient restHighLevelClient;
    31.  
    32.     /**
    33.      * 模糊查询所有以 “三” 结尾的姓名
    34.      * @param queryDto
    35.      */
    36.     public Object fuzzyQuery(MatchQueryDto queryDto) {
    37.         Object result = "";
    38.         try {
    39.             // 构建查询条件
    40.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    41.             searchSourceBuilder.query(QueryBuilders.fuzzyQuery(queryDto.getKey(), queryDto.getValue()).fuzziness(Fuzziness.AUTO));
    42.             // 创建查询请求对象，将查询对象配置到其中
    43.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    44.             searchRequest.source(searchSourceBuilder);
    45.             // 执行查询，然后处理响应结果
    46.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    47.             // 根据状态和数据条数验证是否返回了数据
    48.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    49.                 SearchHits hits = searchResponse.getHits();
    50.                 for (SearchHit hit : hits) {
    51.                     // 将 JSON 转换成对象
    52.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    53.                     // 输出查询信息
    54.                     log.info(userInfo.toString());
    55.                 }
    56.             }
    57.             result = searchResponse.getHits();
    58.         } catch (IOException e) {
    59.             log.error("", e);
    60.         }
    61.         return result;
    62.     }
    63.  
    64. }

    4、范围查询(range)

    (1)、Restful 操作示例

    查询岁数 ≥ 30 岁的员工数据：
    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "range": {
    6.       "age": {
    7.         "gte": 30
    8.       }
    9.     }
    10.   }
    11. }
    查询生日距离现在 30 年间的员工数据： 
    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "range": {
    6.       "birthDate": {
    7.         "gte": "now-30y"
    8.       }
    9.     }
    10.   }
    11. }

    (2)、Java 代码示例 

    1. package com.example.elasticsearch.demos.web.service.query;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.dto.MatchQueryDto;
    5. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.elasticsearch.action.search.SearchRequest;
    8. import org.elasticsearch.action.search.SearchResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.index.query.QueryBuilders;
    12. import org.elasticsearch.rest.RestStatus;
    13. import org.elasticsearch.search.SearchHit;
    14. import org.elasticsearch.search.SearchHits;
    15. import org.elasticsearch.search.builder.SearchSourceBuilder;
    16. import org.springframework.beans.factory.annotation.Autowired;
    17. import org.springframework.stereotype.Service;
    18.  
    19. import java.io.IOException;
    20.  
    21. /**
    22.  * 范围查询
    23.  */
    24. @Slf4j
    25. @Service
    26. public class RangeQueryService {
    27.  
    28.     @Autowired
    29.     private RestHighLevelClient restHighLevelClient;
    30.  
    31.     /**
    32.      * 查询岁数 ≥ 30 岁的员工数据
    33.      * @param queryDto
    34.      */
    35.     public Object rangeQuery(MatchQueryDto queryDto) {
    36.         Object result = "";
    37.         try {
    38.             // 构建查询条件
    39.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    40.             searchSourceBuilder.query(QueryBuilders.rangeQuery("age").gte(30));
    41.             // 创建查询请求对象，将查询对象配置到其中
    42.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    43.             searchRequest.source(searchSourceBuilder);
    44.             // 执行查询，然后处理响应结果
    45.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    46.             // 根据状态和数据条数验证是否返回了数据
    47.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    48.                 SearchHits hits = searchResponse.getHits();
    49.                 for (SearchHit hit : hits) {
    50.                     // 将 JSON 转换成对象
    51.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    52.                     // 输出查询信息
    53.                     log.info(userInfo.toString());
    54.                 }
    55.             }
    56.             result = searchResponse.getHits();
    57.         } catch (IOException e) {
    58.             log.error("", e);
    59.         }
    60.         return result;
    61.     }
    62.  
    63.     /**
    64.      * 查询距离现在 30 年间的员工数据
    65.      * [年(y)、月(M)、星期(w)、天(d)、小时(h)、分钟(m)、秒(s)]
    66.      * 例如：
    67.      * now-1h 查询一小时内范围
    68.      * now-1d 查询一天内时间范围
    69.      * now-1y 查询最近一年内的时间范围
    70.      * @param queryDto
    71.      */
    72.     public Object dateRangeQuery(MatchQueryDto queryDto) {
    73.         Object result = "";
    74.         try {
    75.             // 构建查询条件
    76.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    77. //            // includeLower（是否包含下边界）、includeUpper（是否包含上边界）
    78. //            searchSourceBuilder.query(QueryBuilders.rangeQuery("birthDate")
    79. //                    .gte("now-30y").includeLower(true).includeUpper(true));
    80.             searchSourceBuilder.query(QueryBuilders.rangeQuery("birthDate").gte(queryDto.getFrom()).lte(queryDto.getEnd()));
    81.  
    82.             // 创建查询请求对象，将查询对象配置到其中
    83.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    84.             searchRequest.source(searchSourceBuilder);
    85.             // 执行查询，然后处理响应结果
    86.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    87.             // 根据状态和数据条数验证是否返回了数据
    88.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    89.                 SearchHits hits = searchResponse.getHits();
    90.                 for (SearchHit hit : hits) {
    91.                     // 将 JSON 转换成对象
    92.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    93.                     // 输出查询信息
    94.                     log.info(userInfo.toString());
    95.                 }
    96.             }
    97.             result = searchResponse.getHits();
    98.         } catch (IOException e) {
    99.             log.error("", e);
    100.         }
    101.         return result;
    102.     }
    103.  
    104. }

    5、通配符查询(wildcard)

    (1)、Restful 操作示例

    查询所有以 “三” 结尾的姓名：
    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "wildcard": {
    6.       "name.keyword": {
    7.         "value": "*三"
    8.       }
    9.     }
    10.   }
    11. }

    (2)、Java 代码示例 

    1. package com.example.elasticsearch.demos.web.service.query;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.dto.MatchQueryDto;
    5. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.elasticsearch.action.search.SearchRequest;
    8. import org.elasticsearch.action.search.SearchResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.index.query.QueryBuilders;
    12. import org.elasticsearch.rest.RestStatus;
    13. import org.elasticsearch.search.SearchHit;
    14. import org.elasticsearch.search.SearchHits;
    15. import org.elasticsearch.search.builder.SearchSourceBuilder;
    16. import org.springframework.beans.factory.annotation.Autowired;
    17. import org.springframework.stereotype.Service;
    18.  
    19. import java.io.IOException;
    20.  
    21. /**
    22.  * 通配符查询
    23.  */
    24. @Slf4j
    25. @Service
    26. public class WildcardQueryService {
    27.  
    28.     @Autowired
    29.     private RestHighLevelClient restHighLevelClient;
    30.  
    31.     /**
    32.      * 查询所有以 “三” 结尾的姓名
    33.      * 
    34.      * *：表示多个字符（0个或多个字符）
    35.      * ?：表示单个字符
    36.      * @param queryDto
    37.      */
    38.     public Object wildcardQuery(MatchQueryDto queryDto) {
    39.         Object result = "";
    40.         try {
    41.             // 构建查询条件
    42.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    43.             searchSourceBuilder.query(QueryBuilders.wildcardQuery(queryDto.getKey() + ".keyword", "*" + queryDto.getValue()));
    44.             // 创建查询请求对象，将查询对象配置到其中
    45.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    46.             searchRequest.source(searchSourceBuilder);
    47.             // 执行查询，然后处理响应结果
    48.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    49.             // 根据状态和数据条数验证是否返回了数据
    50.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    51.                 SearchHits hits = searchResponse.getHits();
    52.                 for (SearchHit hit : hits) {
    53.                     // 将 JSON 转换成对象
    54.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    55.                     // 输出查询信息
    56.                     log.info(userInfo.toString());
    57.                 }
    58.             }
    59.             result = searchResponse.getHits();
    60.         } catch (IOException e) {
    61.             log.error("", e);
    62.         }
    63.         return result;
    64.     }
    65.  
    66. }

    6、布尔查询(bool)

    (1)、Restful 操作示例

    查询出生在 1990-1995 年期间，且地址在 北京市昌平区、北京市大兴区、北京市房山区 的员工信息：

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "query": {
    5.     "bool": {
    6.       "filter": {
    7.         "range": {
    8.           "birthDate": {
    9.             "format": "yyyy", 
    10.             "gte": 1990,
    11.             "lte": 1995
    12.           }
    13.         }
    14.       },
    15.       "must": [
    16.         {
    17.           "terms": {
    18.             "address.keyword": [
    19.               "北京市昌平区",
    20.               "北京市大兴区",
    21.               "北京市房山区"
    22.             ]
    23.           }
    24.         }
    25.       ]
    26.     }
    27.   }
    28. }

     (2)、Java 代码示例

    1. package com.example.elasticsearch.demos.web.service.query;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.dto.MatchQueryDto;
    5. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.elasticsearch.action.search.SearchRequest;
    8. import org.elasticsearch.action.search.SearchResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.index.query.BoolQueryBuilder;
    12. import org.elasticsearch.index.query.QueryBuilders;
    13. import org.elasticsearch.rest.RestStatus;
    14. import org.elasticsearch.search.SearchHit;
    15. import org.elasticsearch.search.SearchHits;
    16. import org.elasticsearch.search.builder.SearchSourceBuilder;
    17. import org.springframework.beans.factory.annotation.Autowired;
    18. import org.springframework.stereotype.Service;
    19.  
    20. import java.io.IOException;
    21.  
    22. /**
    23.  * 布尔查询
    24.  */
    25. @Slf4j
    26. @Service
    27. public class BoolQueryService {
    28.  
    29.     @Autowired
    30.     private RestHighLevelClient restHighLevelClient;
    31.  
    32.     /**
    33.      * 布尔查询
    34.      * @param queryDto
    35.      */
    36.     public Object boolQuery(MatchQueryDto queryDto) {
    37.         Object result = "";
    38.         try {
    39.             // 创建 Bool 查询构建器
    40.             BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    41.             // 构建查询条件
    42.             boolQueryBuilder.must(QueryBuilders.termsQuery("address.keyword", "北京市昌平区", "北京市大兴区", "北京市房山区"))
    43.                     .filter().add(QueryBuilders.rangeQuery("birthDate").format("yyyy").gte("1990").lte("1995"));
    44.             // 构建查询源构建器
    45.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    46.             searchSourceBuilder.query(boolQueryBuilder);
    47.             // 创建查询请求对象，将查询对象配置到其中
    48.             SearchRequest searchRequest = new SearchRequest(queryDto.getIndexName());
    49.             searchRequest.source(searchSourceBuilder);
    50.             // 执行查询，然后处理响应结果
    51.             SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    52.             // 根据状态和数据条数验证是否返回了数据
    53.             if (RestStatus.OK.equals(searchResponse.status()) && searchResponse.getHits().getTotalHits().value > 0) {
    54.                 SearchHits hits = searchResponse.getHits();
    55.                 for (SearchHit hit : hits) {
    56.                     // 将 JSON 转换成对象
    57.                     UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    58.                     // 输出查询信息
    59.                     log.info(userInfo.toString());
    60.                 }
    61.             }
    62.             result = searchResponse.getHits();
    63.         } catch (IOException e) {
    64.             log.error("", e);
    65.         }
    66.         return result;
    67.     }
    68.  
    69. }

    八、聚合查询操作示例

    1、Metric 聚合分析

    (1)、Restful 操作示例

    1. GET http://localhost:9200/testindex/_search
    2.  
    3. 1、统计员工总数、工资最高值、工资最低值、工资平均工资、工资总和：
    4. //请求
    5. {
    6.   "size": 0,
    7.   "aggs": {
    8.     "salary_stats": {
    9.       "stats": {
    10.         "field": "salary"
    11.       }
    12.     }
    13.   }
    14. }
    15.  
    16. 2、统计员工工资最低值：
    17. //请求
    18. {
    19.   "size": 0,
    20.   "aggs": {
    21.     "salary_min": {
    22.       "min": {
    23.         "field": "salary"
    24.       }
    25.     }
    26.   }
    27. }
    28.  
    29. 3、统计员工工资最高值：
    30. //请求
    31. {
    32.   "size": 0,
    33.   "aggs": {
    34.     "salary_max": {
    35.       "max": {
    36.         "field": "salary"
    37.       }
    38.     }
    39.   }
    40. }
    41.  
    42. 4、统计员工工资平均值：
    43. //请求
    44. {
    45.   "size": 0,
    46.   "aggs": {
    47.     "salary_avg": {
    48.       "avg": {
    49.         "field": "salary"
    50.       }
    51.     }
    52.   }
    53. }
    54.  
    55. 5、统计员工工资总值：
    56. //请求
    57. {
    58.   "size": 0,
    59.   "aggs": {
    60.     "salary_sum": {
    61.       "sum": {
    62.         "field": "salary"
    63.       }
    64.     }
    65.   }
    66. }
    67.  
    68. 6、统计员工总数：
    69. //请求
    70. {
    71.   "size": 0,
    72.   "aggs": {
    73.     "employee_count": {
    74.       "value_count": {
    75.         "field": "salary"
    76.       }
    77.     }
    78.   }
    79. }
    80.  
    81. 7、统计员工工资百分位：
    82. //请求
    83. {
    84.   "size": 0,
    85.   "aggs": {
    86.     "salary_percentiles": {
    87.       "percentiles": {
    88.         "field": "salary"
    89.       }
    90.     }
    91.   }
    92. }

    (2)、Java 代码示例

    1. package com.example.elasticsearch.demos.web.service.aggregation;
    2.  
    3. import com.example.elasticsearch.demos.web.model.dto.MatchQueryDto;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.elasticsearch.action.search.SearchRequest;
    6. import org.elasticsearch.action.search.SearchResponse;
    7. import org.elasticsearch.client.RequestOptions;
    8. import org.elasticsearch.client.RestHighLevelClient;
    9. import org.elasticsearch.rest.RestStatus;
    10. import org.elasticsearch.search.aggregations.AggregationBuilder;
    11. import org.elasticsearch.search.aggregations.AggregationBuilders;
    12. import org.elasticsearch.search.aggregations.Aggregations;
    13. import org.elasticsearch.search.aggregations.metrics.*;
    14. import org.elasticsearch.search.builder.SearchSourceBuilder;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.beans.factory.annotation.Value;
    17. import org.springframework.stereotype.Component;
    18. import org.springframework.stereotype.Service;
    19.  
    20. import java.io.IOException;
    21.  
    22. /**
    23.  * 聚合 Metric
    24.  */
    25. @Slf4j
    26. @Service
    27. public class AggrMetricService {
    28.  
    29.     @Autowired
    30.     private RestHighLevelClient restHighLevelClient;
    31.     @Value("${myindex}")
    32.     private String indexName;
    33.  
    34.     /**
    35.      * stats 统计员工总数、工资最高值、工资最低值、工资平均工资、工资总和
    36.      * @param queryDto
    37.      */
    38.     public Object aggregationStats(MatchQueryDto queryDto) {
    39.         String responseResult = "";
    40.         try {
    41.             // 设置聚合条件
    42.             String field = queryDto.getKey();
    43.             AggregationBuilder aggr = AggregationBuilders.stats(field + "_stats").field(field);
    44.             // 查询源构建器
    45.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    46.             searchSourceBuilder.aggregation(aggr);
    47.             // 设置查询结果不返回，只返回聚合结果
    48.             searchSourceBuilder.size(0);
    49.             // 创建查询请求对象，将查询条件配置到其中
    50.             SearchRequest request = new SearchRequest(indexName);
    51.             request.source(searchSourceBuilder);
    52.             // 执行请求
    53.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    54.             // 获取响应中的聚合信息
    55.             Aggregations aggregations = response.getAggregations();
    56.             // 输出内容
    57.             if (RestStatus.OK.equals(response.status()) || aggregations != null) {
    58.                 // 转换为 Stats 对象
    59.                 ParsedStats aggregation = aggregations.get(field + "_stats");
    60.                 log.info("-------------------------------------------");
    61.                 log.info("聚合信息: {}", field);
    62.                 log.info("count：{}", aggregation.getCount());
    63.                 log.info("avg：{}", aggregation.getAvg());
    64.                 log.info("max：{}", aggregation.getMax());
    65.                 log.info("min：{}", aggregation.getMin());
    66.                 log.info("sum：{}", aggregation.getSum());
    67.                 log.info("-------------------------------------------");
    68.             }
    69.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将返回响应对象Json串
    70.             responseResult = response.toString();
    71.         } catch (IOException e) {
    72.             log.error("", e);
    73.         }
    74.         return responseResult;
    75.     }
    76.  
    77.     /**
    78.      * min 统计员工工资最低值
    79.      */
    80.     public Object aggregationMin() {
    81.         String responseResult = "";
    82.         try {
    83.             // 设置聚合条件
    84.             AggregationBuilder aggr = AggregationBuilders.min("salary_min").field("salary");
    85.             // 查询源构建器
    86.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    87.             searchSourceBuilder.aggregation(aggr);
    88.             searchSourceBuilder.size(0);
    89.             // 创建查询请求对象，将查询条件配置到其中
    90.             SearchRequest request = new SearchRequest(indexName);
    91.             request.source(searchSourceBuilder);
    92.             // 执行请求
    93.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    94.             // 获取响应中的聚合信息
    95.             Aggregations aggregations = response.getAggregations();
    96.             // 输出内容
    97.             if (RestStatus.OK.equals(response.status()) || aggregations != null) {
    98.                 // 转换为 Min 对象
    99.                 ParsedMin aggregation = aggregations.get("salary_min");
    100.                 log.info("-------------------------------------------");
    101.                 log.info("聚合信息:");
    102.                 log.info("min：{}", aggregation.getValue());
    103.                 log.info("-------------------------------------------");
    104.             }
    105.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将返回响应对象Json串
    106.             responseResult = response.toString();
    107.         } catch (IOException e) {
    108.             log.error("", e);
    109.         }
    110.         return responseResult;
    111.     }
    112.  
    113.     /**
    114.      * max 统计员工工资最高值
    115.      */
    116.     public Object aggregationMax() {
    117.         String responseResult = "";
    118.         try {
    119.             // 设置聚合条件
    120.             AggregationBuilder aggr = AggregationBuilders.max("salary_max").field("salary");
    121.             // 查询源构建器
    122.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    123.             searchSourceBuilder.aggregation(aggr);
    124.             searchSourceBuilder.size(0);
    125.             // 创建查询请求对象，将查询条件配置到其中
    126.             SearchRequest request = new SearchRequest(indexName);
    127.             request.source(searchSourceBuilder);
    128.             // 执行请求
    129.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    130.             // 获取响应中的聚合信息
    131.             Aggregations aggregations = response.getAggregations();
    132.             // 输出内容
    133.             if (RestStatus.OK.equals(response.status()) || aggregations != null) {
    134.                 // 转换为 Max 对象
    135.                 ParsedMax aggregation = aggregations.get("salary_max");
    136.                 log.info("-------------------------------------------");
    137.                 log.info("聚合信息:");
    138.                 log.info("max：{}", aggregation.getValue());
    139.                 log.info("-------------------------------------------");
    140.             }
    141.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将返回响应对象Json串
    142.             responseResult = response.toString();
    143.         } catch (IOException e) {
    144.             log.error("", e);
    145.         }
    146.         return responseResult;
    147.     }
    148.  
    149.     /**
    150.      * avg 统计员工工资平均值
    151.      */
    152.     public Object aggregationAvg() {
    153.         String responseResult = "";
    154.         try {
    155.             // 设置聚合条件
    156.             AggregationBuilder aggr = AggregationBuilders.avg("salary_avg").field("salary");
    157.             // 查询源构建器
    158.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    159.             searchSourceBuilder.aggregation(aggr);
    160.             searchSourceBuilder.size(0);
    161.             // 创建查询请求对象，将查询条件配置到其中
    162.             SearchRequest request = new SearchRequest(indexName);
    163.             request.source(searchSourceBuilder);
    164.             // 执行请求
    165.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    166.             // 获取响应中的聚合信息
    167.             Aggregations aggregations = response.getAggregations();
    168.             // 输出内容
    169.             if (RestStatus.OK.equals(response.status()) || aggregations != null) {
    170.                 // 转换为 Avg 对象
    171.                 ParsedAvg aggregation = aggregations.get("salary_avg");
    172.                 log.info("-------------------------------------------");
    173.                 log.info("聚合信息:");
    174.                 log.info("avg：{}", aggregation.getValue());
    175.                 log.info("-------------------------------------------");
    176.             }
    177.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将返回响应对象Json串
    178.             responseResult = response.toString();
    179.         } catch (IOException e) {
    180.             log.error("", e);
    181.         }
    182.         return responseResult;
    183.     }
    184.  
    185.     /**
    186.      * sum 统计员工工资总值
    187.      */
    188.     public Object aggregationSum() {
    189.         String responseResult = "";
    190.         try {
    191.             // 设置聚合条件
    192.             SumAggregationBuilder aggr = AggregationBuilders.sum("salary_sum").field("salary");
    193.             // 查询源构建器
    194.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    195.             searchSourceBuilder.aggregation(aggr);
    196.             searchSourceBuilder.size(0);
    197.             // 创建查询请求对象，将查询条件配置到其中
    198.             SearchRequest request = new SearchRequest(indexName);
    199.             request.source(searchSourceBuilder);
    200.             // 执行请求
    201.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    202.             // 获取响应中的聚合信息
    203.             Aggregations aggregations = response.getAggregations();
    204.             // 输出内容
    205.             if (RestStatus.OK.equals(response.status()) || aggregations != null) {
    206.                 // 转换为 Sum 对象
    207.                 ParsedSum aggregation = aggregations.get("salary_sum");
    208.                 log.info("-------------------------------------------");
    209.                 log.info("聚合信息:");
    210.                 log.info("sum：{}", String.valueOf((aggregation.getValue())));
    211.                 log.info("-------------------------------------------");
    212.             }
    213.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将返回响应对象Json串
    214.             responseResult = response.toString();
    215.         } catch (IOException e) {
    216.             log.error("", e);
    217.         }
    218.         return responseResult;
    219.     }
    220.  
    221.     /**
    222.      * count 统计员工总数
    223.      */
    224.     public Object aggregationCount() {
    225.         String responseResult = "";
    226.         try {
    227.             // 设置聚合条件
    228.             AggregationBuilder aggr = AggregationBuilders.count("employee_count").field("salary");
    229.             // 查询源构建器
    230.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    231.             searchSourceBuilder.aggregation(aggr);
    232.             searchSourceBuilder.size(0);
    233.             // 创建查询请求对象，将查询条件配置到其中
    234.             SearchRequest request = new SearchRequest(indexName);
    235.             request.source(searchSourceBuilder);
    236.             // 执行请求
    237.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    238.             // 获取响应中的聚合信息
    239.             Aggregations aggregations = response.getAggregations();
    240.             // 输出内容
    241.             if (RestStatus.OK.equals(response.status()) || aggregations != null) {
    242.                 // 转换为 ValueCount 对象
    243.                 ParsedValueCount aggregation = aggregations.get("employee_count");
    244.                 log.info("-------------------------------------------");
    245.                 log.info("聚合信息:");
    246.                 log.info("count：{}", aggregation.getValue());
    247.                 log.info("-------------------------------------------");
    248.             }
    249.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将返回响应对象Json串
    250.             responseResult = response.toString();
    251.         } catch (IOException e) {
    252.             log.error("", e);
    253.         }
    254.         return responseResult;
    255.     }
    256.  
    257.     /**
    258.      * percentiles 统计员工工资百分位
    259.      */
    260.     public Object aggregationPercentiles() {
    261.         String responseResult = "";
    262.         try {
    263.             // 设置聚合条件
    264.             AggregationBuilder aggr = AggregationBuilders.percentiles("salary_percentiles").field("salary");
    265.             // 查询源构建器
    266.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    267.             searchSourceBuilder.aggregation(aggr);
    268.             searchSourceBuilder.size(0);
    269.             // 创建查询请求对象，将查询条件配置到其中
    270.             SearchRequest request = new SearchRequest(indexName);
    271.             request.source(searchSourceBuilder);
    272.             // 执行请求
    273.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    274.             // 获取响应中的聚合信息
    275.             Aggregations aggregations = response.getAggregations();
    276.             // 输出内容
    277.             if (RestStatus.OK.equals(response.status()) || aggregations != null) {
    278.                 // 转换为 Percentiles 对象
    279.                 ParsedPercentiles aggregation = aggregations.get("salary_percentiles");
    280.                 log.info("-------------------------------------------");
    281.                 log.info("聚合信息:");
    282.                 for (Percentile percentile : aggregation) {
    283.                     log.info("百分位：{}：{}", percentile.getPercent(), percentile.getValue());
    284.                 }
    285.                 log.info("-------------------------------------------");
    286.             }
    287.             // 根据具体业务逻辑返回不同结果，这里为了方便直接将返回响应对象Json串
    288.             responseResult = response.toString();
    289.         } catch (IOException e) {
    290.             log.error("", e);
    291.         }
    292.         return responseResult;
    293.     }
    294.  
    295. }

    2、Bucket 聚合分析

    (1)、Restful 操作示例

    1. GET http://localhost:9200/testindex/_search
    2.  
    3. 1、按岁数进行聚合分桶，统计各个岁数员工的人数：
    4. //请求
    5. {
    6.   "size": 0,
    7.   "aggs": {
    8.     "age_bucket": {
    9.       "terms": {
    10.         "field": "age",
    11.         "size": "10"
    12.       }
    13.     }
    14.   }
    15. }
    16.  
    17. 2、按工资范围进行聚合分桶，统计工资在 3000-5000、5000-9000 和 9000 以上的员工信息：
    18. //请求
    19. {
    20.   "aggs": {
    21.     "salary_range_bucket": {
    22.       "range": {
    23.         "field": "salary",
    24.         "ranges": [
    25.           {
    26.             "key": "低级员工", 
    27.             "to": 3000
    28.           },{
    29.             "key": "中级员工",
    30.             "from": 5000,
    31.             "to": 9000
    32.           },{
    33.             "key": "高级员工",
    34.             "from": 9000
    35.           }
    36.         ]
    37.       }
    38.     }
    39.   }
    40. }
    41.  
    42. 3、按照时间范围进行分桶，统计 1985-1990 年和 1990-1995 年出生的员工信息：
    43. //请求
    44. {
    45.   "size": 10,
    46.   "aggs": {
    47.     "date_range_bucket": {
    48.       "date_range": {
    49.         "field": "birthDate",
    50.         "format": "yyyy", 
    51.         "ranges": [
    52.           {
    53.             "key": "出生日期1985-1990的员工", 
    54.             "from": "1985",
    55.             "to": "1990"
    56.           },{
    57.             "key": "出生日期1990-1995的员工", 
    58.             "from": "1990",
    59.             "to": "1995"
    60.           }
    61.         ]
    62.       }
    63.     }
    64.   }
    65. }
    66.  
    67. 4、按工资多少进行聚合分桶，设置统计的最小值为 0，最大值为 12000，区段间隔为 3000：
    68. //请求
    69. {
    70.   "size": 0,
    71.   "aggs": {
    72.     "salary_histogram": {
    73.       "histogram": {
    74.         "field": "salary",
    75.         "extended_bounds": {
    76.           "min": 0,
    77.           "max": 12000
    78.         }, 
    79.         "interval": 3000
    80.       }
    81.     }
    82.   }
    83. }
    84.  
    85. 5、按出生日期进行分桶：
    86. //请求
    87. {
    88.   "size": 0,
    89.   "aggs": {
    90.     "birthday_histogram": {
    91.       "date_histogram": {
    92.         "format": "yyyy", 
    93.         "field": "birthDate",
    94.         "interval": "year"
    95.       }
    96.     }
    97.   }
    98. }

    (2)、Java 代码示例 

    1. package com.example.elasticsearch.demos.web.service.aggregation;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.elasticsearch.action.search.SearchRequest;
    5. import org.elasticsearch.action.search.SearchResponse;
    6. import org.elasticsearch.client.RequestOptions;
    7. import org.elasticsearch.client.RestHighLevelClient;
    8. import org.elasticsearch.rest.RestStatus;
    9. import org.elasticsearch.search.aggregations.AggregationBuilder;
    10. import org.elasticsearch.search.aggregations.AggregationBuilders;
    11. import org.elasticsearch.search.aggregations.Aggregations;
    12. import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
    13. import org.elasticsearch.search.aggregations.bucket.histogram.Histogram;
    14. import org.elasticsearch.search.aggregations.bucket.range.Range;
    15. import org.elasticsearch.search.aggregations.bucket.terms.Terms;
    16. import org.elasticsearch.search.builder.SearchSourceBuilder;
    17. import org.springframework.beans.factory.annotation.Autowired;
    18. import org.springframework.beans.factory.annotation.Value;
    19. import org.springframework.stereotype.Service;
    20.  
    21. import java.io.IOException;
    22. import java.util.HashMap;
    23. import java.util.List;
    24. import java.util.Map;
    25.  
    26. /**
    27.  * 聚合 Bucket
    28.  */
    29. @Slf4j
    30. @Service
    31. public class AggrBucketService {
    32.  
    33.     @Autowired
    34.     private RestHighLevelClient restHighLevelClient;
    35.     @Value("${myindex}")
    36.     private String indexName;
    37.  
    38.     /**
    39.      * 按岁数进行聚合分桶，统计各个岁数员工的人数：
    40.      */
    41.     public Object aggrBucketTerms() {
    42.         Map keyCountMap = new HashMap<>();
    43.         try {
    44.             AggregationBuilder aggr = AggregationBuilders.terms("age_bucket").field("age");
    45.             // 查询源构建器
    46.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    47.             searchSourceBuilder.size(10);
    48.             searchSourceBuilder.aggregation(aggr);
    49.             // 创建查询请求对象，将查询条件配置到其中
    50.             SearchRequest request = new SearchRequest(indexName);
    51.             request.source(searchSourceBuilder);
    52.             // 执行请求
    53.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    54.             // 获取响应中的聚合信息
    55.             Aggregations aggregations = response.getAggregations();
    56.             // 输出内容
    57.             if (RestStatus.OK.equals(response.status())) {
    58.                 // 分桶
    59.                 Terms byCompanyAggregation = aggregations.get("age_bucket");
    60.                 Listextends Terms.Bucket> buckets = byCompanyAggregation.getBuckets();
    61.                 // 输出各个桶的内容
    62.                 log.info("-------------------------------------------");
    63.                 log.info("聚合信息:");
    64.                 for (Terms.Bucket bucket : buckets) {
    65.                     keyCountMap.put(bucket.getKeyAsString(),  bucket.getDocCount());
    66.                     log.info("桶名：{} | 总数：{}", bucket.getKeyAsString(), bucket.getDocCount());
    67.                 }
    68.                 log.info("-------------------------------------------");
    69.             }
    70.         } catch (IOException e) {
    71.             log.error("", e);
    72.         }
    73.         return keyCountMap;
    74.     }
    75.  
    76.     /**
    77.      * 按工资范围进行聚合分桶，统计工资在 3000-5000、5000-9000 和 9000 以上的员工信息：
    78.      */
    79.     public Object aggrBucketRange() {
    80.         Map keyCountMap = new HashMap<>();
    81.         try {
    82.             AggregationBuilder aggr = AggregationBuilders.range("salary_range_bucket")
    83.                     .field("salary")
    84.                     .addUnboundedTo("低级员工", 3000)
    85.                     .addRange("中级员工", 5000, 9000)
    86.                     .addUnboundedFrom("高级员工", 9000);
    87.             // 查询源构建器
    88.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    89.             searchSourceBuilder.size(0);
    90.             searchSourceBuilder.aggregation(aggr);
    91.             // 创建查询请求对象，将查询条件配置到其中
    92.             SearchRequest request = new SearchRequest(indexName);
    93.             request.source(searchSourceBuilder);
    94.             // 执行请求
    95.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    96.             // 获取响应中的聚合信息
    97.             Aggregations aggregations = response.getAggregations();
    98.             // 输出内容
    99.             if (RestStatus.OK.equals(response.status())) {
    100.                 // 分桶
    101.                 Range byCompanyAggregation = aggregations.get("salary_range_bucket");
    102.                 Listextends Range.Bucket> buckets = byCompanyAggregation.getBuckets();
    103.                 // 输出各个桶的内容
    104.                 log.info("-------------------------------------------");
    105.                 log.info("聚合信息:");
    106.                 for (Range.Bucket bucket : buckets) {
    107.                     keyCountMap.put(bucket.getKeyAsString(),  bucket.getDocCount());
    108.                     log.info("桶名：{} | 总数：{}", bucket.getKeyAsString(), bucket.getDocCount());
    109.                 }
    110.                 log.info("-------------------------------------------");
    111.             }
    112.         } catch (IOException e) {
    113.             log.error("", e);
    114.         }
    115.         return keyCountMap;
    116.     }
    117.  
    118.     /**
    119.      * 按照时间范围进行分桶，统计 1985-1990 年和 1990-1995 年出生的员工信息：
    120.      */
    121.     public Object aggrBucketDateRange() {
    122.         Map keyCountMap = new HashMap<>();
    123.         try {
    124.             AggregationBuilder aggr = AggregationBuilders.dateRange("date_range_bucket")
    125.                     .field("birthDate")
    126.                     .format("yyyy")
    127.                     .addRange("出生日期1985-1990的员工", "1985", "1990")
    128.                     .addRange("出生日期1990-1995的员工", "1990", "1995");
    129.             // 查询源构建器
    130.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    131.             searchSourceBuilder.size(0);
    132.             searchSourceBuilder.aggregation(aggr);
    133.             // 创建查询请求对象，将查询条件配置到其中
    134.             SearchRequest request = new SearchRequest(indexName);
    135.             request.source(searchSourceBuilder);
    136.             // 执行请求
    137.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    138.             // 获取响应中的聚合信息
    139.             Aggregations aggregations = response.getAggregations();
    140.             // 输出内容
    141.             if (RestStatus.OK.equals(response.status())) {
    142.                 // 分桶
    143.                 Range byCompanyAggregation = aggregations.get("date_range_bucket");
    144.                 Listextends Range.Bucket> buckets = byCompanyAggregation.getBuckets();
    145.                 // 输出各个桶的内容
    146.                 log.info("-------------------------------------------");
    147.                 log.info("聚合信息:");
    148.                 for (Range.Bucket bucket : buckets) {
    149.                     keyCountMap.put(bucket.getKeyAsString(),  bucket.getDocCount());
    150.                     log.info("桶名：{} | 总数：{}", bucket.getKeyAsString(), bucket.getDocCount());
    151.                 }
    152.                 log.info("-------------------------------------------");
    153.             }
    154.         } catch (IOException e) {
    155.             log.error("", e);
    156.         }
    157.         return keyCountMap;
    158.     }
    159.  
    160.     /**
    161.      * 按工资多少进行聚合分桶
    162.      */
    163.     public Object aggrBucketHistogram() {
    164.         Map keyCountMap = new HashMap<>();
    165.         try {
    166.             //按工资多少进行聚合分桶，设置统计的最小值为 0，最大值为 12000，区段间隔为 3000：
    167.             AggregationBuilder aggr = AggregationBuilders.histogram("salary_histogram")
    168.                     .field("salary")
    169.                     .extendedBounds(0, 12000)
    170.                     .interval(3000);
    171.             // 查询源构建器
    172.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    173.             searchSourceBuilder.size(0);
    174.             searchSourceBuilder.aggregation(aggr);
    175.             // 创建查询请求对象，将查询条件配置到其中
    176.             SearchRequest request = new SearchRequest(indexName);
    177.             request.source(searchSourceBuilder);
    178.             // 执行请求
    179.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    180.             // 获取响应中的聚合信息
    181.             Aggregations aggregations = response.getAggregations();
    182.             // 输出内容
    183.             if (RestStatus.OK.equals(response.status())) {
    184.                 // 分桶
    185.                 Histogram byCompanyAggregation = aggregations.get("salary_histogram");
    186.                 Listextends Histogram.Bucket> buckets = byCompanyAggregation.getBuckets();
    187.                 // 输出各个桶的内容
    188.                 log.info("-------------------------------------------");
    189.                 log.info("聚合信息:");
    190.                 for (Histogram.Bucket bucket : buckets) {
    191.                     keyCountMap.put(bucket.getKeyAsString(),  bucket.getDocCount());
    192.                     log.info("桶名：{} | 总数：{}", bucket.getKeyAsString(), bucket.getDocCount());
    193.                 }
    194.                 log.info("-------------------------------------------");
    195.             }
    196.         } catch (IOException e) {
    197.             log.error("", e);
    198.         }
    199.         return keyCountMap;
    200.     }
    201.  
    202.     /**
    203.      * 按出生日期进行分桶：
    204.      */
    205.     public Object aggrBucketDateHistogram() {
    206.         Map keyCountMap = new HashMap<>();
    207.         try {
    208.             AggregationBuilder aggr = AggregationBuilders.dateHistogram("birthday_histogram")
    209.                     .field("birthDate")
    210.                     .interval(1)
    211.                     .dateHistogramInterval(DateHistogramInterval.YEAR)
    212.                     .format("yyyy");
    213.             // 查询源构建器
    214.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    215.             searchSourceBuilder.size(0);
    216.             searchSourceBuilder.aggregation(aggr);
    217.             // 创建查询请求对象，将查询条件配置到其中
    218.             SearchRequest request = new SearchRequest(indexName);
    219.             request.source(searchSourceBuilder);
    220.             // 执行请求
    221.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    222.             // 获取响应中的聚合信息
    223.             Aggregations aggregations = response.getAggregations();
    224.             // 输出内容
    225.             if (RestStatus.OK.equals(response.status())) {
    226.                 // 分桶
    227.                 Histogram byCompanyAggregation = aggregations.get("birthday_histogram");
    228.  
    229.                 Listextends Histogram.Bucket> buckets = byCompanyAggregation.getBuckets();
    230.                 // 输出各个桶的内容
    231.                 log.info("-------------------------------------------");
    232.                 log.info("聚合信息:");
    233.                 for (Histogram.Bucket bucket : buckets) {
    234.                     keyCountMap.put(bucket.getKeyAsString(),  bucket.getDocCount());
    235.                     log.info("桶名：{} | 总数：{}", bucket.getKeyAsString(), bucket.getDocCount());
    236.                 }
    237.                 log.info("-------------------------------------------");
    238.             }
    239.         } catch (IOException e) {
    240.             log.error("", e);
    241.         }
    242.         return keyCountMap;
    243.     }
    244.  
    245. }

    3、Metric 与 Bucket 聚合分析

    (1)、Restful 操作示例

    按照员工岁数分桶、然后统计每个岁数员工工资最高值:

    1. GET http://localhost:9200/testindex/_search
    2. //请求
    3. {
    4.   "size": 0,
    5.   "aggs": {
    6.     "salary_bucket": {
    7.       "terms": {
    8.         "field": "age",
    9.         "size": "10"
    10.       },
    11.       "aggs": {
    12.         "salary_max_user": {
    13.           "top_hits": {
    14.             "size": 1,
    15.             "sort": [
    16.               {
    17.                 "salary": {
    18.                   "order": "desc"
    19.                 }
    20.               }
    21.             ]
    22.           }
    23.         }
    24.       }
    25.     }
    26.   }
    27. }

    (2)、Java 代码示例

    1. package com.example.elasticsearch.demos.web.service.aggregation;
    2.  
    3. import com.alibaba.fastjson.JSON;
    4. import com.example.elasticsearch.demos.web.model.entity.UserInfo;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.elasticsearch.action.search.SearchRequest;
    7. import org.elasticsearch.action.search.SearchResponse;
    8. import org.elasticsearch.client.RequestOptions;
    9. import org.elasticsearch.client.RestHighLevelClient;
    10. import org.elasticsearch.rest.RestStatus;
    11. import org.elasticsearch.search.SearchHit;
    12. import org.elasticsearch.search.aggregations.AggregationBuilder;
    13. import org.elasticsearch.search.aggregations.AggregationBuilders;
    14. import org.elasticsearch.search.aggregations.Aggregations;
    15. import org.elasticsearch.search.aggregations.bucket.terms.Terms;
    16. import org.elasticsearch.search.aggregations.metrics.ParsedTopHits;
    17. import org.elasticsearch.search.builder.SearchSourceBuilder;
    18. import org.elasticsearch.search.sort.SortOrder;
    19. import org.springframework.beans.factory.annotation.Autowired;
    20. import org.springframework.beans.factory.annotation.Value;
    21. import org.springframework.stereotype.Service;
    22.  
    23. import java.io.IOException;
    24. import java.util.HashMap;
    25. import java.util.List;
    26. import java.util.Map;
    27.  
    28. /**
    29.  * 聚合 Bucket 与 Metric
    30.  */
    31. @Slf4j
    32. @Service
    33. public class AggrBucketMetricService {
    34.  
    35.     @Autowired
    36.     private RestHighLevelClient restHighLevelClient;
    37.     @Value("${myindex}")
    38.     private String indexName;
    39.  
    40.     /**
    41.      * topHits 按照员工岁数分桶、然后统计每个岁数员工工资最高值
    42.      */
    43.     public Object aggregationTopHits() {
    44.         Map ageMaxSalaryMap = new HashMap<>();
    45.         try {
    46.             AggregationBuilder testTop = AggregationBuilders.topHits("salary_max_user")
    47.                     .size(1)
    48.                     .sort("salary", SortOrder.DESC);
    49.             AggregationBuilder salaryBucket = AggregationBuilders.terms("salary_bucket")
    50.                     .field("age")
    51.                     .size(10);
    52.             salaryBucket.subAggregation(testTop);
    53.             // 查询源构建器
    54.             SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    55.             searchSourceBuilder.size(0);
    56.             searchSourceBuilder.aggregation(salaryBucket);
    57.             // 创建查询请求对象，将查询条件配置到其中
    58.             SearchRequest request = new SearchRequest(indexName);
    59.             request.source(searchSourceBuilder);
    60.             // 执行请求
    61.             SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
    62.             // 获取响应中的聚合信息
    63.             Aggregations aggregations = response.getAggregations();
    64.             // 输出内容
    65.             if (RestStatus.OK.equals(response.status())) {
    66.                 // 分桶
    67.                 Terms byCompanyAggregation = aggregations.get("salary_bucket");
    68.                 Listextends Terms.Bucket> buckets = byCompanyAggregation.getBuckets();
    69.                 // 输出各个桶的内容
    70.                 log.info("-------------------------------------------");
    71.                 log.info("聚合信息:");
    72.                 for (Terms.Bucket bucket : buckets) {
    73.                     log.info("桶名：{}", bucket.getKeyAsString());
    74.                     ParsedTopHits topHits = bucket.getAggregations().get("salary_max_user");
    75.                     for (SearchHit hit : topHits.getHits()) {
    76.                         UserInfo userInfo = JSON.parseObject(hit.getSourceAsString(), UserInfo.class);
    77.                         ageMaxSalaryMap.put(bucket.getKeyAsString(),  userInfo.getSalary());
    78.                         log.info(hit.getSourceAsString());
    79.                     }
    80.                 }
    81.                 log.info("-------------------------------------------");
    82.             }
    83.         } catch (IOException e) {
    84.             log.error("", e);
    85.         }
    86.         return ageMaxSalaryMap;
    87.     }
    88.  
    89. }

    九、项目源码及对应ES安装包

    1、elasticsearch-7.6.1安装包

    elasticsearch7.6.1icon-default.png?t=N7T8https://download.csdn.net/download/asd051377305/88397087

    2、项目源代码

    基于SpringBoot+elasticsearch的操作项目icon-default.png?t=N7T8https://download.csdn.net/download/asd051377305/88397090

     

  • 相关阅读:
    Asymmetric channel bandwidths(非对称信道带宽)
    drools规则引擎04
    【Python】简记操作：Centos安装Python3虚拟环境-virtualenvwrapper
    Overleaf(Latex)论文里插入高清matlab图像，亲测有效！！
    VP牛客小白月赛88（A---F)（收获很多）
    基于ARM的环境参数检测系统设计（Labview+STM32+ZigBee）
    OpenAI：我们暂停了ChatGPT Plus新用户注册
    使用Spring Security保障你的Web应用安全
    个保法(PIPL)颁布实施一周年，给行业带来了哪些变化？
    【HBZ分享】ES的聚合函数汇总
  • 原文地址：https://blog.csdn.net/asd051377305/article/details/133581804