SpringCloud详细介绍 zh-分布式搜索引擎(1) 05

谁借莪１个温暖的怀抱￠ 2024-03-26 21:06 24阅读 0赞

> 目标
> 
>  *  elasticsearch基础
>  *  索引库操作

## 1.初识elasticsearch ##

### 1)了解ES ###

#### (1)elasticsearch的作用 ####

`elasticsearch`是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容

例如：

*  在GitHub搜索代码

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

*  在电商网站搜索商品

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

*  在百度搜索答案  
    ![在这里插入图片描述][437d2436d2e1419db777cfaa4513cf6e.png]
 *  在打车软件搜索附近的车

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

#### (2)ELK技术栈 ####

`elasticsearch`结合`kibana`、`Logstash`、`Beats`，也就是`elastic stack`（ELK）。被广泛应用在日志数据分析、实时监控等领域：

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

而`elasticsearch`是`elastic stack`的核心，`负责存储、搜索、分析数据`。

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

#### (3)elasticsearch和lucene ####

`elasticsearch`底层是基于**lucene**来实现的。

**Lucene**是一个Java语言的搜索引擎类库，是Apache公司的顶级项目，由DougCutting于1999年研发。官网地址：https://lucene.apache.org/ 。  
![在这里插入图片描述][c1ba8168cde645bfb75422c49a0c4c4c.png]

**elasticsearch**的发展历史：

*  2004年Shay Banon基于Lucene开发了Compass
 *  2010年Shay Banon 重写了Compass，取名为Elasticsearch。

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

#### (4)为什么不是其他搜索技术？ ####

目前比较知名的`搜索引擎技术排名`：

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

虽然在早期，`Apache Solr`是最主要的搜索引擎技术，但随着发展`elasticsearch已经渐渐超越了Solr`，独占鳌头：

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

#### (5)总结 ####

什么是elasticsearch？

*  一个开源的分布式搜索引擎，可以用来`实现搜索、日志统计、分析、系统监控等功能`

什么是elastic stack（ELK）？

*  是以elasticsearch为核心的技术栈，包括`beats、Logstash、kibana、elasticsearch`

什么是Lucene？

*  是`Apache的开源搜索引擎类库`，提供了`搜索引擎的核心API`

### 2)倒排索引 ###

倒排索引的概念是基于MySQL这样的正向索引而言的。

#### (1)正向索引 ####

那么什么是正向索引呢？例如给下表（tb\_goods）中的id创建索引：

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

如果是`根据id查询`，那么直接走索引，查询速度非常快。

但如果是`基于title做模糊查询`，只能是逐行扫描数据，流程如下：

1）用户搜索数据，条件是title符合`"%手机%"`

2）逐行获取数据，比如id为1的数据

3）判断数据中的title是否符合用户搜索条件

4）如果符合则放入结果集，不符合则丢弃。回到步骤1

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

#### (2)倒排索引 ####

`倒排索引`中有两个非常重要的概念：

*  文档（`Document`）：用来`搜索的数据，其中的每一条数据就是一个文档`。例如一个网页、一个商品信息
 *  词条（`Term`）：`对文档数据或用户搜索数据`，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条

**创建倒排索引**是`对正向索引的一种特殊处理`，流程如下：

*  将每一个文档的数据`利用算法分词`，`得到一个个词条`
 *  `创建表`，每行数据包括`词条、词条所在文档id、位置等信息`
 *  因为词条唯一性，可以给词条创建索引，例如hash表结构索引

如图：

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

倒排索引的**搜索流程**如下（以搜索"华为手机"为例）：

1）用户输入条件`"华为手机"`进行搜索。

2）对用户输入内容**分词**，得到词条：`华为`、`手机`。

3）拿着词条在倒排索引中查找，可以得到包含词条的文档id：1、2、3。

4）拿着文档id到正向索引中查找具体文档。

如图：

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

虽然要先`查询倒排索引`，`再查询倒排索引`，但是无论是词条、还是文档id都建立了索引，`查询速度非常快！无需全表扫描`。

#### (3)正向和倒排 ####

