06-ElasticSearch搜索结果处理

3、ElasticSearch搜索结果处理

3.1、排序

• Elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序，可以排序的字段类型有如下几种
  
  
  
  • keyword类型
    
  • 数值类型
    
  • 地理坐标类型
    
  • 日期类型
    
  • ...
    
  
  

3.1.1、普通字段排序

• keyword、数值、日期类型排序的语法基本一致；DSL语法如下所示
  
  
  
  • 1. GET /indexName/_search
    2. {
    3.   "query": {
    4.     "match_all": {}
    5.   },
    6.   "sort": [
    7.     {
    8.       "FIELD": "desc"  // 排序字段、排序方式ASC、DESC
    9.     }
    10.   ]
    11. }

    复制代码
  
  
• 排序条件是一个数组，也就是可以写多个排序条件；按照声明的排序，当第一个条件相等的时候，再按照第二个条件排序，依次类推
  
• 示例
  
  
  
  • 酒店数据按照用户评价（score）降序排序，评价相同的按照价格（price）升序排序
    
  • DSL语句如下所示（match处是自定义的，也可以直接使用match_all）
    
    
    
    • 1. GET hotel/_search
      2. {
      3.   "query": {
      4.     "match": {
      5.       "name": "酒店"
      6.     }
      7.   },
      8.   "sort": [
      9.     {
      10.       "score": {
      11.         "order": "desc"
      12.       }
      13.     },
      14.     {
      15.       "price": {
      16.         "order": "asc"
      17.       }
      18.     }
      19.   ],
      20.   "size": 100
      21. }

      复制代码
    
    
  • 运行结果如下所示
    
    
    
    • 
      
    
    
  
  

3.1.2、地理坐标排序

• 地理坐标排序跟上面的普通字段排序略有不同，DSL语法格式如下所示
  
  
  
  • 1. GET /indexName/_search
    2. {
    3.   "query": {
    4.     "match_all": {}
    5.   },
    6.   "sort": [
    7.     {
    8.       "_geo_distance" : {
    9.           "FIELD" : "纬度，经度", // 文档中geo_point类型的字段名、目标坐标点
    10.           "order" : "asc", // 排序方式
    11.           "unit" : "km" // 排序的距离单位
    12.       }
    13.     }
    14.   ]
    15. }

    复制代码
  
  
• 这个查询的含义是
  
  
  
  • ①、指定一个坐标，作为目标点
    
  • ②、计算每一个文档中，指定字段（必须是geo_point类型）的坐标，到目标点的距离是多少
    
  • ③、根据距离排序
    
  
  
• 示例
  
  
  
  • 实现对酒店数据按照自己的位置坐标的距离升序排序
    
    
    
    • 获取自己位置的经纬度方式可以访问这个网站：https://lbs.amap.com/demo/jsapi-v2/example/map/click-to-get-lnglat/
      
    
    
  • 假设我的位置坐标是：113.266022,22.995959，寻找周围距离最近的酒店的DSL语句如下所示（location字段也可以不使用大括号，直接使用字符串）
    
    
    
    • 1. GET hotel/_search
      2. {
      3.   "query": {
      4.     "match_all": {}
      5.   },
      6.   "sort": [
      7.     {
      8.       "_geo_distance": {
      9.         "location": {
      10.           "lat": 22.995959,
      11.           "lon": 113.266022
      12.         },
      13.         "order": "asc",
      14.         "unit": "km"
      15.       }
      16.     }
      17.   ]
      18. }

      复制代码
    
    
  • 运行结果如下所示
    
    
    
    • 
      
    
    
  
  

3.1.3、普通字段排序RestAPI

