分布式搜索引擎elasticsearch搜索功能介绍及实际案例剖析_elasticsearch 搜索

1、DSL查询文档

1.1 DSL查询分类

1.1.1 DSLQuery的分类

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

1.1.2 Query基本语法

条件查询：

GET /indexName/_search { "query": { "查询类型": { "查询条件": "条件值" } } }

查询所有

GET /indexName/_search { "query": { "match_all": { } } }

总结：查询DSL的基本语法是什么？

• GET /索引库名/_search
• { "query": { "查询类型": { "FIELD": "TEXT"}}}

1.2 全文检索查询

全文检索查询，会对用户输入内容分词，常用于搜索框搜索：

match查询：全文检索查询的一种，会对用户输入内容分词，然后去倒排索引库检索，语法：

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

multi_match：与match查询类似，只不过允许同时查询多个字段，语法：

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

match和multi_match的区别是什么？

match：根据一个字段查询

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

1.3 精准查询

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

term：根据词条精确值查询

range：根据值的范围查询

精确查询常见的有term查询和range查询。语法如下：

term查询

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

range查询

GET /indexName/_search { "query": { "range": { "FIELD": { "gte": 10, "lte": 20 } } } }

总结：精确查询常见的有哪些？

term查询：根据词条精确匹配，一般搜索keyword类型、数值类型、布尔类型、日期类型字段

range查询：根据数值范围查询，可以是数值、日期的范围

1.4 地理坐标查询

根据经纬度查询。常见的使用场景包括：

携程：搜索我附近的酒店

滴滴：搜索我附近的出租车

微信：搜索我附近的人

geo_bounding_box：查询geo_point值落在某个矩形范围的所有文档

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", "FIELD": "31.21,121.5" } } }

1.5 组合查询

复合（compound）查询：复合查询可以将其它简单查询组合起来，实现更复杂的搜索逻辑，例如：

fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名。例如百度竞价

相关性算分

当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列。

例如，我们搜索 "虹桥如家"，结果如下：

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

elasticsearch中的相关性打分算法是什么？

TF-IDF：在elasticsearch5.0之前，会随着词频增加而越来越大

BM25：在elasticsearch5.0之后，会随着词频增加而增大，但增长曲线会趋于水平

Function Score Query

使用 function score query，可以修改文档的相关性算分（query score），根据新得到的算分排序。

案例：给“如家”这个品牌的酒店排名靠前一些

把这个问题翻译一下，function score需要的三要素：

1、哪些文档需要算分加权？

品牌为如家的酒店

2、算分函数是什么？

weight就可以

3、加权模式是什么？

求和

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {// ... },
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是如家
            "term": {
              "brand": "如家"
            }
          },
          "weight": 2 // 算分权重为2
        }
      ],
"boost_mode": "sum"
    }
  }
}

function score query定义的三要素是什么？

• 过滤条件：哪些文档要加分
• 算分函数：如何计算function score
• 加权方式：function score 与 query score如何运算

复合查询 Boolean Query

布尔查询是一个或多个查询子句的组合。子查询的组合方式有：

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

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

must_not：必须不匹配，不参与算分，类似“非”

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

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

案例：利用bool查询实现功能

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

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {"name": "如家"}
        }
      ],
      "must_not": [
        {
          "range": { "price": {"gt": 400}}
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "10km", "location": {"lat": 31.21, "lon": 121.5}
          }
        }
      ]
    }
  }
}

总结：bool查询有几种逻辑关系？

must：必须匹配的条件，可以理解为“与”

should：选择性匹配的条件，可以理解为“或”

must_not：必须不匹配的条件，不参与打分

filter：必须匹配的条件，不参与打分

2、搜索结果处理

2.1 排序

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

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

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance" : {
          "FIELD" : "纬度，经度",
          "order" : "asc",
          "unit" : "km"
      }
    }
  ]
}

案例：对酒店数据按照用户评价降序排序，评价相同的按照价格升序排序

评价是score字段，价格是price字段，按照顺序添加两个排序规则即可。

