springCloud学习【5】之分布式搜索引擎(2)

小鱼儿 2024-03-24 10:23 34阅读 0赞

#### 文章目录 ####

*  前言
 *  一 DSL查询文档
 *   *  1.1 DSL查询分类
     *  1.2 全文检索查询
     *  1.3 精准查询
     *  1.4 地理坐标查询
     *  1.5 复合查询
     *   *  1.5.1 算分函数查询
         *  1.5.2 布尔查询
 *  二 结果处理
 *   *  2.1 排序
     *   *  2.1.1 普通字段排序
         *  2.1.2 地理坐标排序
     *  2.2 分页
     *   *  2.2.1 基本的分页
         *  2.2.2 深度分页问题
     *  2.3 小结
     *  2.4 高亮
 *  三 RestClient查询文档
 *   *  3.1 快速入门
     *  3.2 解析响应
     *  3.3 全文检索查询
     *  3.4 精确查询
     *  3.5 布尔查询
     *  3.6 排序&分页
     *  3.7 高亮
 *  结语：关于黑马旅游的建议

## 前言 ##

*  本文学自黑马，当经过作者亲身实践后整理重要内容
 *  建议：多动手，多动手！！

## 一 DSL查询文档 ##

### 1.1 DSL查询分类 ###

*  Elasticsearch提供了基于JSON的DSL（[Domain Specific Language][]）来定义查询。常见的查询类型包括：
 *  **查询所有**：查询出所有数据，一般测试用。例如：match\_all
 *  **全文检索（full text）查询**：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：match\_query，multi\_match\_query
 *  **精确查询**：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：ids， range，term
 *  **地理（geo）查询**：根据经纬度查询。例如：geo\_distance，geo\_bounding\_box
 *  **复合（compound）查询**：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：bool，function\_score

--------------------

*  查询的语法基本一致：
    
        GET /indexName/_search
        {
              
          "query": {
              
            "查询类型": {
              
              "查询条件": "条件值"
            }
          }
        }
 *  查询所有的内容：查询类型为match\_all && 没有查询条件
    
        # 查询所有
        GET /indexName/_search
        {
              
          "query": {
              
            "match_all": {
              
            }
          }
        }

### 1.2 全文检索查询 ###

*  全文检索查询的基本流程：
    
    1.  对搜索的内容做分词，得到词条
    2.  根据词条去倒排索引库中匹配，得到文档id
    3.  根据文档id找到文档，返回给用户

>  *  因为是使用词条去匹配，因此参与搜索的字段也必须是可分词的text类型的字段。

--------------------

*  常见的全文检索查询包括：
    
     *  `match`查询：单字段查询
     *  `multi_match`查询：多字段查询，任意一个字段符合条件即可
 *  match查询语法如下：
    
        GET /indexName/_search
        {
              
          "query": {
              
            "match": {
              
              "FIELD": "TEXT"
            }
          }
        }
        #match查询示例
        GET /hotel/_search
        {
              
          "query": {
              
            "match": {
              
              "all": "外滩如家"
            }
          }
        }
 *  mulit\_match语法如下：
    
        GET /indexName/_search
        {
              
          "query": {
              
            "multi_match": {
              
              "query": "TEXT",
              "fields": ["FIELD1", " FIELD12"]
            }
          }
        }
        #multi_match查询示例
        GET /hotel/_search
        {
              
          "query": {
              
            "multi_match": {
              
              "query": "外滩如家",
              "fields": ["brand","name","business"]
            }
          }
        }

--------------------

*  `copy_to`参数允许您将多个字段的值复制到一个组字段中，然后可以将其作为单个字段进行查询。
    
        PUT /test
        {
              
          "mappings": {
              
            "properties": {
              
              "first_name": {
              
                "type": "text",
                "copy_to": "full_name" 
              },
              "last_name": {
              
                "type": "text",
                "copy_to": "full_name" 
              },
              "full_name": {
              
                "type": "text"
              }
            }
          }
        }
        
        PUT test/_doc/1
        {
              
          "first_name": "shanghai",
          "last_name": "beijing"
        }
        
        GET test/_search
        {
              
          "query": {
              
            "match": {
              
              "full_name": {
               
                "query": "shanghai beijing",
                "operator": "and"
              }
            }
          }
        }
 *  `copy_to`是字段值，而不是 term（由分析过程产生）
 *  可以将相同的值复制到多个字段，使用 `"copy_to": [ "field_1", "field_2" ]`
 *  **搜索字段越多，对查询性能影响越大，因此建议采用copy\_to，然后单字段查询的方式。**

