devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：小丑西瓜9 | 2024-06-07 07:07:13

赞

踩

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. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="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.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.example</groupId>
  6.     <artifactId>elasticsearch</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <name>elasticsearch</name>
  9.     <description>Demo project for Spring Boot</description>
  10.     <properties>
  11.         <java.version>1.8</java.version>
  12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  14.         <spring-boot.version>2.3.12.RELEASE</spring-boot.version>
  15.     </properties>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-web</artifactId>
  20.         </dependency>
  21.  
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-test</artifactId>
  25.             <scope>test</scope>
  26.             <exclusions>
  27.                 <exclusion>
  28.                     <groupId>org.junit.vintage</groupId>
  29.                     <artifactId>junit-vintage-engine</artifactId>
  30.                 </exclusion>
  31.             </exclusions>
  32.         </dependency>
  33.  
  34.         <dependency>
  35.             <groupId>org.projectlombok</groupId>
  36.             <artifactId>lombok</artifactId>
  37.             <optional>true</optional>
  38.         </dependency>
  39.         <!--fastjson-->
  40.         <dependency>
  41.             <groupId>com.alibaba</groupId>
  42.             <artifactId>fastjson</artifactId>
  43.             <version>1.2.61</version>
  44.         </dependency>
  45.         <!--elasticsearch-->
  46.         <dependency>
  47.             <groupId>org.elasticsearch.client</groupId>
  48.             <artifactId>elasticsearch-rest-high-level-client</artifactId>
  49.             <version>7.6.1</version>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>org.elasticsearch</groupId>
  53.             <artifactId>elasticsearch</artifactId>
  54.             <version>7.6.1</version>
  55.         </dependency>
  56.     </dependencies>
  57.     <dependencyManagement>
  58.         <dependencies>
  59.             <dependency>
  60.                 <groupId>org.springframework.boot</groupId>
  61.                 <artifactId>spring-boot-dependencies</artifactId>
  62.                 <version>${spring-boot.version}</version>
  63.                 <type>pom</type>
  64.                 <scope>import</scope>
  65.             </dependency>
  66.         </dependencies>
  67.     </dependencyManagement>
  68.  
  69.     <build>
  70.         <plugins>
  71.             <plugin>
  72.                 <groupId>org.apache.maven.plugins</groupId>
  73.                 <artifactId>maven-compiler-plugin</artifactId>
  74.                 <version>3.8.1</version>
  75.                 <configuration>
  76.                     <source>1.8</source>
  77.                     <target>1.8</target>
  78.                     <encoding>UTF-8</encoding>
  79.                 </configuration>
  80.             </plugin>
  81.             <plugin>
  82.                 <groupId>org.springframework.boot</groupId>
  83.                 <artifactId>spring-boot-maven-plugin</artifactId>
  84.                 <version>${spring-boot.version}</version>
  85.                 <configuration>
  86.                     <mainClass>com.example.elasticsearch.ElasticsearchApplication</mainClass>
  87.                     <skip>true</skip>
  88.                 </configuration>
  89.                 <executions>
  90.                     <execution>
  91.                         <id>repackage</id>
  92.                         <goals>
  93.                             <goal>repackage</goal>
  94.                         </goals>
  95.                     </execution>
  96.                 </executions>
  97.             </plugin>
  98.         </plugins>
  99.     </build>
  100.  
  101. </project>

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<HttpHost> 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.      * <p>
  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<String, Long> 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.                 List<? extends 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<String, Long> 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.                 List<? extends 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<String, Long> 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.                 List<? extends 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<String, Long> 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.                 List<? extends 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<String, Long> 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.                 List<? extends 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<String, Float> 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.                 List<? extends 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

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/684388
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号