Elasticsearch 分布式搜索引擎 速学

一. elasticsearch入门

1. Es的概述

        elasticsearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容，它结合kibana、Logstash、Beats，也就是elastic stack（ELK）。它被广泛应用在日志数据分析、实时监控等领域，而elasticsearch是elastic stack的核心，负责存储、搜索、分析数据，底层是基于lucene来实现的，而Lucene是一个Java语言的搜索引擎类库，是Apache公司的顶级项目，由DougCutting于1999年研发。参考官网 。

2. 倒排索引

        文档（Document）：用来搜索的数据，其中的每一条数据就是一个文档。例如一个网页、一个商品信息

        词条（Term）：对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条

        将文档中指定列的内容分成各个词条，先找到用户要搜索的词条，根据词条得到保护词条的文档的id，然后根据id获取文档。

3. Es和Mysql对比

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

4. IK分词器

        4.1 安装ik插件

# 进入容器内部
docker exec -it elasticsearch /bin/bash

# 在线下载并安装
./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip

#退出
exit
#重启容器
docker restart elasticsearch

        4.2 启动容器

# 重启容器
docker restart es

# 查看es日志
docker logs -f es

        4.3 IK分词器包含两种模式

• ik_smart：最少切分

• ik_max_word：最细切分

5. 扩展词词典

        5.1 打开IK分词器config目录

        5.2 在IKAnalyzer.cfg.xml配置文件内容添加

        IK Analyzer 扩展配置
        
        ext.dic

        5.3 启动容器

docker restart es

# 查看 日志
docker logs -f elasticsearch

二. 索引库的CRUD

1. 创建索引库和映射

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

2. 查询索引库

GET /索引库名

3. 修改索引库

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

4. 删除索引库

DELETE /索引库名

三. 文档操作

1.新增文档

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

2. 查询文档

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

3. 删除文档

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

4. 修改文档

        4.1 全量修改

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

        4.2 增量修改

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

四. RestAPI

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES官方文档

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

• Java Low Level Rest Client

• Java High Level Rest Client

1. Java HighLevel Rest Client客户端AP

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

索引库操作的基本步骤：

• 初始化RestHighLevelClient

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

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

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

2. RestClient操作文档

文档操作的基本步骤：

• 初始化RestHighLevelClient

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

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

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

• 解析结果（Get时需要）

五. DSL查询文档

1. DSL查询分类

• 查询所有：

        查询出所有数据，一般测试用。例如：match_all

• 全文检索（full text）查询：

        利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如: match_query        multi_match_query

• 精确查询：

        根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：ids        range        term

• 地理（geo）查询：

        根据经纬度查询。例如：geo_distance        geo_bounding_box

• 复合（compound）查询：

        复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：bool    function_score

2. 全文检索查询

        常见的全文检索查询包括：match查询：单字段查询        multi_match查询：多字段查询，任意一个字段符合条件就算符合查询条件

        2.1 match查询语法如下：

GET /indexName/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  }
}

        2.2 mulit_match语法如下：

GET /indexName/_search
{
  "query": {
    "multi_match": {
      "query": "TEXT",
      "fields": ["FIELD1", " FIELD12"]
    }
  }
}

3. 精准查询

        精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。常见的有：term：根据词条精确值查询        range：根据值的范围查询

        3.1 term查询

// term查询
GET /indexName/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": "VALUE"
      }
    }
  }
}

        3.2 range查询

// range查询
GET /indexName/_search
{
  "query": {
    "range": {
      "FIELD": {
        "gte": 10, // 这里的gte代表大于等于，gt则代表大于
        "lte": 20 // lte代表小于等于，lt则代表小于
      }
    }
  }
}

4. 地理坐标查询

        4.1 矩形范围查询

// geo_bounding_box查询
GET /indexName/_search
{
  "query": {
    "geo_bounding_box": {
      "FIELD": {
        "top_left": { // 左上点
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": { // 右下点
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}

        4.2 附近查询

// geo_distance 查询
GET /indexName/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "FIELD": "31.21,121.5" // 圆心
    }
  }
}

5. 复合查询

        复合（compound）查询：复合查询可以将其它简单查询组合起来，实现更复杂的搜索逻辑。常见的有两种：fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名        bool query：布尔查询，利用逻辑关系组合多个其它的查询，实现复杂搜索

        5.1 相关性算分

[
  {
    "_score" : 17.850193,
    "_source" : {
      "name" : "虹桥如家酒店真不错",
    }
  },
  {
    "_score" : 12.259849,
    "_source" : {
      "name" : "外滩如家酒店真不错",
    }
  },
  {
    "_score" : 11.91091,
    "_source" : {
      "name" : "迪士尼如家酒店真不错",
    }
  }
]

        5.2 布尔查询

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {"city": "上海" }}
      ],
      "should": [
        {"term": {"brand": "皇冠假日" }},
        {"term": {"brand": "华美达" }}
      ],
      "must_not": [
        { "range": { "price": { "lte": 500 } }}
      ],
      "filter": [
        { "range": {"score": { "gte": 45 } }}
      ]
    }
  }
}