### 1.3 精准查询 ###

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

--------------------

*  **term查询**
    
     *  因为精确查询的字段搜是不分词的字段，所以查询的条件也必须是**不分词**的词条。查询时，输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多，反而搜索不到数据。
 *  语法说明：
    
        // term查询
        GET /indexName/_search
        {
              
          "query": {
              
            "term": {
              
              "FIELD": {
              
                "value": "VALUE"
              }
            }
          }
        }

![在这里插入图片描述][4a13a6753f6141e1b18834d395eec6d8.png]

--------------------

*  **range查询**
    
     *  范围查询，一般应用在对数值类型做范围过滤
     *  基本语法：
    
        // range查询
        GET /indexName/_search
        {
              
          "query": {
              
            "range": {
              
              "FIELD": {
              
                "gte": 10, // 这里的gte代表大于等于，gt则代表大于
                "lte": 20 // lte代表小于等于，lt则代表小于
              }
            }
          }
        }

![在这里插入图片描述][5646803ccf1b44e9bdcac92f1cbcdcb3.png_pic_center]

### 1.4 地理坐标查询 ###

*  地理坐标查询，就是根据经纬度查询，[官方文档][Link 1]

--------------------

*  **矩形范围查询**
    
     *  矩形范围查询【`geo_bounding_box`查询】，查询坐标落在某个矩形范围的所有文档
     *  查询时，需要指定矩形的**左上**、**右下**两个点的坐标，然后画出一个矩形，落在该矩形内的都是符合条件的点  
        ![在这里插入图片描述][39bd76ad917a4d0ca2265bd05a9b11a7.gif]
     *  语法说明
    
        // 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）】：查询到指定中心点小于某个距离值的所有文档  
        ![在这里插入图片描述][983410a0f4384fec9faa3d2f38f52703.gif]
     *  语法说明：
    
        // geo_distance 查询
        GET /indexName/_search
        {
              
          "query": {
              
            "geo_distance": {
              
              "distance": "15km", // 半径
              "FIELD": "31.21,121.5" // 圆心
            }
          }
        }

### 1.5 复合查询 ###

*  复合（compound）查询：将其它简单查询组合起来，实现更复杂的搜索逻辑。常见的有两种：
    
     *  `fuction score`：算分函数查询，可以控制文档相关性算分，控制文档排名
     *  `bool query`：布尔查询，利用逻辑关系组合多个其它的查询，实现复杂搜索
 *  当使用match查询时，文档结果会根据与搜索词条的关联度打分（\_score），返回结果时按照分值降序排列。

--------------------

*  打分算法：
    
     *  早期elasticsearch中，使用的打分算法是TF-IDF算法：  
        ![在这里插入图片描述][a13d572ce9d448b19d1b92f225c4f601.png]
     *  在后来的5.1版本升级中，elasticsearch将算法改进为BM25算法  
        ![在这里插入图片描述][5b716cad24ec4e309c4bc5289590be88.png]
     *  想要深入了解的小伙伴，参看[《史上最小白之BM25详解与实现》][BM25]
 *  TF-IDF算法有一各缺陷，就是词条频率越高，文档得分也会越高，单个词条对文档影响较大。而BM25则会让单个词条的算分有一个上限，曲线更加平滑：  
    ![在这里插入图片描述][c0075f34fcfa471d9cb8c8de1f58dab2.png]

#### 1.5.1 算分函数查询 ####

