【DAY 05】Spring Cloud学习日记 ElasticSearch入门

1. 了解ElasticSearch

1.1 应用场景

ES是一个非常强大的开源搜索引擎，可以快速的从海量数据中查找到所需内容

比如我们在GitHub上搜索代码的时候，可以搜索到具体的每一行代码中的相关信息

再比如说我们在Google上搜搜相关内容，可以查找到相关的内容，并且关键字还会高亮

可以说，ES搜索在生活中被广泛的应用

1.2 ELK技术栈

elasticsearch结合kibana、Logstash、Beats，也就是elastic stack（ELK）。被广泛应用在日志数据分析、实时监控等领域：
而elasticsearch是elastic stack的核心，负责存储、搜索、分析数据。

1.3 ES和lucene

ES的底层是基于lucene实现的，它是一个由Java语言编写的搜索引擎类库，由DougCutting于1999年研发。官网地址：https://lucene.apache.org/

1.4 ES的发展史

• 2004年Shay Banon基于Lucene开发了Compass，但是Compass本身不支持分布式。
• 2010年Shay Banon 重写了Compass，取名为Elasticsearch。

ES的优势

• 支持分布式，可以进行水平扩展
• 对外使用RESTFul风格的接口，可以被任何语言调用

1.5 总结

什么是ES

• ES是一个开源的分布式搜搜引擎，可以用来搜索，日志管理，分析和系统监控等功能

什么是ELK

• 以ES为核心的技术栈，包含Beats，Logstash ，kibana、elasticsearch

什么是Lucene？

• 是一个开源的搜索引擎类库，是ES的底层实现。

2. 倒排索引

2.1 正向索引

在上图中，如果根据ID查询，那么由于索引出存在，查询速度非常快。

但是如果使用title做模糊查询的话，那么只能遍历所有的数据，导致查询效率比较低。流程如下：

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

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

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

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

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

2.2 倒排索引

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

• 文档(Document)：他是被用来搜索的数据，其中每一条数据就是一个文档。文档就对应了数据库中的一条记录。
• 词条(Term)：是对文档中的某一些数据使用某种分词算法得到的具有具体含义的词组。比如：今天天气真好啊。可以分为，今天，天气，真好，啊。这几个词条。

创建倒排索引的流程如下：

• 将没一个文档中的数据利用分词算法得到一组词条
• 创建表，每行数据包括词条，以及词条对应的文档ID
• 因此词条具有唯一性，因此可以使用词条作为索引
  

倒排索引的搜索的流程如下：

• 假设用户输入华为手机进行搜索
• 首先对用户输入内容分词，得到华为，手机
• 然后拿着词条到索引中找，可以发现符合的文档id为1，2，3
• 根据文档id找到具体的文档
  

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

2.3 正向和倒排

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

• 正向索引是根据ID索引的方式。当根据词条查询的时候，必须遍历所有的文档，然后判断是否包含所需要的词条，就是根据文档查找词条的过程
• 倒排索引正好相反，它是根据用户输入内容，转化为词条，然后拿着词条去找文档ID。是根据词条查找文档的过程

正向索引

• 优点
  • 可以给多个字段建立索引
  • 根据索引字段查询速度很快
• 缺点：对非索引字段或索引字段中的部分词条进行查找时，索引失效，只能遍历

倒排索引

• 优点：根据词条查询，模糊查询的时候，速度很快
• 缺点：只能给词条创建索引，而不是字段

3. ES中的一些概念

3.1 文档和字段

ES中存储的每一条数据就是一个文档。这些数据会格式化成JSON形式以后存储在ES中。
而Json文档中往往包含很多的字段（Field），类似于数据库中的列。

3.2 索引和映射

索引就是相同类型文档的集合，如：

• 所有用户文档，就可以组织在一起，称为用户的索引；
• 所有商品的文档，可以组织在一起，称为商品的索引；
• 所有订单的文档，可以组织在一起，称为订单的索引；
  

因此，ES中的索引就相当于数据库中的表，而数据库中的表结构就是ES中的映射。

