第2章 Elasticsearch入门

我会带着你远行 2023-10-03 21:41 15阅读 0赞

### **2.1** **Elasticsearch** **安装** ###

#### **2** **.** **1** **.1** **下载软件** ####

Elasticsearch的官方地址：[www.elastic.co/cn/][www.elastic.co_cn]

Elasticsearch最新的版本是7.11.2（截止2021.3.10），我们选择7.8.0版本（最新版本半年前的版本）

下载地址：[www.elastic.co/cn/download…][www.elastic.co_cn_download]

![format_png][]

Elasticsearch分为Linux和Windows版本，基于我们主要学习的是Elasticsearch的Java客户端的使用，所以课程中使用的是安装较为简便的Windows版本。

#### **2** **.** **1** **.** **2** **安装软件** ####

Windows版的Elasticsearch的安装很简单，解压即安装完毕，解压后的Elasticsearch的目录结构如下

![format_png 1][]

<table> 
 <thead> 
  <tr> 
   <th>目录</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>bin</td> 
   <td>可执行脚本目录</td> 
  </tr> 
  <tr> 
   <td>config</td> 
   <td>配置目录</td> 
  </tr> 
  <tr> 
   <td>jdk</td> 
   <td>内置JDK目录</td> 
  </tr> 
  <tr> 
   <td>lib</td> 
   <td>类库</td> 
  </tr> 
  <tr> 
   <td>logs</td> 
   <td>日志目录</td> 
  </tr> 
  <tr> 
   <td>modules</td> 
   <td>模块目录</td> 
  </tr> 
  <tr> 
   <td>plugins</td> 
   <td>插件目录</td> 
  </tr> 
 </tbody> 
</table>

解压后，进入bin文件目录，点击elasticsearch.bat文件启动ES服务

![format_png 2][]

**注意：** **9300** **端口为** **Elastic** **s** **earch** **集群间组件的通信端口，** **9200** **端口为浏览器访问的http协议RESTful端口。**

打开浏览器（推荐使用谷歌浏览器），输入地址：[http://localhost:9200，测试结果][http_localhost_9200]

![format_png 3][]

#### **2** **.** **1** **.** **3** **问题解决** ####

Ø Elasticsearch是使用java开发的，且7.8版本的ES需要JDK版本1.8以上，默认安装包带有jdk环境，如果系统配置JAVA\_HOME，那么使用系统默认的JDK，如果没有配置使用自带的JDK，一般建议使用系统配置的JDK。

Ø 双击启动窗口闪退，通过路径访问追踪错误，如果是“空间不足”，请修改config/jvm.options配置文件

# 设置JVM初始内存为1G。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存
    
    # Xms represents the initial size of total heap space
    
    # 设置JVM最大可用内存为1G
    
    # Xmx represents the maximum size of total heap space
    -Xms1g
    -Xmx1g
    复制代码

### **2.** **2** **Elasticsearch基本操作** ###

#### **2** **.** **2** **.** **1 RESTful** ####

REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。Web 应用程序最重要的 REST 原则是，客户端和服务器之间的交互在请求之间是无状态的。从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何时间点重启，客户端不会得到通知。此外，无状态请求可以由任何可用服务器回答，这十分适合云计算之类的环境。客户端可以缓存数据以改进性能。

在服务器端，应用程序状态和功能可以分为各种资源。资源是一个有趣的概念实体，它向客户端公开。资源的例子有：应用程序对象、数据库记录、算法等等。每个资源都使用 URI (Universal Resource Identifier) 得到一个唯一的地址。所有资源都共享统一的接口，以便在客户端和服务器之间传输状态。使用的是标准的 HTTP 方法，比如 GET、PUT、POST 和 DELETE。

在 REST 样式的 Web 服务中，每个资源都有一个地址。资源本身都是方法调用的目标，方法列表对所有资源都是一样的。这些方法都是标准方法，包括 HTTP GET、POST、PUT、DELETE，还可能包括 HEAD 和 OPTIONS。简单的理解就是，如果想要访问互联网上的资源，就必须向资源所在的服务器发出请求，请求体中必须包含资源的网络路径，以及对资源进行的操作(增删改查)。

#### **2** **.** **2** **.** **2客户端安装**\*\*\*\* ####

如果直接通过浏览器向Elasticsearch服务器发请求，那么需要在发送的请求中包含HTTP标准的方法，而HTTP 的大部分特性且仅支持 GET和POST 方法。所以为了能方便地进行客户端的访问，可以使用Postman软件

Postman是一款强大的网页调试工具，提供功能强大的Web API 和 HTTP 请求调试。软件功能强大，界面简洁明晰、操作方便快捷，设计得很人性化。Postman中文版能够发送任何类型的HTTP 请求 (GET, HEAD, POST, PUT..)，不仅能够表单提交，且可以附带任意类型请求体。

Postman官网：[www.getpostman.com][]

Postman下载：[www.getpostman.com/apps][www.getpostman.com_apps]

![format_png 4][]

#### **2** **.** **2** **.** **3数据格式** ####

Elasticsearch是面向文档型数据库，一条数据在这里就是一个文档。为了方便大家理解，我们将Elasticsearch里存储文档数据和关系型数据库MySQL存储数据的概念进行一个类比

![format_png 5][]

ES里的Index可以看做一个库，而Types相当于表，Documents则相当于表的行。

这里Types的概念已经被逐渐弱化，Elasticsearch 6.X中，一个index下已经只能包含一个type，Elasticsearch 7.X中, Type的概念已经被删除了。

6用JSON作为文档序列化的格式，比如一条用户信息：

{
    
        "name" : "John",
    
        "sex" : "Male",
    
        "age" : 25,
    
        "birthDate": "1990/05/01",
    
        "about" : "I love to go rock climbing",
    
        "interests": [ "sports", "music" ]
    
    }
    复制代码

#### **2** **.** **2** **.** **4 HTTP操作** ####

**2** **.** **2** **.** **4** **.1** **索引操作**

1) **创建索引**\*\*\*\*

对比关系型数据库，创建索引就等同于创建数据库

在 Postman中，向ES服务器发**PUT**请求 ：[http://127.0.0.1:9200/shopping][http_127.0.0.1_9200_shopping]

![format_png 6][]

请求后，服务器返回响应

![format_png 7][]

{
    
        "acknowledged"【响应结果】: true, # true操作成功
    
        "shards_acknowledged"【分片结果】: true, # 分片操作成功
    
        "index"【索引名称】: "shopping"
    
    }
    
    # 注意：创建索引库的分片数默认1片，在7.0.0之前的Elasticsearch版本中，默认5片
    复制代码

如果重复添加索引，会返回错误信息

![format_png 8][]

2) **查看所有索引**

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/\_cat/indices?v][http_127.0.0.1_9200_cat_indices_v]

![format_png 9][]

这里请求路径中的\_cat表示查看的意思，indices表示索引，所以整体含义就是查看当前ES服务器中的所有索引，就好像MySQL中的show tables的感觉，服务器响应结果如下