*  根据相关度打分是比较合理的需求，但**合理的不一定是产品经理需要**的。
 *  语法说明  
    ![在这里插入图片描述][8258a7087b754021b81fb381876b31bc.png]
 *  function score 查询中包含四部分内容：
    
     *  **原始查询**条件：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）基于**运算模式**做运算，得到最终结果，作为相关性算分。
 *  关键点：
    
     *  过滤条件：决定哪些文档的算分被修改
     *  算分函数：决定函数算分的算法
     *  运算模式：决定最终算分结果
 *  演示
    
        GET /hotel/_search
        {
              
          "query": {
              
            "function_score": {
              
              "query": {
              
                "match": {
              
                 "all": "外滩"
                }
              }, 
              "functions": [ #算分函数
                {
              
                  "filter": {
              
                    "term": {
              
                      "brand": "如家" # 过滤条件
                    }
                  },
                  "weight": 10 # 算分权重
                }
              ],
              "boost_mode": "sum" # 加权模式
            }
          }
        }

#### 1.5.2 布尔查询 ####

*  布尔查询是一个或多个查询子句的组合，每一个子句就是一个**子查询**。子查询的组合方式有：
    
     *  must：必须匹配每个子查询，类似“与”
     *  should：选择性匹配子查询，类似“或”
     *  must\_not：必须不匹配，**不参与算分**，类似“非”
     *  filter：必须匹配，**不参与算分**
 *  注意：搜索时，参与**打分的字段越多，查询的性能也越差**。因此多条件查询时，建议：
    
     *  搜索框的关键字搜索，是全文检索查询，使用must查询，参与算分
     *  其它过滤条件，采用filter查询。不参与算分
 *  演示
    
        #bool查询
        GET /hotel/_search
        {
              
          "query": {
              
            "bool": {
              
              "must": [
                {
              
                  "term": {
              "city": "上海"}
                }
              ],
              "should": [
                {
              "term":{
              "brand": "皇冠假日" }},
                {
              "term":{
              "brand": "华美达"}}
              ],
              "must_not": [
                {
               "range": {
               "price": {
               "lte": 500 } }}
              ],
              "filter": [
                {
              "range": {
              "score": {
               "gte": 45 } }}
              ]
            }
          }
        }

## 二 结果处理 ##

*  搜索的结果可以按照用户指定的方式去处理或展示。

### 2.1 排序 ###

#### 2.1.1 普通字段排序 ####

*  elasticsearch默认是根据相关度算分（\_score）来排序，但是也支持自定义方式对搜索[结果排序][Link 2]。可以排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。
    
        GET /indexName/_search
        {
              
          "query": {
              
            "match_all": {
              }
          },
          "sort": [
            {
              
              "FIELD": "desc"  // 排序字段、排序方式ASC、DESC
            }
          ]
        }
 *  排序条件是一个数组，也就是可以写多个排序条件。按照声明的顺序，当第一个条件相等时，再按照第二个条件排序，以此类推
 *  演示：酒店数据按照用户评价（score)降序排序，评价相同的按照价格(price)升序排序
    
        #排序
        GET /hotel/_search
        {
              
          "query": {
              
            "match_all": {
              }
          },
          "sort": [
            {
              
              "score": {
              
                "order": "desc"
              },
              "price": {
              
                "order": "asc"
              }
            }
          ]
        }

#### 2.1.2 地理坐标排序 ####

*  **语法说明**：
    
        GET /indexName/_search
        {
              
          "query": {
              
            "match_all": {
              }
          },
          "sort": [
            {
              
              "_geo_distance" : {
              
                  "FIELD" : "纬度，经度", // 文档中geo_point类型的字段名、目标坐标点
                  "order" : "asc", // 排序方式
                  "unit" : "km" // 排序的距离单位
              }
            }
          ]
        }
    
     *  指定一个坐标，作为目标点，同时计算每一个文档中，指定字段（必须是geo\_point类型）的坐标到目标点的距离，然后根据距离排序

### 2.2 分页 ###

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

#### 2.2.1 基本的分页 ####

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

#### 2.2.2 深度分页问题 ####

