elasticsearch的入门使用01

亦凉 2023-09-24 23:55 70阅读 0赞

#### 目录 ####

*  一.索引库操作
 *   *  1.mapping映射属性
     *  2.索引库的CRUD
     *   *  2.1.创建索引库和映射
         *  2.2.查询索引库
         *  2.3.修改索引库
         *  2.4.删除索引库
 *  二.文档操作
 *   *   *  1.新增文档
         *  2.查询文档
         *  3.删除文档
         *  4.修改文档
         *   *  4.1.全量修改
             *  4.2.增量修改
         *  5.总结
 *  三. RestClient操作索引库
 *   *  3.1 初始化RestClient
     *  3.2 创建索引库
     *   *  3.2.1 代码解读
         *  4.1.2.完整示例
     *  3.2 删除索引库
     *  3.3 判断索引库是否存在
     *  3.4 总结
 *  四. RestClient操作文档
 *   *  1.新增文档
     *   *  1.1.索引库实体类
         *  1.2.语法说明
         *  1.3.完整代码
     *  2.查询文档
     *   *  2.1.语法说明
         *  5.2.2.完整代码
     *  5.3.删除文档
     *  5.4.修改文档
     *   *  5.4.1.语法说明
         *  5.4.2.完整代码
     *  5.5.批量导入文档
     *   *  5.5.1.语法说明
         *  5.5.2.完整代码
     *  5.6.小结

## 一.索引库操作 ##

索引库就类似数据库表，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": "第一次学习全局检索",
        "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；无需分词器  
        ![在这里插入图片描述][f0ed04b53de948b8ad18317d8e868632.png]

### 2.索引库的CRUD ###

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

#### 2.1.创建索引库和映射 ####

基本语法：

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

格式：

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

示例：

# 创建索引
    PUT /fruits
    {
        
      "mappings": {
        
        "properties": {
        
          "info": {
        
            "type": "text",
            "analyzer": "ik_smart"
          },
          "email": {
        
            "type": "keyword",
            "index": false
          },
          "name": {
        
            "type": "object",
            "properties": {
        
              "firstName": {
        
                "type": "keyword"
              },
              "lastName": {
        
                "type": "keyword"
              }
            }
          }
        }
      }
    }

#### 2.2.查询索引库 ####

**基本语法**：

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

**格式**：

GET /索引库名

**示例**：  
![在这里插入图片描述][3a3d34f8255d4c85aa3239115049acd9.png]

#### 2.3.修改索引库 ####

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

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

**语法说明**：

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

**示例**：

#修改索引库，添加新字段
    PUT /fruits/_mapping
    {
        
      "properties":{
        
        "price":{
        
          "type": "double"
        }
      }
    }

**测试：**  
![在这里插入图片描述][c2ce022fec95409e8ff9c2772842a489.png]  
**再次查询索引：**  
![在这里插入图片描述][d0cc351e033d41a29b8c29721017d0ca.png]

#### 2.4.删除索引库 ####

**语法：**

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

**格式：**

DELETE /索引库名

**示例**：

#删除索引
    DELETE /fruits

**测试：**  
![在这里插入图片描述][eb6be50b23aa48a3822c1ff2336fff86.png]

## 二.文档操作 ##

#### 1.新增文档 ####

![在这里插入图片描述][197ba70ae89f4546b08f85875cf120bf.png]  
**语法：**

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

**示例：**

POST /teacher/_doc/1
    {
        
        "info": "老师",
        "email": "zy@qq.cn",
        "name": {
        
            "firstName": "云",
            "lastName": "赵"
        }
    }

**测试：**  
![在这里插入图片描述][73bfe78f28e64bc6a9e485742247561e.png]

#### 2.查询文档 ####

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

**语法：**

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

**示例：**

GET /teacher/_doc/1

**测试：**  
![在这里插入图片描述][6ac94e1388f84d489455ca814b520eb1.png]

#### 3.删除文档 ####

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

**语法：**

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

**示例：**

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

**测试：**  
![在这里插入图片描述][a72367bb4fb5447fbd4f7322cb6780fd.png]

#### 4.修改文档 ####

修改有两种方式：

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

##### 4.1.全量修改 #####

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

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

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

**语法：**

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

**示例：**

#添加文档
    POST /teacher/_doc/1
    {
        
        "info": "我是曹操老师！",
        "email": "zy@qq.cn",
        "name": {
        
            "firstName": "操",
            "lastName": "曹"
        }
    }

##### 4.2.增量修改 #####

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

**语法：**

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

**示例：**

#增量修改
    POST /teacher/_update/1
    {
        
      "doc": {
        
        "info": "都是我"
      }
    }

#### 5.总结 ####

文档操作有哪些？

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

## 三. RestClient操作索引库 ##

### 3.1 初始化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.1.100: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.1.100:9200")
            ));
        }
    
        @AfterEach
        void tearDown() throws IOException {
        
            this.client.close();
        }
    }

### 3.2 创建索引库 ###

#### 3.2.1 代码解读 ####

创建索引库的API如下：![在这里插入图片描述][2d532c34d08545c7af5e466b2490a90a.png]  
代码分为三步：

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

