使用ES的数据搜索功能

2025-01-12 约 8632 字预计阅读 18 分钟

$使用ES的数据搜索功能_es 搜索field:[{"value":"""中文"""}]$

使用ES的数据搜索功能

DSL查询文档

elasticsearch的查询是基于JSON风格的DSL来实现的

使用下面的代码首先看es的，把数据批量导入之后在运行在Kibana中

查询所有，查询类型时match_all ，没有查询条件

#显示所有
GET /hotel/_search
{
  "query": {
    "match_all": {
      
    }
  }
}

全文检索查询：

使用场景：对内容分词得到词条，根据词条去倒排索引库中匹配，得到文档id。根据文档id找到文档，返回给用户。（因为时词条去匹配，字段是可分词的text类型的字段）

match查询：单字段查询

#单字段查询
GET /hotel/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  }
}

multi

#多字段查询，结果只能是并集     
GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "外滩如家",
      "fields": ["name","all"]
    }
  }
}

#多字段分词查询 结果可控，并集或交集 OR AND
GET /hotel/_search
{
"query": {
"query_string": {
"fields": ["name","all"],
"query": "北京 OR 如家"
}
}
}

#多字段查询，结果可控，交集或并集 + |
GET /hotel/_search
{
"query": {
"simple_query_string": {
"query": "北京+如家",
"fields": ["name","all"]
}
}
}

精确查询：一般用于查找 keyword，数值，日期，boolean 等字段，不会对搜索条件分词

term 查询：不分词的词条，查询时用户输入内容和自动值完全匹配才符合条件

##term 查询，根据字段值精确查询 FIELD 是符合的字段
GET /hotel/_search
{
"query": {
"term": {
"FIELD": {
"value": "VALUE"
}
}
}
}

range 查询：范围查询，一般是对数值型做范围过滤的时候，（如果要复制，把#和前面的空格删除）

#range 查询 范围查询
GET /hotel/_search
{
"query": {
"range": {
"price": {
"gte": 1000, #gte 表示大于等于，gt 表示大于
"lte": 3000 #lte 代表小于等于，lt 表示小于
}
}
}
}

地理坐标查询

根据经纬度查询，官方文档：

geo_bounding_box ：矩形查询，坐标落在某个矩形范围的文档，查询时指定矩形左上，右下两个点的坐标（如果要复制，把#和前面的空格删除）

#矩形查询
GET /hotel/_search
{
"query": {
"geo_bounding_box":{
"location":{
"top_left":{ #左上
"lat":31.1,
"lon":121.5
},
"bottom_right":{ #右下
"lat":30.9,
"lon":121.7
}
}
}
}
}

附近查询：也叫距离查询（geo_distance）：查询到指定中心点小于某个距离值的所有文档。

圆型查询

#圆形查询
GET /hotel/_search
{
"query": {
"geo_distance":{
"distance": "15km" , #半径
"location": "31.21,121.5" #圆心
}
}
}

复合查询：将其他简单查询组合起来，实现更复杂的搜索逻辑

fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名

bool query：布尔查询，利用逻辑关系组合多个其它的查询，实现复杂搜索

相关性算法：在用 match 查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列。

在 es5.1 之前的版本使用 TF-IDF 算法

在 5.1 版本之后使用 BM25 算法

算法函数查询

原始查询 查询条件：query 部分，基于这个条件搜索文档，基于 BM25 算法给文档打分，原始算分（query score）
过滤条件：filter 部分，符合该条件的文档从新算分
算法函数：符合 filter 条件的文档要根据这个函数做运算，得到的 函数算分 （function score），有四种函数 weight：函数结果是常量 field_value_factor：以文档中的某个字段值作为函数结果 random_score：以随机数作为函数结果 script_score：自定义算分函数算法
运算模式：算法函数的结果，原始查询的相关性算分，两者之间的运算方法。包括 multiply 相乘 replace 用 function score 替换 query score 其它，例如：sum、avg、max、min 等
function score 的运行流程如下：
1）根据 原始条件 查询搜索文档，并且计算相关性算分，称为 原始算分 （query score）
2）根据 过滤条件 ，过滤文档
3）符合 过滤条件 的文档，基于 算分函数 运算，得到 函数算分 （function score）

