• 倒排索引：是先找到用户要搜索的词条，根据词条得到保护词条的文档的id，然后根据id获取文档。是根据词条找文档的过程。

我们统一的把mysql与elasticsearch的概念做一下对比：

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

• type：字段数据类型，常见的简单类型有：
  • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
  • 数值：long、integer、short、byte、double、float、
  • 布尔：boolean
  • 日期：date
  • 对象：object
• index：是否创建索引，默认为true
• analyzer：使用哪种分词器
• properties：该字段的子字段

ES操作

基础增删改查

• 创建客户端对象 ```java private RestHighLevelClient client;

// 创建客户端连接 @BeforeEach void setUp() { this.client = new RestHighLevelClient(RestClient.builder( HttpHost.create(“http://192.168.150.101:9200“))); }

// 关闭客户端连接 @AfterEach void tearDown() throws IOException { this.client.close(); }

- 添加 -- IndexRequest
```java
@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);
}

• 查询 — GetRequest

  @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);
  }
  

• 删除 — DeleteRequest

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

• 更新 — UpdateRequest

  @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);
  }
  

查询文档

全文检索-matchQuery()

• 利用分词器对用户输入内容分词，然后去倒排索引库中匹配

基本流程：

• 对用户搜索的内容做分词，得到词条
• 根据词条去倒排索引库中匹配，得到文档id

• 根据文档id找到文档，返回给用户

• match：根据一个字段查询

• multi_match：根据多个字段查询，参与查询字段越多，查询性能越差 ```json

  match 查询

  GET /hotel/_search { “query”: {

    "match":{
        "all": "外滩如家" # 根据 all 字段进行查询
    }
  

  } }

multi_match 查询

GET /hotel/_search { “query”: { “multi_match”:{ “query”: “外滩如家”, “fields”: [“brand”, “name”, “business”] } } }

- RestClient
```java
@Test
void testMatch() throws IOException {
    // 1.准备Request
    SearchRequest request = new SearchRequest("hotel");
    // 2.准备DSL
    // match 查询
    request.source()
        .query(QueryBuilders.matchQuery("all", "外滩如家"));
    // multi_match 查询
    request.source().
        query(QueryBuilders.multiMatchQuery("外滩如家", "brand", "name", "business"));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);

}

精确查找-term/rangeQuery()

• 根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段
• term：根据词条精确值查询（查询的条件也必须是不分词的词条。查询时，用户输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多，反而搜索不到数据）
• range：根据值的范围查询（一般应用在对数值类型做范围过滤的时候。比如做价格范围过滤） ```json

  term 查询

  GET /hotel/_search { “query”: { “term”: {

  "city": { # FIELD属性
    "value": "上海" # VALUE属性
  }
  

  } } }

range查询

GET /hotel/_search { “query”:{ “range”:{ “price”:{ # FIELD属性 “gte”: 1000, # 查询区间 “lte”:3000 } } } }

- RestClient
```java
// term 查询
QueryBuilders.termQuery("city", "上海");
// range 查询
QueryBuilders.rangeQuery("price").gte(1000).lte(3000);

地理查询-geoDistanceQuery()

• 根据经纬度查询
• 搜索我附近的酒店、附近的出租车、搜索我附近的人等 ```json // 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
    }
  }
  

  } } }

// 距离查询 geo_distance GET /indexName/_search { “query”: { “geo_distance”: { “distance”: “15km”, // 半径 “location”: “31.21,121.5” // 圆心 FIELD属性 } } }

- RestClient
```java
QueryBuilders.geoDistanceQuery("location") // 字段名
    .distance("15", DistanceUnit.KILOMETERS) // 半径
    .point(31.21D, 121.5D); // 圆心

复合查询-boolQuery()

• 复合查询可以将上述各种查询条件组合起来，合并查询条件
• fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名

# function_score 算分函数查询
GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": { // 原始查询，可以是任意条件
        "match": {
          "all": "外滩" // 查询all字段下包含外滩的条目
        }
      }, 
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是如家
            "term": {
              "brand": "如家"
            }
          },
          "weight": 2 // 算分权重为2
        }
      ],
      "boost_mode": "sum" // 加权模式，求和
    }
  }
}

• bool query：布尔查询，利用逻辑关系组合多个其它的查询。布尔查询是一个或多个查询子句的组合，每一个子句就是一个子查询。子查询的组合方式有：
  • must：必须匹配每个子查询，类似“与”
  • should：选择性匹配子查询，类似“或”
  • must_not：必须不匹配，不参与算分，类似“非”
  • filter：必须匹配，不参与算分

