springCloud学习【4】之elasticsearch(1)

梦里梦外; 2024-03-26 21:59 61阅读 0赞

#### 文章目录 ####

*  一 初识elasticsearch
 *   *  1.1 认识ES
     *  1.2 基知：倒排索引
     *  1.3 正向和倒排总结
     *  1.4 es基础概念
 *  二 安装elasticsearch
 *   *  2.1 部署部署单点es
     *   *  2.1.1 创建网络
         *  2.1.2 下载镜像
         *  2.1.3 加载镜像
         *  2.1.4 运行
         *  2.1.5 访问
     *  2.2 部署kibana
     *   *  2.2.1 下载镜像
         *  2.2.2 加载镜像
         *  2.2.3 运行kibana
         *  2.2.4 查看日志
         *  2.2.5 使用DevTools
     *  2.3 安装IK分词器
     *   *  2.3.1 在线安装ik插件（较慢）
         *  2.3.2 离线安装ik插件（推荐）
     *  2.4 拓展词典
     *  2.5 停用词词典
     *  2.6 部署es集群【补充】
 *  三 索引库操作
 *   *  3.1 mapping映射属性
     *  3.2 创建索引库和映射
     *  3.3 查询索引库
     *  3.4 修改索引库
     *  3.5 删除索引库
     *  3.6 总结
 *  四 文档操作
 *   *  4.1 新增文档
     *  4.2 查询文档
     *  4.3 删除文档
     *  4.4 修改文档
     *  4.5 总结
 *  五 RestAPI
 *   *  5.1 分析数据结构：apping映射分析
     *  5.2 初始化RestClient
     *  5.3 创建索引库
     *  5.4 删除索引库
     *  5.5 判断索引库存在
     *  5.6 总结
 *  六 RestClient操作文档
 *   *  6.1 新增文档
     *  6.2 查询文档
     *  6.3 修改文档
     *  6.4 删除文档
     *  6.5 批量导入文档
     *  6.6 小结

## 一 初识elasticsearch ##

### 1.1 认识ES ###

![在这里插入图片描述][397e8975160341169374b045f3649922.png]

*  elasticsearch的作用
    
     *  **elasticsearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容**  
        ![在这里插入图片描述][b1a22a3dce38478b97b5d59d3d4b75dc.png]

--------------------

*  ELK技术栈
    
     *  **elasticsearch结合kibana、Logstash、Beats，也就是elastic stack（ELK）。被广泛应用在日志数据分析、实时监控等领域:**
     *  而elasticsearch是elastic stack的核心，负责存储、搜索、分析数据。  
        ![在这里插入图片描述][933d22e4b36a40c582225abf0769b332.png]

--------------------

*  **elasticsearch和[lucene][]**
    
     *  elasticsearch底层是基于[**lucene**][lucene]来实现的。
     *  [**Lucene**][lucene]是一个Java语言的搜索引擎类库，是Apache公司的顶级项目，由DougCutting于1999年研发。  
        ![在这里插入图片描述][dc225bf0c43448b3a217febe8ad323d2.png]

--------------------

*  [**elasticsearch**][elasticsearch]的发展历史：
    
     *  2004年Shay Banon基于Lucene开发了Compass
     *  2010年Shay Banon 重写了Compass，取名为Elasticsearch。  
        ![在这里插入图片描述][f6e3fd325d52403a8a4f18dda60b182a.png]

### 1.2 基知：倒排索引 ###

*  倒排索引的概念是基于MySQL这样的正向索引而言的。
 *  正向索引：
    
     *  基于文档id创建索引。查询词条时必须先找到文档，而后判断是否包含词条

![\-][-]

>  *  逐行扫描，也就是全表扫描，随着数据量增加，其查询效率也会越来越低。当数据量达到数百万时，就是一场灾难。

*  elasticsearch采用**倒排索引**：
    
     *  文档（document）：**用来搜索的数据，每条数据就是一个文档** 例如：一个网页、一个商品信息
     *  词条（term）：**对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。** 例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条
 *  **创建倒排索引**是对正向索引的一种特殊处理，流程如下：
    
    1.  将每一个文档的数据利用算法分词，得到一个个词条
    2.  创建表，每行数据包括词条、词条所在文档id、位置等信息
    3.  因为词条唯一性，可以给词条创建索引，例如hash表结构索引  
        ![在这里插入图片描述][a3f435cab046460baf6e5fe6aa1b8c43.gif_pic_center]
 *  倒排索引的**搜索流程**如下（以搜索"华为手机"为例）：
    
     *  1）用户输入条件`"华为手机"`进行搜索。
     *  2）对用户输入内容**分词**，得到词条：`华为`、`手机`。
     *  3）拿着词条在倒排索引中查找，可以得到包含词条的文档id：1、2、3。
     *  4）拿着文档id到正向索引中查找具体文档。  
        ![在这里插入图片描述][84f703b7bc7247598cea3cc3550e73f0.gif_pic_center]
 *  **虽然要先查询倒排索引，再查询倒排索引，但是无论是词条、还是文档id都建立了索引，查询速度非常快！无需全表扫描。**

--------------------

*  **posting list**
 *  倒排索引中包含两部分内容：
    
     *  词条词典（Term Dictionary）：记录所有词条，以及词条与倒排列表（Posting List）之间的关系，会给词条创建索引，提高查询和插入效率
     *  倒排列表（Posting List）：记录词条所在的文档id、词条出现频率 、词条在文档中的位置等信息
        
         *  文档id：用于快速获取文档
         *  词条频率（TF）：文档在词条出现的次数，用于评分  
            ![在这里插入图片描述][d9c2cc9004a74d088e68bdb875336465.png]

### 1.3 正向和倒排总结 ###

*  **正向索引**是最传统的，根据id索引的方式。但根据词条查询时，必须先逐条获取每个文档，然后判断文档中是否包含所需要的词条，是**根据文档找词条的过程**。
 *  而**倒排索引**则相反，是先找到用户要搜索的词条，根据词条得到保护词条的文档的id，然后根据id获取文档。是**根据词条找文档的过程**。
 *  **正向索引**：
    
     *  优点：
        
         *  可以给多个字段创建索引
         *  根据索引字段搜索、排序速度非常快
     *  缺点：
        
         *  根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。
 *  **倒排索引**：
    
     *  优点：
        
         *  根据词条搜索、模糊搜索时，速度非常快
     *  缺点：
        
         *  只能给词条创建索引，而不是字段
         *  无法根据字段做排序

### 1.4 es基础概念 ###

