分布式搜索引擎Elasticsearch讲解专题

Posted 编程指南针

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了分布式搜索引擎Elasticsearch讲解专题相关的知识，希望对你有一定的参考价值。

 今天主要介绍索引库和文档的相关Rest操作，使用PostMan或者Kibbna来进行相关请求接口的调用，实现索引库的创建和维护，文档的添加和维护等。以及使用ES提供的API实现索引库和文档的CRUD操作。

3.索引库操作

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

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

3.1.mapping映射属性

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

  • type：字段数据类型，常见的简单类型有：

    • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）

    • 数值：long、integer、short、byte、double、float、

    • 布尔：boolean

    • 日期：date

    • 对象：object

  • index：是否创建索引，默认为true,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；无需分词器

3.2.索引库的CRUD

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

3.2.1.创建索引库和映射

基本语法：

  • 请求方式：PUT

  • 请求路径：/索引库名，可以自定义

  • 请求参数：mapping映射

格式：

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

示例：

PUT /znz

 "mappings": 
   "properties":     
     "info":
        "type":"text",
        "analyzer":"ik_smart"
     ,
    "email":
        "type":"keyword",
        "index":"false"
    ,
    "name":
        "properties":
           "firstName":
              "type":"keyword"
        ,
        "lastname":
             "type":"keyword"

2.2.2.查询索引库

基本语法：

  • 请求方式：GET

  • 请求路径：/索引库名

  • 请求参数：无

格式：

 GET /索引库名

2.2.3.修改索引库

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

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

语法说明： 

#修改索引库  只能添加索引字段，不能修改己有的
 PUT /znz/_mapping
 
   "properties":
     "sex":
       "type":"integer"
    
  
 

2.2.4.删除索引库

语法：

  • 请求方式：DELETE

  • 请求路径：/索引库名

  • 请求参数：无

格式：

 DELETE /索引库名

2.2.5.总结

索引库操作有哪些？

  • 创建索引库：PUT /索引库名

  • 查询索引库：GET /索引库名

  • 删除索引库：DELETE /索引库名

  • 添加字段：PUT /索引库名/_mapping

4.文档操作

4.1.新增文档

语法：

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

示例：

 #插入文档
 POST /znz/_doc/1
 
   "info":"指南针毕业设计作品",
     "email":"469603589@qq.com",
     "name":
        "firstName":"南针",
        "lastName":"指"
     
 

4.2.查询文档

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

语法：

 GET /索引库名称/_doc/id

通过kibana查看数据：

 GET /znz/_doc/1

#查询所有文档
GET /znz/_search

4.3.删除文档

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

语法：

 DELETE /索引库名/_doc/id值

示例：

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

4.4.修改文档

修改有两种方式：

  • 全量修改：直接覆盖原来的文档

  • 增量修改：修改文档中的部分字段

4.4.1.全量修改

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

  • 根据指定的id删除文档

  • 新增一个相同id的文档

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

语法：

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

示例：

 #全量修改：先删除再插入  如果找不到此文档就执行插入文档
 PUT /znz/_doc/1
 
    "info":"指南针毕业设计作品",
    "email":"469603589@qq.com",
    "name":
       "firstName":"南针",
       "lastName":"指"
     
 
  ​

4.4.2.增量修改

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

语法：

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

示例：

 POST /znz/_update/1
 
   "doc": 
     "email": "469603589@qq.com"
   
 

4.5.总结

文档操作有哪些？

  • 创建文档：POST /索引库名/_doc/文档id json文档

  • 查询文档：GET /索引库名/_doc/文档id

  • 删除文档：DELETE /索引库名/_doc/文档id

  • 修改文档：

    • 全量修改：PUT /索引库名/_doc/文档id json文档

    • 增量修改：POST /索引库名/_update/文档id "doc": 字段

5.使用API来操作索引库和文档

5.1 创建表结构

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;

5.2 操作索引库

5.2.1  定义其对应的Mapping映射

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"

为方便引用，我们定义一个常量来存储分析设计的映射结构：

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" +
            "";

几个特殊字段说明：

  • location：地理坐标，里面包含精度、纬度

  • all：一个组合字段，其目的是将多字段的值 利用copy_to合并，提供给用户搜索.其值在查询时不显示。

地理坐标说明：

copy_to说明：copy_to指向的字段字段类型要为：text。

 

 5.2.2  初始化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版本：

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

3）初始化RestHighLevelClient：

初始化的代码如下：

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

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

 package cn.znz.hotel;
 ​
 import org.apache.http.HttpHost;
 import org.elasticsearch.client.RequestOptions;
 import org.elasticsearch.client.RestClient;
 import org.elasticsearch.client.RestHighLevelClient;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 ​
 import java.io.IOException;
 ​
 ​
 public class HotelIndexTest 
     private RestHighLevelClient client;
 ​
    @Before
     public void setUp() 
         this.client = new RestHighLevelClient(RestClient.builder(
                 HttpHost.create("http://192.168.136.160:9200")
         ));
     
 ​
     @After
     public void tearDown() throws IOException 
         this.client.close();
     
 ​
    
 