<table> 
 <thead> 
  <tr> 
   <th>表头</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>health</td> 
   <td>当前服务器健康状态：<strong>green</strong>(集群完整) <strong>yellow</strong>(单点正常、集群不完整) red(单点不正常)</td> 
  </tr> 
  <tr> 
   <td>status</td> 
   <td>索引打开、关闭状态</td> 
  </tr> 
  <tr> 
   <td>index</td> 
   <td>索引名</td> 
  </tr> 
  <tr> 
   <td>uuid</td> 
   <td>索引统一编号</td> 
  </tr> 
  <tr> 
   <td>pri</td> 
   <td>主分片数量</td> 
  </tr> 
  <tr> 
   <td>rep</td> 
   <td>副本数量</td> 
  </tr> 
  <tr> 
   <td>docs.count</td> 
   <td>可用文档数量</td> 
  </tr> 
  <tr> 
   <td>docs.deleted</td> 
   <td>文档删除状态（逻辑删除）</td> 
  </tr> 
  <tr> 
   <td>store.size</td> 
   <td>主分片和副分片整体占空间大小</td> 
  </tr> 
  <tr> 
   <td>pri.store.size</td> 
   <td>主分片占空间大小</td> 
  </tr> 
 </tbody> 
</table>

3) **查看单个索引**

在 Postman中，向ES服务器发**GET**请[http://127.0.0.1:9200/shopping][http_127.0.0.1_9200_shopping]

![format_png 10][]

查看索引向ES服务器发送的请求路径和创建索引是一致的。但是HTTP方法不一致。这里可以体会一下RESTful的意义， 请求后，服务器响应结果如下：

{
    
        "shopping"【索引名】: {        
    
            "aliases"【别名】: {},
    
            "mappings"【映射】: {},
    
            "settings"【设置】: {
    
                "index"【设置 - 索引】: {
    
                    "creation_date"【设置 - 索引 - 创建时间】: "1614265373911",
    
                    "number_of_shards"【设置 - 索引 - 主分片数量】: "1",
    
                    "number_of_replicas"【设置 - 索引 - 副分片数量】: "1",
    
                    "uuid"【设置 - 索引 - 唯一标识】: "eI5wemRERTumxGCc1bAk2A",
    
                    "version"【设置 - 索引 - 版本】: {
    
                        "created": "7080099"
    
                    },
    
                    "provided_name"【设置 - 索引 - 名称】: "shopping"
    
                }
    
            }
    
        }
    
    }
    复制代码

4) **删除索引**\*\*\*\*

在 Postman中，向ES服务器发**DELETE**请求 ：[http://127.0.0.1:9200/shopping][http_127.0.0.1_9200_shopping]

![format_png 11][]

重新访问索引时，服务器返回响应：**索引不存在**

**2** **.** **2** **.** **4** **.** **2** **文档操作**

1) **创建文档**

索引已经创建好了，接下来我们来创建文档，并添加数据。这里的文档可以类比为关系型数据库中的表数据，添加的数据格式为JSON格式

在 Postman中，向ES服务器发**POST**请求 ：[http://127.0.0.1:9200/shopping/\_doc][http_127.0.0.1_9200_shopping_doc]

请求体内容为：

{
    
        "title":"小米手机",
    
        "category":"小米",
    
        "images":"http://www.gulixueyuan.com/xm.jpg",
    
        "price":3999.00
    
    }
    复制代码

![format_png 12][]

此处发送请求的方式必须为**POST**，不能是**PUT**，否则会发生错误

服务器响应结果如下：

![format_png 13][]

{
    
        "_index"【索引】: "shopping",
    
        "_type"【类型-文档】: "_doc",
    
        "_id"【唯一标识】: "Xhsa2ncBlvF_7lxyCE9G", #可以类比为MySQL中的主键，随机生成
    
        "_version"【版本】: 1,
    
        "result"【结果】: "created", #这里的create表示创建成功
    
        "_shards"【分片】: {
    
            "total"【分片 - 总数】: 2,
    
            "successful"【分片 - 成功】: 1,
    
            "failed"【分片 - 失败】: 0
    
        },
    
        "_seq_no": 0,
    
        "_primary_term": 1
    
    }
    复制代码

上面的数据创建后，由于没有指定数据唯一性标识（ID），默认情况下，ES服务器会随机生成一个。

如果想要自定义唯一性标识，需要在创建时指定：[http://127.0.0.1:9200/shopping/\_doc/1][http_127.0.0.1_9200_shopping_doc_1]

![format_png 14][]

此处需要注意：如果增加数据时明确数据主键，那么请求方式也可以为PUT

2) **查看文档**

查看文档时，需要指明文档的唯一性标识，类似于MySQL中数据的主键查询

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/shopping/\_doc/1][http_127.0.0.1_9200_shopping_doc_1]

![format_png 15][]

查询成功后，服务器响应结果：

![format_png 16][]

{
    
        "_index"【索引】: "shopping",
    
        "_type"【文档类型】: "_doc",
    
        "_id": "1",
    
        "_version": 2,
    
        "_seq_no": 2,
    
        "_primary_term": 2,
    
        "found"【查询结果】: true, # true表示查找到，false表示未查找到
    
        "_source"【文档源信息】: {
    
            "title": "华为手机",
    
            "category": "华为",
    
            "images": "http://www.gulixueyuan.com/hw.jpg",
    
            "price": 4999.00
    
        }
    
    }
    复制代码

3) **修改文档**\*\*\*\*

和新增文档一样，输入相同的URL地址请求，如果请求体变化，会将原有的数据内容覆盖

在 Postman中，向ES服务器发**POST**请求 ：

http://127.0.0.1:9200/shopping/_doc/1
    复制代码

请求体内容为:

{
    
        "title":"华为手机",
    
        "category":"华为",
    
        "images":"http://www.gulixueyuan.com/hw.jpg",
    
        "price":4999.00
    
    }
    复制代码

![format_png 17][]

修改成功后，服务器响应结果：

![format_png 18][]

{
    
        "_index": "shopping",
    
        "_type": "_doc",
    
        "_id": "1",
    
        "_version"【版本】: 2,
    
        "result"【结果】: "updated", # updated表示数据被更新
    
        "_shards": {
    
            "total": 2,
    
            "successful": 1,
    
            "failed": 0
    
        },
    
        "_seq_no": 2,
    
        "_primary_term": 2
    
    }
    复制代码

4) **修改字段**

修改数据时，也可以只修改某一给条数据的局部信息

在 Postman中，向ES服务器发**POST**请求 ：[http://127.0.0.1:9200/shopping/\_update/1][http_127.0.0.1_9200_shopping_update_1]

请求体内容为：

{
    
      "doc": {
    
        "price":3000.00
    
      }
    
    }
    复制代码

![format_png 19][]

修改成功后，服务器响应结果：

根据唯一性标识，查询文档数据，文档数据已经更新

![format_png 20][]

5) **删除文档**

删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）。

在 Postman中，向ES服务器发**DELETE**请求 ：[http://127.0.0.1:9200/shopping/\_doc/1][http_127.0.0.1_9200_shopping_doc_1]

![format_png 21][]

删除成功，服务器响应结果：

![format_png 22][]

{
    
        "_index": "shopping",
    
        "_type": "_doc",
    
        "_id": "1",
    
        "_version"【版本】: 4, #对数据的操作，都会更新版本
    
        "result"【结果】: "deleted", # deleted表示数据被标记为删除
    
        "_shards": {
    
            "total": 2,
    
            "successful": 1,
    
            "failed": 0
    
        },
    
        "_seq_no": 4,
    
        "_primary_term": 2
    
    }
    复制代码

删除后再查询当前文档信息

![format_png 23][]

如果删除一个并不存在的文档

{
    
        "_index": "shopping",
    
        "_type": "_doc",
    
        "_id": "1",
    
        "_version": 1,
    
        "result"【结果】: "not_found", # not_found表示未查找到
    
        "_shards": {
    
            "total": 2,
    
            "successful": 1,
    
            "failed": 0
    
        },
    
        "_seq_no": 5,
    
        "_primary_term": 2
    
    }
    复制代码

6) **条件删除文档**