*  文档和字段
    
     *  elasticsearch是面向**文档（Document）** 存储的，可以是数据库中的一条商品数据，一个订单信息。
     *  文档数据会被序列化为json格式后存储在elasticsearch中，而Json文档中往往包含很多的**字段（Field）**  
        ![在这里插入图片描述][40d31eb315dd4923ba2242789e132750.png]

--------------------

*  索引和映射
    
     *  **索引（Index）**，就是相同类型的文档的集合。
     *  映射（mapping）：索引中文档的字段约束信息，类似表的结构约束  
        ![在这里插入图片描述][1dd7928aa3c94f829b07da4341b4649d.gif_pic_center]

--------------------

*  \*\*mysql与elasticsearch的概念对比：**加粗样式**

<table> 
 <thead> 
  <tr> 
   <th><strong>MySQL</strong></th> 
   <th><strong>Elasticsearch</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Table</td> 
   <td>Index</td> 
   <td>索引(index)，就是文档的集合，类似数据库的表(table)</td> 
  </tr> 
  <tr> 
   <td>Row</td> 
   <td>Document</td> 
   <td>文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式</td> 
  </tr> 
  <tr> 
   <td>Column</td> 
   <td>Field</td> 
   <td>字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）</td> 
  </tr> 
  <tr> 
   <td>Schema</td> 
   <td>Mapping</td> 
   <td>Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）</td> 
  </tr> 
  <tr> 
   <td>SQL</td> 
   <td>DSL</td> 
   <td>DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD</td> 
  </tr> 
 </tbody> 
</table>

--------------------

*  架构
    
     *  Mysql：擅长事务类型操作，可以确保数据的安全和一致性
     *  Elasticsearch：擅长海量数据的搜索、分析、计算
 *  因此在企业中，往往是两者结合使用：
    
     *  对安全性要求较高的写操作，使用mysql实现
     *  对查询性能要求较高的搜索需求，使用elasticsearch实现
     *  两者再基于某种方式，实现数据的同步，保证一致性

![在这里插入图片描述][288cfcede6584223ba3d5bf431937b12.gif_pic_center]

## 二 安装elasticsearch ##

### 2.1 部署部署单点es ###

#### 2.1.1 创建网络 ####

*  因为还需要部署kibana容器，因此需要让es和kibana容器互联。先创建一个网络：
    
        docker network create es-net

#### 2.1.2 下载镜像 ####

*  这里采用elasticsearch的7.12.1版本的镜像，不建议pull。
 *  [Elasticsearch中文社区下载地址][Elasticsearch]  
    ![在这里插入图片描述][2d2d30de909b4797ba26135a3ecad985.png]  
    ![在这里插入图片描述][321db3d9ed9e4b8894e8baaa7fc632a1.png]
    
     *  记得将压缩包的名称修改为`es.tar`

#### 2.1.3 加载镜像 ####

[root@kongyue ~]# systemctl start docker
    [root@kongyue ~]# cd /tmp/
    [root@kongyue tmp]# docker load -i es.tar
    2653d992f4ef: Loading layer [==================================================>]  216.5MB/216.5MB
    0ba8eff8aa04: Loading layer [==================================================>]  101.4MB/101.4MB
    2a944434ad00: Loading layer [==================================================>]  314.9kB/314.9kB
    ade95a7611c0: Loading layer [==================================================>]  543.9MB/543.9MB
    09a575a6e776: Loading layer [==================================================>]  26.62kB/26.62kB
    498ae65924d7: Loading layer [==================================================>]   7.68kB/7.68kB
    36b3f8db7aaa: Loading layer [==================================================>]  490.5kB/490.5kB
    Loaded image: elasticsearch:7.12.1

#### 2.1.4 运行 ####

docker run -d \
    	--name es \
        -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
        -e "discovery.type=single-node" \
        -v es-data:/usr/share/elasticsearch/data \
        -v es-plugins:/usr/share/elasticsearch/plugins \
        --privileged \
        --network es-net \
        -p 9200:9200 \
        -p 9300:9300 \
    elasticsearch:7.12.1

命令解释：

*  `-e "cluster.name=es-docker-cluster"`：设置集群名称
 *  `-e "http.host=0.0.0.0"`：监听的地址，可以外网访问
 *  `-e "ES_JAVA_OPTS=-Xms512m -Xmx512m"`：内存大小
 *  `-e "discovery.type=single-node"`：非集群模式
 *  `-v es-data:/usr/share/elasticsearch/data`：挂载逻辑卷，绑定es的数据目录
 *  `-v es-logs:/usr/share/elasticsearch/logs`：挂载逻辑卷，绑定es的日志目录
 *  `-v es-plugins:/usr/share/elasticsearch/plugins`：挂载逻辑卷，绑定es的插件目录
 *  `--privileged`：授予逻辑卷访问权
 *  `--network es-net` ：加入一个名为es-net的网络中
 *  `-p 9200:9200`：端口映射配置

[root@kongyue tmp]# docker run -d \
    > --name es \
    >     -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
    >     -e "discovery.type=single-node" \
    >     -v es-data:/usr/share/elasticsearch/data \
    >     -v es-plugins:/usr/share/elasticsearch/plugins \
    >     --privileged \
    >     --network es-net \
    >     -p 9200:9200 \
    >     -p 9300:9300 \
    > elasticsearch:7.12.1
    f1f899239f106e6f0718b632383ed0401cb4b8e96772a7cb1e0d3c890862cfb6

#### 2.1.5 访问 ####

*  访问：http://xxx.xxx.xxx.xxx:9200 即可看到elasticsearch的响应结果：  
    ![在这里插入图片描述][92badf752da34f9888149c7e9fb556ca.png]

### 2.2 部署kibana ###

#### 2.2.1 下载镜像 ####

*  [官方地址Download Kibana][Download Kibana]
 *  [Elasticsearch中文社区下载地址][Elasticsearch]  
    ![在这里插入图片描述][62ee6111af6744bb823c8a5a2e20920e.png]
    
     *  记得将压缩包的名称修改为`kibana.tar`

#### 2.2.2 加载镜像 ####

[root@kongyue tmp]# docker load -i kibana.tar
    d797e87ed4ce: Loading layer [==================================================>]  112.9MB/112.9MB
    80ce41fc1f8a: Loading layer [==================================================>]  26.62kB/26.62kB
    3345a8ffd0ea: Loading layer [==================================================>]  3.584kB/3.584kB
    d736a1702974: Loading layer [==================================================>]  20.34MB/20.34MB
    570575469db2: Loading layer [==================================================>]  56.83kB/56.83kB
    459d502a3562: Loading layer [==================================================>]  770.7MB/770.7MB
    f22a9f0649d0: Loading layer [==================================================>]  2.048kB/2.048kB
    4b66f24ba0de: Loading layer [==================================================>]  4.096kB/4.096kB
    0a50faa06266: Loading layer [==================================================>]  15.36kB/15.36kB
    8a310ff91413: Loading layer [==================================================>]  4.096kB/4.096kB
    5997553ddc84: Loading layer [==================================================>]  479.2kB/479.2kB
    f87dadd7c340: Loading layer [==================================================>]  309.8kB/309.8kB
    Loaded image: kibana:7.12.1