那么为什么一个叫做正向索引，一个叫做倒排索引呢？

*  **正向索引**是最传统的，`根据id索引的方式`。但根据词条查询时，必须先逐条获取每个文档，然后判断文档中是否包含所需要的词条，是**根据文档找词条的过程**。
 *  而**倒排索引**则相反，是`先找到用户要搜索的词条`，`根据词条得到保护词条的文档的id，然后根据id获取文档`。是**根据词条找文档的过程**。

是不是恰好反过来了？

那么两者方式的优缺点是什么呢？

**正向索引**：

*  `优点：`
    
     *  可以给多个字段创建索引
     *  根据索引字段搜索、排序速度非常快
 *  `缺点：`
    
     *  根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。

**倒排索引**：

*  `优点：`
    
     *  根据词条搜索、`模糊搜索时，速度非常快`
 *  `缺点：`
    
     *  只能给词条创建索引，而不是字段
     *  无法根据字段做排序

### 3)es的一些概念 ###

`elasticsearch`中有很多独有的概念，与mysql中略有差别，但也有相似之处。

#### (1)文档和字段 ####

elasticsearch是面向**文档（Document）** 存储的，可以是数据库中的一条商品数据，一个订单信息。文档`数据会被序列化为json格式后存储在elasticsearch中`：

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

而Json文档中往往包含很多的**字段（Field）**，类似于数据库中的列。

#### (2)索引和映射 ####

**索引（Index）**，就是`相同类型的文档的集合`。

例如：

*  所有用户文档，就可以组织在一起，称为`用户的索引`；
 *  所有商品的文档，可以组织在一起，称为`商品的索引`；
 *  所有订单的文档，可以组织在一起，称为`订单的索引`；  
    ![在这里插入图片描述][19fc2ed053094c198da5676d15630a4b.png]

因此，我们可以把索引当做是数据库中的表。

数据库的表会有约束信息，用来定义表的结构、字段的名称、类型等信息。因此，索引库中就有**映射（mapping）**，是索引中文档的字段约束信息，类似表的结构约束。

#### (3)mysql与elasticsearch ####