一般删除数据都是根据文档的唯一性标识进行删除，实际操作时，也可以根据条件对多条数据进行删除

首先分别增加多条数据:

{
    
        "title":"小米手机",
    
        "category":"小米",
    
        "images":"http://www.gulixueyuan.com/xm.jpg",
    
        "price":4000.00
    
    }
    
     
    
    {
    
        "title":"华为手机",
    
        "category":"华为",
    
        "images":"http://www.gulixueyuan.com/hw.jpg",
    
        "price":4000.00
    
    }
    复制代码

![format_png 24][]

![format_png 25][]

向ES服务器发**POST**请求 ： [http://127.0.0.1:9200/shopping/\_delete\_by\_query][http_127.0.0.1_9200_shopping_delete_by_query] 请求体内容为：

{
    
      "query":{
    
        "match":{
    
          "price":4000.00
    
        }
    
      }
    
    }
    复制代码

![format_png 26][]

删除成功后，服务器响应结果：

{
    
        "took"【耗时】: 175,
    
        "timed_out"【是否超时】: false,
    
        "total"【总数】: 2,
    
        "deleted"【删除数量】: 2,
    
        "batches": 1,
    
        "version_conflicts": 0,
    
        "noops": 0,
    
        "retries": {
    
            "bulk": 0,
    
            "search": 0
    
        },
    
        "throttled_millis": 0,
    
        "requests_per_second": -1.0,
    
        "throttled_until_millis": 0,
    
        "failures": []
    
    }
    复制代码

**2** **.** **2** **.** **4** **.** **3** **映射操作**

有了索引库，等于有了数据库中的database。

接下来就需要建索引库(index)中的映射了，类似于数据库(database)中的表结构(table)。创建数据库表需要设置字段名称，类型，长度，约束等；索引库也一样，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做映射(mapping)。

1) **创建映射**\*\*\*\*

在 Postman中，向ES服务器发**PUT**请求 ：[http://127.0.0.1:9200/student/\_mapping][http_127.0.0.1_9200_student_mapping]

请求体内容为：

{
    
      "properties": {
    
        "name":{
    
          "type": "text",
    
          "index": true
    
        },
    
        "sex":{
    
          "type": "text",
    
          "index": false
    
        },
    
        "age":{
    
          "type": "long",
    
          "index": false
    
        }
    
      }
    
    }
    复制代码

![format_png 27][]

服务器响应结果如下：

映射数据说明：

*  字段名：任意填写，下面指定许多属性，例如：title、subtitle、images、price
 *  type：类型，Elasticsearch中支持的数据类型非常丰富，说几个关键的：
    
     *  String类型，又分两种：
        
         *  text：可分词
         *  keyword：不可分词，数据会作为完整字段进行匹配
 *  Numerical：数值类型，分两类
    
     *  基本数据类型：long、integer、short、byte、double、float、half\_float
     *  浮点数的高精度类型：scaled\_float
 *  Date：日期类型
 *  Array：数组类型
 *  Object：对象
 *  index：是否索引，默认为true，也就是说你不进行任何配置，所有字段都会被索引。
 *  true：字段会被索引，则可以用来进行搜索
 *  false：字段不会被索引，不能用来搜索
 *  store：是否将数据进行独立存储，默认为false
    
    > 原始的文本会存储在\_source里面，默认情况下其他提取出来的字段都不是独立存储的，是从\_source里面提取出来的。当然你也可以独立的存储某个字段，只要设置"store": true即可，获取独立存储的字段要比从\_source中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。
 *  analyzer：分词器，这里的ik\_max\_word即使用ik分词器,后面会有专门的章节学习

2) **查看映射**

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student][http_127.0.0.1_9200_student] **/\_mapping**\*\*\*\*

![format_png 28][]

服务器响应结果如下：

3) **索引映射关联**

在 Postman中，向ES服务器发**PUT**请求 ：[http://127.0.0.1:9200/student1][http_127.0.0.1_9200_student1]

{
    
      "settings": {},
    
      "mappings": {
    
      "properties": {
    
    "name":{
    
      "type": "text",
    
      "index": true
    
      
    
    },
    
    "sex":{
    
      "type": "text",
    
      "index": false
    
    },
    
    "age":{
    
      "type": "long",
    
      "index": false
    
    }
    
      }
    
      }
    
    }
    复制代码

![format_png 29][]

服务器响应结果如下：

**2** **.** **2** **.** **4** **.** **4** **高级查询**

Elasticsearch提供了基于JSON提供完整的查询DSL来定义查询

定义数据 :

# POST /student/_doc/1001
    
    {
    
    "name":"zhangsan",
    
    "nickname":"zhangsan",
    
        "sex":"男",
    
        "age":30
    
    }
    
    # POST /student/_doc/1002
    
    {
    
    "name":"lisi",
    
    "nickname":"lisi",
    
        "sex":"男",
    
        "age":20
    
    }
    
    # POST /student/_doc/1003
    
    {
    
    "name":"wangwu",
    
        "nickname":"wangwu",
    
        "sex":"女",
    
        "age":40
    
    }
    
    # POST /student/_doc/1004
    
    {
    
    "name":"zhangsan1",
    
    "nickname":"zhangsan1",
    
        "sex":"女",
    
        "age":50
    
    }
    
    # POST /student/_doc/1005
    
    {
    
    "name":"zhangsan2",
    
    "nickname":"zhangsan2",
    
        "sex":"女",
    
        "age":30
    
    }
    复制代码

1) **查询所有文档**\*\*\*\*

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "match_all": {}
    
      }
    
    }
    
    # "query"：这里的query代表一个查询对象，里面可以有不同的查询属性
    
    # "match_all"：查询类型，例如：match_all(代表查询所有)， match，term ， range 等等
    
    # {查询条件}：查询条件会根据类型的不同，写法也有差异
    复制代码

![format_png 30][]

服务器响应结果如下：

![format_png 31][]

{
    
      "took【查询花费时间，单位毫秒】" : 1116,
    
      "timed_out【是否超时】" : false,
    
      "_shards【分片信息】" : {
    
        "total【总数】" : 1,
    
        "successful【成功】" : 1,
    
        "skipped【忽略】" : 0,
    
        "failed【失败】" : 0
    
      },
    
      "hits【搜索命中结果】" : {
    
         "total"【搜索条件匹配的文档总数】: {
    
             "value"【总命中计数的值】: 3,
    
             "relation"【计数规则】: "eq" # eq 表示计数准确， gte表示计数不准确
    
         },
    
        "max_score【匹配度分值】" : 1.0,
    
        "hits【命中结果集合】" : [
    
           。。。
    
          }
    
        ]
    
      }
    
    }
    复制代码

2) **匹配查询**

match匹配类型查询，会把查询条件进行分词，然后进行查询，多个词条之间是or的关系

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "match": {
    
            "name":"zhangsan"
    
        }
    
      }
    
    }
    复制代码

![format_png 32][]

服务器响应结果为：

3) **字段匹配查询**

multi\_match与match类似，不同的是它可以在多个字段中查询。

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "multi_match": {
    
            "query": "zhangsan",
    
            "fields": ["name","nickname"]
    
        }
    
      }
    
    }
    复制代码

![format_png 33][]

服务器响应结果：

![format_png 34][]

4) **关键字精确查询**

term查询，精确的关键词匹配查询，不对查询条件进行分词。

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "term": {
    
          "name": {
    
            "value": "zhangsan"
    
          }
    
        }
    
      }
    
    }
    复制代码

![format_png 35][]