#### 2.2.3 运行kibana ####

*  **kibana启动一般比较慢，需要多等待一会**

[root@kongyue tmp]# docker run -d \
    > --name kibana \
    > -e ELASTICSEARCH_HOSTS=http://es:9200 \
    > --network=es-net \
    > -p 5601:5601  \
    > kibana:7.12.1
    d8ade4066ec86d48c10effe249b65c122b63bd6734b1708b941a221bc633be78

*  `--network es-net` ：加入一个名为es-net的网络中，与elasticsearch在同一个网络中
 *  `-e ELASTICSEARCH_HOSTS=http://es:9200"`：设置elasticsearch的地址，因为kibana已经与elasticsearch在一个网络，因此可以用容器名直接访问elasticsearch
 *  `-p 5601:5601`：端口映射配置

#### 2.2.4 查看日志 ####

*  可以通过命令,查看运行日志:
    
        docker logs -f kibana
 *  当查看到下面的日志，说明成功：
    
        {
              "type":"log","@timestamp":"2023-03-24T05:05:05+00:00","tags":["info","http","server","Kibana"],"pid":7,"message":"http server running at http://0.0.0.0:5601"}

#### 2.2.5 使用DevTools ####

*  访问`http://xxx.xxx.xxx.xxx:5601`,即可看到以下页面，选择`Explore on my own`  
    ![在这里插入图片描述][44c89ad7831a4e2c819071555783d67f.png]
 *  选择开发工具  
    ![在这里插入图片描述][3d6a7dc54ce54e7abe4f74eb205188e0.png]
 *  然后进入以下界面  
    ![在这里插入图片描述][b8a98b79d1cb44afb2cae28d7716fd80.png]
 *  界面中可以编写DSL来操作elasticsearch。并且对DSL语句有自动补全功能。  
    ![在这里插入图片描述][66abfbd05fab447a9df27f1650448eea.png]

### 2.3 安装IK分词器 ###

#### 2.3.1 在线安装ik插件（较慢） ####

# 进入容器内部
    docker exec -it elasticsearch /bin/bash
    
    # 在线下载并安装
    ./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip
    
    #退出
    exit
    #重启容器
    docker restart elasticsearch

#### 2.3.2 离线安装ik插件（推荐） ####

1.  查看数据卷目录

*  安装插件需要知道elasticsearch的plugins目录位置，而我们用了数据卷挂载，因此需要查看elasticsearch的数据卷目录
 *  通过下面命令查看:
    
        docker volume inspect es-plugins
 *  显示结果：
    
        [root@kongyue tmp]# docker volume inspect es-plugins
        [
            {
              
                "CreatedAt": "2023-03-24T12:51:40+08:00",
                "Driver": "local",
                "Labels": null,
                "Mountpoint": "/var/lib/docker/volumes/es-plugins/_data",
                "Name": "es-plugins",
                "Options": null,
                "Scope": "local"
            }
        ]
    
     *  说明plugins目录被挂载到了：`/var/lib/docker/volumes/es-plugins/_data`这个目录中。

1.  下载IK分词器

*  [Elasticsearch中文社区下载地址][Elasticsearch]  
    ![在这里插入图片描述][29bf78b710fb47a0a34c3650831abe51.png]

1.  解压缩分词器安装包

*  把`ik`分词器解压缩，重命名为`ik`

1.  上传到es容器的插件数据卷中

*  将`ik`文件夹上传到查询出来的挂载目录

1.  重启容器

# 重启容器
    docker restart es
    # 查看es日志
    docker logs -f es

1.  测试：

*  IK分词器包含两种模式：
    
     *  `ik_smart`：最少切分
     *  `ik_max_word`：最细切分

GET /_analyze
    {
        
      "analyzer": "ik_max_word",
      "text": "天生我才必有用，大可不必独叹息"
    }

{
        
      "tokens" : [
        {
        
          "token" : "天生我才必有用",
          "start_offset" : 0,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 0
        },
        {
        
          "token" : "天生我才",
          "start_offset" : 0,
          "end_offset" : 4,
          "type" : "CN_WORD",
          "position" : 1
        },
        {
        
          "token" : "天生",
          "start_offset" : 0,
          "end_offset" : 2,
          "type" : "CN_WORD",
          "position" : 2
        },
        {
        
          "token" : "我",
          "start_offset" : 2,
          "end_offset" : 3,
          "type" : "CN_CHAR",
          "position" : 3
        },
        {
        
          "token" : "才",
          "start_offset" : 3,
          "end_offset" : 4,
          "type" : "CN_CHAR",
          "position" : 4
        },
        {
        
          "token" : "必有用",
          "start_offset" : 4,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 5
        },
        {
        
          "token" : "必有",
          "start_offset" : 4,
          "end_offset" : 6,
          "type" : "CN_WORD",
          "position" : 6
        },
        {
        
          "token" : "有用",
          "start_offset" : 5,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 7
        },
        {
        
          "token" : "大可不必",
          "start_offset" : 8,
          "end_offset" : 12,
          "type" : "CN_WORD",
          "position" : 8
        },
        {
        
          "token" : "大可",
          "start_offset" : 8,
          "end_offset" : 10,
          "type" : "CN_WORD",
          "position" : 9
        },
        {
        
          "token" : "可不",
          "start_offset" : 9,
          "end_offset" : 11,
          "type" : "CN_WORD",
          "position" : 10
        },
        {
        
          "token" : "不必",
          "start_offset" : 10,
          "end_offset" : 12,
          "type" : "CN_WORD",
          "position" : 11
        },
        {
        
          "token" : "独",
          "start_offset" : 12,
          "end_offset" : 13,
          "type" : "CN_CHAR",
          "position" : 12
        },
        {
        
          "token" : "叹息",
          "start_offset" : 13,
          "end_offset" : 15,
          "type" : "CN_WORD",
          "position" : 13
        }
      ]
    }

### 2.4 拓展词典 ###

*  随着互联网的发展，出现了很多新的词语，在原有的词汇列表中并不存在。所以我们的词汇也需要不断的更新，IK分词器提供了扩展词汇的功能。

1.  打开IK分词器config目录：  
    ![在这里插入图片描述][132bf7f1c6684507bb3162350bb801ef.png]