4）将 原始算分 （query score）和 函数算分 （function score）基于 运算模式 做运算，得到最终结果，作为相关性算分。

#算法相关性 满足外滩条件的所有查询中，满足如家的相关性算法加 10，获得查询结果
GET /hotel/_search
{
"query": {
"function_score": {
"query": {"match": {
"all": "外滩"
}},
"functions": [
{
"filter":{"term": {
"brand": "如家"
}
},
"weight": 10
}
],
"boost_mode":"sum"
}
}
}

布尔查询：一个或多个查询子句的组合，每个子句就是一个子查询。每一个不同的字段，其查询的条件、方式都不一样，必须是多个不同的查询，而要组合这些查询，就必须用 bool 查询了。

must：必须匹配每个子查询，类似”与“

should：选择性匹配子查询，类似”或“

must_not:不匹配，不参与算法，类似’非‘

filter：必须匹配，不参与算分

#布尔查询
#must:必须匹配每个子查询
#should 选择性匹配
#must_not 不匹配 不参与算分
#filter 必须匹配，不参与算分
#-城市在北京，品牌二选一、价格不小于 500、评分大于 45
GET /hotel/_search
{
"query": {
"bool": {
"must": [
{
"term": {
"city": {
"value": "北京"
}
}
}
],
"should": [
{
"term": {
"brand": {
"value": "皇冠假日"
}
}
},
{
"term": {
"brand": {
"value": "华美达"
}
}
}
],
"must_not": [
{
"range":{
"price": {
"lte": 500
}
}
}
],
"filter": [
{"range": {
"score": {
"gte": 45
}
}}
]
}
}
}

#boolean 查询 名字包含如家 、价格不高于 400
GET /hotel/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"name": "如家"
}
}
],
"must_not": [
{
"range": {
"price": {
"gte": 400

            }
          }
        }
      ]
    }

}
}

将搜索结构按指定方式处理

elasticsearch 默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。可以排序字段类型有：keyword 类型、数值类型、地理坐标类型、日期类型等。

1.普通字段排序：keyword、数值、日期类型排序的语法基本一致。排序条件可以是多个，依次排序

#搜索方法结果处理(简写) FIELD 是排序字段，排序方式 ASC,DESC
GET /hotel/_search
{
"query": {
"match": {
"name": "北京如家"
}
},
"sort":[
{
"FIELD":"desc"
}]
}
GET /hotel/_search
{
"query": {
"match": {
"name": "北京如家"
}
},
"sort": [
{
"price": {
"order": "desc"
}
}
]
}

基本的分页

#分页 from 分页开始位置默认为 0 size 期望获取的文档总数
GET /hotel/_search
{
"query": {
"match_all": {}
},
"from": 200
, "size": 1
}

深度分页问题

要查询 990~1000 的数据，查询逻辑要这么写

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

查询从 990 开始的数据，也就是 990~1000 条数据

如果 es 是单点模式，elasticsearch 内部分页时，先查询 0~1000 条，然后截取其中的 990 ~ 1000 的这 10 条

如果 es 是集群模式，例如集群有 5 个节点，查询 TOP1000 的数据，并不是每个节点查询 200 条就可以了。因为节点 A 的 TOP200，在另一个节点可能排到 10000 名以外了。因此要想获取整个集群的 TOP1000，必须先查询出每个节点的 TOP1000，汇总结果后，重新排名，重新截取 TOP1000。

当查询分页深度较大时，汇总数据过多，对内存和 CPU 会产生非常大的压力，因此 elasticsearch 会禁止 from+ size 超过 10000 的请求。

针对深度分页，es 提供了两种解决方式：

1.search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。

2.scroll：原理将排序后的文档 id 形成快照，保存在内存。官方已经不推荐使用。

分页查询的常见实现方法

from + size ：
- 优点：支持随机翻页
- 缺点：深度分页问题，默认查询上限（from + size）是 10000
- 场景：百度、京东、谷歌、淘宝这样的随机翻页搜索
after search ：
- 优点：没有查询上限（单次查询的 size 不超过 10000）
- 缺点：只能向后逐页查询，不支持随机翻页
- 场景：没有随机翻页需求的搜索，例如手机向下滚动翻页
scroll ：
- 优点：没有查询上限（单次查询的 size 不超过 10000）
- 缺点：会有额外内存消耗，并且搜索结果是非实时的
- 场景：海量数据的获取和迁移。从 ES7.1 开始不推荐，建议用 after search 方案。