• 代码如下所示
  
  
  
  • 1.     /**
    2.      * 普通字段排序查询
    3.      */
    4.     @Test
    5.     public void testCommonFieldSortQuery() throws IOException {
    6.         // 1. 创建查询请求对象
    7.         SearchRequest searchRequest = new SearchRequest("hotel");
    8.         // 2. 添加查询请求体
    9.         searchRequest.source().query(
    10.                 QueryBuilders.matchAllQuery()
    11.         ).sort(
    12.                 SortBuilders.fieldSort("score").order(SortOrder.DESC)
    13.         ).sort(
    14.                 SortBuilders.fieldSort("price").order(SortOrder.ASC)
    15.         );
    17.         // 3. 执行查询，获取响应结果
    18.         SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    20.         // 4. 处理响应数据
    21.         handlerCommonResponse(response);
    22.     }
    25.     /**
    26.      * 用来处理响应数据（相当于解析返回的JSON数据）
    27.      * @param response
    28.      */
    29.     private void handlerCommonResponse(SearchResponse response) throws JsonProcessingException {
    30.         // 1. 得到命中的数量（即总记录数量）
    31.         SearchHits hits = response.getHits();
    32.         long totalCount = hits.getTotalHits().value;// 总记录数
    33.         System.out.println("总记录数量为：" + totalCount);
    35.         // 2. 获取本次查询出来的列表数据
    36.         SearchHit[] hitsArray = hits.getHits();
    37.         for (SearchHit hit : hitsArray) {
    38.             Object[] sortValues = hit.getSortValues();
    39.             if (sortValues.length > 0) {
    40.                 System.out.println("当前酒店得分为【" + sortValues[0] + "】");
    41.                 System.out.println("当前酒店价格为【" + sortValues[1] + "】");
    42.             }
    44.             // 得到json字符串
    45.             String json = hit.getSourceAsString();
    46.             // 将json字符串转换为实体类对象
    47.             HotelDoc hotelDoc = objectMapper.readValue(json, HotelDoc.class);
    48.             System.out.println(hotelDoc);
    49.         }
    50.     }

    复制代码
  • ​
    
  
  

3.1.4、地理坐标排序RestAPI

• 代码如下所示
  
  
  
  • 1.     /**
    2.      * 地理坐标排序测试
    3.      */
    4.     @Test
    5.     public void testGeoDistanceSortQuery() throws IOException {
    6.         // 1. 创建查询请求体
    7.         SearchRequest searchRequest = new SearchRequest("hotel");
    9.         // 2. 添加查询请求体
    10.         searchRequest.source().query(
    11.                 QueryBuilders.matchAllQuery()
    12.         ).sort(
    13.                 SortBuilders.geoDistanceSort(
    14.                         "location",
    15.                         new GeoPoint(22.995959,113.266022)
    16.                 ).order(SortOrder.ASC).unit(DistanceUnit.KILOMETERS)
    17.         );
    19.         // 3. 执行查询，获取响应数据
    20.         SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    22.         // 4. 处理响应结果
    23.         handlerGeoResponse(response);
    25.     }
    28.     /**
    29.      * 用来处理响应数据（相当于解析返回的JSON数据）
    30.      * @param response
    31.      */
    32.     private void handlerGeoResponse(SearchResponse response) throws JsonProcessingException {
    33.         // 1. 得到命中的数量（即总记录数量）
    34.         SearchHits hits = response.getHits();
    35.         long totalCount = hits.getTotalHits().value;// 总记录数
    36.         System.out.println("总记录数量为：" + totalCount);
    38.         // 2. 获取本次查询出来的列表数据
    39.         SearchHit[] hitsArray = hits.getHits();
    40.         for (SearchHit hit : hitsArray) {
    41.             Object[] sortValues = hit.getSortValues();
    42.             if (sortValues.length > 0) {
    43.                 System.out.println("距离当前位置【" + sortValues[0] + "】公里");
    44.             }
    46.             // 得到json字符串
    47.             String json = hit.getSourceAsString();
    48.             // 将json字符串转换为实体类对象
    49.             HotelDoc hotelDoc = objectMapper.readValue(json, HotelDoc.class);
    50.             System.out.println(hotelDoc);
    51.         }
    52.     }

    复制代码
  
  

3.2、分页

• Elasticsearch默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了
  
• Elasticsearch中通过修改from、size参数来控制要返回的分页结果
  
  
  
  • from：从第几个文档开始，从0开始
    
  • size：总共查询几个文档
    
  
  
• 类似于MySQL中的limit ?, ?
  
• DSL格式比较简单，这里就不多说了；只需要添加上面说的两个参数即可
  

3.2.1、分页查询

• DSL语句如下图所示
  
  
  
  • 
    
  
  

3.2.2、RestAPI