• 需求：搜索名字包含“如家”，价格不高于400，在坐标31.21,121.5周围10km范围内的酒店。

  GET /hotel/_search
  {
  "query":{
    "bool":{
      "must":[ // 名字包含如家
        {"match":{"name":"如家" }}
      ],
      "must_not":[ // 价格不高于400
        {"range":{"price":{"gte":400}}} 
      ],
      "filter":[ // 周围10km以内
        {"geo_distance":{ 
            "distance": "10km",
            "location":{ "lat":31.21, "lon":121.5}}
        }
      ]}
  }
  }
  

• RestClient ```java // 准备BooleanQuery BoolQueryBuilder boolQuery = QueryBuilders.boolQuery(); // 添加term boolQuery.must(QueryBuilders.termQuery(“name”, “如家”)); // 添加range boolQuery.mustNot(QueryBuilders.rangeQuery(“price”).gte(400)); // 添加geo_distance

request.source().query(boolQuery);

<a name="xfOKW"></a>
## 搜索结果处理
![image.png](https://cdn.nlark.com/yuque/0/2022/png/21563681/1649575658323-4f04f473-6962-4566-96e8-3413c6fc6a40.png#clientId=u5f377133-3139-4&crop=0&crop=0&crop=1&crop=1&id=Y0A2I&name=image.png&originHeight=688&originWidth=795&originalType=binary&ratio=1&rotation=0&showTitle=false&size=77945&status=done&style=none&taskId=u21c3badc-e294-42f7-bde3-352e88e8be8&title=)

<a name="RSkzN"></a>
### 排序-SortBuilder
elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索[结果排序](https://www.elastic.co/guide/en/elasticsearch/reference/current/sort-search-results.html)。可以排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

- 普通字段排序
```json
GET /hotel/_search
{
  "query":{"match_all":{}},
  "sort":[
    {"score":"desc"}, // 根据分数降序
    {"price":"asc"} // 根据价格升序
  ]
}

• 地理坐标排序

  GET /hotel/_search
  {
  "query":{"match_all":{}},
  "sort":[
    {
      "geo_distance":{ // 位置信息
        "location":{
          "lat": 31.31,
          "lon": 32.32
        }
      },
      "order":"asc", // 升序
      "unit":"km" // 单位km
    }
  ]
  }
  

分页-from() size()

• 基本分页：

  • from：从第几个文档开始
  • size：总共查询几个文档

    GET /hotel/_search
    {
    "query":{"match_all":{}},
    "from": 0, // 从第0条开始（默认）
    "size": 10, // 获取10个文档
    "sort":[{"price": "asc"}]
    }
    

• RestClient

// 查询
request.source().query(QueryBuilders.matchAllQuery());
// 分页
request.source().from(0).size(10);
// 价格排序
request.source().sort("price", SortOrder.ASC);

• 查询第990~第1000条数据：必须先查询 0~1000条，然后截取其中的990 ~ 1000的这10条
• 集群模式查询查询TOP1000：必须先查询出每个节点的TOP1000，汇总结果后，重新排名，重新截取TOP1000。当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力，因此elasticsearch会禁止from+ size 超过10000的请求。

针对深度分页，可采取 search after进行查询

• search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。只能向后逐页查询，不支持随机翻页。

高亮-HighlightBuilder

高亮显示的实现分为两步：

• 1）给文档中的所有关键字都添加一个标签，例如<em>标签
• 2）页面给<em>标签编写CSS样式

注意：

• 高亮搜索必须使用全文检索查询（match, multi_match）
• 高亮是对关键字高亮，因此搜索条件必须带有关键字，而不能是范围这样的查询。
• 默认情况下，高亮的字段，必须与搜索指定的字段一致，否则无法高亮
• 如果要对非搜索字段高亮，则需要添加一个属性：required_field_match=false

GET /hotel/_search
{
  "query":{"match":{"all":"如家"}}, // 搜索字段是all
  "highlight":{
    "fields":{
      "name":{"require_field_match":"false"} // 高亮属性为name
    }
  }
}

• RestClient

  // 2.1.query
  request.source().query(QueryBuilders.matchQuery("all", "如家"));
  // 2.2.高亮
  request.source().highlighter(
    new HighlightBuilder().field("name").requireFieldMatch(false));
  

• 高亮的结果与查询的文档结果默认是分离的，并不在一起。

• 因此解析高亮的代码需要额外处理：

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

聚合-AggregationBuilders

• 实现对数据的统计、分析、运算。实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

聚合常见的有三类：

• 桶（Bucket）聚合：用来对文档做分组
  • TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
  • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
• 度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
  • Avg：求平均值
  • Max：求最大值
  • Min：求最小值
  • Stats：同时求max、min、avg、sum等

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

• 对酒店品牌进行聚合，根据价格限定聚合范围，并对结果排序

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

• 子聚合：对聚合结果进行平均值、最大最小值的统计

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

  另外，我们还可以给聚合结果做个排序，例如按照每个桶的酒店平均分做排序：
  

• RestClient

• 聚合查询语法

• 结果处理

RestClient查询操作

查询的基本步骤是：