服务器响应结果：

![format_png 36][]

5) **多关键字精确查询**

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。

如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于mysql的in

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "terms": {
    
          "name": ["zhangsan","lisi"]
    
        }
    
      }
    
    }
    复制代码

![format_png 37][]

服务器响应结果：

![format_png 38][]

6) **指定查询字段**\*\*\*\*

默认情况下，Elasticsearch在搜索的结果中，会把文档中保存在\_source的所有字段都返回。

如果我们只想获取其中的部分字段，我们可以添加\_source的过滤

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "_source": ["name","nickname"],  
    
      "query": {
    
        "terms": {
    
          "nickname": ["zhangsan"]
    
        }
    
      }
    
    }
    复制代码

![format_png 39][]

服务器响应结果：

7) **过滤字段**

我们也可以通过：

Ø includes：来指定想要显示的字段

Ø excludes：来指定不想要显示的字段

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "_source": {
    
        "includes": ["name","nickname"]
    
      },  
    
      "query": {
    
        "terms": {
    
          "nickname": ["zhangsan"]
    
        }
    
      }
    
    }
    复制代码

![format_png 40][]

服务器响应结果：

![format_png 41][]

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "_source": {
    
        "excludes": ["name","nickname"]
    
      },  
    
      "query": {
    
        "terms": {
    
          "nickname": ["zhangsan"]
    
        }
    
      }
    
    }
    复制代码

![format_png 42][]

服务器响应结果：

![format_png 43][]

8) **组合查询**\*\*\*\*

`bool`把各种其它查询通过`must`（必须 ）、`must_not`（必须不）、`should`（应该）的方式进行组合

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "bool": {
    
          "must": [
    
            {
    
              "match": {
    
                "name": "zhangsan"
    
              }
    
            }
    
          ],
    
          "must_not": [
    
            {
    
              "match": {
    
                "age": "40"
    
              }
    
            }
    
          ],
    
          "should": [
    
            {
    
              "match": {
    
                "sex": "男"
    
              }
    
            }
    
          ]
    
        }
    
      }
    
    }
    复制代码

![format_png 44][]

服务器响应结果：

![format_png 45][]

9) **范围查询**

range 查询找出那些落在指定区间内的数字或者时间。range查询允许以下字符

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "range": {
    
          "age": {
    
            "gte": 30,
    
            "lte": 35
    
          }
    
        }
    
      }
    
    }
    复制代码

![format_png 46][]

服务器响应结果：

![format_png 47][]

10) **模糊查询**

返回包含与搜索字词相似的字词的文档。

编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：

l 更改字符（box → fox）

l 删除字符（black → lack）

l 插入字符（sic → sick）

l 转置两个相邻字符（act → cat）

为了找到相似的术语，fuzzy查询会在指定的编辑距离内创建一组搜索词的所有可能的变体或扩展。然后查询返回每个扩展的完全匹配。

通过fuzziness修改编辑距离。一般使用默认值AUTO，根据术语的长度生成编辑距离。

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "fuzzy": {
    
          "title": {
    
            "value": "zhangsan"
    
          }
    
        }
    
      }
    
    }
    复制代码

![format_png 48][]

服务器响应结果：

![format_png 49][]

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "fuzzy": {
    
          "title": {
    
            "value": "zhangsan",
    
    "fuzziness": 2
    
          }
    
        }
    
      }
    
    }
    复制代码

![format_png 50][]

服务器响应结果：

11) **单字段排序**

sort 可以让我们按照不同的字段进行排序，并且通过order指定排序的方式。desc降序，asc升序。

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "match": {
    
            "name":"zhangsan"
    
        }
    
      },
    
      "sort": [{
    
        "age": {
    
            "order":"desc"
    
        }
    
      }]
    
    }
    复制代码

![format_png 51][]

服务器响应结果：

12) **多字段排序**

假定我们想要结合使用 age和 \_score进行查询，并且匹配的结果首先按照年龄排序，然后按照相关性得分排序

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "match_all": {}
    
      },
    
      "sort": [
    
        {
    
          "age": {
    
            "order": "desc"
    
          }
    
        },
    
        {
    
          "_score":{
    
            "order": "desc"
    
          }
    
        }
    
      ]
    
    }
    复制代码

![format_png 52][]

服务器响应结果：

![format_png 53][]

13) **高亮查询**

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。

Ø 在百度搜索"京东"

![format_png 54][]

Elasticsearch可以对查询内容中的关键字部分，进行标签和样式(高亮)的设置。

在使用match查询的同时，加上一个highlight属性：

l pre\_tags：前置标签

l post\_tags：后置标签

l fields：需要高亮的字段

l title：这里声明title字段需要高亮，后面可以为这个字段设置特有配置，也可以空

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "match": {
    
          "name": "zhangsan"
    
        }
    
      },
    
      "highlight": {
    
        "pre_tags": "<font color='red'>",
    
        "post_tags": "</font>",
    
        "fields": {
    
          "name": {}
    
        }
    
      }
    
    }
    复制代码

![format_png 55][]

服务器响应结果：

![format_png 56][]

14) **分页查询**

from：当前页的起始索引，默认从0开始。 from = (pageNum - 1) \* size

size：每页显示多少条

在 Postman中，向ES服务器发**GET**请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
      "query": {
    
        "match_all": {}
    
      },
    
      "sort": [
    
        {
    
          "age": {
    
            "order": "desc"
    
          }
    
        }
    
      ],
    
      "from": 0,
    
      "size": 2
    
    }
    复制代码

![format_png 57][]

服务器响应结果：

15) **聚合查询**

聚合允许使用者对es文档进行统计分析，类似与关系型数据库中的group by，当然还有很多其他的聚合，例如取最大值、平均值等等。

Ø 对某个字段取最大值max

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
        "aggs":{
    
          "max_age":{
    
            "max":{"field":"age"}
    
          }
    
        },
    
        "size":0
    
    }
    复制代码

![format_png 58][]

服务器响应结果：

Ø 对某个字段取最小值min

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
        "aggs":{
    
          "min_age":{
    
            "min":{"field":"age"}
    
          }
    
        },
    
        "size":0
    
    }
    复制代码

![format_png 59][]

服务器响应结果：

![format_png 60][]

Ø 对某个字段求和sum

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
        "aggs":{
    
          "sum_age":{
    
            "sum":{"field":"age"}
    
          }
    
        },
    
        "size":0
    
    }
    复制代码

![format_png 61][]

服务器响应结果：

![format_png 62][]

Ø 对某个字段取平均值avg

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
        "aggs":{
    
          "avg_age":{
    
            "avg":{"field":"age"}
    
          }
    
        },
    
        "size":0
    
    }
    复制代码

![format_png 63][]

服务器响应结果：

![format_png 64][]

Ø 对某个字段的值进行去重之后再取总数

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
        "aggs":{
    
          "distinct_age":{
    
            "cardinality":{"field":"age"}
    
          }
    
        },
    
        "size":0
    
    }
    复制代码

![format_png 65][]

服务器响应结果： Ø State聚合

stats聚合，对某个字段一次性返回count，max，min，avg和sum五个指标

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
        "aggs":{
    
          "stats_age":{
    
            "stats":{"field":"age"}
    
          }
    
        },
    
        "size":0
    
    }
    复制代码

![format_png 66][]

服务器响应结果：

![format_png 67][]

16) **桶聚合查询**

桶聚和相当于sql中的group by语句

Ø terms聚合，分组统计

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

{
    
        "aggs":{
    
          "age_groupby":{
    
            "terms":{"field":"age"}
    
          }
    
        },
    
        "size":0
    
    }
    复制代码