5.2.3 创建索引库

代码分为三步：

  • 1）创建Request对象。因为是创建索引库的操作，因此Request是CreateIndexRequest。

  • 2）添加请求参数，其实就是DSL的JSON参数部分。因为json字符串很长，这里是定义了静态字符串常量MAPPING_TEMPLATE，让代码看起来更加优雅。

  • 3）发送请求，client.indices()方法的返回值是IndicesClient类型，封装了所有与索引库操作有关的方法。

package cn.znz.hotel;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;

import static cn.itcast.hotel.constants.HotelConstants.MAPPING_TEMPLATE;

public class HotelIndexTest 
    private RestHighLevelClient client;

   @Before
    public void setUp() 
        this.client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.136.160:9200")
        ));
    

    @After
    public void tearDown() throws IOException 
        this.client.close();
    

    @Test
    public 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.2.4.删除索引库

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

 DELETE /hotel

与创建索引库相比：

  • 请求方式从PUT变为DELTE

  • 请求路径不变

  • 无请求参数

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

  • 1）创建Request对象。这次是DeleteIndexRequest对象

  • 2）准备参数。这里是无参

  • 3）发送请求。改用delete方法

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

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

5.2.5.判断索引库是否存在

判断索引库是否存在，本质就是查询，对应的DSL是：

 GET /hotel

因此与删除的Java代码流程是类似的。依然是三步走：

  • 1）创建Request对象。这次是GetIndexRequest对象

  • 2）准备参数。这里是无参

  • 3）发送请求。改用exists方法

 @Test
 public 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.2.5.总结

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

索引库操作的基本步骤：

  • 初始化RestHighLevelClient

  • 创建XxxIndexRequest。XXX是Create、Get、Delete

  • 准备DSL（ Create时需要，其它是无参）

  • 发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete

5.3 操作文档

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

  • 初始化RestHighLevelClient

  • 我们的酒店数据在数据库，需要利用IHotelService去查询，所以注入这个接口

 package cn.znz.hotel;
 ​
 import cn.znz.hotel.pojo.Hotel;
 import cn.znz.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.136.160:9200")
         ));
     
 ​
     @AfterEach
     void tearDown() throws IOException 
         this.client.close();
     
 
 ​

5.3.1.新增文档

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

数据库查询后的结果是一个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.znz.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();
     
 
 ​

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

  • 酒店数据来自于数据库，我们需要先查询出来，得到hotel对象

  • hotel对象需要转为HotelDoc对象

  • HotelDoc需要序列化为json格式

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

  • 1）根据id查询酒店数据Hotel

  • 2）将Hotel封装为HotelDoc

  • 3）将HotelDoc序列化为JSON

  • 4）创建IndexRequest，指定索引库名和id

  • 5）准备请求参数，也就是JSON文档

  • 6）发送请求

在项目的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);
 

5.3.2 查询文档

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

  • 1）准备Request对象。这次是查询，所以是GetRequest

  • 2）发送请求，得到结果。因为是查询，这里调用client.get()方法

  • 3）解析结果，就是对JSON做反序列化

在项目的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.3.删除文档

删除的DSL为是这样的：

 DELETE /hotel/_doc/id

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

  • 1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id

  • 2）准备参数，无参

  • 3）发送请求。因为是删除，所以是client.delete()方法

在项目的HotelDocumentTest测试类中，编写单元测试：

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

5.3.4 修改文档

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

  • 1）准备Request对象。这次是修改，所以是UpdateRequest

  • 2）准备参数。也就是JSON文档，里面包含要修改的字段

  • 3）更新文档。这里调用client.update()方法

在项目的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.3.5.批量导入文档

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

步骤如下：

  • 利用mybatis-plus查询酒店数据

  • 将查询到的酒店数据（Hotel）转换为文档类型数据（HotelDoc）

  • 利用JavaRestClient中的BulkRequest批处理，实现批量新增文档

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

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

 

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

  • IndexRequest，也就是新增

  • UpdateRequest，也就是修改

  • DeleteRequest，也就是删除

其实还是三步走：

  • 1）创建Request对象。这里是BulkRequest

  • 2）准备参数。批处理的参数，就是其它Request对象，这里就是多个IndexRequest

  • 3）发起请求。这里是批处理，调用的方法为client.bulk()方法

在项目的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.3.6.小结

文档操作的基本步骤：

  • 初始化RestHighLevelClient

  • 创建XxxRequest。XXX是Index、Get、Update、Delete、Bulk

  • 准备参数（Index、Update、Bulk时需要）

  • 发送请求。调用RestHighLevelClient#.xxx()方法，xxx是index、get、update、delete、bulk

  • 解析结果（Get时需要）

以上是关于分布式搜索引擎Elasticsearch讲解专题的主要内容，如果未能解决你的问题，请参考以下文章

分布式搜索引擎Elasticsearch讲解专题

分布式搜索引擎Elasticsearch讲解专题

一起来看Java最细致的Elasticsearch讲解

分布式搜索elasticsearch配置文件详解

分布式搜索elasticsearch配置文件详解

分布式搜索引擎elasticsearch的架构原理