我们统一的把`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>

是不是说，我们学习了elasticsearch就不再需要mysql了呢？

并不是如此，两者各自有自己的擅长支出：

*  `Mysql`：`擅长事务类型操作，可以确保数据的安全和一致性`
 *  `Elasticsearch`：`擅长海量数据的搜索、分析、计算`

因此在企业中，往往是两者结合使用：

*  `对安全性要求较高的写操作`，使用`mysql实现`
 *  对`查询性能要求较高的搜索需求`，使用`elasticsearch实现`
 *  `两者再基于某种方式，实现数据的同步，保证一致性`

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

### 4)安装es、kibana ###

#### (1)安装 ####

[es安装教程详细地址][es]

[kibana安装教程详细地址][kibana]

#### (2)分词器 ####

[ik安装教程详细地址][ik]

#### (3)总结 ####

分词器的作用是什么？

*  `创建倒排索引时对文档分词`
 *  `用户搜索时，对输入的内容分词`

IK分词器有几种模式？

*  `ik_smart`：智能切分，粗粒度
 *  `ik_max_word`：最细切分，细粒度

IK分词器如何拓展词条？如何停用词条？

*  利用config目录的IkAnalyzer.cfg.xml文件添加拓展词典和停用词典
 *  在词典中添加拓展词条或者停用词条

## 2.索引库操作 ##

索引库就类似数据库表，mapping映射就类似表的结构。

我们要向es中存储数据，必须先创建“库”和“表”。

### 1)mapping映射属性 ###

`mapping`是对索引库中文档的约束，常见的mapping属性包括：

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

例如下面的json文档：

{
        
        "age": 21,
        "weight": 52.1,
        "isMarried": false,
        "info": "黑马程序员Java讲师",
        "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；无需分词器

### 2)索引库的CRUD ###

这里我们统一使用`Kibana编写DSL的方式来演示`。

#### (1)创建索引库和映射 ####

##### 基本语法： #####

*  `请求方式`：PUT
 *  `请求路径`：/索引库名，可以自定义
 *  `请求参数`：mapping映射

格式：

PUT /索引库名称
    {
        
      "mappings": {
        
        "properties": {
        
          "字段名":{
        
            "type": "text",
            "analyzer": "ik_smart"
          },
          "字段名2":{
        
            "type": "keyword",
            "index": "false"
          },
          "字段名3":{
        
            "properties": {
        
              "子字段": {
        
                "type": "keyword"
              }
            }
          },
          // ...略
        }
      }
    }

##### 示例： #####

PUT /heima
    {
      "mappings": {
        "properties": {
          "info":{
            "type": "text",
            "analyzer": "ik_smart"
          },
          "email":{
            "type": "keyword",
            "index": "falsae"
          },
          "name":{
            "properties": {
              "firstName": {
                "type": "keyword"
              }
            }
          },
          // ... 略
        }
      }
    }

#### (2)查询索引库 ####

**基本语法**：

*  `请求方式`：GET
 *  `请求路径`：/索引库名
 *  `请求参数`：无

**格式**：

GET /索引库名

**示例**：

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

#### (3)修改索引库 ####

倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库**一旦创建，无法修改mapping**。

虽然无法修改mapping中已有的字段，但是却`允许添加新的字段到mapping`中，因为不会对倒排索引产生影响。

**语法说明**：

PUT /索引库名/_mapping
    {
        
      "properties": {
        
        "新字段名":{
        
          "type": "integer"
        }
      }
    }

**示例**：

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

#### (4)删除索引库 ####

**语法：**

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

**格式：**

DELETE /索引库名

在kibana中测试：

#### (5)总结 ####

索引库操作有哪些？

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

## 3.文档操作 ##

### 1)新增文档 ###

**语法：**

POST /索引库名/_doc/文档id
    {
        
        "字段1": "值1",
        "字段2": "值2",
        "字段3": {
        
            "子属性1": "值3",
            "子属性2": "值4"
        },
        // ...
    }

**示例：**

POST /heima/_doc/1
    {
        
        "info": "黑马程序员Java讲师",
        "email": "zy@itcast.cn",
        "name": {
        
            "firstName": "云",
            "lastName": "赵"
        }
    }

**响应：**

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

### 2)查询文档 ###

`根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把文档id带上`。

**语法：**

GET /{
        索引库名称}/_doc/{
        id}

**通过kibana查看数据：**

GET /heima/_doc/1

**查看结果：**

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

### 3)删除文档 ###

`删除使用DELETE请求，同样，需要根据id进行删除`：

**语法：**

DELETE /{
        索引库名}/_doc/id值

**示例：**

# 根据id删除数据
    DELETE /heima/_doc/1

**结果：**

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

### 4)修改文档 ###

修改有`两种`方式：

*  `全量修改`：直接覆盖原来的文档
 *  `增量修改`：修改文档中的部分字段

#### (1)全量修改 ####

`全量修改`是`覆盖原来的文档`，其本质是：

*  `根据指定的id删除文档`
 *  `新增一个相同id的文档`

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

**语法：**

PUT /{
        索引库名}/_doc/文档id
    {
        
        "字段1": "值1",
        "字段2": "值2",
        // ... 略
    }

**示例：**

PUT /heima/_doc/1
    {
        
        "info": "黑马程序员高级Java讲师",
        "email": "zy@itcast.cn",
        "name": {
        
            "firstName": "云",
            "lastName": "赵"
        }
    }

#### (2)增量修改 ####

`增量修改`是`只修改指定id匹配的文档中的部分字段。`

**语法：**

POST /{
        索引库名}/_update/文档id
    {
        
        "doc": {
        
             "字段名": "新的值",
        }
    }

**示例：**

POST /heima/_update/1
    {
        
      "doc": {
        
        "email": "ZhaoYun@itcast.cn"
      }
    }

### 5)总结 ###

文档操作有哪些？

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

## 4.RestAPI ##

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。官方文档地址：https://www.elastic.co/guide/en/elasticsearch/client/index.html

其中的`Java Rest Client`又包括两种：

*  `Java Low Level Rest Client`
 *  `Java High Level Rest Client`  
    ![在这里插入图片描述][cd71a4b966c2443f92da5d2929b1a63b.png]

我们学习的是`Java HighLevel Rest Client客户端API`

### 1)导入Demo工程 ###

#### (1)导入数据 ####

首先导入课前资料提供的数据库数据：  
![在这里插入图片描述][52aed10e8d484c32a04af49cf566974b.png]

数据结构如下：

CREATE TABLE `tb_hotel` (
      `id` bigint(20) NOT NULL COMMENT '酒店id',
      `name` varchar(255) NOT NULL COMMENT '酒店名称；例：7天酒店',
      `address` varchar(255) NOT NULL COMMENT '酒店地址；例：航头路',
      `price` int(10) NOT NULL COMMENT '酒店价格；例：329',
      `score` int(2) NOT NULL COMMENT '酒店评分；例：45，就是4.5分',
      `brand` varchar(32) NOT NULL COMMENT '酒店品牌；例：如家',
      `city` varchar(32) NOT NULL COMMENT '所在城市；例：上海',
      `star_name` varchar(16) DEFAULT NULL COMMENT '酒店星级，从低到高分别是：1星到5星，1钻到5钻',
      `business` varchar(255) DEFAULT NULL COMMENT '商圈；例：虹桥',
      `latitude` varchar(32) NOT NULL COMMENT '纬度；例：31.2497',
      `longitude` varchar(32) NOT NULL COMMENT '经度；例：120.3925',
      `pic` varchar(255) DEFAULT NULL COMMENT '酒店图片；例:/img/1.jpg',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

#### (2)导入项目 ####

然后导入课前资料提供的项目:

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

项目结构如图：  
![在这里插入图片描述][8dfd05e7f283416a8ba222b8ca3913e1.png]

#### (3)mapping映射分析 ####

创建索引库，最关键的是mapping映射，而mapping映射要考虑的信息包括：

*  `字段名`
 *  `字段数据类型`
 *  `是否参与搜索`
 *  `是否需要分词`
 *  `如果分词，分词器是什么？`

其中：

*  `字段名、字段数据类型`，可以参考`数据表结构的名称和类型`
 *  是否参与搜索要分析业务来判断，例如图片地址，就无需参与搜索
 *  是否分词呢要看内容，内容如果是一个整体就无需分词，反之则要分词
 *  分词器，我们可以统一使用ik\_max\_word

来看下酒店数据的索引库结构:

PUT /hotel
    {
        
      "mappings": {
        
        "properties": {
        
          "id": {
        
            "type": "keyword"
          },
          "name":{
        
            "type": "text",
            "analyzer": "ik_max_word",
            "copy_to": "all"
          },
          "address":{
        
            "type": "keyword",
            "index": false
          },
          "price":{
        
            "type": "integer"
          },
          "score":{
        
            "type": "integer"
          },
          "brand":{
        
            "type": "keyword",
            "copy_to": "all"
          },
          "city":{
        
            "type": "keyword",
            "copy_to": "all"
          },
          "starName":{
        
            "type": "keyword"
          },
          "business":{
        
            "type": "keyword"
          },
          "location":{
        
            "type": "geo_point"
          },
          "pic":{
        
            "type": "keyword",
            "index": false
          },
          "all":{
        
            "type": "text",
            "analyzer": "ik_max_word"
          }
        }
      }
    }

几个特殊字段说明：

*  `location`：地理坐标，里面包含精度、纬度
 *  `all`：一个组合字段，其目的是将多字段的值 利用copy\_to合并，提供给用户搜索

地理坐标说明：

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

copy\_to说明：

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

#### (4)初始化RestClient ####

在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为`RestHighLevelClient`的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。

`分为三步：`

1）引入es的`RestHighLevelClient`依赖：

<dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>elasticsearch-rest-high-level-client</artifactId>
    </dependency>

2）因为`SpringBoot默认的ES版本是7.6.2`，所以我们需要覆盖默认的ES版本：

3）`初始化RestHighLevelClient`：

初始化的代码如下：

RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
            HttpHost.create("http://192.168.150.101:9200")
    ));

这里为了单元测试方便，我们创建一个测试类HotelIndexTest，然后将初始化的代码编写在@BeforeEach方法中：

package cn.itcast.hotel;
    
    import org.apache.http.HttpHost;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.junit.jupiter.api.AfterEach;
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;
    
    import java.io.IOException;
    
    public class HotelIndexTest {
        
        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();
        }
    }

### 2)创建索引库 ###

#### (1)代码解读 ####

`创建索引库的API`如下：

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

`代码分为三步`：

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

#### (2)完整示例 ####

在hotel-demo的cn.itcast.hotel.constants包下，创建一个类，`定义mapping映射的JSON字符串常量`：

package cn.itcast.hotel.constants;
    
    public 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);
    }

### 3)删除索引库 ###

删除索引库的DSL语句非常简单：

DELETE /hotel

与创建索引库相比：

*  `请求方式从PUT变为DELTE`
 *  `请求路径不变`
 *  `无请求参数`

所以代码的差异，注意体现在Request对象上。依然是三步走：

*  1）`创建Request对象`。这次是`DeleteIndexRequest对象`
 *  2）`准备参数`。这里是`无参`
 *  3）`发送请求`。改用`delete方法`

在hotel-demo中的HotelIndexTest测试类中，编写单元测试，实现删除索引：

@Test
    void testDeleteHotelIndex() throws IOException {
        
        // 1.创建Request对象
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        // 2.发送请求
        client.indices().delete(request, RequestOptions.DEFAULT);
    }

### 4)判断索引库是否存在 ###

`判断索引库是否存在，本质就是查询，对应的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)总结 ###