![format_png 68][]

服务器响应结果：

Ø 在terms分组下再进行聚合

在 Postman中，向ES服务器发GET请求 ：[http://127.0.0.1:9200/student/\_search][http_127.0.0.1_9200_student_search]

![format_png 69][]

服务器响应结果：

![format_png 70][]

#### **2** **.** **2** **.** **5 Java API操作** ####

Elasticsearch软件是由Java语言开发的，所以也可以通过Java API的方式对Elasticsearch服务进行访问

**2** **.** **2** **.** **5** **.1** **创建Maven项目**

我们在IDEA开发工具中创建Maven项目(模块也可)ES

![format_png 71][]

修改pom文件，增加Maven依赖关系

<dependencies>
    
        <dependency>
    
            <groupId>org.elasticsearch</groupId>
    
            <artifactId>elasticsearch</artifactId>
    
            <version>**7.8.0**</version>
    
        </dependency>
    
        
    
        <dependency>
    
            <groupId>org.elasticsearch.client</groupId>
    
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
    
            <version>**7.8.0**</version>
    
        </dependency>
    
        
    
        <dependency>
    
            <groupId>org.apache.logging.log4j</groupId>
    
            <artifactId>log4j-api</artifactId>
    
            <version>2.8.2</version>
    
        </dependency>
    
        <dependency>
    
            <groupId>org.apache.logging.log4j</groupId>
    
            <artifactId>log4j-core</artifactId>
    
            <version>2.8.2</version>
    
    </dependency>
    
    <dependency>
    
    <groupId>com.fasterxml.jackson.core</groupId>
    
    <artifactId>jackson-databind</artifactId>
    
    <version>2.9.9</version>
    
    </dependency>
    
        
    
        <dependency>
    
            <groupId>junit</groupId>
    
            <artifactId>junit</artifactId>
    
            <version>4.12</version>
    
        </dependency>
    
    </dependencies>
    复制代码

**2** **.** **2** **.** **5** **.** **2** **客户端对象**

创建com.atguigu.es.test.Elasticsearch01\_Client类，代码中创建Elasticsearch客户端对象

因为早期版本的客户端对象已经不再推荐使用，且在未来版本中会被删除，所以这里我们采用高级REST客户端对象

![format_png 72][]

// 创建客户端对象
    
    RestHighLevelClient client = new RestHighLevelClient(
    
    RestClient.builder(new HttpHost("localhost", 9200, "http"))
    
    );
    
    ...
    // 关闭客户端连接
    
    client.close();
    复制代码

**注意：** **9200**端口为Elasticsearch的Web通信端口 **，** **localhost**为启动ES服务的主机名 执行代码，查看控制台信息：

![format_png 73][]

**2** **.** **2** **.** **5** **.** **3** **索引操作**

ES服务器正常启动后，可以通过Java API 客户端对象对ES索引进行操作

1) **创建索引**

// 创建索引 - 请求对象
    
    CreateIndexRequest request = new CreateIndexRequest("user");
    
    // 发送请求，获取响应
    
    CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
    
    boolean acknowledged = response.isAcknowledged();
    
    // 响应状态
    
    System.out.println("操作状态 = " + acknowledged);
    复制代码

操作结果:

![format_png 74][]

2) **查看索引**

// 查询索引 - 请求对象
    
    GetIndexRequest request = new GetIndexRequest("user");
    
    // 发送请求，获取响应
    
    GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
    
    System.out.println("aliases:"+response.getAliases());
    
    System.out.println("mappings:"+response.getMappings());
    
    System.out.println("settings:"+response.getSettings());
    复制代码

操作结果:

![format_png 75][]

3) **删除索引**

// 删除索引 - 请求对象
    
    DeleteIndexRequest request = new DeleteIndexRequest("user");
    
    // 发送请求，获取响应
    
    AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
    
    // 操作结果
    
    System.out.println("操作结果 ： " + response.isAcknowledged());
    复制代码

操作结果:

![format_png 76][]

**2** **.** **2** **.** **5** **.** **4** **文档操作**

1) **新增文档**

创建数据模型

class User {                         
    
        private String name;             
    
        private Integer age;             
    
        private String sex;              
    
                                         
    
        public String getName() {        
    
            return name;                 
    
        }                                
    
        public void setName(String name)
    
            this.name = name;            
    
        }                                
    
        public Integer getAge() {        
    
            return age;                  
    
        }                                
    
        public void setAge(Integer age) {
    
            this.age = age;              
    
        }                                
    
        public String getSex() {         
    
            return sex;                  
    
        }                                
    
        public void setSex(String sex) {
    
            this.sex = sex;              
    
        }                                
    
    }                                    
    复制代码

创建数据，添加到文档中

// 新增文档 - 请求对象
    
    IndexRequest request = new IndexRequest();
    
    // 设置索引及唯一性标识
    
    request.index("user").id("1001");
    
    // 创建数据对象
    
    User user = new User();
    
    user.setName("zhangsan");
    
    user.setAge(30);
    
    user.setSex("男");
    
    ObjectMapper objectMapper = new ObjectMapper();
    
    String productJson = objectMapper.writeValueAsString(user);
    
    // 添加文档数据，数据格式为JSON格式
    
    request.source(productJson,XContentType.JSON);
    
    // 客户端发送请求，获取响应对象
    
    IndexResponse response = client.index(request, RequestOptions.DEFAULT);
    
    3.打印结果信息
    
    System.out.println("_index:" + response.getIndex());
    
    System.out.println("_id:" + response.getId());
    
    System.out.println("_result:" + response.getResult());                           
    复制代码

操作结果:

![format_png 77][]

2) **修改文档**

// 修改文档 - 请求对象
    
    UpdateRequest request = new UpdateRequest();
    
    // 配置修改参数
    
    request.index("user").id("1001");
    
    // 设置请求体，对数据进行修改
    
    request.doc(XContentType.JSON, "sex", "女");
    
    // 客户端发送请求，获取响应对象
    
    UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
    
    System.out.println("_index:" + response.getIndex());
    
    System.out.println("_id:" + response.getId());
    
    System.out.println("_result:" + response.getResult());
    
    复制代码

执行结果：

![format_png 78][]

3) **查询文档**

//1.创建请求对象
    
    GetRequest request = new GetRequest().index("user").id("1001");
    
    //2.客户端发送请求，获取响应对象
    
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    
    3.打印结果信息
    
    System.out.println("_index:" + response.getIndex());
    
    System.out.println("_type:" + response.getType());
    
    System.out.println("_id:" + response.getId());
    
    System.out.println("source:" + response.getSourceAsString());
    复制代码

执行结果为：

![format_png 79][]

4) **删除文档**

//创建请求对象
    
    DeleteRequest request = new DeleteRequest().index("user").id("1");
    
    //客户端发送请求，获取响应对象
    
    DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
    
    //打印信息
    
    System.out.println(response.toString());
    复制代码

执行结果为：

![format_png 80][]

5) **批量操作**\*\*\*\*

Ø 批量新增：

//创建批量新增请求对象
    
    BulkRequest request = new BulkRequest();
    
    request.add(new IndexRequest().index("user").id("1001").source(XContentType.JSON, "name", "zhangsan"));
    
    request.add(new IndexRequest().index("user").id("1002").source(XContentType.JSON, "name", "lisi"));
    
    request.add(new IndexRequest().index("user").id("1003").source(XContentType.JSON, "name", "wangwu"));
    
    //客户端发送请求，获取响应对象
    
    BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
    
    //打印结果信息
    
    System.out.println("took:" + responses.getTook());
    
    System.out.println("items:" + responses.getItems());
    复制代码