六. 搜索结果处理

1. 普通字段排序

        keyword、数值、日期类型排序的语法基本一致。

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "FIELD": "desc"  // 排序字段、排序方式ASC、DESC
    }
  ]
}

2. 地理坐标排序

        地理坐标排序略有不同。

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance" : {
          "FIELD" : "纬度，经度", // 文档中geo_point类型的字段名、目标坐标点
          "order" : "asc", // 排序方式
          "unit" : "km" // 排序的距离单位
      }
    }
  ]
}

3. 分页

        elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。elasticsearch中通过修改from、size参数来控制要返回的分页结果：from：从第几个文档开始        size：总共查询几个文档

        3.1 基本的分页

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
  ]
}

        3.2 深度分页问题

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 990, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
  ]
}

4. 高亮

GET /hotel/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT" // 查询条件，高亮一定要使用全文检索查询
    }
  },
  "highlight": {
    "fields": { // 指定要高亮的字段
      "FIELD": {
        "pre_tags": "",  // 用来标记高亮字段的前置标签
        "post_tags": "" // 用来标记高亮字段的后置标签
      }
    }
  }
}

七. RestClient查询文档

        基本步骤是：创建SearchRequest对象 --->准备Request.source()，也就是DSL(QueryBuilders来构建查询条件、传入Request.source() 的 query() 方法) --->发送请求，得到结果 --->解析结果（参考JSON结果，从外到内，逐层解析）

1. match查询

@Test
void testMatch() throws IOException {
    // 1.准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.准备DSL
    request.source()
        .query(QueryBuilders.matchQuery("all", "如家"));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);

}

2. 精确查询

        精确查询主要是两者：term：词条精确匹配        range：范围查询

3. 布尔查询

@Test
void testBool() throws IOException {
    // 1.准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.准备DSL
    // 2.1.准备BooleanQuery
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    // 2.2.添加term
    boolQuery.must(QueryBuilders.termQuery("city", "杭州"));
    // 2.3.添加range
    boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));

    request.source().query(boolQuery);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);

}

4. 排序、分页

@Test
void testPageAndSort() throws IOException {
    // 页码，每页大小
    int page = 1, size = 5;

    // 1.准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.准备DSL
    // 2.1.query
    request.source().query(QueryBuilders.matchAllQuery());
    // 2.2.排序 sort
    request.source().sort("price", SortOrder.ASC);
    // 2.3.分页 from、size
    request.source().from((page - 1) * size).size(5);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);

}

5. 高亮

        高亮的代码与之前代码差异较大，有两点：查询的DSL：其中除了查询条件，还需要添加高亮条件，同样是与query同级。        结果解析：结果除了要解析_source文档数据，还要解析高亮结果

        5.1 高亮请求构建

@Test
void testHighlight() throws IOException {
    // 1.准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.准备DSL
    // 2.1.query
    request.source().query(QueryBuilders.matchQuery("all", "如家"));
    // 2.2.高亮
    request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

八. 数据聚合

1.聚合的种类

        1.1 聚合的常见种类

Bucket：对文档数据分组，并统计每组数量

Metric：对文档数据做计算，例如avg

Pipeline：基于其它聚合结果再做聚合

        1.2 参与聚合的字段类型

keyword        数值        日期        布尔

2. DSL实现聚合

        2.1 聚合必须的三要素

聚合名称        聚合类型        聚合字段

        2.2 聚合可配置属性

size：指定聚合结果数量

order：指定聚合结果排序方式

field：指定聚合字段

3. 自动补全

        3.1 拼音分词器

        要实现根据字母做补全，就必须对文档按照拼音分词。在GitHub上恰好有elasticsearch的拼音分词插件。地址

        安装方式与IK分词器一样，分三步：解压--->上传到虚拟机中，elasticsearch的plugin目录--->重启elasticsearch--->测试

        3.2 自定义分词器

        elasticsearch中分词器（analyzer）的组成包含三部分：character filters：在tokenizer之前对文本进行处理。例如删除字符、替换字符        tokenizer：将文本按照一定的规则切割成词条（term）。例如keyword，就是不分词；还有ik_smart        tokenizer filter：将tokenizer输出的词条做进一步处理。例如大小写转换、同义词处理、拼音处理等

//声明自定义分词器的语法
PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { // 自定义分词器
        "my_analyzer": {  // 分词器名称
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": { // 自定义tokenizer filter
        "py": { // 过滤器名称
          "type": "pinyin", // 过滤器类型，这里是pinyin
		  "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "my_analyzer",
        "search_analyzer": "ik_smart"
      }
    }
  }
}

        3.3 自动补全查询

        elasticsearch提供了Completion Suggester查询来实现自动补全功能。这个查询会匹配以用户输入内容开头的词条并返回。为了提高补全查询的效率，对于文档中字段的类型有一些约束：        参与补全查询的字段必须是completion类型。        字段的内容一般是用来补全的多个词条形成的数组。

