Spring Cloud学习（十）【Elasticsearch搜索功能 分布式搜索引擎02】

DSL查询文档

DSL查询分类

DSL Query的分类

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

查询的基本语法如下：

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

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

全文检索查询

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

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

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

match 和 multi_match 的区别是什么？

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

精准查询

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

• term：根据词条精确值查询
• range：根据值的范围查询

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

精确查询常见的有哪些？

• term查询：根据词条精确匹配，一般搜索keyword类型、数值类型、布尔类型、日期类型字段
• range查询：根据数值范围查询，可以是数值、日期的范围

地理坐标查询

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

• 携程：搜索我附近的酒店
• 滴滴：搜索我附近的出租车
• 微信：搜索我附近的人

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

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

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

• geo_distance：查询到指定中心点小于某个距离值的所有文档

组合查询

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

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

相关性算分

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

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

• TF-IDF：在elasticsearch5.0之前，会随着词频增加而越来越大
• BM25：在elasticsearch5.0之后，会随着词频增加而增大，但增长曲线会趋于水平

Function Score Query

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

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

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

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

• 品牌为如家的酒店

2. 算分函数是什么？

• weight就可以

3. 加权模式是什么？

• 求和

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

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

复合查询 Boolean Query

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

• must：必须匹配每个子查询，类似“与”
• should：选择性匹配子查询，类似“或”
• must_not：必须不匹配，不参与算分，类似“非”
• filter：必须匹配，不参与算分

利用bool查询实现功能

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

bool查询有几种逻辑关系？

• must：必须匹配的条件，可以理解为“与”
• should：选择性匹配的条件，可以理解为“或”
• must_not：必须不匹配的条件，不参与打分
• filter：必须匹配的条件，不参与打分

搜索结果处理

排序

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

分页

elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。
elasticsearch中通过修改from、size参数来控制要返回的分页结果：

深度分页问题

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方案。

高亮

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

原理是这样的：

• 将搜索结果中的关键字用标签标记出来
• 在页面中给标签添加css样式

语法：

搜索结果处理整体语法：

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": "",  // 用来标记高亮字段的前置标签
        "post_tags": "" // 用来标记高亮字段的后置标签
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

RestClient查询文档

快速入门

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

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

@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. 解析响应
    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);
    }

    System.out.println(response);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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

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

查询的基本步骤是：

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

match查询

全文检索查询

全文检索的 match 和 multi_match 查询与 match_all 的API基本一致。差别是查询条件，也就是 query 的部分。
同样是利用 QueryBuilders 提供的方法：

精确查询

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

复合查询

复合查询-boolean query

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

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

排序、分页、高亮

排序、分页

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

高亮

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

高亮的结果处理相对比较麻烦：

• 所有搜索DSL的构建，记住一个API：SearchRequest的source()方法。
• 高亮结果解析是参考JSON结果，逐层解析

// 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);
    // 获取高亮结果
    Map<String, HighlightField> highlightFields = hit.getHighlightFields();
    if(!CollectionUtils.isEmpty(highlightFields)){
        // 根据字段名称获取高亮结果
        HighlightField highlightField = highlightFields.get("name");
        if(highlightField != null){
            // 获取高亮值
            String name = highlightField.getFragments()[0].string();
            // 覆盖非高亮结果
            hotelDoc.setName(name);
        }
    }
    System.out.println("hotelDoc = " + hotelDoc);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

黑马旅游案例

案例1：实现黑马旅游的酒店搜索功能，完成关键字搜索和分页

我们课前提供的hotel-demo项目中，自带了前端页面，启动后可以看到：

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

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

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

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

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

• 请求方式：Post
• 请求路径：/hotel/list
• 请求参数：对象，类型为RequestParam
• 返回值：PageResult，包含两个属性
  Long total：总条数
  List hotels：酒店数据

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

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

2. 在HotelService中实现该方法，满足下列要求：
   利用match查询，根据参数中的key搜索all字段，查询酒店信息并返回
   利用参数中的page、size实现分页