下面将MySQL和ES中的一些概念进行了对比。

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

那么既然已经有了MySQL，我们为什么还要学习ES呢？这是因为两者的侧重点不同

• MySQL：擅长事务操作，可以保证数据的安全性和一致性
• ES：擅长海量数据的查询分析和计算

因此在实际开发中，一般是结合ES和MySQL进行使用的。对于一些安全性较高的业务，使用MySQL实现；对于查询性能要求比较高的使用ES实现。然后再基于某一种方式，让MySQL和ES中的数据保持一致性

3.3 分词器

我们之前提到，ES会将我们输入的文档进行分词，但是ES自带的分词器是基于英语的，对于中文分词效果很差，因此我们这里使用IK分词器实现对中文的分词。

IK分词器就两种模式

• ik_smart 智能切分，粗粒度
• ik_max_word 最细切分，细粒度

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

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

4. 索引库操作

索引库就类似于数据库中的表，而映射就是数据库中的表结构。要想向ES中插入数据，就必须创建索引和映射。

4.1 映射属性

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

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

例如下面的json文档：

PUT /student
{
  "mappings": {
    "properties": {
      "info" : {
        "type": "text",
        "analyzer": "ik_smart"
      },
      "stuNo" : {
        "type": "keyword",
        "index": false
      },
      "score" : {
        "type": "object",
        "properties": {
          "math" : {
            "type" : "integer",
            "index" : false
          },
          "english" : {
            "type" : "integer",
            "index" : false
          }
        }
      }
    }
  }
}

而符合上面这个映射的一条文档如下

POST /student/_doc/1 
{
  "stuNo" : "12132132",
  "info" : "今天天气真好",
  "score" : {
    "math" : 60,
    "english" : 70
  }
}

4.2 创建索引库映射

基本语法：

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

格式：

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

如创建名字为student的映射

PUT /student
{
  "mappings": {
    "properties": {
      "info" : {
        "type": "text",
        "analyzer": "ik_smart"
      },
      "stuNo" : {
        "type": "keyword",
        "index": false
      },
      "score" : {
        "type": "object",
        "properties": {
          "math" : {
            "type" : "integer",
            "index" : false
          },
          "english" : {
            "type" : "integer",
            "index" : false
          }
        }
      }
    }
  }
}

4.3 查询索引库映射

基本语法：

• 请求方式：GET

• 请求路径：/索引库名

• 请求参数：无

格式：

GET /索引库名

4.4 修改索引库映射

ES中索引库一旦创建，则无法修改索引库映。虽然说不能修改映射中已有字段，但是可以给映射新增字段
语法说明：

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

4.5 删除索引库映射

语法：

• 请求方式：DELETE

• 请求路径：/索引库名

• 请求参数：无

格式：

DELETE /索引库名

4.6 总结

索引库操作有哪些？

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

5. 文档操作

5.1 新增文档

语法：

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

示例：

# 添加文档
POST /student/_doc/1 
{
  "stuNo" : "12132132",
  "info" : "今天天气真好",
  "score" : {
    "math" : 60,
    "english" : 70
  }
}

5.2 查询文档

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

语法：

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

举例：

查询文档

GET /student/_doc/1

5.3 删除文档

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

语法：

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

举例：

# 删除
DELETE /student/_doc/1

5.4 修改文档

修改有两种方式：

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

5.4.1 全量修改

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

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

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

语法：

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

举例：

# 全量修改文档
PUT /student/_doc/1 
{
  "stuNo" : "12132132",
  "info" : "今天天气真好123",
  "score" : {
    "math" : 60,
    "english" : 70
  }
}

5.4.2 增量修改

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

语法：

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

举例：

# 修改指定的字段
POST /student/_update/1
{
  "doc": {
    "stuNo" : "88888"
  }
}

5.5 总结

文档操作有哪些？

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

6. RestAPI–RestClient

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

6.1 搭建测试环境

在MySQL中创建下表

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;

在ES中根据数据库创建映射
我们在创建映射的的和，需要考虑一下信息：