*  假如现在查询990~1000的数据，查询逻辑要这么写：
    
        GET /hotel/_search
        {
              
          "query": {
              
            "match_all": {
              }
          },
          "from": 990, // 分页开始的位置，默认为0
          "size": 10, // 期望获取的文档总数
          "sort": [
            {
              "price": "asc"}
          ]
        }
 *  这里是查询990开始的数据，也就是  第 990 → 第 1000 第990\\to第1000 第990→第1000条 数据。不过，elasticsearch内部分页时，必须先查询  0 → 1000 0\\to1000 0→1000条，然后截取其中的 990 1000 990 ~ 1000 9901000的这10条：  
    ![在这里插入图片描述][ac88fbea7c994e149ce33ef8aaabed3b.png]
 *  ES是分布式的，所以会面临深度分页问题。例如按price排序后，获取from = 990，size =10的数据：
    
    1.  首先在每个数据分片上都排序并查询前1000条文档。
    2.  然后将所有节点的结果聚合，在内存中重新排序选出前1000条文档
    3.  最后从这1000条中，选取从990开始的10条文档
 *  如果搜索页数过深，或者结果集（from + size）越大，对内存和CPU的消耗也越高。因此ES设定结果集查询的上限是10000  
    ![在这里插入图片描述][3c8d5223f0c14fa69688a648974cd011.png]
 *  针对深度分页，ES提供了两种解决方案
    
     *  search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。\[推荐\]
     *  scroll：原理将排序数据形成快照，保存在内存。\[不推荐使用\]

### 2.3 小结 ###

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

### 2.4 高亮 ###

*  高亮显示的实现分为两步：
    
    1.  给文档中的所有关键字都添加一个标签，例如`<em>`标签
    2.  页面给`<em>`标签编写CSS样式
 *  **高亮语法**：
    
        GET /hotel/_search
        {
              
          "query": {
              
            "match": {
              
              "FIELD": "TEXT" // 查询条件，高亮一定要使用全文检索查询
            }
          },
          "highlight": {
              
            "fields": {
               // 指定要高亮的字段
              "FIELD": {
              
                "pre_tags": "<em>",  // 用来标记高亮字段的前置标签
                "post_tags": "</em>" // 用来标记高亮字段的后置标签
              }
            }
          }
        }
 *  **注意：**
    
     *  高亮是对关键字高亮，因此**搜索条件必须带有关键字**，而不能是范围这样的查询。
     *  默认情况下，**高亮的字段，必须与搜索指定的字段一致**，否则无法高亮
     *  如果要对非搜索字段高亮，则需要添加一个属性：required\_field\_match=false
 *  演示  
    ![在这里插入图片描述][fcaaf4f1af29472c8cfb77ab26b8eebe.png]
    
        # 实现高亮
        GET /hotel/_search
        {
              
          "query": {
              
            "match": {
              
              "all": "如家"
            }
          },
          "highlight": {
              
            "fields": {
              
              "name": {
              
                "require_field_match": "false",
                "pre_tags": "<em>", 
                "post_tags": "</em>"
              }
            }
          }
        }

## 三 RestClient查询文档 ##

### 3.1 快速入门 ###

![在这里插入图片描述][5a8a81fc51344d3db991de39fd78289f.png]

*  代码解读：
    
     *  第一步，创建`SearchRequest`对象，指定索引库名
     *  第二步，利用`request.source()`构建DSL，DSL中可以包含查询、分页、排序、高亮等
     *  `query()`：代表查询条件，利用`QueryBuilders.matchAllQuery()`构建一个match\_all查询的DSL
     *  第三步，利用client.search()发送请求，得到响应
 *  **关键的API：**
    
     *  `request.source()`，其中包含了查询、排序、分页、高亮等所有功能
     *  `QueryBuilders`，其中包含match、term、function\_score、bool等各种查询

--------------------

### 3.2 解析响应 ###

![在这里插入图片描述][cfd27ac4215f4e0381e0a1c22e5ad142.png]  
**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文档数据
 *  完整代码
    
        @Test
        void testMatchAll() throws IOException {
              
            // 1.准备Request
            SearchRequest request = new SearchRequest("hotel");
            // 2.准备DSL
            request.source()
                .query(QueryBuilders.matchAllQuery());
            // 3.发送请求
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        
            // 4.解析响应
            handleResponse(response);
        }
        
        private void handleResponse(SearchResponse response) {
              
            // 4.解析响应
            SearchHits searchHits = response.getHits();
            // 4.1.获取总条数
            long total = searchHits.getTotalHits().value;
            System.out.println("共搜索到" + total + "条数据");
            // 4.2.文档数组
            SearchHit[] hits = searchHits.getHits();
            // 4.3.遍历
            for (SearchHit hit : hits) {
              
                // 获取文档source
                String json = hit.getSourceAsString();
                // 反序列化
                HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
                System.out.println("hotelDoc = " + hotelDoc);
            }
        }