`JavaRestClient`操作`elasticsearch`的流程基本类似。核心是`client.indices()方法`来`获取索引库的操作对象`。

索引库操作的基本步骤：

*  `初始化RestHighLevelClient`
 *  `创建XxxIndexRequest。XXX是Create、Get、Delete`
 *  `准备DSL（ Create时需要，其它是无参）`
 *  `发送请求。`调用RestHighLevelClient\#indices().xxx()方法，xxx是create、exists、delete

## 5.RestClient操作文档 ##

`为了与索引库操作分离`，我们再次参加一个测试类，做两件事情：

*  初始化`RestHighLevelClient`
 *  我们的酒店数据在数据库，需要利用IHotelService去查询，所以注入这个接口

package cn.itcast.hotel;
    
    import cn.itcast.hotel.pojo.Hotel;
    import cn.itcast.hotel.service.IHotelService;
    import org.junit.jupiter.api.AfterEach;
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.io.IOException;
    import java.util.List;
    
    @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();
        }
    }

### 1)新增文档 ###

我们要将数据库的酒店数据查询出来，写入elasticsearch中。

#### (1)索引库实体类 ####

数据库查询后的结果是一个Hotel类型的对象。结构如下：

@Data
    @TableName("tb_hotel")
    public class Hotel {
        
        @TableId(type = IdType.INPUT)
        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 longitude;
        private String latitude;
        private String pic;
    }

