ElasticSearch开发知识点汇总1

拒绝画大饼

已于 2022-08-07 16:05:12 修改

阅读量427

点赞数

分类专栏： ElasticSearch 文章标签： elasticsearch 搜索引擎 java

于 2022-08-07 16:01:34 首次发布

本文链接：https://blog.csdn.net/m0_60575975/article/details/126210456

版权

ElasticSearch 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

ElasticSearch知识总结

初始ES

ElasticSearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容.
ElasticSearch技术栈:ElasticSearch可以结合kibana(数据可视化)、Logstash、Beats(数据抓取)一起使用.
倒排索引:是先找到用户要搜索的词条，根据词条得到包含词条的文档的id，然后根据id获取文档。是根据词条找文档的过程。简而言之,倒排索引就是根据内容找到对应的文档

ES概念

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

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

索引库操作

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

type：字段数据类型，常见的简单类型有
- https://www.elastic.co/guide/en/elasticsearch/reference/7.12/mapping-types.html(参考网站)
- 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
- 数值：long、integer、short、byte、double、float、
- 布尔：boolean
- 日期：date
```
PUT 索引名称
{
  "mappings": {
    "properties": {
      "date": {
        "type":   "date",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
      }
    }
  }
}
```
- 对象：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；无需分词器

索引库的CRUD

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

#创建索引库
PUT /user
{
  "mappings": {
    "properties": {
      "age":{
        "type": "integer"
      },
      "weight": {
        "type": "double"
      },
      "isMarried":{
        "type": "boolean"
      },
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": false
      },
      "score":{
        "type": "double"
      },
      "name":{
        "type": "object",
        "properties": {
          "firstName":{
            "type": "keyword"
          },
          "lastName":{
            "type": "keyword"
          }
        }
      },
      "birth":{
        "type": "date",
        "format": "yyyy-MM-dd"
      }
    }
  }
}

查询索引库
- 请求方式：GET
- 请求路径：/索引库名，可以自定义
- 请求参数：无
- 格式：

#查询索引库
GET /user

删除索引库
- 请求方式：DELETE
- 请求路径：/索引库名，可以自定义
- 请求参数：无
- 格式：

DELETE/user

修改索引库(实际上就是添加)

#修改索引库
PUT /user/_mapping
{
  "properties": {
    "sex":{
      "type": "integer"
    }
  }
}

文档操作

新增文档

#添加文档
POST /user/_doc/1
{
  "age":"23",
  "name":{
    "firstName":"云",
    "lastName":"码"
  },
  "sex":"1"
}

查询文档

#查询文档
GET /user/_doc/1

删除文档

# 根据id删除文档
DELETE /user/_doc/1

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

#修改文档(增量修改)
POST /user/_update/1
{
    "doc": {
         "weight": "59",
         "birthday":"2020-12-12"
   }
}

#修改文档(全量修改,不推荐)
PUT /user/_doc/1
{
    "weight": "590",
    "birthday":"2022-12-12"
    
}

RestAPI常用接口

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。官方文档地址：https://www.elastic.co/guide/en/elasticsearch/client/index.html
注意:在项目中使用ES和Kibana一定要保持两个版本的一致性.
初始化RestClient
- 第一步引入es的RestHighLevelClient依赖

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

- 第二步初始化RestHighLevelClient
- 创建常量类

/**
 * ES常量类
 */
public interface ESConstant {

    /**
     * es服务器主机
     */
    String ES_HOST = "";

    /**
     * es端口
     */
    int ES_PORT = 9200;

    /**
     * 索引名称
     */
    String INDEX = "hotel";

    /**
     * mapping结构
     */
    String MAPPINGS = "{\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" +
            "}";

}

- 创建配置

/**
 * RestHighLevelClient配置类
 */
@Configuration
public class RestHighLevelClientConfig {

//参数一:es服务器主机
//参数二:es端口号
    @Bean
    public RestHighLevelClient client(){
        return new RestHighLevelClient(RestClient.builder(new HttpHost(ESConstant.ES_HOST,  ESConstant.ES_PORT)));
    }

}

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

//注入RestHighLevelClient 
 @Autowired
    RestHighLevelClient client;
    /**
     * 创建索引库
     *
     * @throws Exception
     */
    @Test
    public void testCreateIndex() throws Exception {
        //创建索引请求
        CreateIndexRequest request = new CreateIndexRequest(EsConstant.INDEX);
        //提供索引映射源
        request.source(EsConstant.MAPPING, XContentType.JSON);
        //同步执行
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }

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

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

1）创建Request对象。这次是GetIndexRequest对象
2）准备参数。这里是无参
3）发送请求。改用exists方法
API代码案例

/**
     * 判断索引库是否存在
     *
     * @throws Exception
     */
    @Test
    public void testExistsIndex() throws Exception {
        //创建请求
        GetIndexRequest request = new GetIndexRequest(EsConstant.INDEX);
        //同步执行
        client.indices().exists(request, RequestOptions.DEFAULT);
    }

删除索引库

/**
     * 删除索引库
     *
     * @throws Exception
     */
    @Test
    public void testDeleteIndex() throws Exception {
        //创建请求
        DeleteIndexRequest deleteIndesRequest = new DeleteIndexRequest();
        //同步执行
        client.indices().delete(deleteIndesRequest, RequestOptions.DEFAULT);
    }

RestClient操作文档