2.  在IKAnalyzer.cfg.xml配置文件内容添加：
    
        <?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
        <properties>
                <comment>IK Analyzer 扩展配置</comment>
                
                <entry key="ext_dict">ext.dic</entry>
        </properties>
3.  新建一个 ext.dic，可以参考config目录下复制一个配置文件进行修改
    
     *  **注意当前文件的编码必须是 UTF-8 格式**

emo
    芭比Q了

1.  重启elasticsearch

docker restart es

1.  测试效果：

GET /_analyze
    {
        
      "analyzer": "ik_max_word",
      "text": "竞争太激烈，这次面试又芭比Q了，我真的很emo"
    }

{
        
      "token" : "emo",
      "start_offset" : 20,
      "end_offset" : 23,
      "type" : "ENGLISH",
      "position" : 13
    }

### 2.5 停用词词典 ###

*  在互联网项目中，在网络间传输的速度很快，所以很多语言是不允许在网络上传递的，如：关于宗教、政治等敏感词语，那么我们在搜索时也应该忽略当前词汇。
 *  IK分词器也提供了强大的停用词功能，让我们在索引时就直接忽略当前的停用词汇表中的内容。

1.  IKAnalyzer.cfg.xml配置文件内容添加：
    
        <?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
        <properties>
                <comment>IK Analyzer 扩展配置</comment>
                
                <entry key="ext_dict">ext.dic</entry>
                 
                <entry key="ext_stopwords">stopword.dic</entry>
        </properties>
2.  在 stopword.dic 添加停用词
    
     *  **注意当前文件的编码必须是 UTF-8 格式**
    
        草泥马
        特么的
3.  重启elasticsearch
    
        # 重启服务
        docker restart elasticsearch
        docker restart kibana
4.  测试效果
    
        GET /_analyze
        {
              
          "analyzer": "ik_max_word",
          "text": "草泥马,特么的,都是不文明网络用语"
        }
    
        {
              
          "tokens" : [
            {
              
              "token" : "草",
              "start_offset" : 0,
              "end_offset" : 1,
              "type" : "CN_CHAR",
              "position" : 0
            },
            {
              
              "token" : "泥",
              "start_offset" : 1,
              "end_offset" : 2,
              "type" : "CN_CHAR",
              "position" : 1
            },
            {
              
              "token" : "马",
              "start_offset" : 2,
              "end_offset" : 3,
              "type" : "CN_CHAR",
              "position" : 2
            },
            {
              
              "token" : "特",
              "start_offset" : 4,
              "end_offset" : 5,
              "type" : "CN_CHAR",
              "position" : 3
            },
            {
              
              "token" : "么",
              "start_offset" : 5,
              "end_offset" : 6,
              "type" : "CN_CHAR",
              "position" : 4
            },
            {
              
              "token" : "的",
              "start_offset" : 6,
              "end_offset" : 7,
              "type" : "CN_CHAR",
              "position" : 5
            },
            {
              
              "token" : "都是",
              "start_offset" : 8,
              "end_offset" : 10,
              "type" : "CN_WORD",
              "position" : 6
            },
            {
              
              "token" : "不文明",
              "start_offset" : 10,
              "end_offset" : 13,
              "type" : "CN_WORD",
              "position" : 7
            },
            {
              
              "token" : "不文",
              "start_offset" : 10,
              "end_offset" : 12,
              "type" : "CN_WORD",
              "position" : 8
            },
            {
              
              "token" : "文明",
              "start_offset" : 11,
              "end_offset" : 13,
              "type" : "CN_WORD",
              "position" : 9
            },
            {
              
              "token" : "网络",
              "start_offset" : 13,
              "end_offset" : 15,
              "type" : "CN_WORD",
              "position" : 10
            },
            {
              
              "token" : "用语",
              "start_offset" : 15,
              "end_offset" : 17,
              "type" : "CN_WORD",
              "position" : 11
            }
          ]
        }

### 2.6 部署es集群【补充】 ###

*  部署es集群可以直接使用docker-compose来完成，不过要求你的Linux虚拟机至少有**4G**的内存空间

1.  首先编写一个docker-compose文件，内容如下：
    
        version: '2.2'
        services:
          es01:
            image: docker.elastic.co/elasticsearch/elasticsearch:7.12.1
            container_name: es01
            environment:
              - node.name=es01
              - cluster.name=es-docker-cluster
              - discovery.seed_hosts=es02,es03
              - cluster.initial_master_nodes=es01,es02,es03
              - bootstrap.memory_lock=true
              - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
            ulimits:
              memlock:
                soft: -1
                hard: -1
            volumes:
              - data01:/usr/share/elasticsearch/data
            ports:
              - 9200:9200
            networks:
              - elastic
          es02:
            image: docker.elastic.co/elasticsearch/elasticsearch:7.12.1
            container_name: es02
            environment:
              - node.name=es02
              - cluster.name=es-docker-cluster
              - discovery.seed_hosts=es01,es03
              - cluster.initial_master_nodes=es01,es02,es03
              - bootstrap.memory_lock=true
              - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
            ulimits:
              memlock:
                soft: -1
                hard: -1
            volumes:
              - data02:/usr/share/elasticsearch/data
            networks:
              - elastic
          es03:
            image: docker.elastic.co/elasticsearch/elasticsearch:7.12.1
            container_name: es03
            environment:
              - node.name=es03
              - cluster.name=es-docker-cluster
              - discovery.seed_hosts=es01,es02
              - cluster.initial_master_nodes=es01,es02,es03
              - bootstrap.memory_lock=true
              - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
            ulimits:
              memlock:
                soft: -1
                hard: -1
            volumes:
              - data03:/usr/share/elasticsearch/data
            networks:
              - elastic
        
        volumes:
          data01:
            driver: local
          data02:
            driver: local
          data03:
            driver: local
        
        networks:
          elastic:
            driver: bridge
2.  Run `docker-compose` to bring up the cluster:
    
        docker-compose up

## 三 索引库操作 ##

*  索引库就类似数据库表，mapping映射就类似表的结构。要向es中存储数据，必须先创建“库”和“表”。
 *  **使用统一使用Kibana编写DSL的方式来演示**

### 3.1 mapping映射属性 ###

*  type：字段数据类型，常见的简单类型有：
    
     *  字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
     *  数值：long、integer、short、byte、double、float、
     *  布尔：boolean
     *  日期：date
     *  对象：object
 *  index：是否创建索引，默认为true
 *  analyzer：使用哪种分词器
 *  properties：该字段的子字段

--------------------