与我们的索引库结构存在差异：

*  longitude和latitude需要合并为location

因此，我们需要定义一个新的类型，与索引库结构吻合：

package cn.itcast.hotel.pojo;
    
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @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();
        }
    }

#### (2)语法说明 ####

新增文档的DSL语句如下：

POST /{
        索引库名}/_doc/1
    {
        
        "name": "Jack",
        "age": 21
    }

对应的java代码如图：

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

可以看到与`创建索引库类似，同样是三步走`：

*  1）创建Request对象
 *  2）准备请求参数，也就是DSL中的JSON文档
 *  3）发送请求

变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。

#### (3)完整代码 ####

我们导入酒店数据，基本流程一致，但是需要考虑几点变化：

*  酒店数据来自于数据库，我们需要先查询出来，得到hotel对象
 *  hotel对象需要转为HotelDoc对象
 *  HotelDoc需要序列化为json格式

因此，`代码整体步骤如下：`

*  1）`根据id查询酒店数据Hotel`
 *  2）`将Hotel封装为HotelDoc`
 *  3）`将HotelDoc序列化为JSON`
 *  4）`创建IndexRequest，指定索引库名和id`
 *  5）`准备请求参数，也就是JSON文档`
 *  6）`发送请求`

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@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);
    }

### 2)查询文档 ###