新增文档
新增文档的DSL语句如下：

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

可以看到与创建索引库类似，同样是三步走：
- 1）创建Request对象
- 2）准备请求参数，也就是DSL中的JSON文档
- 3）发送请求
变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。
API代码案例
我们导入酒店数据，基本流程一致，但是需要考虑几点变化：
- 酒店数据来自于数据库，我们需要先查询出来，得到hotel对象
- hotel对象需要转为HotelDoc对象
- HotelDoc需要序列化为json格式
因此，代码整体步骤如下：
- 1）根据id查询酒店数据Hotel
- 2）将Hotel封装为HotelDoc
- 3）将HotelDoc序列化为JSON
- 4）创建IndexRequest，指定索引库名和id
- 5）准备请求参数，也就是JSON文档
- 6）发送请求

 /**
     * 创建文档
     *
     * @throws Exception
     */
    @Test
    public void testCreateDoc() throws Exception {
        //根据id查询酒店
        Hotel hotel = hotelMapper.selectById("581859");
        //获取HotelDoc
        HotelDoc hotelDoc = new HotelDoc(hotel);
        //转成JSON格式
        String JsonHotel = JSON.toJSONString(hotelDoc);

        //创建索引请求并设置id
        IndexRequest indexRequest = new IndexRequest(EsConstant.INDEX).id(hotel.getId().toString());
        //提供索引映射源
        indexRequest.source(JsonHotel, XContentType.JSON);
        //发送请求
        client.index(indexRequest, RequestOptions.DEFAULT);

    }

查询文档
查询的DSL语句如下：

GET /hotel/_doc/{id}

非常简单，因此代码大概分两步：
- 准备Request对象
- 发送请求
不过查询的目的是得到结果，解析为HotelDoc，因此难点是结果的解析。
- 可以看到，结果是一个JSON，其中文档放在一个_source属性中，因此解析就是拿到_source，反序列化为Java对象即可。
与之前类似，也是三步走：
- 1）准备Request对象。这次是查询，所以是GetRequest
- 2）发送请求，得到结果。因为是查询，这里调用client.get()方法
- 3）解析结果，就是对JSON做反序列化
API代码案例

/**
     * 查询文档
     *
     * @throws Exception
     */
    @Test
    public void testGetDoc() throws Exception {
        //创建索引请求并设置id
        GetRequest getRequest = new GetRequest(EsConstant.INDEX, "581859");
        //发送请求
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        //解析响应结果
        String json = response.getSourceAsString();
	    HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
	    System.out.println(hotelDoc);
    }

删除文档
删除的DSL为是这样的：

DELETE /hotel/_doc/{id}

与查询相比，仅仅是请求方式从DELETE变成GET，可以想象Java代码应该依然是三步走：
- 1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id
- 2）准备参数，无参
- 3）发送请求。因为是删除，所以是client.delete()方法
API代码案例

  /**
     * 删除文档
     *
     * @throws Exception
     */
    @Test
    public void testDeleteDoc() throws Exception {
        //创建索引请求
        DeleteRequest deleteRequest = new DeleteRequest(EsConstant.INDEX, "581859");
        //发送请求
        client.delete(deleteRequest, RequestOptions.DEFAULT);
    }

修改文档
修改我们讲过两种方式：
- 全量修改：本质是先根据id删除，再新增
- 增量修改：修改文档中的指定字段值
在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：
- 如果新增时，ID已经存在，则修改
- 如果新增时，ID不存在，则新增
这里不再赘述，我们主要关注增量修改。代码示例如图：与之前类似，也是三步走：
- 1）准备Request对象。这次是修改，所以是UpdateRequest
- 2）准备参数。可以是Map数据
- 3）更新文档。这里调用client.update()方法
API代码案例

  /**
     * 修改文档
     *
     * @throws Exception
     */
    @Test
    public void testUpdateDoc() throws Exception {
        //创建索引请求
        UpdateRequest updateRequest = new UpdateRequest(EsConstant.INDEX, "581859");
        //修改文档
        updateRequest.doc(
                "address", "杭州延安路89号",
                " city", "杭州"
        );
        //发送请求
        client.update(updateRequest, RequestOptions.DEFAULT);
    }

批量导入文档
步骤如下：
- 利用mybatis-plus查询酒店数据
- 将查询到的酒店数据（Hotel）转换为文档类型数据（HotelDoc）
- 利用JavaRestClient中的BulkRequest批处理，实现批量新增文档
API代码案例

 /**
     * 批量新增操作
     *
     * @throws Exception
     */
    @Test
    public void testBulkDoc() throws Exception {
        //创建索引请求
        //发送请求
        BulkRequest bulkRequest = new BulkRequest();
        List<Hotel> hotels = hotelMapper.selectList(null);
        for (Hotel hotel : hotels) {
            //获取HotelDoc
            HotelDoc hotelDoc = new HotelDoc(hotel);
            //转成JSON格式
            String JsonHotel = JSON.toJSONString(hotelDoc);
            //创建索引请求并设置id
            IndexRequest indexRequest = new IndexRequest(EsConstant.INDEX).id(hotel.getId().toString());
            //提供索引映射源
            indexRequest.source(JsonHotel, XContentType.JSON);
            //添加文档
            bulkRequest.add(indexRequest);
        }
        client.bulk(bulkRequest, RequestOptions.DEFAULT);
    }