高亮显示：在搜索的时候关键字变成红色，比较醒目

实现高亮，就是给文档中的所有关键字都添加一个标签，例如 <em> 标签，页面给 <em> 标签编写 CSS 样式

#高亮

GET /hotel/_search
{
"query": {
"match": {
"name": "北京如家"
}
}
, "highlight": {
"fields": {
"name": {
"pre_tags": "<em>"
, "post_tags": "</em>"
}
}
}
}

默认情况下， 高亮的字段，必须与搜索指定的字段一致 ，否则无法高亮。如果要对非搜索字段高亮，则需要添加一个属性：required_field_match=false

RestClient 查询文档

前期准备，先连接上虚拟机中的 es

@SpringBootTest
public class HotelSearchTest {

    //初始化ES客户端连接实例
    private RestHighLevelClient client;
    //单元测试执行前创建客户端实例
    @BeforeEach
    void initClient(){
        client = new RestHighLevelClient(RestClient.builder(HttpHost.create("192.168.190.136:9200")));
    }
    //单元测试执行后关系客户端实例
    @AfterEach
    void closeClient(){
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

发起请求代码解读：

第一步，创建 SearchRequest 对象，指定索引库名
第二步，利用 searchRequest.source()构建 DSL，DSL 中可以包含查询、分页、排序、高亮等
- query() ：代表查询条件，利用 QueryBuilders.matchAllQuery() 构建一个 match_all 查询的 DSL
第三步，利用 client.search()发送请求，得到响应

 //查询所有
@Test
void testMatchAll(){
//1 创建搜索请求对象
SearchRequest searchRequest = new SearchRequest("hotel");
//2 设置搜索类型
searchRequest.source().query(QueryBuilders.matchAllQuery());

        try {
            //3.发起请求
            SearchResponse searchResponse  = client.search(searchRequest, RequestOptions.DEFAULT);
            //4.解析响应结果（从外向内解析）
            long total = searchResponse.getHits().getTotalHits().value;
            //4.2 遍历获取命中的具体文档数据SON字符串
            SearchHit[] searchHits = searchResponse.getHits().getHits();
            if(searchHits!=null && searchHits.length>0){
                for (SearchHit hit : searchHits) {
                    String hotelDocJson = hit.getSourceAsString();
                    System.out.println("命中的数据：" + hotelDocJson);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

响应结果解析：elasticsearch返回的结果是一个JSON字符串

hits ：命中的结果
- total ：总条数，其中的value是具体的总条数值
- max_score ：所有结果中得分最高的文档的相关性算分
- hits ：搜索结果的文档数组，其中的每个文档都是一个json对象
  - _source ：文档中的原始数据，也是json对象

因此，我们解析响应结果，就是逐层解析JSON字符串，流程如下：

SearchHits ：通过response.getHits()获取，就是JSON中的最外层的hits，代表命中的结果
- SearchHits#getTotalHits().value ：获取总条数信息
- SearchHits#getHits() ：获取SearchHit数组，也就是文档数组
  - SearchHit#getSourceAsString() ：获取文档结果中的_source，也就是原始的json文档数据

   //查询类型2：全文检索查询
    @Test
    void testMatch(){
        //1.创建搜索对象
        SearchRequest searchRequest  = new SearchRequest("hotel");
        //2设置搜索类型
        //单字段查询
        //searchRequest.source().query(QueryBuilders.matchQuery("name","北京如家"));

        //多字段查询
        searchRequest.source().query(QueryBuilders.multiMatchQuery("北京如家","name","all"));

        try {
            //3发起请求
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

            //4解析响应结果
            //4.1搜索名中的记录总数
            long total = searchResponse.getHits().getTotalHits().value;
            //4.2 遍历获取命中的具体文档数据SON字符串
            SearchHit[] searchHits = searchResponse.getHits().getHits();
            if(searchHits!=null&&searchHits.length>0){
                for (SearchHit hit : searchHits) {
                    String hotelDocJson = hit.getSourceAsString();
                    System.out.println("命中数据"+hotelDocJson);
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    //查询3，精确查询
    @Test
    void testTerm(){
        //创建搜索实例
        SearchRequest searchRequest = new SearchRequest("hotel");

        //2.设置搜索类型
        //term查询
        //searchRequest.source().query(QueryBuilders.termQuery("city","上海"));

        //ids查询
        //searchRequest.source().query(QueryBuilders.idsQuery().addIds("45845","47066"));

        //range查询
        searchRequest.source().query(QueryBuilders.rangeQuery("price").gte(300).lte(500));
        try {

            //3.发起请求
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

            //4.解析响应结果（从外向内解析）
            //4.1 搜索命中的记录总数
            long total = searchResponse.getHits().getTotalHits().value;
            System.out.println("总记录数：" + total);
            //4.2 遍历获取命中的具体文档数据SON字符串
            SearchHit[] searchHits = searchResponse.getHits().getHits();
            if(searchHits!=null && searchHits.length>0){
                for (SearchHit hit : searchHits) {
                    String hotelDocJson = hit.getSourceAsString();
                    System.out.println("命中的数据：" + hotelDocJson);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    //查询4 布尔查询
    @Test
    void testComp() {
        //创建查询请求对象
        SearchRequest searchRequest = new SearchRequest("hotel");
        //设置搜索类型
        //创建布尔查询
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        //添加must条件
        boolQuery.must(QueryBuilders.termQuery("city", "上海"));
        //添加filter条件
        boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));

        //构建查询语句
        searchRequest.source().query(boolQuery);
        try {

            //3.发起请求
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

            //4.解析响应结果（从外向内解析）
            //4.1 搜索命中的记录总数
            long total = searchResponse.getHits().getTotalHits().value;
            System.out.println("总记录数：" + total);
            //4.2 遍历获取命中的具体文档数据SON字符串
            SearchHit[] searchHits = searchResponse.getHits().getHits();
            if (searchHits != null && searchHits.length > 0) {
                for (SearchHit hit : searchHits) {
                    String hotelDocJson = hit.getSourceAsString();
                    System.out.println("命中的数据：" + hotelDocJson);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 查询结果处理：排序和分析
     */
    @Test
    void testSortAndPage(){
        //1.创建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("hotel");

        //2.设置搜索类型
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(QueryBuilders.termQuery("city","上海"));
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(250));

        //range查询
        searchRequest.source().query(boolQueryBuilder);

        searchRequest.source().from(0).size(3);//从第0条开始查询3条
        searchRequest.source().sort("price", SortOrder.DESC);//按照价格倒序
        try {

            //3.发起请求
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

            //4.解析响应结果（从外向内解析）
            //4.1 搜索命中的记录总数
            long total = searchResponse.getHits().getTotalHits().value;
            System.out.println("总记录数：" + total);
            //4.2 遍历获取命中的具体文档数据SON字符串
            SearchHit[] searchHits = searchResponse.getHits().getHits();
            if(searchHits!=null && searchHits.length>0){
                for (SearchHit hit : searchHits) {
                    String hotelDocJson = hit.getSourceAsString();
                    System.out.println("命中的数据：" + hotelDocJson);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 查询结果处理：高亮
     */
    @Test
    void  testHighLight(){
        //1.创建搜索请求对象
        SearchRequest searchRequest = new SearchRequest("hotel");

        //2.设置搜索类型
        searchRequest.source().query(QueryBuilders.matchQuery("all","北京酒店"));

        searchRequest.source().from(8).size(10);//从第4条开始查询3条
        searchRequest.source().sort("price", SortOrder.DESC);//按照价格倒序

// HighlightBuilder highlightBuilder = new HighlightBuilder();
// highlightBuilder.field("name"); //高亮字段
// highlightBuilder.requireFieldMatch(false); //高亮字段是否与查询条件字段一致
// highlightBuilder.preTags("<em>"); //高亮前置标签
// highlightBuilder.postTags("</em>"); //高亮后置标签

        searchRequest.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false).preTags("<em>").postTags("</em>"));
        try {

            //3.发起请求
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

            //4.解析响应结果（从外向内解析）
            //4.1 搜索命中的记录总数
            long total = searchResponse.getHits().getTotalHits().value;
            System.out.println("总记录数：" + total);
            //4.2 遍历获取命中的具体文档数据SON字符串
            SearchHit[] searchHits = searchResponse.getHits().getHits();
            if(searchHits!=null && searchHits.length>0){
                for (SearchHit hit : searchHits) {
                    String hotelDocJson = hit.getSourceAsString();
                    HotelDoc hotelDoc = JSON.parseObject(hotelDocJson, HotelDoc.class);

                    HighlightField highlightField = hit.getHighlightFields().get("name");
                    if(highlightField!=null){
                        //获取带高亮标签的酒店名称
                        String highLightName = highlightField.getFragments()[0].toString();
                        hotelDoc.setName(highLightName);
                    }

                    System.out.println("处理后的数据：" + JSON.toJSONString(hotelDoc));
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

高亮结果解析，高亮的结果与查询的文档结果默认是分离的

代码解读：

第一步：从结果中获取 source。hit.getSourceAsString()，这部分是非高亮结果，json 字符串。还需要反序列为 HotelDoc 对象
第二步：获取高亮结果。hit.getHighlightFields()，返回值是一个 Map，key 是高亮字段名称，值是 HighlightField 对象，代表高亮值
第三步：从 map 中根据高亮字段名称，获取高亮字段值对象 HighlightField
第四步：从 HighlightField 中获取 Fragments，并且转为字符串。这部分就是真正的高亮字符串了
第五步：用高亮的结果替换 HotelDoc 中的非高亮结果

数据聚合

聚合（aggregations)可以让我们方便的实现对数据的统计运算分析

聚合常见的三类：

桶（Bucket） 聚合：用来对文档分组

度量（Metric） 聚合：用以计算一些值

管道（pipeline） 聚合：其他聚合的结果为基础做聚合

注：参加聚合的字段必须为 keyword，日期，数值，布尔类型

DSL 实现聚合

Bucket 聚合语法

GET /hotel/_search
{
  "size": 0,  //  设置 size 为 0，结果中不包含文档，只包含聚合结果
  "aggs": { //  定义聚合
    "brandAgg": { //给聚合起个名字
      "terms": { //  聚合的类型，按照品牌值聚合，所以选择 term
        "field": "brand", //  参与聚合的字段
        "size": 20 //  希望获取的聚合结果数量
      }
    }
  }
}

默认情况下，Bucket 聚合会统计 Bucket 内的文档数量，记作 count，并按照 count 降序排序

指定 order 属性，自定义聚合的排序方式：

GET /hotel/_search
{
  "size": 0, 
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "order": {
          "_count": "asc" //  按照_count 升序排列
        },
        "size": 20
      }
    }
  }
}

限定聚合范围

默认情况下，Bucket 聚合是对索引库的所有文档做聚合，但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。可以限定要聚合的文档范围，只要添加 query 条件即可：

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200 // 只对 200 元以下的文档聚合
      }
    }
  }, 
  "size": 0, 
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

Metric 聚合语法

GET /hotel/_search
{
  "size": 0, 
  "aggs": {
    "brandAgg": { 
      "terms": { 
        "field": "brand", 
        "size": 20
      },
      "aggs": { //  是 brands 聚合的子聚合，也就是分组后对每组分别计算
        "score_stats": { //  聚合名称
          "stats": { //  聚合类型，这里 stats 可以计算 min、max、avg 等
            "field": "score" //  聚合字段，这里是 score
          }
        }
      }
    }
  }
}

score_stats 聚合是在 brandAgg 的聚合内部嵌套的子聚合。因为我们需要在每个桶分别计算。

聚合的三要素：聚合名称，聚合类型，聚合字段

聚合可配置属性：

size：指定聚合结果数量 order：指定聚合结果排序方式 field：指定聚合字段

自动补全

在搜索框输入字符时，我们应该提示出与该字符有关的搜索项。要实现根据字母做补全，就必须对文档按照拼音分词。在 GitHub 上恰好有 elasticsearch 的拼音分词插件。地址：安装方式：

自定义分词器

默认的拼音分词器会将每个汉字单独分为拼音，而我们希望的是每个词条形成一组拼音，需要对拼音分词器做个性化定制，形成自定义分词器。

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"
      }
    }
  }
}

为了避免搜索到同音字，搜索时不要使用拼音分词器

自动补全查询

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

参与补全查询的字段必须是 completion 类型。
字段的内容一般是用来补全的多个词条形成的数组。

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

数据同步

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

常见的同步方式：1.同步调用 2.异步通知 3.监听 binlog

同步调用

基本步骤如下：

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

异步通知

流程如下：

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

监听 binlog

流程如下：

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

选择

方式一：同步调用

优点：实现简单，粗暴
缺点：业务耦合度高

方式二：异步通知

优点：低耦合，实现难度一般
缺点：依赖 mq 的可靠性

方式三：监听 binlog

优点：完全解除服务间耦合
缺点：开启 binlog 增加数据库负担、实现复杂度高

集群

单机的 elasticsearch 做数据存储，必然面临两个问题：海量数据存储问题、单点故障问题。

海量数据存储问题：将索引库从逻辑上拆分为 N 个分片（shard），存储到多个节点
单点故障问题：将分片数据在不同节点备份（replica ）

ES 集群相关概念 :

集群（cluster）：一组拥有共同的 cluster name 的节点。
节点（node) ：集群中的一个 Elasticearch 实例
分片（shard）：索引可以被拆分为不同的部分进行存储，称为分片。在集群环境下，一个索引的不同分片可以拆分到不同的节点中解决问题：数据量太大，单点存储量有限的问题。

主分片（Primary shard）：相对于副本分片的定义。
副本分片（Replica shard）每个主分片可以有一个或者多个副本，数据和主分片一样。

数据备份可以保证高可用，但是每个分片备份一份，所需要的节点数量就会翻一倍，成本实在是太高了！

为了在高可用和成本间寻求平衡，我们可以这样做：

首先对数据分片，存储到不同节点
然后对每个分片进行备份，放到对方节点，完成互相备份

这样可以大大减少所需要的服务节点数量，如图，我们以 3 分片，每个分片备份一份为例：

集群职责划分

默认情况下，集群中的任何一个节点都同时具备上述四种角色。

真实的集群一定要将集群职责分离：

master 节点：对 CPU 要求高，但是内存要求低。参与集群选主，主节点可以管理集群状态、管理分片信息、处理创建和删除索引库的请求
data 节点：对 CPU 和内存要求都高。数据的 CRUD
coordinating 节点：对网络带宽、CPU 要求高。路由请求到其它节点，合并查询到的结果，返回给用户

职责分离可以让我们根据不同节点的需求分配不同的硬件去部署。而且避免业务之间的互相干扰。

一个典型的 es 集群职责划分如图：

集群中的脑裂问题：

脑裂是因为集群中的节点失联导致的，例如一个集群中，主节点 m 与其他节点失联。此时，其他节点任务主节点宕机，会重新选择选主。当选出新的主节点 n 时，n 和其他节点自成集群，m 自成集群，两个集群数据不同步，出现数据差异。当网络恢复时，因为集群中有两个主节点，集群状态不一致，出现脑裂问题。

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

例如：3 个节点形成的集群，选票必须超过（3 + 1） / 2 ，也就是 2 票。node3 得到 node2 和 node3 的选票，当选为主。node1 只有自己 1 票，没有当选。集群中依然只有 1 个主节点，没有出现脑裂。

分片存储原理

elasticsearch 会通过 hash 算法来计算文档应该存储到哪个分片：

_routing 默认是文档的 id。算法与分片数量有关，因此索引库一旦创建，分片数量不能修改！

新增文档的流程如下：

集群分布式查询

elasticsearch 的查询分成两个阶段：

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

集群故障转移

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

目录

使用ES的数据搜索功能

使用ES的数据搜索功能

DSL查询文档

将搜索结构按指定方式处理

RestClient 查询文档

数据聚合

DSL 实现聚合

限定聚合范围

Metric 聚合语法

自动补全

自定义分词器

自动补全查询

数据同步

同步调用

异步通知

监听 binlog

选择

集群

集群职责划分

集群中的脑裂问题：

分片存储原理

集群分布式查询

集群故障转移