案例：实现对酒店数据按照到你的位置坐标的距离升序排序

获取经纬度的方式：获取鼠标点击经纬度-地图属性-示例中心-JS API 2.0 示例 | 高德地图API

2.2 分页

elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。

elasticsearch中通过修改from、size参数来控制要返回的分页结果：

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

深度分页问题

ES是分布式的，所以会面临深度分页问题。例如按price排序后，获取from = 990，size =10的数据：

1. 首先在每个数据分片上都排序并查询前1000条文档。
2. 然后将所有节点的结果聚合，在内存中重新排序选出前1000条文档
3. 最后从这1000条中，选取从990开始的10条文档

如果搜索页数过深，或者结果集（from + size）越大，对内存和CPU的消耗也越高。因此ES设定结果集查询的上限是10000

深度分页解决方案

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

• search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。
• scroll：原理将排序数据形成快照，保存在内存。官方已经不推荐使用。

总结：

from + size：

优点：支持随机翻页

缺点：深度分页问题，默认查询上限（from + size）是10000

场景：百度、京东、谷歌、淘宝这样的随机翻页搜索

after search：

优点：没有查询上限（单次查询的size不超过10000）

缺点：只能向后逐页查询，不支持随机翻页

场景：没有随机翻页需求的搜索，例如手机向下滚动翻页

scroll：

优点：没有查询上限（单次查询的size不超过10000）

缺点：会有额外内存消耗，并且搜索结果是非实时的

场景：海量数据的获取和迁移。从ES7.1开始不推荐，建议用 after search方案。

2.3 高亮

高亮：就是在搜索结果中把搜索关键字突出显示。

原理是这样的：

将搜索结果中的关键字用标签标记出来

在页面中给标签添加css样式

语法：

GET /hotel/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  },
  "highlight": {
    "fields": { // 指定要高亮的字段
      "FIELD": {
        "pre_tags": "<em>",  // 用来标记高亮字段的前置标签
        "post_tags": "</em>" // 用来标记高亮字段的后置标签
      }
    }
  }
}

搜索结果处理整体语法：

GET /hotel/_search
{
  "query": {
    "match": {
      "name": "如家"
    }
  },
  "from": 0, // 分页开始的位置
  "size": 20, // 期望获取的文档总数
  "sort": [ 
    {  "price": "asc" }, // 普通排序
    {
      "_geo_distance" : { // 距离排序
          "location" : "31.040699,121.618075", 
          "order" : "asc",
          "unit" : "km"
      }
    }
  ],
  "highlight": {
    "fields": { // 高亮字段
      "name": {
        "pre_tags": "<em>",  // 用来标记高亮字段的前置标签
        "post_tags": "</em>" // 用来标记高亮字段的后置标签
      }
    }
  }
}

3、RestClient查询文档

3.1 快速入门

我们通过match_all来演示下基本的API，先看请求DSL的组织：

我们通过match_all来演示下基本的API，再看结果的解析：

RestAPI中其中构建DSL是通过HighLevelRestClient中的resource()来实现的，其中包含了查询、排序、分页、高亮等所有功能：

RestAPI中其中构建查询条件的核心部分是由一个名为QueryBuilders的工具类提供的，其中包含了各种查询方法：

总结：查询的基本步骤是：

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

3.2 match查询

全文检索的match和multi_match查询与match_all的API基本一致。差别是查询条件，也就是query的部分。

同样是利用QueryBuilders提供的方法：

// 单字段查询QueryBuilders.matchQuery("all", "如家");

// 多字段查询QueryBuilders.multiMatchQuery("如家", "name", "business");

GET /hotel/_search
{
  "query": {
    "match_all": {}
  }
}
GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  }
}
GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "如家",
      "fields": ["brand", "name"]
    }
  }
}

3.3 精确查询

精确查询常见的有term查询和range查询，同样利用QueryBuilders实现：

// 词条查询QueryBuilders.termQuery("city", "杭州");

// 范围查询QueryBuilders.rangeQuery("price").gte(100).lte(150);