// 创建索引库
PUT test
{
  "mappings": {
    "properties": {
      "title":{
        "type": "completion"
      }
    }
  }
}

// 创建索引库
PUT test
{
  "mappings": {
    "properties": {
      "title":{
        "type": "completion"
      }
    }
  }
}

// 示例数据,插入数据
POST test/_doc
{
  "title": ["Sony", "WH-1000XM3"]
}
POST test/_doc
{
  "title": ["SK-II", "PITERA"]
}
POST test/_doc
{
  "title": ["Nintendo", "switch"]
}

// 自动补全查询,查询的DSL语句
GET /test/_search
{
  "suggest": {
    "title_suggest": {
      "text": "s", // 关键字
      "completion": {
        "field": "title", // 补全查询的字段
        "skip_duplicates": true, // 跳过重复的
        "size": 10 // 获取前10条结果
      }
    }
  }
}

九. 数据同步

        elasticsearch中的酒店数据来自于mysql数据库，因此mysql数据发生改变时，elasticsearch也必须跟着改变，这个就是elasticsearch与mysql之间的数据同步。

1. 同步调用

基本步骤：hotel-demo对外提供接口，用来修改elasticsearch中的数据        酒店管理服务在完成数据库操作后，直接调用hotel-demo提供的接口，

2. 异步通知

流程：hotel-admin对mysql数据库数据完成增、删、改后，发送MQ消息        hotel-demo监听MQ，接收到消息后完成elasticsearch数据修改

3. 监听binlog

流程：给mysql开启binlog功能        mysql完成增、删、改操作都会记录在binlog中        hotel-demo基于canal监听binlog变化，实时更新elasticsearch中的内容

4. 选择

方式一：同步调用

• 优点：实现简单，粗暴

• 缺点：业务耦合度高

方式二：异步通知

• 优点：低耦合，实现难度一般

• 缺点：依赖mq的可靠性

方式三：监听binlog

• 优点：完全解除服务间耦合

• 缺点：开启binlog增加数据库负担、实现复杂度高

十. 集群

        单机的elasticsearch做数据存储，必然面临两个问题：海量数据存储问题、单点故障问题。海量数据存储问题：将索引库从逻辑上拆分为N个分片（shard），存储到多个节点        单点故障问题：将分片数据在不同节点备份（replica ）

1. ES集群相关概念

• 集群（cluster）：一组拥有共同的 cluster name 的 节点。

• 节点（node) ：集群中的一个 Elasticearch 实例

• 分片（shard）：索引可以被拆分为不同的部分进行存储，称为分片。在集群环境下，一个索引的不同分片可以拆分到不同的节点中

• 主分片（Primary shard）：相对于副本分片的定义。

• 副本分片（Replica shard）每个主分片可以有一个或者多个副本，数据和主分片一样。

2. 集群脑裂问题

        2.1 集群职责划分

         2.2 脑裂问题

        脑裂是因为集群中的节点失联导致的。解决脑裂的方案是，要求选票超过 ( eligible节点数量 + 1 ）/ 2 才能当选为主，因此eligible节点数量最好是奇数。对应配置项是discovery.zen.minimum_master_nodes，在es7.0以后，已经成为默认配置，因此一般不会发生脑裂问题。

        2.3 集群分布式查询

        elasticsearch的查询分成两个阶段：scatter phase：分散阶段，coordinating node会把请求分发到每一个分片        gather phase：聚集阶段，coordinating node汇总data node的搜索结果，并处理为最终结果集返回给用户

         2.4 集群故障转移

        集群的master节点会监控集群中的节点状态，如果发现有节点宕机，会立即将宕机节点的分片数据迁移到其它节点，确保数据安全，这个叫做故障转移。