案例2：添加品牌、城市、星级、价格等过滤功能

需求效果如图：

步骤：

1. 修改RequestParams类，添加brand、city、starName、minPrice、maxPrice等参数
2. 修改search方法的实现，在关键字搜索时，如果brand等参数存在，对其做过滤

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

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

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

过滤条件包括：

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

注意事项：

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

案例3：我附近的酒店

前端页面点击定位后，会将你所在的位置发送到后台：

我们要根据这个坐标，将酒店结果按照到这个点的距离升序排序。
实现思路如下：

• 修改RequestParams参数，接收location字段
• 修改search方法业务逻辑，如果location有值，添加根据geo_distance排序的功能

距离排序

距离排序与普通字段排序有所差异，API如下：

按照距离排序后，还需要显示具体的距离值：

案例4：让指定的酒店在搜索结果中排名置顶

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

实现步骤分析：

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

组合查询-function score

Function Score查询可以控制文档的相关性算分，使用方式如下：

给黑马旅游添加排序功能

前端会传递sortBy参数，就是排序方式，我们需要判断sortBy值是什么：

• default：相关度算分排序，这个不用管，es的默认排序策略
• score：根据酒店的score字段排序，也就是用户评价，降序
• price：根据酒店的price字段排序，就是价格，升序

给黑马旅游添加搜索关键字高亮效果

前端已经给标签写好CSS样式了。我们只需要负责服务端高亮即可。

@Data
public class RequestParams {
    private String key;
    private Integer page;
    private Integer size;
    private String sortBy;
    private String city;
    private String brand;
    private String starName;
    private Integer minPrice;
    private Integer maxPrice;
    private String location;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

@Data
public class PageResult {

    private Long total;
    private List<HotelDoc> hotels;

    public PageResult(Long total, List<HotelDoc> hotels) {
        this.total = total;
        this.hotels = hotels;
    }

    public PageResult() {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Service
public class HotelService extends ServiceImpl<HotelMapper, Hotel> implements IHotelService {

    @Autowired
    private RestHighLevelClient client;

    @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 && !"".equals(location)){
                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);
        }
    }

    private void buildBasicQuery(RequestParams params, SearchRequest request) {
        // 1. 构建BooleanQuery
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        // 关键字搜索
        String key = params.getKey();
        if(key == null || "".equals(key)){
            boolQuery.must(QueryBuilders.matchAllQuery());
        }else{
            boolQuery.must(QueryBuilders.matchQuery("all", key));
        }
        // 条件过滤
        // 城市条件
        if (params.getCity() != null && !params.getCity().equals("")){
            boolQuery.filter(QueryBuilders.termQuery("city", params.getCity()));
        }
        // 品牌条件
        if (params.getBrand() != null && !params.getBrand().equals("")){
            boolQuery.filter(QueryBuilders.termQuery("brand", params.getBrand()));
        }
        // 星级条件
        if (params.getStarName() != null && !params.getStarName().equals("")){
            boolQuery.filter(QueryBuilders.termQuery("starName", params.getBrand()));
        }
        // 价格
        if (params.getMinPrice() != null && params.getMaxPrice() != null){
            boolQuery.filter(QueryBuilders
                     .rangeQuery("price").gte(params.getMinPrice()).lte(params.getMaxPrice()));
        }
        // 2. 算分控制
        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);
    }

    private PageResult 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 遍历
        ArrayList<HotelDoc> hotels = new ArrayList<>();
        for (SearchHit hit : hits) {
            // 获取文档 source
            String json = hit.getSourceAsString();
            // 反序列化
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            // 获取排序值
            Object[] sortValues = hit.getSortValues();
            if (sortValues.length > 0){
                Object sortValue = sortValues[0];
                hotelDoc.setDistance(sortValue);
            }
            hotels.add(hotelDoc);
        }
        // 封装返回
        return new PageResult(total, hotels);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113