![在这里插入图片描述][f83d86e70a7e4e398f8dfbd8ea6bac24.png]

--------------------

### 3.3 全文检索查询 ###

*  全文检索的match和multi\_match查询与match\_all的API基本一致。差别是查询条件，也就是query的部分。同样是利用QueryBuilders提供的方法：  
    ![在这里插入图片描述][94392ac6793b447b9e0652324a2e1fe5.png]

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

![在这里插入图片描述][a2d3da20ca974c2caa081c9bf63c30d7.png]

--------------------

### 3.4 精确查询 ###

![在这里插入图片描述][0a0a49c8f0554cfda7ebdef00958b5a9.png]

@Test
        void testTerm() throws IOException {
        
            // 1.准备Request
            SearchRequest request = new SearchRequest("hotel");
            // 2.准备DSL
            //request.source().query(QueryBuilders.termQuery("city", "杭州"));
            request.source().query(QueryBuilders.rangeQuery("price").gte(100).lte(150));
            // 3.发送请求
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.解析响应
            handleResponse(response);
    
        }

![在这里插入图片描述][aaf6debc24aa4baf9ad2af8f83234652.png]

--------------------

### 3.5 布尔查询 ###

*  布尔查询是用must、must\_not、filter等方式组合其它查询  
    ![在这里插入图片描述][169e063a50664546b22ab637894d5c57.png]

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

![在这里插入图片描述][a262c5af4d954d03a8cc688ba63180cd.png]

--------------------

### 3.6 排序&分页 ###

![在这里插入图片描述][ffea324d10c048139635f9a97dde583c.png]

@Test
        void testPageAndSort() throws IOException {
        
            // 页码，每页大小
            int page = 1, size = 3;
    
            // 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(size);
            // 3.发送请求
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            // 4.解析响应
            handleResponse(response);
    
        }

![在这里插入图片描述][e62c28582336438ca8b2048512e3b13b.png]

--------------------

### 3.7 高亮 ###

*  高亮API包括请求DSL构建和结果解析两部分。我们先看请求的DSL构建：  
    ![在这里插入图片描述][25f56e5fd9db4710a47ed0b2159683b7.png]
 *  高亮的结果处理相对比较麻烦：  
    ![在这里插入图片描述][80df821c88ac4b9587b899b72792c14e.png]

@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.解析响应
            //高亮的结果与查询的文档结果默认是分离的，并不在一起。
            highlightResponse(response);
        }
        private static void highlightResponse(SearchResponse response) {
        
            SearchHits searchHits = response.getHits();
            //查询的总条数
            long total = searchHits.getTotalHits().value;
            System.out.println("共搜索到" + total + "条数据");
            //查询的结果数组 文档数组
            SearchHit[] hits = searchHits.getHits();
            for(SearchHit hit:hits) {
        
                //获取文档source
                String json = hit.getSourceAsString();
                //反序列化
                HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
                //获取高亮结果
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                if (!CollectionUtils.isEmpty(new Map[]{
        highlightFields})) {
        
                    // 根据字段名获取高亮结果
                    HighlightField highlightField = highlightFields.get("name");
                    if (highlightField != null) {
        
                        // 获取高亮值
                        String name = highlightField.getFragments()[0].string();
                        // 覆盖非高亮结果
                        hotelDoc.setName(name);
                    }
                }
    
                System.out.println("hotelDoc="+hotelDoc);
            }
        }

![在这里插入图片描述][98545b2775e64c91890beaf733a9dcbe.png]

## 结语：关于黑马旅游的建议 ##