执行结果为：

![format_png 81][]

Ø 批量删除：

//创建批量删除请求对象
    
    BulkRequest request = new BulkRequest();
    
    request.add(new DeleteRequest().index("user").id("1001"));
    
    request.add(new DeleteRequest().index("user").id("1002"));
    
    request.add(new DeleteRequest().index("user").id("1003"));
    
    //客户端发送请求，获取响应对象
    
    BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
    
    //打印结果信息
    
    System.out.println("took:" + responses.getTook());
    
    System.out.println("items:" + responses.getItems());
    复制代码

执行结果为：

![format_png 82][]

**2** **.** **2** **.** **5** **.** **5** **高级查询**

1) **请求体查询**\*\*\*\*

Ø 查询所有索引数据

// 创建搜索请求对象
    
    SearchRequest request = new SearchRequest();
    
    request.indices("student");
    
     
    
    // 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    // 查询所有数据
    
    sourceBuilder.query(QueryBuilders.**matchAllQuery**());
    
    request.source(sourceBuilder);
    
     
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 83][]

Ø term查询，查询条件为关键字

// 创建搜索请求对象
    
    SearchRequest request = new SearchRequest();
    
    request.indices("student");
    
     
    
    // 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    sourceBuilder.query(QueryBuilders.**termQuery**("age", "30"));
    
    request.source(sourceBuilder);
    
     
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 84][]

Ø 分页查询

// 创建搜索请求对象
    
    SearchRequest request = new SearchRequest();
    
    request.indices("student");
    
     
    
    // 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    
     
    
    // 分页查询
    
    // 当前页其实索引(第一条数据的顺序号)，from
    
    sourceBuilder.from(0);
    
    // 每页显示多少条size
    
    sourceBuilder.size(2);
    
     
    
    request.source(sourceBuilder);
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 85][]

Ø 数据排序

// 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    
     
    
    // 排序
    
    sourceBuilder.sort("age", SortOrder.ASC);
    
     
    
    request.source(sourceBuilder);
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 86][]

Ø 过滤字段

// 创建搜索请求对象
    
    SearchRequest request = new SearchRequest();
    
    request.indices("student");
    
     
    
    // 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    
     
    
    //查询字段过滤
    
    String[] excludes = {};
    
    String[] includes = {"name", "age"};
    
    sourceBuilder.fetchSource(includes, excludes);
    
     
    
    request.source(sourceBuilder);
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 87][]

Ø Bool查询

// 创建搜索请求对象
    
    SearchRequest request = new SearchRequest();
    
    request.indices("student");
    
     
    
    // 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
     
    
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    
    // 必须包含
    
    boolQueryBuilder.must(QueryBuilders.matchQuery("age", "30"));
    
    // 一定不含
    
    boolQueryBuilder.mustNot(QueryBuilders.matchQuery("name", "zhangsan"));
    
    // 可能包含
    
    boolQueryBuilder.should(QueryBuilders.matchQuery("sex", "男"));
    
     
    
    sourceBuilder.query(boolQueryBuilder);
    
    request.source(sourceBuilder);
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 88][]

Ø 范围查询

// 创建搜索请求对象
    
    SearchRequest request = new SearchRequest();
    
    request.indices("student");
    
     
    
    // 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
     
    
    RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
    
    // 大于等于
    
    rangeQuery.gte("30");
    
    // 小于等于
    
    rangeQuery.lte("40");
    
     
    
    sourceBuilder.query(rangeQuery);
    
    request.source(sourceBuilder);
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 89][]

Ø 模糊查询

// 创建搜索请求对象
    
    SearchRequest request = new SearchRequest();
    
    request.indices("student");
    
     
    
    // 构建查询的请求体
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
     
    
    sourceBuilder.query(QueryBuilders.fuzzyQuery("name","zhangsan").fuzziness(Fuzziness.ONE));
    
    request.source(sourceBuilder);
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
    // 查询匹配
    
    SearchHits hits = response.getHits();
    
    System.out.println("took:" + response.getTook());
    
    System.out.println("timeout:" + response.isTimedOut());
    
    System.out.println("total:" + hits.getTotalHits());
    
    System.out.println("MaxScore:" + hits.getMaxScore());
    
    System.out.println("hits========>>");
    
    for (SearchHit hit : hits) {
    
    //输出每条查询的结果信息
    
    System.out.println(hit.getSourceAsString());
    
    }
    
    System.out.println("<<========");
    复制代码

![format_png 90][]

2) **高亮查询**\*\*\*\*

// 高亮查询
    
    SearchRequest request = new SearchRequest().indices("student");
    
    //2.创建查询请求体构建器
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    //构建查询方式：高亮查询
    
    TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("name","zhangsan");
    
    //设置查询方式
    
    sourceBuilder.query(termsQueryBuilder);
    
    //构建高亮字段
    
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    
    highlightBuilder.preTags("<font color='red'>");//设置标签前缀
    
    highlightBuilder.postTags("</font>");//设置标签后缀
    
    highlightBuilder.field("name");//设置高亮字段
    
    //设置高亮构建对象
    
    sourceBuilder.highlighter(highlightBuilder);
    
    //设置请求体
    
    request.source(sourceBuilder);
    
    //3.客户端发送请求，获取响应对象
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
     
    
    //4.打印响应结果
    
    SearchHits hits = response.getHits();
    
    System.out.println("took::"+response.getTook());
    
    System.out.println("time_out::"+response.isTimedOut());
    
    System.out.println("total::"+hits.getTotalHits());
    
    System.out.println("max_score::"+hits.getMaxScore());
    
    System.out.println("hits::::>>");
    
    for (SearchHit hit : hits) {
    
    String sourceAsString = hit.getSourceAsString();
    
    System.out.println(sourceAsString);
    
    //打印高亮结果
    
    Map<String, HighlightField> highlightFields = hit.getHighlightFields();
    
    System.out.println(highlightFields);
    
    }
    
    System.out.println("<<::::");
    复制代码

![format_png 91][]

3) **聚合查询**

Ø 最大年龄

// 高亮查询
    
    SearchRequest request = new SearchRequest().indices("student");
    
     
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    sourceBuilder.aggregation(AggregationBuilders.max("maxAge").field("age"));
    
    //设置请求体
    
    request.source(sourceBuilder);
    
    //3.客户端发送请求，获取响应对象
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
     
    
    //4.打印响应结果
    
    SearchHits hits = response.getHits();
    
    System.out.println(response);
    复制代码

![format_png 92][]

Ø 分组统计

// 高亮查询
    
    SearchRequest request = new SearchRequest().indices("student");
    
     
    
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    
    sourceBuilder.aggregation(AggregationBuilders.terms("age_groupby").field("age"));
    
     
    
    //设置请求体
    
    request.source(sourceBuilder);
    
    //3.客户端发送请求，获取响应对象
    
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    
     
    
    //4.打印响应结果
    
    SearchHits hits = response.getHits();
    
    System.out.println(response);
    复制代码

![format_png 93][]