*  举例：
    
        {
              
            "age": 21,
            "weight": 52.1,
            "isMarried": false,
            "info": "武神",
            "email": "zy@itcast.cn",
            "score": [99.1, 99.5, 98.9],
            "name": {
              
                "firstName": "云",
                "lastName": "赵"
            }
        }
 *  对应的每个字段映射（mapping）：
    
     *  age：类型为 integer；参与搜索，因此需要index为true；无需分词器
     *  weight：类型为float；参与搜索，因此需要index为true；无需分词器
     *  isMarried：类型为boolean；参与搜索，因此需要index为true；无需分词器
     *  info：类型为字符串，需要分词，因此是text；参与搜索，因此需要index为true；分词器可以用ik\_smart
     *  email：类型为字符串，但是不需要分词，因此是keyword；不参与搜索，因此需要index为false；无需分词器
     *  score：虽然是数组，但是我们只看元素的类型，类型为float；参与搜索，因此需要index为true；无需分词器
     *  name：类型为object，需要定义多个子属性
        
         *  name.firstName；类型为字符串，但是不需要分词，因此是keyword；参与搜索，因此需要index为true；无需分词器
         *  name.lastName；类型为字符串，但是不需要分词，因此是keyword；参与搜索，因此需要index为true；无需分词器

### 3.2 创建索引库和映射 ###

*  基本语法：
    
     *  请求方式：PUT
     *  请求路径：/索引库名，可以自定义
     *  请求参数：mapping映射
 *  格式：
    
        PUT /索引库名称
        {
              
          "mappings": {
              
            "properties": {
              
              "字段名":{
              
                "type": "text",
                "analyzer": "ik_smart"
              },
              "字段名2":{
              
                "type": "keyword",
                "index": "false"
              },
              "字段名3":{
              
                "properties": {
              
                  "子字段": {
              
                    "type": "keyword"
                  }
                }
              }
            }
          }
        }
 *  举例：
    
        PUT /test01
        {
              
          "mappings": {
              
            "properties": {
              
              "info":{
              
                "type": "text",
                "analyzer": "ik_smart"
              },
              "email":{
              
                "type": "keyword",
                "index": "false"
              },
              "name":{
              
                "properties": {
              
                  "firstName": {
              
                    "type": "keyword"
                  }
                }
              }
            }
          }
        }
 *  演示结果：
    
        {
              
          "acknowledged" : true,
          "shards_acknowledged" : true,
          "index" : "test01"
        }

### 3.3 查询索引库 ###

*  **基本语法**：
    
     *  请求方式：GET
     *  请求路径：/索引库名
     *  请求参数：无
 *  **格式**：
    
        GET /索引库名
 *  演示：  
    ![在这里插入图片描述][0620b06b41584e1c906dd880c9309c48.png]

### 3.4 修改索引库 ###

*  倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库**一旦创建，无法修改mapping**。
 *  虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。
 *  **语法说明**：
    
        PUT /索引库名/_mapping
        {
              
          "properties": {
              
            "新字段名":{
              
              "type": "integer"
            }
          }
        }
 *  演示：  
    ![在这里插入图片描述][5348ab88416143d48960fd8830d781ff.png]

### 3.5 删除索引库 ###

*  **语法：**
    
     *  请求方式：`DELETE`
     *  请求路径：/索引库名
     *  请求参数：无
 *  **格式：**
    
        DELETE /索引库名

### 3.6 总结 ###

*  索引库操作：
    
     *  创建索引库：`PUT /索引库名`
     *  查询索引库：`GET /索引库名`
     *  删除索引库：`DELETE /索引库名`
     *  添加字段：`PUT /索引库名/_mapping`

## 四 文档操作 ##

### 4.1 新增文档 ###

*  **语法：**
    
        POST /索引库名/_doc/文档id
        {
              
            "字段1": "值1",
            "字段2": "值2",
            "字段3": {
              
                "子属性1": "值3",
                "子属性2": "值4"
            },
            // ...
        }
 *  演示： ![在这里插入图片描述][a8e87f4fe46245b1902e5b84c306f9e6.png]

### 4.2 查询文档 ###

*  **语法：**
    
        GET /{
              索引库名称}/_doc/{
              id}
 *  **通过kibana查看数据：**
    
        GET /heima/_doc/1
 *  演示：  
    ![在这里插入图片描述][b826e8891315467086702cbfa885812e.png]

### 4.3 删除文档 ###

*  **语法：**
    
        DELETE /{
              索引库名}/_doc/id值
 *  演示：  
    ![在这里插入图片描述][538d605d0a1442929f7627971d43b962.png]

### 4.4 修改文档 ###

*  修改有两种方式：
    
     *  全量修改：直接覆盖原来的文档
     *  增量修改：修改文档中的部分字段

--------------------

*  **全量修改**
 *  全量修改是覆盖原来的文档，其本质是：
    
     *  根据指定的id删除文档
     *  新增一个相同id的文档

>  *  **注意**：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。

*  **语法：**
    
        PUT /{
              索引库名}/_doc/文档id
        {
              
            "字段1": "值1",
            "字段2": "值2",
            // ... 略
        }
 *  演示： ![在这里插入图片描述][be6bb7d17a034e20850ba14098682c9c.png]

--------------------

*  **增量修改**
 *  增量修改是只修改指定id匹配的文档中的部分字段。
 *  **语法：**
    
        POST /{
              索引库名}/_update/文档id
        {
              
            "doc": {
              
                 "字段名": "新的值"
            }
        }
 *  演示：  
    ![在这里插入图片描述][8848832a7d7e4aa3a56b9083ff2e09cb.png]

### 4.5 总结 ###

*  文档操作：
    
     *  创建文档：`POST /{索引库名}/_doc/文档id { json文档 }`
     *  查询文档：`GET /{索引库名}/_doc/文档id`
     *  删除文档：`DELETE /{索引库名}/_doc/文档id`
     *  修改文档：
        
         *  全量修改：`PUT /{索引库名}/_doc/文档id { json文档 }`
         *  增量修改：`POST /{索引库名}/_update/文档id { "doc": {字段}}`

## 五 RestAPI ##

*  ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。[官方文档地址][Link 1]
 *  其中的Java Rest Client又包括两种：
    
     *  Java Low Level Rest Client
     *  Java High Level Rest Client
 *  这里使用Java HighLevel Rest Client客户端API

### 5.1 分析数据结构：apping映射分析 ###

*  创建索引库，最关键的是mapping映射，而mapping映射要考虑的信息包括：
    
     *  字段名
     *  字段数据类型
     *  是否参与搜索
     *  是否需要分词
     *  如果分词，分词器是什么？
 *  其中：
    
     *  字段名、字段数据类型，可以参考数据表结构的名称和类型
     *  是否参与搜索要分析业务来判断，例如图片地址，就无需参与搜索
     *  是否分词呢要看内容，内容如果是一个整体就无需分词，反之则要分词
     *  分词器，我们可以统一使用ik\_max\_word