*  如果使用的时edge浏览器，访问黑马的案例页面，**建议关闭网站的跟踪防护**  
    ![在这里插入图片描述][a54dfe53a2a64adc9d82ea6d1727bcbc.png]
 *  **在添加广告标记的部分：进行验证结果的时候，可以先查询到添加广告标记的酒店信息，直接去页面搜索该酒店**  
    ![在这里插入图片描述][090aee83d99942a1acbc1c7fc9abcfbe.png]

![在这里插入图片描述][7421ecd4a4484939bf873278272acf0e.png]

[Domain Specific Language]: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
[4a13a6753f6141e1b18834d395eec6d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/cc1d4bb789dc41db8dbc58077b38e3ab.png
[5646803ccf1b44e9bdcac92f1cbcdcb3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f0ed46eeaee046589cbebef2291f9904.png
[Link 1]: https://www.elastic.co/guide/en/elasticsearch/reference/current/geo-queries.html
[39bd76ad917a4d0ca2265bd05a9b11a7.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6d72199bbf04461ea7e3b7405724f08c.png
[983410a0f4384fec9faa3d2f38f52703.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3ce5a73ec60445f5b33a6e0dbc1b32b6.png
[a13d572ce9d448b19d1b92f225c4f601.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b504618a856e431ca1ab02578aa3c9a2.png
[5b716cad24ec4e309c4bc5289590be88.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e4824ef085554b5cb383d89dbe0688c4.png
[BM25]: https://blog.csdn.net/Tink1995/article/details/104745144
[c0075f34fcfa471d9cb8c8de1f58dab2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2756809d7cfc4a829a18f81591ca60db.png
[8258a7087b754021b81fb381876b31bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/4f5d93226ee74cfb84be2f613b6ad650.png
[Link 2]: https://www.elastic.co/guide/en/elasticsearch/reference/current/sort-search-results.html
[ac88fbea7c994e149ce33ef8aaabed3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/018fde79f5554fc78bf3918676d2ae0e.png
[3c8d5223f0c14fa69688a648974cd011.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/1aa78803dd65475d800327dd98d41fcd.png
[fcaaf4f1af29472c8cfb77ab26b8eebe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/dff2ec3f7e6b48f795dea6f8f1a83486.png
[5a8a81fc51344d3db991de39fd78289f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/4914a503906445dfa9271cbfcba25f93.png
[cfd27ac4215f4e0381e0a1c22e5ad142.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/176cc65b5f0142859653ff96241ed33a.png
[f83d86e70a7e4e398f8dfbd8ea6bac24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/47cf4fae6b5b466299ae9f9eb20ad058.png
[94392ac6793b447b9e0652324a2e1fe5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e94757dac8b6480bb31e8a91fdcc1fc5.png
[a2d3da20ca974c2caa081c9bf63c30d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/969b137c8b0745cc87933200bf443ad2.png
[0a0a49c8f0554cfda7ebdef00958b5a9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/fb1612afca2d41e59b7818165ecea703.png
[aaf6debc24aa4baf9ad2af8f83234652.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e9767273c3fe4ca297050ac333081cb6.png
[169e063a50664546b22ab637894d5c57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b00cccc4e7554d6fb2d8f550ad96a0e6.png
[a262c5af4d954d03a8cc688ba63180cd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a4aae2a368f94216b1c2cb17a5cbd2de.png
[ffea324d10c048139635f9a97dde583c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5b129d0516ae4e5e8daf668a06eca8ec.png
[e62c28582336438ca8b2048512e3b13b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d99fabe17bbe4ebcbc71a633222aaf87.png
[25f56e5fd9db4710a47ed0b2159683b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/59bab78de17b4bc2adc2ef738b82f36c.png
[80df821c88ac4b9587b899b72792c14e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f824337ac21e48d3ad9b9f8331fc7711.png
[98545b2775e64c91890beaf733a9dcbe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/65817ca3c123498ea9798ca561d8e2c3.png
[a54dfe53a2a64adc9d82ea6d1727bcbc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/77744c7ce6834925828e63e703c02b2c.png
[090aee83d99942a1acbc1c7fc9abcfbe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/1b0e6ed3ead0401a93feb441be4e12e7.png
[7421ecd4a4484939bf873278272acf0e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/9ee405ac4a7d410fa5027fd4b15e4ff3.png