#### 4.1.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对象
        //import org.elasticsearch.client.indices.CreateIndexRequest;
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        // 2.准备请求的参数：DSL语句
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        // 3.发送请求
        client.indices().create(request, RequestOptions.DEFAULT);
    }

### 3.2 删除索引库 ###

删除索引库的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);
    }

### 3.3 判断索引库是否存在 ###

判断索引库是否存在，本质就是查询，对应的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 ? "索引库已经存在！" : "索引库不存在！");
    }

### 3.4 总结 ###

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

索引库操作的基本步骤：

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

## 四. RestClient操作文档 ##

### 1.新增文档 ###

**资料：**[mysql数据库数据][mysql]  
我们要将数据库的酒店数据查询出来，写入elasticsearch中。

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

#### 1.2.语法说明 ####

新增文档的DSL语句如下：

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

对应的java代码如图：

![在这里插入图片描述][f9bbc330a066475b80f5b7dccb704c1b.png]  
可以看到与创建索引库类似，同样是三步走：

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

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

#### 1.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.查询文档 ###

#### 2.1.语法说明 ####

查询的DSL语句如下：

GET /hotel/_doc/{
        id}

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

*  准备Request对象
 *  发送请求

不过查询的目的是得到结果，解析为HotelDoc，因此难点是结果的解析。完整代码如下：  
![在这里插入图片描述][38ccfb52b2c641b98b1e936585e5a6ee.png]  
可以看到，结果是一个JSON，其中文档放在一个`_source`属性中，因此解析就是拿到`_source`，反序列化为Java对象即可。

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

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

#### 5.2.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);
    }

### 5.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);
    }

### 5.4.修改文档 ###

#### 5.4.1.语法说明 ####

修改我们讲过两种方式：

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

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

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

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

代码示例如图：  
![在这里插入图片描述][ec2ffc4b4851462c85a46e3e51e0eff0.png]  
与之前类似，也是三步走：

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

#### 5.4.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.5.批量导入文档 ###

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

步骤如下：

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

#### 5.5.1.语法说明 ####

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

其中提供了一个add方法，用来添加其他请求：![在这里插入图片描述][da1080cbb7a64f3aaca821ff789c5c50.png]  
可以看到，能添加的请求包括：

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

因此Bulk中添加了多个IndexRequest，就是批量新增功能了。示例：![在这里插入图片描述][3a902782e4b04656ad76d3a34f3f8ff1.png]  
其实还是三步走：

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

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

#### 5.5.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);
    }

### 5.6.小结 ###

文档操作的基本步骤：

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

[f0ed04b53de948b8ad18317d8e868632.png]: https://img-blog.csdnimg.cn/f0ed04b53de948b8ad18317d8e868632.png
[3a3d34f8255d4c85aa3239115049acd9.png]: https://img-blog.csdnimg.cn/3a3d34f8255d4c85aa3239115049acd9.png
[c2ce022fec95409e8ff9c2772842a489.png]: https://img-blog.csdnimg.cn/c2ce022fec95409e8ff9c2772842a489.png
[d0cc351e033d41a29b8c29721017d0ca.png]: https://img-blog.csdnimg.cn/d0cc351e033d41a29b8c29721017d0ca.png
[eb6be50b23aa48a3822c1ff2336fff86.png]: https://img-blog.csdnimg.cn/eb6be50b23aa48a3822c1ff2336fff86.png
[197ba70ae89f4546b08f85875cf120bf.png]: https://img-blog.csdnimg.cn/197ba70ae89f4546b08f85875cf120bf.png
[73bfe78f28e64bc6a9e485742247561e.png]: https://img-blog.csdnimg.cn/73bfe78f28e64bc6a9e485742247561e.png
[6ac94e1388f84d489455ca814b520eb1.png]: https://img-blog.csdnimg.cn/6ac94e1388f84d489455ca814b520eb1.png
[a72367bb4fb5447fbd4f7322cb6780fd.png]: https://img-blog.csdnimg.cn/a72367bb4fb5447fbd4f7322cb6780fd.png
[2d532c34d08545c7af5e466b2490a90a.png]: https://img-blog.csdnimg.cn/2d532c34d08545c7af5e466b2490a90a.png
[mysql]: https://pan.baidu.com/s/13OoS_pbT_Yx4wJ35POzobQ?pwd=1234
[f9bbc330a066475b80f5b7dccb704c1b.png]: https://img-blog.csdnimg.cn/f9bbc330a066475b80f5b7dccb704c1b.png
[38ccfb52b2c641b98b1e936585e5a6ee.png]: https://img-blog.csdnimg.cn/38ccfb52b2c641b98b1e936585e5a6ee.png
[ec2ffc4b4851462c85a46e3e51e0eff0.png]: https://img-blog.csdnimg.cn/ec2ffc4b4851462c85a46e3e51e0eff0.png
[da1080cbb7a64f3aaca821ff789c5c50.png]: https://img-blog.csdnimg.cn/da1080cbb7a64f3aaca821ff789c5c50.png
[3a902782e4b04656ad76d3a34f3f8ff1.png]: https://img-blog.csdnimg.cn/3a902782e4b04656ad76d3a34f3f8ff1.png