• 代码如下所示
  
  
  
  • 1. package com.coolman.hotel.test;
    3. import com.coolman.hotel.pojo.HotelDoc;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.elasticsearch.action.search.SearchRequest;
    7. import org.elasticsearch.action.search.SearchResponse;
    8. import org.elasticsearch.client.RequestOptions;
    9. import org.elasticsearch.client.RestHighLevelClient;
    10. import org.elasticsearch.index.query.QueryBuilder;
    11. import org.elasticsearch.index.query.QueryBuilders;
    12. import org.elasticsearch.search.SearchHit;
    13. import org.elasticsearch.search.SearchHits;
    14. import org.junit.jupiter.api.Test;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.boot.test.context.SpringBootTest;
    18. import java.io.IOException;
    20. /**
    21. * 分页
    22. */
    23. @SpringBootTest
    24. public class PageQueryTest {
    26.     @Autowired
    27.     private RestHighLevelClient restHighLevelClient;
    29.     //jackson
    30.     private final ObjectMapper objectMapper = new ObjectMapper();
    32.     /**
    33.      * 分页查询测试
    34.      * @throws IOException
    35.      */
    36.     @Test
    37.     public void testPage() throws IOException {
    38.         int from = 0;
    39.         int size = 2;
    40.         // 1. 创建查询请求体
    41.         SearchRequest searchRequest = new SearchRequest("hotel");
    43.         // 2. 添加查询请求体
    44.         searchRequest.source().query(
    45.                 QueryBuilders.matchAllQuery()
    46.         ).from(from).size(size);
    48.         // 3. 执行操作，获取响应数据
    49.         SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    51.         // 4. 处理响应数据
    52.         handlerResponse(response);
    53.     }
    56.     /**
    57.      * 用来处理响应数据（相当于解析返回的JSON数据）
    58.      * @param response
    59.      */
    60.     private void handlerResponse(SearchResponse response) throws JsonProcessingException {
    61.         // 1. 得到命中的数量（即总记录数量）
    62.         SearchHits hits = response.getHits();
    63.         long totalCount = hits.getTotalHits().value;// 总记录数
    64.         System.out.println("总记录数量为：" + totalCount);
    66.         // 2. 获取本次查询出来的列表数据
    67.         SearchHit[] hitsArray = hits.getHits();
    68.         for (SearchHit hit : hitsArray) {
    69.             // 得到json字符串
    70.             String json = hit.getSourceAsString();
    71.             // 将json字符串转换为实体类对象
    72.             HotelDoc hotelDoc = objectMapper.readValue(json, HotelDoc.class);
    73.             System.out.println(hotelDoc);
    74.         }
    75.     }
    76. }

    复制代码
  
  

3.3、高亮显示

3.3.1、高亮原理

• 高亮查询的概念
  
  
  
  • 我们在百度，京东等网站搜索的时候，关键字会变红色，比较醒目，这就叫做高亮显示
    
    
    
    • 
      
    
    
  • 使用检查工具查看源代码可以发现
    
    
    
    • 
      
    
    
  
  
• 高亮显示的实现分为两步
  
  
  
  • 1）给文档中的所有关键字都添加一个标签，例如<em>标签
    
  • 2）页面给<em>标签编写CSS样式
    
  
  

3.3.2、高亮显示查询DSL

• 语法格式
  
  
  
  • 1. GET /indexName/_search
    2. {
    3.   "query": {
    4.     "match": {
    5.       "FIELD": "TEXT" // 查询条件，高亮一定要使用全文检索查询
    6.     }
    7.   },
    8.   "highlight": {
    9.     "fields": { // 指定要高亮的字段
    10.       "FIELD": {
    11.         "pre_tags": "<em>",  // 用来标记高亮字段的前置标签 ,默认使用<em>标签
    12.         "post_tags": "</em>" // 用来标记高亮字段的后置标签
    13.       }
    14.     }
    15.   }
    16. }

    复制代码
  • 注意
    
    
    
    • 高亮是对关键字高亮，因此搜索条件必须带有关键字，而不能是范围这样的查询。
      
    • 默认情况下，高亮的字段，必须与搜索指定的字段一致，否则无法高亮
      
    • 如果要对非搜索字段高亮，则需要添加一个属性：required_field_match=false
      
    
    
  
  
• 示例
  
  
  
  • 需求：让酒店搜索结果的name字段高亮显示关键词
    
  • DSL语句如下所示
    
    
    
    • 1. # 高亮显示
      3. # 需求：让酒店搜索结果的name字段高亮显示关键词
      5. # fields: 指定需要高亮显示的字段名
      6. # pre_tags： 样式前缀        不指定的话，就默认是<em>标签
      7. # post_tags：样式后缀
      8. # require_field_match:
      9. # true 代表高亮字段必须出现在条件中,才可以高亮
      10. # false代表高亮字段不一定要出现在条件，也可以高亮
      12. GET hotel/_search
      13. {
      14.   "query": {
      15.     "match": {
      16.       "name": "如家"
      17.     }
      18.   },
      19.   "highlight": {
      20.     "fields": {
      21.       "brand": {},
      22.       "name": {}
      23.     },
      24.     "require_field_match": "false",
      25.     "pre_tags": "<front color='red'>",
      26.     "post_tags": "</front>"
      27.   }
      28. }

      复制代码
    
    
  • 查询结果如下所示
    
    
    
    • 
      
    • PS：这里的DSL语句可以有些不同，比如fields可以是数组，然后require_field_match、pre_tags、post_tags都可以放在字段中
      
    • 变化有点多，这里就不演示了，上面的是相当于全局配置的意思
      
    
    
  
  