GET /hotel/_search
{
  "query": {
    "term": {
      "city": "杭州"
    }
  }
}
GET /hotel/_search
{
  "query": {
    "range": {
      "price": { "gte": 100, "lte": 150 }
    }
  }
}

3.4 复合查询

精确查询常见的有term查询和range查询，同样利用QueryBuilders实现：

// 创建布尔查询

BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

// 添加must条件

boolQuery.must(QueryBuilders.termQuery("city", "杭州"));

// 添加filter条件

boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": { "city": "杭州" }
        }
      ],
      "filter": [
        {
          "range": {
            "price": { "lte": 250 }
          }
        }
      ]
    }
  }
}

总结：要构建查询条件，只要记住一个类：QueryBuilders

3.5 排序、分页、高亮

搜索结果的排序和分页是与query同级的参数，对应的API如下：

// 查询

request.source().query(QueryBuilders.matchAllQuery());

// 分页

request.source().from(0).size(5);

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 5, 
  "sort": [
    {
      "FIELD": "desc"  
    },
  ]
}

高亮API包括请求DSL构建和结果解析两部分。我们先看请求的DSL构建：

GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}

总结：

所有搜索DSL的构建，记住一个API：

SearchRequest的source()方法。

高亮结果解析是参考JSON结果，逐层解析

4、搜索旅游案例

4.1 基本搜索和分页-酒单搜索功能，完成关键字搜索和分页

先实现其中的关键字搜索功能，实现步骤如下：

1. 定义实体类，接收前端请求
2. 定义controller接口，接收页面请求，调用IHotelService的search方法
3. 定义IHotelService中的search方法，利用match查询实现根据关键字搜索酒店信息

步骤1：定义类，接收前端请求参数：

@Data
public class RequestParams {
    private String key;
         private Integer page;    
          private Integer size;    
          private String sortBy;
}

步骤2：定义controller接口，接收前端请求：

定义一个HotelController，声明查询接口，满足下列要求：

• 请求方式：Post
• 请求路径：/hotel/list
• 请求参数：对象，类型为RequestParam
• 返回值：PageResult，包含两个属性

Long total：总条数

List hotels：酒店数据

步骤3：在IHotelService中定义一个方法，实现搜索功能：

1. 在IHotelService中定义一个方法，声明如下：

/** 
* 根据关键字搜索酒店信息 
* @param params 请求参数对象，包含用户输入的关键字  
* @return 酒店文档列表 
*/
PageResult search(RequestParam params);

1. 在HotelService中实现该方法，满足下列要求：

• 利用match查询，根据参数中的key搜索all字段，查询酒店信息并返回
• 利用参数中的page、size实现分页

4.2 条件过滤-添加品牌、城市、星级、价格等过滤功能

步骤：

修改RequestParams类，添加brand、city、starName、minPrice、maxPrice等参数

修改search方法的实现，在关键字搜索时，如果brand等参数存在，对其做过滤

步骤一：拓展IUserService的search方法的参数列表

修改RequestParams类，接收所有参数：

@Data
public class RequestParams {
    private String key;    
     private Integer page;    
     private Integer size;    
     private String sortBy;    
     private String brand;     
     private String starName;    
     private String city;    
     private Integer minPrice;    
     private Integer maxPrice;
}

步骤二：修改search方法，在match查询基础上添加过滤条件

过滤条件包括：

• city精确匹配
• brand精确匹配
• starName精确匹配
• price范围过滤

注意事项：

• 多个条件之间是AND关系，组合多条件用BooleanQuery
• 参数存在才需要过滤，做好非空判断

4.3 广告置顶-让指定的酒店在搜索结果中排名置顶

我们给需要置顶的酒店文档添加一个标记。然后利用function score给带有标记的文档增加权重。

实现步骤分析：

1. 给HotelDoc类添加isAD字段，Boolean类型
2. 挑选几个你喜欢的酒店，给它的文档数据添加isAD字段，值为true
3. 修改search方法，添加function score功能，给isAD值为true的酒店增加权重