1. 创建SearchRequest对象
2. 准备Request.source()，也就是DSL。
   ① QueryBuilders来构建查询条件
   ② 传入Request.source() 的 query() 方法
3. 发送请求，得到结果
4. 解析结果（参考JSON结果，从外到内，逐层解析）

这里关键的API有两个，一个是request.source()，其中包含了查询、排序、分页、高亮等所有功能：

另一个是QueryBuilders，其中包含match、term、function_score、bool等各种查询：

响应结果的解析：

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文档数据

案例一：复合查询+分页

• 根据名称搜索酒店，并根据品牌、价格区间进行筛选，返回分页结果 ```java /* 搜索业务 / public PageResult search(RequestParams params) { // 创建 SearchRequest 对象 SearchRequest request = new SearchRequest(“hotel”); // 构建 boolQuery buildBasicQuery(params, request); // 分页 request.source().from(params.getFrom()).size(params.getSize()); // 处理响应结果 // … }

/* 构建 boolQuery 复合查找对象 / private void buildBasicQuery(RequestParams params, SearchRequest request) { // 1. 构建 boolQuery BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

// 2.关键字搜索 (must + matchQuery)
String key = params.getKey();
if (key == null || "".equals(key)) {
    boolQuery.must(QueryBuilders.matchAllQuery());
} else {
    boolQuery.must(QueryBuilders.matchQuery("all", key));
}

// 3.品牌筛选 (filter + termQuery)
if (params.getBrand() != null && !params.getBrand().equals("")) {
    boolQuery.filter(QueryBuilders.termQuery("brand", params.getBrand()));
}

// 4.价格区间 (filter + rangeQuery)
if (params.getMinPrice() != null && params.getMaxPrice() != null) {
    boolQuery.filter(QueryBuilders
                     .rangeQuery("price")
                     .gte(params.getMinPrice())
                     .lte(params.getMaxPrice())
                    );
}
// 5.放入 request.source()
request.source().query(boolQuery);

}

<a name="BFWOD"></a>
### 案例二：根据距离排序

- request.source().sort(SortBuilders)
```java
@Override
public PageResult search(RequestParams params) {
    try {
        // 1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        // 2.准备DSL
        // 2.1.query
        buildBasicQuery(params, request);

        // 2.2.分页
        int page = params.getPage();
        int size = params.getSize();
        request.source().from((page - 1) * size).size(size);

        // 2.3.排序
        String location = params.getLocation();
        if (location != null && !location.equals("")) {
            request.source().sort(SortBuilders
                                  .geoDistanceSort("location", new GeoPoint(location))
                                  .order(SortOrder.ASC)
                                  .unit(DistanceUnit.KILOMETERS)
                                 );
        }

        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4.解析响应
        return handleResponse(response);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

案例三：function_socre查询

• 这里的需求是：让指定酒店排名靠前。因此我们需要给这些酒店添加一个标记，这样在过滤条件中就可以根据这个标记来判断，是否要提高算分。比如，我们给酒店添加一个字段：isAD，Boolean类型

这样function_score包含3个要素就很好确定了：

• 过滤条件：判断isAD 是否为true
• 算分函数：我们可以用最简单暴力的weight，固定加权值
• 加权方式：可以用默认的相乘，大大提高算分

我们可以将之前写的boolean查询作为原始查询条件放到query中，接下来就是添加过滤条件、算分函数、加权模式了。所以原来的代码依然可以沿用。

// 算分控制
FunctionScoreQueryBuilder functionScoreQuery =
    QueryBuilders.functionScoreQuery(
    // 原始查询，相关性算分的查询
    boolQuery,
    // function score的数组
    new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
        // 其中的一个function score 元素
        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
            // 过滤条件
            QueryBuilders.termQuery("isAD", true),
            // 算分函数
            ScoreFunctionBuilders.weightFactorFunction(10)
        )
    });

request.source().query(functionScoreQuery);

ES深入

MySQL数据库同步

方案一：同步调用

基本步骤如下：

• 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增加数据库负担、实现复杂度高

集群

新增文档

解读：
1）新增一个id=1的文档
2）对id做hash运算，假如得到的是2，则应该存储到shard-2
3）shard-2的主分片在node3节点，将数据路由到node3，同时node3成为coordinating node
4）协调节点将数据转发给对应primary sharding所在的data node
4）保存文档：data node节点上的primary sharding处理请求，写入数据库并同步给shard-2的副本replica-2，在node2节点
6）返回结果给coordinating-node节点

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

流程：

• 客户端发送请求给任意节点，该节点成为协调节点
• 协调节点将请求广播给所有数据节点，数据节点上的分片会处理请求
• 每个分片向协调节点返回查询数据的ID、节点信息、分片信息等，协调节点汇总结果并排序
• 协调节点向包含ID的分片发送get请求，整合响应数据后返回给客户端