3.3.3、高亮显示查询RestAPI

• 代码如下所示，可以参考DSL语句的格式来写
  
  
  
  • 1. package com.coolman.hotel.test;
    3. import com.coolman.hotel.pojo.HotelDoc;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.elasticsearch.action.search.SearchRequest;
    7. import org.elasticsearch.action.search.SearchResponse;
    8. import org.elasticsearch.client.RequestOptions;
    9. import org.elasticsearch.client.RestHighLevelClient;
    10. import org.elasticsearch.common.text.Text;
    11. import org.elasticsearch.index.query.QueryBuilder;
    12. import org.elasticsearch.index.query.QueryBuilders;
    13. import org.elasticsearch.search.SearchHit;
    14. import org.elasticsearch.search.SearchHits;
    15. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
    16. import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
    17. import org.junit.jupiter.api.Test;
    18. import org.springframework.beans.factory.annotation.Autowired;
    19. import org.springframework.boot.test.context.SpringBootTest;
    21. import java.io.IOException;
    22. import java.util.Collection;
    23. import java.util.Collections;
    24. import java.util.Map;
    26. /**
    27. * 高亮显示
    28. */
    29. @SpringBootTest
    30. public class HighLightQueryTest {
    32.     @Autowired
    33.     private RestHighLevelClient restHighLevelClient;
    35.     //jackson
    36.     private final ObjectMapper objectMapper = new ObjectMapper();
    38.     @Test
    39.     public void testHighLightSearch() throws IOException {
    40.         // 1. 创建查询请求对象
    41.         SearchRequest searchRequest = new SearchRequest("hotel");
    43.         // 2. 添加查询请求体
    45.         HighlightBuilder highlightBuilder = new HighlightBuilder();
    46.         // 添加高亮字段方式1（暂时不知道什么区别，了解就好）
    47. //        highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
    48. //        highlightBuilder.fields().add(new HighlightBuilder.Field("brand"));
    49.         // 添加高亮字段方式2
    50.         highlightBuilder.field("name");
    51.         highlightBuilder.field("brand");
    52.         // 这里相当于是全局的配置，也可以在上面添加配置，如  highlightBuilder.field("name").requireFieldMatch(false).postTags("...").preTags("...");
    53.         highlightBuilder.requireFieldMatch(false).preTags("<front color='red'>").postTags("</front>");
    55.         searchRequest.source().query(
    56.                 QueryBuilders.matchQuery("name", "如家")
    57.         ).highlighter(highlightBuilder);
    59.         // 3. 执行操作，获取响应数据
    60.         SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    62.         // 4. 处理响应数据
    63.         handlerResponse(response);
    64.     }
    67.     /**
    68.      * 用来处理响应数据（相当于解析返回的JSON数据）
    69.      * @param response
    70.      */
    71.     private void handlerResponse(SearchResponse response) throws JsonProcessingException {
    72.         // 1. 得到命中的数量（即总记录数量）
    73.         SearchHits hits = response.getHits();
    74.         long totalCount = hits.getTotalHits().value;// 总记录数
    75.         System.out.println("总记录数量为：" + totalCount);
    77.         // 2. 获取本次查询出来的列表数据
    78.         SearchHit[] hitsArray = hits.getHits();
    79.         for (SearchHit hit : hitsArray) {
    81.             // 得到json字符串
    82.             String json = hit.getSourceAsString();
    83.             // 将json字符串转换为实体类对象
    84.             HotelDoc hotelDoc = objectMapper.readValue(json, HotelDoc.class);
    86.             // 处理高亮的情况
    87.             Map<String, HighlightField> highlightFields = hit.getHighlightFields();
    88.             if (highlightFields.size() > 0) {
    89.                 if (highlightFields.get("name") != null) {
    90.                     Text nameHighLight = highlightFields.get("name").fragments()[0];
    91.                     hotelDoc.setName(nameHighLight.toString());
    92.                 }
    93.                 if (highlightFields.get("brand") != null) {
    94.                     Text brandHighLight = highlightFields.get("brand").fragments()[0];
    95.                     hotelDoc.setBrand(brandHighLight.toString());
    96.                 }
    97.             }
    98.             System.out.println(hotelDoc);
    99.         }
    100.     }
    101. }

    复制代码
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！