#### (1)语法说明 ####

查询的DSL语句如下：

GET /hotel/_doc/{
        id}

非常简单，因此代码大概分两步：

*  `准备Request对象`
 *  `发送请求`

不过查询的目的是得到结果，解析为HotelDoc，因此难点是结果的解析。完整代码如下：

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

可以看到，结果是一个JSON，其中文档放在一个`_source`属性中，因此解析就是拿到`_source`，反序列化为Java对象即可。

与之前类似，也是三步走：

*  1）`准备Request对象。这次是查询，所以是GetRequest`
 *  2）`发送请求，得到结果。因为是查询，这里调用client.get()方法`
 *  3）`解析结果，就是对JSON做反序列化`

#### (2)完整代码 ####

在hotel-demo的`HotelDocumentTest`测试类中，编写单元测试：

@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);
    }

### 3)删除文档 ###

删除的DSL为是这样的：

DELETE /hotel/_doc/{
        id}

与查询相比，仅仅是请求方式从`DELETE变成GET`，可以想象Java代码应该依然是三步走：

*  1）`准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id`
 *  2）`准备参数，无参`
 *  3）`发送请求。因为是删除，所以是client.delete()方法`

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@Test
    void testDeleteDocument() throws IOException {
        
        // 1.准备Request
        DeleteRequest request = new DeleteRequest("hotel", "61083");
        // 2.发送请求
        client.delete(request, RequestOptions.DEFAULT);
    }

### 4)修改文档 ###

#### (1)语法说明 ####

修改我们讲过`两种方式`：

*  `全量修改`：本质是先根据id删除，再新增
 *  `增量修改`：修改文档中的指定字段值

在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：

*  如果新增时，ID已经存在，则修改
 *  如果新增时，ID不存在，则新增

这里不再赘述，我们主要关注增量修改。

代码示例如图：

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

与之前类似，也是三步走：

*  1）准备Request对象。这次是修改，所以是UpdateRequest
 *  2）准备参数。也就是JSON文档，里面包含要修改的字段
 *  3）更新文档。这里调用client.update()方法

#### (2)完整代码 ####

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@Test
    void testUpdateDocument() throws IOException {
        
        // 1.准备Request
        UpdateRequest request = new UpdateRequest("hotel", "61083");
        // 2.准备请求参数
        request.doc(
            "price", "952",
            "starName", "四钻"
        );
        // 3.发送请求
        client.update(request, RequestOptions.DEFAULT);
    }

### 5)批量导入文档 ###

案例需求：利用BulkRequest批量将数据库数据导入到索引库中。

步骤如下：

*  利用mybatis-plus查询酒店数据
 *  将查询到的酒店数据（Hotel）转换为文档类型数据（HotelDoc）
 *  利用JavaRestClient中的BulkRequest批处理，实现批量新增文档

#### (1)语法说明 ####

`批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。`

其中提供了一个add方法，用来添加其他请求：

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

可以看到，能添加的请求包括：

*  `IndexRequest`，也就是新增
 *  `UpdateRequest`，也就是修改
 *  `DeleteRequest`，也就是删除

因此Bulk中添加了多个IndexRequest，就是批量新增功能了。示例：

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

其实还是三步走：

*  1）`创建Request对象`。这里是BulkRequest
 *  2）`准备参数`。批处理的参数，就是其它Request对象，这里就是多个IndexRequest
 *  3）`发起请求`。这里是批处理，调用的方法为client.bulk()方法

我们在导入酒店数据时，将上述代码改造成for循环处理即可。

#### (2)完整代码 ####

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@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);
    }

### 6)小结 ###

文档操作的基本步骤：

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