• 字段名
• 数据类型
• 是否参与搜索
• 是否需要分词
• 如果分词，使用什么分词器

其中

• 字段名，数据类型可以参考表结构
• 是否参与搜索需要根据业务判断，比如图片地址就没必要参与搜索
• 是否需要分词看一下是不是一个整体，比如酒店的品牌就是一个整体，不需要分词
• 分词器，可以统一使用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,
        "copy_to": "all"
      },
      "price" : {
        "type": "integer"
      },
      "score" : {
        "type": "integer"
      },
      "brand" : {
        "type": "keyword",
        "copy_to": "all"
      },
      
      "city" : {
        "type": "keyword",
        "copy_to": "all"
      },    
      "starName" : {
        "type": "keyword"
      },   
      "business" : {
        "type": "keyword",
        "copy_to": "all"
      },       
      "location" : {
        "type": "geo_point"
      },
      "pic" : {
        "type": "keyword",
        "index": false
      },
      "all" : {
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}

几个特殊字段说明：

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

关于ES中的地理坐标

6.2 初始化RestClient

在Java代码中通过RestHighLevelClient类建立和ES的连接，要想使用这个类需要一下三个步骤：

引入es的RestHighLevelClient依赖：

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

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

<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.12.1</elasticsearch.version>
</properties>

初始化RestHighLevelClient：

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

为了测试方面，我们在将建立和ES连接和断开连接的代码写在了一下两个方法中，使用@BeforeEach和@AfterEach注解。

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

7. RestClient操作索引库映射

7.1 创建索引库

代码分为三步：

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

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

注意：其中MAPPING_TEMPLATE是一个静态常量，内容就是上一节我们根据酒店数据表编写的JSON映射字符串。

7.2 删除索引库

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

DELETE /hotel

与创建索引库相比：

• 请求方式修改为DELETE
• 请求路径不变
• 无参数

所以代码的差异，注意体现在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);
}

7.3 判断索引库是否存在

因此与删除的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.out.println(exists ? "索引库已经存在！" : "索引库不存在！");
}

7.4 总结

索引库操作的基本步骤：

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

8. RestClient操作文档

8.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();
    }
}

8.2 新增文档

从酒店表中查询一条酒店信息，并写入到ES的hotel索引中

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

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

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

具体流程如下：

• 首先从数据库中查询一条酒店信息，得到hotel对象
• 然后将hotel对象转化成hotelDoc对象
• 将hotelDoc对象转化成JSON格式
• 创建IndexRequest对象，执行索引名称为hotel，id为酒店id
• 设置请求参数，也就是hotelDoc对象的JSON字符串
• 发送请求

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

注意：这里要使用JSON.toJSONString(hotelDoc); 不要使用toJSON()。如果使用toJSON()，会导致从ES中取出的数据序列化后属性都为NULL。

8.2 查询文档

可以看到，结果是一个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);
}

8.3 删除文档

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

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

8.4 修改文档

修改我们讲过两种方式：

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

在RestClient中，全量修改和新增的代码完全一样，这里值进行增量修改

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

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

@Test
void updateDoc() throws IOException {
    UpdateRequest request = new UpdateRequest("hotel", "38665");
    HashMap<String, Object> map = new HashMap<>();
    map.put("price", 999);
    request.doc(map);
    this.client.update(request, RequestOptions.DEFAULT);
}

这里我们可以将想要修改的字段用Map封装起来，key就是字段名，value就是修改后的值

8.5 批量导入文档

我们想要将酒店表中所有的数据都导入到ES中，如果使用简单的循环来做，需要多次向ES发送请求，导致耗时非常长，因此我们考虑将我们的请求封装起来，一次性发送给ES进行处理。在ES中我们可以利用BulkRequest批量将数据库数据导入到索引库中。

批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。其中提供了一个add方法，用来添加其他请求：

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

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

因此我们可以循环遍历所有的酒店信息，然后每遍历一条信息就创建一个Request然后存入到BulkRequest里面。当全部遍历完成后，在批量的存入ES

其实还是三步走：

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

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

8.6 总结

文档操作的基本步骤：

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