![在这里插入图片描述][c3a4d0a4c3fb4ccaa1c05acfc67a051e.png]

*  几个特殊字段说明：
    
     *  location：地理坐标，里面包含精度、纬度
     *  all：一个组合字段，其目的是将多字段的值 利用copy\_to合并，提供给用户搜索
 *  地理坐标说明： ![在这里插入图片描述][f1e31253c0804528b38d22f8278a6140.png]
 *  copy\_to说明：  
    ![在这里插入图片描述][494b0035946a4f8aa07b91de08bacd0d.png]

### 5.2 初始化RestClient ###

*  在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。
 *  步骤分为三步：
    
    1.  引入es的RestHighLevelClient依赖：
    
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
        </dependency>
    
    1.  因为SpringBoot默认的ES版本是7.6.2，所以我们需要覆盖默认的ES版本：
    
        <properties>
            <java.version>1.8</java.version>
            <elasticsearch.version>7.12.1</elasticsearch.version>
        </properties>
    
    1.  初始化RestHighLevelClient：
    
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.150.101:9200")
        ));
    
    1.  测试，创建一个测试类HotelIndexTest，然后将初始化的代码编写在@BeforeEach方法中：
    
        public class HotelIndexTest {
              
            private RestHighLevelClient client;
        
            @BeforeEach
            void setUp() {
              
                this.client = new RestHighLevelClient(RestClient.builder(
                		//xxx.xxx.xxx.xxx 虚拟主机的IP
                        HttpHost.create("http://xxx.xxx.xxx.xxx:9200")
                ));
            }
        
            @AfterEach
            void tearDown() throws IOException {
              
                this.client.close();
            }
        }

### 5.3 创建索引库 ###

![在这里插入图片描述][d8aa88bb1f284aa997e1796621d3e0d0.png]

*  代码分为三步：
    
    1.  创建Request对象。因为是创建索引库的操作，因此Request是CreateIndexRequest。
    2.  添加请求参数，其实就是DSL的JSON参数部分。因为json字符串很长，这里是定义了静态字符串常量MAPPING\_TEMPLATE，让代码看起来更加优雅。
    3.  发送请求，client.indices()方法的返回值是IndicesClient类型，封装了所有与索引库操作有关的方法。
 *  演示