[www.elastic.co_cn]: https://link.juejin.cn?target=https%3A%2F%2Fwww.elastic.co%2Fcn%2F
[www.elastic.co_cn_download]: https://link.juejin.cn?target=https%3A%2F%2Fwww.elastic.co%2Fcn%2Fdownloads%2Fpast-releases%23elasticsearch
[format_png]: https://img-blog.csdnimg.cn/img_convert/6b6f463d47d8630baed7552d1bd61c07.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/563c162868a0b30a1578d0d050c5cc1a.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/39d5d85b8f89447a466d9478a02ccfa0.webp?x-oss-process=image/format,png
[http_localhost_9200]: https://link.juejin.cn?target=http%3A%2F%2Flocalhost%3A9200%25EF%25BC%258C%25E6%25B5%258B%25E8%25AF%2595%25E7%25BB%2593%25E6%259E%259C
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/9287b298f19884f1cb6280aff4177fab.webp?x-oss-process=image/format,png
[www.getpostman.com]: https://link.juejin.cn?target=https%3A%2F%2Fwww.getpostman.com
[www.getpostman.com_apps]: https://link.juejin.cn?target=https%3A%2F%2Fwww.getpostman.com%2Fapps
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/f5a3198a905fb29da67ce40d86b52866.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/bbf700f76fbf66473de262fc0a5b21ae.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_shopping]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fshopping
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/9103e20ce4e45840576ca2de0bd5a5f1.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/b159e9643976fd611c0156c4271af2de.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/5a8994adee363281533ae4dc2443839e.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_cat_indices_v]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2F_cat%2Findices%3Fv
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/907863a09ab25e444cb3346bb0e07d0b.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/090dd4f06e20a47d140adb7abc803d16.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/ae23d437a9841cc1a54c36b6c590cada.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_shopping_doc]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fshopping%2F_doc
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/e276258fc9a87e53e8cb31cd3415dccc.webp?x-oss-process=image/format,png
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/7c877568048c3d8f1789e3e3b1bfd38c.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_shopping_doc_1]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fshopping%2F_doc%2F1
[format_png 14]: https://img-blog.csdnimg.cn/img_convert/2f3e866c65a8be4b78f92132d2a80e5f.webp?x-oss-process=image/format,png
[format_png 15]: https://img-blog.csdnimg.cn/img_convert/21002103b6437ad73acda3a3609ee4cd.webp?x-oss-process=image/format,png
[format_png 16]: https://img-blog.csdnimg.cn/img_convert/cdc1d4685a3102f5c7891e17340757ac.webp?x-oss-process=image/format,png
[format_png 17]: https://img-blog.csdnimg.cn/img_convert/c0af97959a01fbdd8424215593bf08db.webp?x-oss-process=image/format,png
[format_png 18]: https://img-blog.csdnimg.cn/img_convert/439bd10ec516c3eb3b7f0e37432e698a.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_shopping_update_1]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fshopping%2F_update%2F1
[format_png 19]: https://img-blog.csdnimg.cn/img_convert/a9517076c2d7cd5339928bb735a33515.webp?x-oss-process=image/format,png
[format_png 20]: https://img-blog.csdnimg.cn/img_convert/8c4253ecbb546d217b474c76e226cd02.webp?x-oss-process=image/format,png
[format_png 21]: https://img-blog.csdnimg.cn/img_convert/44de51c4744809ee327f22178b006c06.webp?x-oss-process=image/format,png
[format_png 22]: https://img-blog.csdnimg.cn/img_convert/5ca588f4c11e7d0cba212d980e34f5f6.webp?x-oss-process=image/format,png
[format_png 23]: https://img-blog.csdnimg.cn/img_convert/42a4828306587a9aa003ef172664390a.webp?x-oss-process=image/format,png
[format_png 24]: https://img-blog.csdnimg.cn/img_convert/d1a8158a4313fd0d0881764638a10b16.webp?x-oss-process=image/format,png
[format_png 25]: https://img-blog.csdnimg.cn/img_convert/0397c87dcd9f78966fc9cd21470280bd.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_shopping_delete_by_query]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fshopping%2F_delete_by_query
[format_png 26]: https://img-blog.csdnimg.cn/img_convert/ae0fccb31cab971ab58a385f7fc7a849.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_student_mapping]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fstudent%2F_mapping
[format_png 27]: https://img-blog.csdnimg.cn/img_convert/c2523a06a7962fdc0c2611b5a5ef9031.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_student]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fstudent
[format_png 28]: https://img-blog.csdnimg.cn/img_convert/3d4696a91a2d2b3fb7f65b3e4a1571e3.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_student1]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fstudent1
[format_png 29]: https://img-blog.csdnimg.cn/img_convert/a3aa95ea3f0cc9b585a635ddb1857a8b.webp?x-oss-process=image/format,png
[http_127.0.0.1_9200_student_search]: https://link.juejin.cn?target=http%3A%2F%2F127.0.0.1%3A9200%2Fstudent%2F_search
[format_png 30]: https://img-blog.csdnimg.cn/img_convert/8a41c29b981e3e0ad182710999cb1870.webp?x-oss-process=image/format,png
[format_png 31]: https://img-blog.csdnimg.cn/img_convert/50d698d0ef42c7a87e5a845f048afd26.webp?x-oss-process=image/format,png
[format_png 32]: https://img-blog.csdnimg.cn/img_convert/833dc07f89a0588a16f6b0bfb76c1fd3.webp?x-oss-process=image/format,png
[format_png 33]: https://img-blog.csdnimg.cn/img_convert/6b212327b10b77c216efdaa4f80a9f1b.webp?x-oss-process=image/format,png
[format_png 34]: https://img-blog.csdnimg.cn/img_convert/1c3be4a6bab076accbc42a155c93b2eb.webp?x-oss-process=image/format,png
[format_png 35]: https://img-blog.csdnimg.cn/img_convert/086adb1521b434451f3bb5778a69bd64.webp?x-oss-process=image/format,png
[format_png 36]: https://img-blog.csdnimg.cn/img_convert/c4430fe18024932fb0ffc51bf6a7d517.webp?x-oss-process=image/format,png
[format_png 37]: https://img-blog.csdnimg.cn/img_convert/9d86c5fa9e7f0a251acd6c1f69881b30.webp?x-oss-process=image/format,png
[format_png 38]: https://img-blog.csdnimg.cn/img_convert/523082e06b3da4352f4de52524af7c17.webp?x-oss-process=image/format,png
[format_png 39]: https://img-blog.csdnimg.cn/img_convert/423cc9fbc1c763e356267910f642931c.webp?x-oss-process=image/format,png
[format_png 40]: https://img-blog.csdnimg.cn/img_convert/76fd7cdcfb45d53980e8b88c277c227a.webp?x-oss-process=image/format,png
[format_png 41]: https://img-blog.csdnimg.cn/img_convert/76bee2488405a0d1b68828e4c97f2348.webp?x-oss-process=image/format,png
[format_png 42]: https://img-blog.csdnimg.cn/img_convert/4a1869d9c0366ee506a6f36d6711c2d9.webp?x-oss-process=image/format,png
[format_png 43]: https://img-blog.csdnimg.cn/img_convert/35f009097c4e0cf261ad35b68413e320.webp?x-oss-process=image/format,png
[format_png 44]: https://img-blog.csdnimg.cn/img_convert/12c56dcdb1e9459217c9708fc0c157fb.webp?x-oss-process=image/format,png
[format_png 45]: https://img-blog.csdnimg.cn/img_convert/15ff368e0aa1d8ddbc8c7f824d0c753b.webp?x-oss-process=image/format,png
[format_png 46]: https://img-blog.csdnimg.cn/img_convert/d1422b08eb695ab751e1d4d492a4b3de.webp?x-oss-process=image/format,png
[format_png 47]: https://img-blog.csdnimg.cn/img_convert/bd4ff8de4010781e5c84c3138d7c1d15.webp?x-oss-process=image/format,png
[format_png 48]: https://img-blog.csdnimg.cn/img_convert/6e3d4d47c0491b352c59a8d8852f1b48.webp?x-oss-process=image/format,png
[format_png 49]: https://img-blog.csdnimg.cn/img_convert/6611c4ea792e1ab6492fc628b232e18d.webp?x-oss-process=image/format,png
[format_png 50]: https://img-blog.csdnimg.cn/img_convert/63b1d9ca239748e013cb869d001086be.webp?x-oss-process=image/format,png
[format_png 51]: https://img-blog.csdnimg.cn/img_convert/8e8e40a2354e5b271b6ffe2855741819.webp?x-oss-process=image/format,png
[format_png 52]: https://img-blog.csdnimg.cn/img_convert/e45f0690149332109d84b94ccbf34f5f.webp?x-oss-process=image/format,png
[format_png 53]: https://img-blog.csdnimg.cn/img_convert/a0daf1e58a064b485175829e7904a073.webp?x-oss-process=image/format,png
[format_png 54]: https://img-blog.csdnimg.cn/img_convert/4a13c1ac8b00fa76b6d87f695325dc71.webp?x-oss-process=image/format,png
[format_png 55]: https://img-blog.csdnimg.cn/img_convert/b3aa0163b3d60ba1910f5209c9996329.webp?x-oss-process=image/format,png
[format_png 56]: https://img-blog.csdnimg.cn/img_convert/27602526f3af4d835f9b98264825454f.webp?x-oss-process=image/format,png
[format_png 57]: https://img-blog.csdnimg.cn/img_convert/8176d4d965634693ad094db002d76ba8.webp?x-oss-process=image/format,png
[format_png 58]: https://img-blog.csdnimg.cn/img_convert/619a716ee3ee913981ab4f9e7d8efceb.webp?x-oss-process=image/format,png
[format_png 59]: https://img-blog.csdnimg.cn/img_convert/6a3b7cbfe2f03c07f70a96e436b950e6.webp?x-oss-process=image/format,png
[format_png 60]: https://img-blog.csdnimg.cn/img_convert/d464e2309f73f77f19975d1e738e5dca.webp?x-oss-process=image/format,png
[format_png 61]: https://img-blog.csdnimg.cn/img_convert/22dfaaebcc23911d6ec495fd6326167c.webp?x-oss-process=image/format,png
[format_png 62]: https://img-blog.csdnimg.cn/img_convert/2f722cf947acd63252f78100ddc2f509.webp?x-oss-process=image/format,png
[format_png 63]: https://img-blog.csdnimg.cn/img_convert/82fb3f5f09961a578dac922f7eac0c64.webp?x-oss-process=image/format,png
[format_png 64]: https://img-blog.csdnimg.cn/img_convert/e2cf2a9e1f2adaa2def94b290bf404f7.webp?x-oss-process=image/format,png
[format_png 65]: https://img-blog.csdnimg.cn/img_convert/1636525adf776c31e12a497030d6d042.webp?x-oss-process=image/format,png
[format_png 66]: https://img-blog.csdnimg.cn/img_convert/e706f1ba36aad5069ba423b02052e912.webp?x-oss-process=image/format,png
[format_png 67]: https://img-blog.csdnimg.cn/img_convert/00404c5ae98dca084636026ec66ee521.webp?x-oss-process=image/format,png
[format_png 68]: https://img-blog.csdnimg.cn/img_convert/bd104b030ebd933b9d3167cb37380cf6.webp?x-oss-process=image/format,png
[format_png 69]: https://img-blog.csdnimg.cn/img_convert/99994b36ab8f146d444bdfeef58be308.webp?x-oss-process=image/format,png
[format_png 70]: https://img-blog.csdnimg.cn/img_convert/634a88248c75234667bc757bfd1e95c1.webp?x-oss-process=image/format,png
[format_png 71]: https://img-blog.csdnimg.cn/img_convert/a7cac1cabaf0cd8ca4269b6ba46d1f46.webp?x-oss-process=image/format,png
[format_png 72]: https://img-blog.csdnimg.cn/img_convert/77771466f6cc9f6b842a3bce3340b980.webp?x-oss-process=image/format,png
[format_png 73]: https://img-blog.csdnimg.cn/img_convert/b558ef98ba50244e28b691d35d6047ce.webp?x-oss-process=image/format,png
[format_png 74]: https://img-blog.csdnimg.cn/img_convert/ff5de674ad44dba1def6fc4986e777ee.webp?x-oss-process=image/format,png
[format_png 75]: https://img-blog.csdnimg.cn/img_convert/3fd32fd6b92e02473046d31bfcca591a.webp?x-oss-process=image/format,png
[format_png 76]: https://img-blog.csdnimg.cn/img_convert/c6583bdc3f773edaedee8e096946d817.webp?x-oss-process=image/format,png
[format_png 77]: https://img-blog.csdnimg.cn/img_convert/e9485d522a91d56a01248eabe40ea0be.webp?x-oss-process=image/format,png
[format_png 78]: https://img-blog.csdnimg.cn/img_convert/7e393ff1db7481dc18bde6caf7afd390.webp?x-oss-process=image/format,png
[format_png 79]: https://img-blog.csdnimg.cn/img_convert/7fdb4d7601f8049ef9b3af1b91abc521.webp?x-oss-process=image/format,png
[format_png 80]: https://img-blog.csdnimg.cn/img_convert/027fd39fa27779a79e8a39f9aef68578.webp?x-oss-process=image/format,png
[format_png 81]: https://img-blog.csdnimg.cn/img_convert/16819a55e55f0a2db26c33aad54af1f3.webp?x-oss-process=image/format,png
[format_png 82]: https://img-blog.csdnimg.cn/img_convert/88bb26996beba978ad4f062d610454ec.webp?x-oss-process=image/format,png
[format_png 83]: https://img-blog.csdnimg.cn/img_convert/45a199d3d5f1f46d164d792b198eadca.webp?x-oss-process=image/format,png
[format_png 84]: https://img-blog.csdnimg.cn/img_convert/1ff927d6c570cf84b8fa1953edf12670.webp?x-oss-process=image/format,png
[format_png 85]: https://img-blog.csdnimg.cn/img_convert/0f743f7b203cf1a9b046afe01bb4b271.webp?x-oss-process=image/format,png
[format_png 86]: https://img-blog.csdnimg.cn/img_convert/1826aab1662bb8e63586a06b735f0e5a.webp?x-oss-process=image/format,png
[format_png 87]: https://img-blog.csdnimg.cn/img_convert/d40a49f07ff471cb3a43885fed064683.webp?x-oss-process=image/format,png
[format_png 88]: https://img-blog.csdnimg.cn/img_convert/45445d518ad1a614e7bd4d52ab981c66.webp?x-oss-process=image/format,png
[format_png 89]: https://img-blog.csdnimg.cn/img_convert/16f213e80e9fa4f8a008f8e5dbb5462c.webp?x-oss-process=image/format,png
[format_png 90]: https://img-blog.csdnimg.cn/img_convert/30c24a8157b7756fb7911996acd52d71.webp?x-oss-process=image/format,png
[format_png 91]: https://img-blog.csdnimg.cn/img_convert/6827a94468391b7784795f7a86b89e38.webp?x-oss-process=image/format,png
[format_png 92]: https://img-blog.csdnimg.cn/img_convert/715a19ae5b94e9d64fd7504c275c9dd7.webp?x-oss-process=image/format,png
[format_png 93]: https://img-blog.csdnimg.cn/img_convert/4aa041c3a4b265092263fa62495bc7a7.webp?x-oss-process=image/format,png