[7c74c659d15743b1979ac6cdf20b6354.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0ae8edea08d2483994879d3b50d0919c.png
[2cb7c7c472d64cd98801d5fb772b1cc4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/eb37830bf774407581e7102edff15e14.png
[437d2436d2e1419db777cfaa4513cf6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5a35793dedd946f58e8c197ee9c72b6d.png
[f283008e680644518e3dfff05673dcd8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1dae765a2e6042fa9d908f4d92dd3329.png
[bf0ab0af03c44df09c59ce04b5d8ec14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fd1b33a70d02426cba0411b9b73bdd1e.png
[3fa6db07a7144793b9ffdaf75758d0c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d749a23344a94a268985b64bd55f0a4f.png
[c1ba8168cde645bfb75422c49a0c4c4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/878a22be5dac4662a240d25c51013452.png
[231b5fe1752544cc8f636f96d483922f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/367219d1d12d459ab6c8c192bb6e39c2.png
[e1295ebc80ca484ebca9b72095996816.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3b31e817c494424ba86d0bbfff1e2cdd.png
[4c1ca1c3461244a484ce87a12df67b84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ce5267f6da4a49688e2217d5d3c89bbc.png
[b5294bc30fe249caa5b165927952d710.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c55cb637dfbc4945acafe814d52955a4.png
[a5729b786e654858bd3d70790b2c4365.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/16c6f2e820fc49b8a46d5993388a4cb9.png
[6b17031575064d00a154565d3ae04a0d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3d3e76fe3c7e4ba287e465c8f1a3a154.png
[69da02371b9440649b306f2cc6549159.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b90b3dcca0374765be0ed483979e16ff.png
[19fc2ed053094c198da5676d15630a4b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e80c5bc2314a4fc697e574a77ec9de17.png
[a79456138dfa40a4b11748bdd4b8bf80.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/18f256eddcc549e1aed44fde498b2a91.png
[es]: https://blog.csdn.net/weixin_45428910/article/details/129847053
[kibana]: https://blog.csdn.net/weixin_45428910/article/details/129847854
[ik]: https://blog.csdn.net/weixin_45428910/article/details/129849144
[e01c95e17c89431fa0709385d94adca2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/58af3eaae149487aa3f4672932d496b5.png
[45783e22bafe4b2dbe18b6b7b0bb76a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d87e9a731ceb484f9b6dea41445ff405.png
[e79c6b2298ee410f88c8349f114992a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/be3ea71d42484fd095e71d68d5119284.png
[5c3c74031b714a4b88c86a55ece68b81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b4258a8be4614b3f8ea0c5ee4d93596f.png
[6f4e86e92ec34f0ebe82dc475bc1a4de.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dac930629966474eadf7a8bc632da2f4.png
[cd71a4b966c2443f92da5d2929b1a63b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e0d692014755438cbb8dcfd5267c2843.png
[52aed10e8d484c32a04af49cf566974b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/6159961ab7bf4b7ca4106c713c548a74.png
[ea1c8e7f73aa473abad78dac327db7cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8346fdbca692406eb2c6c65a86624051.png
[8dfd05e7f283416a8ba222b8ca3913e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/87183d2a51d74e29aeb950000c2048db.png
[d25d2b121ffd48e584f4b93df8247a2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0cf50627f150476f9512b83f32844b1f.png
[7008433e0b624eca8c3fed9465a07dd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/273b8ef09ce8491a8e01663049e60053.png
[dd7eefe75045493fa28b660b0c426082.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/98ddb75baebe41f1afde859b7276a078.png
[14ec16647b5b4e668a547056115509c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d00f198a13a947f58490f7103220eb79.png
[5475f882c4144b0aa3d518ba165316a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c781d292d11949309e9d2cf272c328c3.png
[f545f34987a845ce986de2f985ea72e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/81b585dd7fd54ba5bdd33be4b1417626.png
[5c21ded51537453dbe90b5129b7e7e66.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/61d67b48b0dd4a01a80cb21f86d6e0be.png
[d3842644feb243e7b12ff3f2a92e080e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ed16442f260d4639945d8f190f855a21.png