//创建一个类，定义mapping映射的JSON字符串常量
    class HotelConstants {
        
        public static final String MAPPING_TEMPLATE = "{
        \n" +
                "  \"mappings\": {
        \n" +
                "    \"properties\": {
        \n" +
                "      \"id\": {
        \n" +
                "        \"type\": \"keyword\"\n" +
                "      },\n" +
                "      \"name\":{
        \n" +
                "        \"type\": \"text\",\n" +
                "        \"analyzer\": \"ik_max_word\",\n" +
                "        \"copy_to\": \"all\"\n" +
                "      },\n" +
                "      \"address\":{
        \n" +
                "        \"type\": \"keyword\",\n" +
                "        \"index\": false\n" +
                "      },\n" +
                "      \"price\":{
        \n" +
                "        \"type\": \"integer\"\n" +
                "      },\n" +
                "      \"score\":{
        \n" +
                "        \"type\": \"integer\"\n" +
                "      },\n" +
                "      \"brand\":{
        \n" +
                "        \"type\": \"keyword\",\n" +
                "        \"copy_to\": \"all\"\n" +
                "      },\n" +
                "      \"city\":{
        \n" +
                "        \"type\": \"keyword\",\n" +
                "        \"copy_to\": \"all\"\n" +
                "      },\n" +
                "      \"starName\":{
        \n" +
                "        \"type\": \"keyword\"\n" +
                "      },\n" +
                "      \"business\":{
        \n" +
                "        \"type\": \"keyword\"\n" +
                "      },\n" +
                "      \"location\":{
        \n" +
                "        \"type\": \"geo_point\"\n" +
                "      },\n" +
                "      \"pic\":{
        \n" +
                "        \"type\": \"keyword\",\n" +
                "        \"index\": false\n" +
                "      },\n" +
                "      \"all\":{
        \n" +
                "        \"type\": \"text\",\n" +
                "        \"analyzer\": \"ik_max_word\"\n" +
                "      }\n" +
                "    }\n" +
                "  }\n" +
                "}";
    }
    //在hotel-demo中的HotelIndexTest测试类中，编写单元测试，实现创建索引
    @Test
    void createHotelIndex() throws IOException {
        
        // 1.创建Request对象
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        // 2.准备请求的参数：DSL语句
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        // 3.发送请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }

### 5.4 删除索引库 ###

*  删除索引库的DSL语句非常简单：
    
        DELETE /hotel
 *  与创建索引库相比：
    
     *  请求方式从PUT变为DELTE
     *  请求路径不变
     *  无请求参数
 *  所以代码的差异，注意体现在Request对象上。依然是三步走：
    
    1.  创建Request对象。这次是DeleteIndexRequest对象
    2.  准备参数。这里是无参
    3.  发送请求。改用delete方法
 *  编写单元测试，实现删除索引：
    
        @Test
        void testDeleteHotelIndex() throws IOException {
              
            // 1.创建Request对象
            DeleteIndexRequest request = new DeleteIndexRequest("hotel");
            // 2.发送请求
            client.indices().delete(request, RequestOptions.DEFAULT);
        }

### 5.5 判断索引库存在 ###

*  判断索引库是否存在，本质就是查询，对应的DSL是：
    
        GET /hotel
 *  因此与删除的Java代码流程是类似的。依然是三步走：
    
    1.  创建Request对象。这次是GetIndexRequest对象
    2.  准备参数。这里是无参
    3.  发送请求。改用exists方法
    
        @Test
        void testExistsHotelIndex() throws IOException {
              
            // 1.创建Request对象
            GetIndexRequest request = new GetIndexRequest("hotel");
            // 2.发送请求
            boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
            // 3.输出
            System.err.println(exists ? "索引库已经存在！" : "索引库不存在！");
        }

### 5.6 总结 ###

*  JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。
 *  索引库操作的基本步骤：
    
     *  初始化RestHighLevelClient
     *  创建XxxIndexRequest。XXX是Create、Get、Delete
     *  准备DSL（ Create时需要，其它是无参）
     *  发送请求。调用RestHighLevelClient\#indices().xxx()方法，xxx是create、exists、delete

## 六 RestClient操作文档 ##

*  为了与索引库操作分离，需要增加加一个测试类：
    
     *  初始化RestHighLevelClient
     *  酒店数据在数据库，需要利用IHotelService去查询，所以注入这个接口
    
        @SpringBootTest
        public class HotelDocumentTest {
              
            @Autowired
            private IHotelService hotelService;
        
            private RestHighLevelClient client;
        
            @BeforeEach
            void setUp() {
              
                this.client = new RestHighLevelClient(RestClient.builder(
                        HttpHost.create("http://192.168.150.101:9200")
                ));
            }
        
            @AfterEach
            void tearDown() throws IOException {
              
                this.client.close();
            }
        }

### 6.1 新增文档 ###

1.  索引库实体类
    
     *  数据库实体类->索引库实体类
    
        @Data
        @NoArgsConstructor
        public class HotelDoc {
              
            private Long id;
            private String name;
            private String address;
            private Integer price;
            private Integer score;
            private String brand;
            private String city;
            private String starName;
            private String business;
            private String location;
            private String pic;
        
            public HotelDoc(Hotel hotel) {
              
                this.id = hotel.getId();
                this.name = hotel.getName();
                this.address = hotel.getAddress();
                this.price = hotel.getPrice();
                this.score = hotel.getScore();
                this.brand = hotel.getBrand();
                this.city = hotel.getCity();
                this.starName = hotel.getStarName();
                this.business = hotel.getBusiness();
                this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
                this.pic = hotel.getPic();
            }
        }

![在这里插入图片描述][09db6ab0325f4bc5a3d5b57367ca4556.png]

*  导入酒店数据，基本流程一致，但是需要考虑几点变化：
    
     *  酒店数据来自于数据库，需要先查询出来，得到hotel对象
     *  hotel对象需要转为HotelDoc对象
     *  HotelDoc需要序列化为json格式
 *  因此，代码整体步骤如下：
    
    1.  根据id查询酒店数据Hotel
    2.  将Hotel封装为HotelDoc
    3.  将HotelDoc序列化为JSON
    4.  创建IndexRequest，指定索引库名和id
    5.  准备请求参数，也就是JSON文档
    6.  发送请求
    
        @Test
        void testAddDocument() throws IOException {
              
            // 1.根据id查询酒店数据
            Hotel hotel = hotelService.getById(61083L);
            // 2.转换为文档类型
            HotelDoc hotelDoc = new HotelDoc(hotel);
            // 3.将HotelDoc转json
            String json = JSON.toJSONString(hotelDoc);
        
            // 1.准备Request对象
            IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
            // 2.准备Json文档
            request.source(json, XContentType.JSON);
            // 3.发送请求
            client.index(request, RequestOptions.DEFAULT);
        }
 *  测试运行结果：  
    ![在这里插入图片描述][d0c564f48a0848a8b21993fed62af8c0.png]

### 6.2 查询文档 ###

*  询的目的是得到结果，解析为HotelDoc，因此难点是结果的解析  
    ![在这里插入图片描述][93ff2cbd93be40299d6ee331493b60e0.png]
 *  结果是一个JSON，其中文档放在一个`_source`属性中，因此解析就是拿到`_source`，反序列化为Java对象即可
 *  三步走：
    
    1.  准备Request对象。这次是查询，所以是GetRequest
    2.  发送请求，得到结果。因为是查询，这里调用client.get()方法
    3.  解析结果，就是对JSON做反序列化
 *  编写单元测试：
    
        @Test
        void testGetDocumentById() throws IOException {
              
            // 1.准备Request
            GetRequest request = new GetRequest("hotel", "61082");
            // 2.发送请求，得到响应
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
            // 3.解析响应结果
            String json = response.getSourceAsString();
        
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            System.out.println(hotelDoc);
        }

![在这里插入图片描述][a3c0e6c20dfa4a32b11d03c5cbb566a3.png]

### 6.3 修改文档 ###

*  在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：
    
     *  如果新增时，ID已经存在，则修改
     *  如果新增时，ID不存在，则新增
 *  Upsert：如果文档尚不存在，则可以使用以下upsert方法定义一些内容，这些内容将作为新文档插入
    
        String jsonString = "{\"created\":\"2017-01-01\"}";
        request.upsert(jsonString, XContentType.JSON);
 *  全量修改：
    
        @Test
            void testUpdateDocument() throws IOException {
              
                // 1.准备Request
                UpdateRequest request = new UpdateRequest("hotel", "61083");
                // 2.准备请求参数
                UpdateRequest doc = request.doc(
                        "price", "952",
                        "starName", "四钻"
                );
                request.upsert(doc, XContentType.JSON);
        
                // 3.发送请求
                client.update(request, RequestOptions.DEFAULT);
            }
    
    ![在这里插入图片描述][3ac7eca61eea419ab945076f638a6cd9.png]

--------------------

*  增量修改
    
        /**
         * 增量修改
         * @throws IOException
         */
        @Test
        void testUpdateDocument2() throws IOException {
              
            // 1.准备Request
            UpdateRequest request = new UpdateRequest("hotel", "61083");
            // 2.准备请求参数
            UpdateRequest doc = request.doc(
                    "price", "888",
                    "starName", "八钻"
            );
            // 3.发送请求
            client.update(request, RequestOptions.DEFAULT);
        }
    
    ![在这里插入图片描述][a63a0440466f4f3aa241a040cfed7cc2.png]

### 6.4 删除文档 ###

*  三步走：
    
    1.  准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id
    2.  准备参数，无参
    3.  发送请求。因为是删除，所以是client.delete()方法
    
        @Test
        void testDeleteDocument() throws IOException {
              
            // 1.准备Request
            DeleteRequest request = new DeleteRequest("hotel", "61083");
            // 2.发送请求
            client.delete(request, RequestOptions.DEFAULT);
        }

![在这里插入图片描述][5621d2a106c24fd790246120c94299b3.png]

### 6.5 批量导入文档 ###

*  **需求：利用BulkRequest批量将数据库数据导入到索引库中**
 *  步骤如下：
    
     *  利用mybatis-plus查询酒店数据
     *  将查询到的酒店数据（Hotel）转换为文档类型数据（HotelDoc）
     *  利用JavaRestClient中的BulkRequest批处理，实现批量新增文档
 *  批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。
    
     *  其中提供了一个add方法，用来添加其他请求：  
        ![在这里插入图片描述][61815ac52ce94282b91af7140cb47308.png]
 *  能添加的请求包括：
    
     *  IndexRequest：新增
     *  UpdateRequest：修改
     *  DeleteRequest：删除
 *  Bulk中添加了多个IndexRequest——批量新增功能
 *  编写单元测试
    
        @Test
        void testBulkRequest() throws IOException {
              
            // 批量查询酒店数据
            List<Hotel> hotels = hotelService.list();
        
            // 1.创建Request
            BulkRequest request = new BulkRequest();
            // 2.准备参数，添加多个新增的Request
            for (Hotel hotel : hotels) {
              
                // 2.1.转换为文档类型HotelDoc
                HotelDoc hotelDoc = new HotelDoc(hotel);
                // 2.2.创建新增文档的Request对象
                request.add(new IndexRequest("hotel")
                            .id(hotelDoc.getId().toString())
                            .source(JSON.toJSONString(hotelDoc), XContentType.JSON));
            }
            // 3.发送请求
            client.bulk(request, RequestOptions.DEFAULT);
        }
 *  测试运行结果:
    
    1.  查询数据库的数据量  
        ![在这里插入图片描述][368540b20e9d4781907fe51501b8a9dc.png]
    2.  查询索引库的文档数量  
        ![在这里插入图片描述][5217a24b5fb244d093e83b8b1bbb1176.png]

### 6.6 小结 ###

*  文档操作的基本步骤：
    
     *  初始化`RestHighLevelClient`
     *  创建`XxxRequest`。`XXX`：`Index、Get、Update、Delete、Bulk`
     *  准备参数（`Index、Update、Bulk`时需要）
     *  发送请求。调用`RestHighLevelClient#.xxx()`方法，xxx：`index、get、update、delete、bulk`
     *  解析结果（Get时需要）

[397e8975160341169374b045f3649922.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dad6a34db3be41a1bd8daf0389944f3b.png
[b1a22a3dce38478b97b5d59d3d4b75dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fd8281a6fbba44cbbb544a3d0a1eaef2.png
[933d22e4b36a40c582225abf0769b332.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5867aca6101c4a44b5703fa5fdbdfeac.png
[lucene]: https://lucene.apache.org/
[dc225bf0c43448b3a217febe8ad323d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/890da912793b4920bf57615710ce06cf.png
[elasticsearch]: https://www.elastic.co/cn/
[f6e3fd325d52403a8a4f18dda60b182a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8ffcbca235c54e10a03c54805a78aa4c.png
[-]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/90dac55b393142f9800a13095fc268f5.png
[a3f435cab046460baf6e5fe6aa1b8c43.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d72e200888e04362bfd05affd7982d64.png
[84f703b7bc7247598cea3cc3550e73f0.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/36670bb8d8de41d8aa982512bca4146d.png
[d9c2cc9004a74d088e68bdb875336465.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/583ef5d5c77648cb9600aec07542c6c6.png
[40d31eb315dd4923ba2242789e132750.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/06ede9a5a1bb421e921c03dc03dde959.png
[1dd7928aa3c94f829b07da4341b4649d.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d5b0084ee12b4f6e9723cf97105083a4.png
[288cfcede6584223ba3d5bf431937b12.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d4f5f81a95a94361a762ef90c3bb569a.png
[Elasticsearch]: https://elasticsearch.cn/download/
[2d2d30de909b4797ba26135a3ecad985.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/42101df5d79a4b82904fc4ec88c0aeb8.png
[321db3d9ed9e4b8894e8baaa7fc632a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2cf08e7ebab348988079a848234432b7.png
[92badf752da34f9888149c7e9fb556ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2d2928974e574c5489d44cebf0275356.png
[Download Kibana]: https://www.elastic.co/cn/downloads/kibana
[62ee6111af6744bb823c8a5a2e20920e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bb301627bd4a4e719ab49b74ca394055.png
[44c89ad7831a4e2c819071555783d67f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/255f9717d9a4418b9078ab05079cc82a.png
[3d6a7dc54ce54e7abe4f74eb205188e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/eea178c64e7840b5bf7b62f25152b11f.png
[b8a98b79d1cb44afb2cae28d7716fd80.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/12860ec173a84c7a907a99a9a51b1d14.png
[66abfbd05fab447a9df27f1650448eea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/44fe18c33dfa4740a9fe08c44186edba.png
[29bf78b710fb47a0a34c3650831abe51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/110038fe36704177887143e19c4d247e.png
[132bf7f1c6684507bb3162350bb801ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/323b0d17b2894fbb804afc3b2335544c.png
[0620b06b41584e1c906dd880c9309c48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/23f912403bd848e589c6e37b76efd7e3.png
[5348ab88416143d48960fd8830d781ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ed96652d654740e19e723a3bf874abb1.png
[a8e87f4fe46245b1902e5b84c306f9e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/995cfbf9e1b04b10a6074abe58227195.png
[b826e8891315467086702cbfa885812e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0ede7c15b9a6475ba7b9f345c6482e19.png
[538d605d0a1442929f7627971d43b962.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c23bc69abe4e4465bf279064c7a67ca8.png
[be6bb7d17a034e20850ba14098682c9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fb1ee52a6f254b9e98a8cbbc207585ad.png
[8848832a7d7e4aa3a56b9083ff2e09cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5150162bf5b24f61b094e0dad7eb4970.png
[Link 1]: https://www.elastic.co/guide/en/elasticsearch/client/index.html
[c3a4d0a4c3fb4ccaa1c05acfc67a051e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fd97d02311d54ba5b0ba9d4b4021d571.png
[f1e31253c0804528b38d22f8278a6140.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/966bc2d72cc74881bafdbcb83dc6cbd7.png
[494b0035946a4f8aa07b91de08bacd0d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dcf705a9c94c4d759999fc332af4eebd.png
[d8aa88bb1f284aa997e1796621d3e0d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/6882a2ea5dee44488586735dc2254915.png
[09db6ab0325f4bc5a3d5b57367ca4556.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/35d8afc6db684932803a2c6b594ac528.png
[d0c564f48a0848a8b21993fed62af8c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f594f48f3333424f9a5526e14d74ccc1.png
[93ff2cbd93be40299d6ee331493b60e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/202ade7c25b34ac5ae85cb8e77c51806.png
[a3c0e6c20dfa4a32b11d03c5cbb566a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f3ef653991354832a1eae6e05abee1e0.png
[3ac7eca61eea419ab945076f638a6cd9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a7f681edd9fa412ebb36204a2793a6f1.png
[a63a0440466f4f3aa241a040cfed7cc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c6e55a357ed245b5b69c3012021e75fc.png
[5621d2a106c24fd790246120c94299b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fa579c1464494bbf8461f35e980aa862.png
[61815ac52ce94282b91af7140cb47308.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/75fa796281374a0487f2f43ed781ad55.png
[368540b20e9d4781907fe51501b8a9dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fcf4f6c034554a7091de3d717da3060f.png
[5217a24b5fb244d093e83b8b1bbb1176.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/93e6ca45741745c7b4e2e2ee08fdf591.png