Featured image of post ElasticSearch复合查询
搜索 微服务

ElasticSearch复合查询

本文阅读量次

ElasticSearch

在前面ES的学习中，我们已经导入了大量数据到elasticsearch中，实现了商品数据的存储。不过查询商品数据时依然采用的是根据id查询，而非模糊搜索。

所以今天，我们来研究下elasticsearch的数据搜索功能。Elasticsearch提供了基于JSON的DSL（Domain Specific Language）语句来定义查询条件，其JavaAPI就是在组织DSL条件。

因此，我们先学习DSL的查询语法，然后再基于DSL来对照学习JavaAPI，就会事半功倍。

1、DSL查询

Elasticsearch的查询可以分为两大类：

  • 叶子查询（Leaf query clauses）：一般是在特定的字段里查询特定值，属于简单查询，很少单独使用。
  • 复合查询（Compound query clauses）：以逻辑方式组合多个叶子查询或者更改叶子查询的行为方式。

1.1、快速入门

我们依然在Kibana的DevTools中学习查询的DSL语法。首先来看查询的语法结构：

1
2
3
4
5
6
7
8

GET /{索引库名}/_search
{
  "query": {
    "查询类型": {
      // .. 查询条件
    }
  }
}

说明：

  • GET /{索引库名}/_search：其中的_search是固定路径，不能修改

例如，我们以最简单的无条件查询为例，无条件查询的类型是：match_all，因此其查询语句如下：

1
2
3
4
5
6
7
8

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

由于match_all无条件，所以条件位置不写即可。

执行结果如下：

你会发现虽然是match_all，但是响应结果中并不会包含索引库中的所有文档，而是仅有10000条。这是因为处于安全考虑，elasticsearch设置了默认的查询页数。

1.2、叶子查询

叶子查询的类型也可以做进一步细分，详情大家可以查看官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/query-dsl.html

如图：

这里列举一些常见的，例如：

  • 全文检索查询（Full Text Queries）：利用分词器对用户输入搜索条件先分词，得到词条，然后再利用倒排索引搜索词条。例如：
    • match：
    • multi_match
  • 精确查询（Term-level queries）：不对用户输入搜索条件分词，根据字段内容精确值匹配。但只能查找keyword、数值、日期、boolean类型的字段。例如：
    • ids
    • term
    • range
  • **地理坐标查询：**用于搜索地理位置，搜索方式很多，例如：
    • geo_bounding_box：按矩形搜索
    • geo_distance：按点和半径搜索
  • …略

1.2.1、全文检索

全文检索的种类也很多，详情可以参考官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/full-text-queries.html

以全文检索中的match为例，语法如下：

1
2
3
4
5
6
7
8

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "字段名": "搜索条件"
    }
  }
}

示例：

与match类似的还有multi_match，区别在于可以同时对多个字段搜索，有一个字段符合条件即可，语法示例：

1
2
3
4
5
6
7
8
9

GET /{索引库名}/_search
{
  "query": {
    "multi_match": {
      "query": "搜索条件",
      "fields": ["字段1", "字段2"]
    }
  }
}

示例：

1.2.2、精确查询

精确查询，英文是Term-level query，顾名思义，词条级别的查询。也就是说不会对用户输入的搜索条件再分词，而是作为一个词条，与搜索的字段内容精确值匹配。因此推荐查找keyword、数值、日期、boolean类型的字段。例如：

  • id
  • price
  • 城市
  • 地名
  • 人名

等等，作为一个整体才有含义的字段。

详情可以查看官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/term-level-queries.html

以term查询为例，其语法如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

GET /{索引库名}/_search
{
  "query": {
    "term": {
      "字段名": {
        "value": "搜索条件"
      }
    }
  }
}

示例：

当你输入的搜索条件不是词条，而是短语时，由于不做分词，你反而搜索不到：

再来看下range查询，语法如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

GET /{索引库名}/_search
{
  "query": {
    "range": {
      "字段名": {
        "gte": {最小值},
        "lte": {最大值}
      }
    }
  }
}

range是范围查询，对于范围筛选的关键字有：

  • gte：大于等于
  • gt：大于
  • lte：小于等于
  • lt：小于

示例：

1.3、复合查询

复合查询大致可以分为两类：

  • 第一类：基于逻辑运算组合叶子查询，实现组合条件，例如
    • bool
  • 第二类：基于某种算法修改查询时的文档相关性算分，从而改变文档排名。例如：
    • function_score
    • dis_max

其它复合查询及相关语法可以参考官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/compound-queries.html

1.3.1、算法函数查询（了解）

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

例如，我们搜索 “4G手机”，结果如下：

从elasticsearch5.1开始，采用的相关性打分算法是BM25算法，公式如下：

基于这套公式，就可以判断出某个文档与用户搜索的关键字之间的关联度，还是比较准确的。但是，在实际业务需求中，常常会有竞价排名的功能。不是相关度越高排名越靠前，而是掏的钱多的排名靠前。

例如在百度中搜索Java培训，排名靠前的就是广告推广。

要想认为控制相关性算分，就需要利用elasticsearch中的function score 查询了。

基本语法：

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）基于运算模式做运算，得到最终结果，作为相关性算分。

因此，其中的关键点是：

  • 过滤条件：决定哪些文档的算分被修改
  • 算分函数：决定函数算分的算法
  • 运算模式：决定最终算分结果

示例：给IPhone这个品牌的手机算分提高十倍，分析如下：

  • 过滤条件：品牌必须为IPhone
  • 算分函数：常量weight，值为10
  • 算分模式：相乘multiply

对应代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

GET /items/_search
{
  "query": {
    "function_score": {
      "query": {  .... }, // 原始查询，可以是任意条件
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是Iphone
            "term": {
              "brand": "Iphone"
            }
          },
          "weight": 10 // 算分权重为2
        }
      ],
      "boost_mode": "multipy" // 加权模式，求乘积
    }
  }
}

1.3.2、bool查询

bool查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。bool查询支持的逻辑运算有：

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

bool查询的语法如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

GET /items/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}}
      ],
      "should": [
        {"term": {"brand": { "value": "vivo" }}},
        {"term": {"brand": { "value": "小米" }}}
      ],
      "must_not": [
        {"range": {"price": {"gte": 2500}}}
      ],
      "filter": [
        {"range": {"price": {"lte": 1000}}}
      ]
    }
  }
}

出于性能考虑，与搜索关键字无关的查询尽量采用must_not或filter逻辑运算，避免参与相关性算分。

例如黑马商城的搜索页面：

其中输入框的搜索条件肯定要参与相关性算分，可以采用match。但是价格范围过滤、品牌过滤、分类过滤等尽量采用filter，不要参与相关性算分。

比如，我们要搜索手机，但品牌必须是华为，价格必须是900~1599，那么可以这样写：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

GET /items/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}}
      ],
      "filter": [
        {"term": {"brand": { "value": "华为" }}},
        {"range": {"price": {"gte": 90000, "lt": 159900}}}
      ]
    }
  }
}

1.4、排序

elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。不过分词字段无法排序，能参与排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

详细说明可以参考官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/sort-search-results.html

语法说明：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "排序字段": {
        "order": "排序方式asc和desc"
      }
    }
  ]
}

示例，搜索商品，按照销量排序，销量一样则按照价格升序：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

GET /items/_search
{
  "query": {
    "match_all": {}
  }
  , "sort": [
    {
      "sold": {
        "order": "desc"
      },
      "price": {
        "order": "asc"
      }
    }
  ]
}

1.5、分页

1.5.1、基础分页

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

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

类似于mysql中的limit ?, ?

官方文档如下：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/paginate-search-results.html

示例语法如下；搜索商品，查询出销量排名前10的商品，销量一样时按照价格升序：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

GET /items/_search
{
  "query": {
    "match_all": {}
  }
  , "sort": [
    {
      "sold": {
        "order": "desc"
      },
      "price": {
        "order": "asc"
      }
    }
  ]
  , "from": 0
  , "size": 10
}

1.5.2、深度分页

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。这种存储方式比较有利于数据扩展，但给分页带来了一些麻烦。

比如一个索引库中有100000条数据，分别存储到4个分片，每个分片25000条数据。现在每页查询10条，查询第99页。那么分页查询的条件如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

GET /items/_search
{
  "from": 990, // 从第990条开始查询
  "size": 10, // 每页查询10条
  "sort": [
    {
      "price": "asc"
    }
  ]
}

从语句来分析，要查询第990~1000名的数据。

从实现思路来分析，肯定是将所有数据排序，找出前1000名，截取其中的990~1000的部分。但问题来了，我们如何才能找到所有数据中的前1000名呢？

要知道每一片的数据都不一样，第1片上的第9001000，在另1个节点上并不一定依然是9001000名。所以我们只能在每一个分片上都找出排名前1000的数据，然后汇总到一起，重新排序，才能找出整个索引库中真正的前1000名，此时截取990~1000的数据即可。

如图：

试想一下，假如我们现在要查询的是第999页数据呢，是不是要找第9990~10000的数据，那岂不是需要把每个分片中的前10000名数据都查询出来，汇总在一起，在内存中排序？如果查询的分页深度更深呢，需要一次检索的数据岂不是更多？

由此可知，当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。

因此elasticsearch会禁止from+ size 超过10000的请求。

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

  • search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。（意思是要记录上一次查询的最后一条记录的排序值，然后携带到下一次查询。）官方推荐使用的方式。
  • scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。

详情见文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/paginate-search-results.html

总结：

大多数情况下，我们采用普通分页就可以了。查看百度、京东等网站，会发现其分页都有限制。例如百度最多支持77页，每页不足20条。京东最多100页，每页最多60条。

因此，一般我们采用限制分页深度的方式即可，无需实现深度分页。

1.6、高亮

1.6.1、高亮原理

什么是高亮显示呢？

我们在百度，京东搜索时，关键字会变成红色，比较醒目，这叫高亮显示：

观察页面源码，你会发现两件事情：

  • 高亮词条都被加了``标签
  • em标签都添加了红色样式

css样式肯定是前端实现页面的时候写好的，但是前端编写页面的时候是不知道页面要展示什么数据的，不可能给数据加标签。而服务端实现搜索功能，要是有elasticsearch做分词搜索，是知道哪些词条需要高亮的。

因此词条的高亮标签肯定是由服务端提供数据的时候已经加上的。

因此实现高亮的思路就是：

  • 用户输入搜索关键字搜索数据
  • 服务端根据搜索关键字到elasticsearch搜索，并给搜索结果中的关键字词条添加html标签
  • 前端提前给约定好的html标签添加CSS样式

1.6.2、实现高亮

事实上elasticsearch已经提供了给搜索关键字加标签的语法，无需我们自己编码。

基本语法如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "搜索字段": "搜索关键字"
    }
  },
  "highlight": {
    "fields": {
      "高亮字段名称": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

注意：

  • 搜索必须有查询条件，而且是全文检索类型的查询条件，例如match
  • 参与高亮的字段必须是text类型的字段
  • 默认情况下参与高亮的字段要与搜索字段一致，除非添加：required_field_match=false

示例：

1.7、总结

查询的DSL是一个大的JSON对象，包含下列属性：

  • query：查询条件
  • from和size：分页条件
  • sort：排序条件
  • highlight：高亮条件

示例：

2、RestClient查询

文档的查询依然使用昨天学习的 RestHighLevelClient对象，查询的基本步骤如下：

  • 1）创建request对象，这次是搜索，所以是SearchRequest
  • 2）准备请求参数，也就是查询DSL对应的JSON参数
  • 3）发起请求
  • 4）解析响应，响应结果相对复杂，需要逐层解析

2.1、快速入门

之前说过，由于Elasticsearch对外暴露的接口都是Restful风格的接口，因此JavaAPI调用就是在发送Http请求。而我们核心要做的就是利用利用Java代码组织请求参数，解析响应结果。

这个参数的格式完全参考DSL查询语句的JSON结构，因此我们在学习的过程中，会不断的把JavaAPI与DSL语句对比。大家在学习记忆的过程中，也应该这样对比学习。

2.1.1、发送请求

首先以match_all查询为例，其DSL和JavaAPI的对比如图：

代码解读：

  • 第一步，创建SearchRequest对象，指定索引库名
  • 第二步，利用request.source()构建DSL，DSL中可以包含查询、分页、排序、高亮等
  • query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL
  • 第三步，利用client.search()发送请求，得到响应

这里关键的API有两个，一个是request.source()，它构建的就是DSL中的完整JSON参数。其中包含了query、sort、from、size、highlight等所有功能：

另一个是QueryBuilders，其中包含了我们学习过的各种叶子查询、复合查询等：

2.1.2、解析响应结果

在发送请求以后，得到了响应结果SearchResponse，这个类的结构与我们在kibana中看到的响应结果JSON结构完全一致：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
    "took" : 0,
    "timed_out" : false,
    "hits" : {
        "total" : {
            "value" : 2,
            "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
            {
                "_index" : "heima",
                "_type" : "_doc",
                "_id" : "1",
                "_score" : 1.0,
                "_source" : {
                "info" : "Java讲师",
                "name" : "赵云"
                }
            }
        ]
    }
}

因此，我们解析SearchResponse的代码就是在解析这个JSON结果，对比如下：

代码解读：

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

2.1.3、总结

文档搜索的基本步骤是：

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

完整代码：创建查询商品索引库的搜索测试代码；如下：

hmall\search-service\src\test\java\com\hmall\search\SearchTest.java 内容如下：

 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

package com.hmall.search;

import cn.hutool.json.JSONUtil;
import com.hmall.common.utils.BeanUtils;
import com.hmall.search.domain.po.ItemDoc;
import org.apache.http.HttpHost;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;

public class SearchTest {

    private RestHighLevelClient client;
    //索引库名称
    private static final String INDEX_NAME = "items";

    //初始化client
    @BeforeEach
    public void init() {
        client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.12.168:9200")));
    }

    //关闭client
    @AfterEach
    public void close() throws IOException {
        client.close();
    }

    //测试match_all搜索
    @Test
    public void testMatchAll() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        request.source().query(QueryBuilders.matchAllQuery());
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

    private static void handleResponse(SearchResponse response) {
        System.out.println("共搜索到 " + response.getHits().getTotalHits().value + " 条数据");
        //获取查询数组
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            //获取_source（原始json数据）
            String jsonStr = hit.getSourceAsString();
            ItemDoc itemDoc = JSONUtil.toBean(jsonStr, ItemDoc.class);
            System.out.println(itemDoc);
        }
    }

}

2.2、叶子查询

所有的查询条件都是由QueryBuilders来构建的，叶子查询也不例外。因此整套代码中变化的部分仅仅是query条件构造的方式，其它不动。如下的方法都是在 com.hmall.search.SearchTest 添加即可。

例如match查询：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    //测试match搜索
    @Test
    public void testMatch() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

再比如multi_match查询：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    //测试multi_match搜索
    @Test
    public void testMultiMatch() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        request.source().query(QueryBuilders.multiMatchQuery("脱脂牛奶", "name", "category"));
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

还有range查询：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    //测试range搜索
    @Test
    public void testRange() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        request.source().query(QueryBuilders.rangeQuery("price").gte(10000).lte(20000));
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

还有term查询：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    //测试term搜索
    @Test
    public void testTerm() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        request.source().query(QueryBuilders.termQuery("brand", "华为"));
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

2.3、复合查询

复合查询也是由QueryBuilders来构建，我们以bool查询为例，DSL和JavaAPI的对比如图：

完整代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

    //测试bool搜索
    @Test
    public void testBool() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        //2.1、创建 bool查询对象
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //2.2、设置 must、filter、should、must_not等
        //关键字搜索
        boolQueryBuilder.must(QueryBuilders.termQuery("name", "手机"));
        //品牌过滤
        boolQueryBuilder.filter(QueryBuilders.termQuery("brand", "华为"));
        //价格过滤
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(30000));
        //2.3、将 bool查询对象设置到search请求中
        request.source().query(boolQueryBuilder);
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

2.4、排序和分页

之前说过，requeset.source()就是整个请求JSON参数，所以排序、分页都是基于这个来设置，其DSL和JavaAPI的对比如下：

完整示例代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

    //测试分页与排序
    @Test
    public void testPageAndSort() throws IOException {
        //页号
        int pageNo = 1;
        //页大小
        int pageSize = 5;

        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        request.source().query(QueryBuilders.matchQuery("name", "华为"));
        //设置分页参数
        request.source().from((pageNo-1)*pageSize).size(pageSize);
        //设置排序
        request.source().sort("price", SortOrder.DESC);
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

2.5、高亮

高亮查询与前面的查询有两点不同：

  • 条件同样是在request.source()中指定，只不过高亮条件要基于HighlightBuilder来构造
  • 高亮响应结果与搜索的文档结果不在一起，需要单独解析

首先来看高亮条件构造，其DSL和JavaAPI的对比如图：

代码参考如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    //测试高亮
    @Test
    public void testHighlight() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        request.source().query(QueryBuilders.matchQuery("name", "华为"));
        //设置高亮
        request.source().highlighter(SearchSourceBuilder.highlight()
                .field("name")
                .preTags("<em>")
                .postTags("</em>")
        );
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        handleResponse(response);
    }

再来看结果解析，文档解析的部分不变，主要是高亮内容需要单独解析出来，其DSL和JavaAPI的对比如图：

代码解读：

  • 第3、4步：从结果中获取_source。hit.getSourceAsString()，这部分是非高亮结果，json字符串。还需要反序列为ItemDTO对象
  • 第5步：获取高亮结果。hit.getHighlightFields()，返回值是一个Map，key是高亮字段名称，值是HighlightField对象，代表高亮值
  • 第5.1步：从Map中根据高亮字段名称，获取高亮字段值对象HighlightField
  • 第5.2步：从HighlightField中获取Fragments，并且转为字符串。这部分就是真正的高亮字符串了
  • 最后：用高亮的结果替换ItemDTO中的非高亮结果

改造 handleResponse方法后如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

    private static void handleResponse(SearchResponse response) {
        System.out.println("共搜索到 " + response.getHits().getTotalHits().value + " 条数据");
        //获取查询数组
        SearchHit[] hits = response.getHits().getHits();
        for (SearchHit hit : hits) {
            //获取_source（原始json数据）
            String jsonStr = hit.getSourceAsString();
            ItemDoc itemDoc = JSONUtil.toBean(jsonStr, ItemDoc.class);
            
            //解析高亮结果
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if (CollUtils.isNotEmpty(highlightFields)) {
                HighlightField highlightField = highlightFields.get("name");
                if (highlightField != null) {
                    String highlightStr = highlightField.getFragments()[0].string();
                    itemDoc.setName(highlightStr);
                }
            }
            System.out.println(itemDoc);
        }
    }

3、数据聚合

聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析、运算。例如：

  • 什么品牌的手机最受欢迎？
  • 这些手机的平均价格、最高价格、最低价格？
  • 这些手机每月的销售情况如何？

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

官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations.html

聚合常见的有三类：

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

**注意：**参加聚合的字段必须是keyword、日期、数值、布尔类型

3.1、DSL实现聚合

与之前的搜索功能类似，我们依然先学习DSL的语法，再学习JavaAPI.

3.1.1、Bucket聚合

例如我们要统计所有商品中共有哪些商品分类，其实就是以分类（category）字段对数据分组。category值一样的放在同一组，属于Bucket聚合中的Term聚合。

基本语法如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

GET /items/_search
{
  "size": 0, 
  "aggs": {
    "category_agg": {
      "terms": {
        "field": "category",
        "size": 20
      }
    }
  }
}

语法说明：

  • size：设置size为0，就是每页查0条，则结果中就不包含文档，只包含聚合
  • aggs：定义聚合
    • category_agg：聚合名称，自定义，但不能重复
      • terms：聚合的类型，按分类聚合，所以用term
        • field：参与聚合的字段名称
        • size：希望返回的聚合结果的最大数量

来看下查询的结果：

3.1.2、带条件聚合

默认情况下，Bucket聚合是对索引库的所有文档做聚合，例如我们统计商品中所有的品牌，结果如下：

可以看到统计出的品牌非常多。

但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。

例如，我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？

我们需要从需求中分析出搜索查询的条件和聚合的目标：

  • 搜索查询过滤条件：
    • 价格高于3000
    • 分类必须是手机
  • 聚合目标：统计的是品牌，肯定是对brand字段做term聚合

语法如下：

 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

GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {"term": {
          "category": "手机"
        }}
        ,{"range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0,
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

聚合结果如下：

 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

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 11,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "brand_agg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "Apple",
          "doc_count" : 7
        },
        {
          "key" : "华为",
          "doc_count" : 2
        },
        {
          "key" : "三星",
          "doc_count" : 1
        },
        {
          "key" : "小米",
          "doc_count" : 1
        }
      ]
    }
  }
}

可以看到，结果中只剩下4个品牌了。

3.1.3、Metric聚合

我们统计了价格高于3000的手机品牌，形成了一个个桶。现在我们需要对桶内的商品做运算，获取每个品牌价格的最小值、最大值、平均值。

这就要用到Metric聚合了，例如stat聚合，就可以同时获取min、max、avg等结果。

语法如下：

 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

GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {"term": {
          "category": "手机"
        }}
        ,{"range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0,
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
      , "aggs": {
        "stats_metric": {
          "stats": {
            "field": "price"
          }
        }
      }
    }
  }
}

query部分就不说了，我们重点解读聚合部分语法。

可以看到我们在brand_agg聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。

  • stats_metric：聚合名称
    • stats：聚合类型，stats是metric聚合的一种
      • field：聚合字段，这里选择price，统计价格

由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值。结果如下：

另外，我们还可以让聚合按照每个品牌的价格平均值排序：

3.1.4、总结

aggs代表聚合，与query同级，此时query的作用是？

  • 限定聚合的的文档范围

聚合必须的三要素：

  • 聚合名称
  • 聚合类型
  • 聚合字段

聚合可配置属性有：

  • size：指定聚合结果数量
  • order：指定聚合结果排序方式
  • field：指定聚合字段

3.2、RestClient实现聚合

可以看到在DSL中，aggs聚合条件与query条件是同一级别，都属于查询JSON参数。因此依然是利用request.source()方法来设置。

不过聚合条件的要利用AggregationBuilders这个工具类来构造。DSL与JavaAPI的语法对比如下：

聚合结果与搜索文档同一级别，因此需要单独获取和解析。具体解析语法如下：

完整代码如下：

 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

    //测试聚合
    @Test
    public void testAgg() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        //设置查询过滤条件
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery()
                .filter(QueryBuilders.termQuery("category", "手机"))
                .filter(QueryBuilders.rangeQuery("price").gte(300000));
        request.source().query(boolQueryBuilder);
        //不返回文档
        request.source().size(0);
        //设置品牌聚合
        request.source().aggregation(
                AggregationBuilders.terms("brand_agg").field("brand").size(20)
        );
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        Aggregations aggregations = response.getAggregations();
        //获取品牌聚合；注意下面的 Terms 是 org.elasticsearch.search.aggregations.bucket.terms.Terms
        Terms brandTerms = aggregations.get("brand_agg");
        //获取桶内数据
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        //遍历输出桶内数据
        buckets.forEach(bucket -> {
            System.out.println("-------------------------------------------------------");
            System.out.println(bucket.getKeyAsString() + "：" + bucket.getDocCount());
        });
    }

Metric聚合代码参考：

 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

    //测试Metric聚合
    @Test
    public void testAgg() throws IOException {
        //1、创建搜索请求
        SearchRequest request = new SearchRequest(INDEX_NAME);
        //2、设置查询参数
        //设置查询过滤条件
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery()
                .filter(QueryBuilders.termQuery("category", "手机"))
                .filter(QueryBuilders.rangeQuery("price").gte(300000));
        request.source().query(boolQueryBuilder);
        //不返回文档
        request.source().size(0);
        //设置品牌聚合
        request.source().aggregation(
                AggregationBuilders.terms("brand_agg").field("brand").size(20)
                        .subAggregation(
                                AggregationBuilders.stats("stats_metric").field("price")
                        )
        );
        //3、发送请求获取响应结果
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4、解析响应结果
        Aggregations aggregations = response.getAggregations();
        //获取品牌聚合；注意下面的 Terms 是 org.elasticsearch.search.aggregations.bucket.terms.Terms
        Terms brandTerms = aggregations.get("brand_agg");
        //获取桶内数据
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        //遍历输出桶内数据
        buckets.forEach(bucket -> {
            System.out.println("-------------------------------------------------------");
            System.out.println(bucket.getKeyAsString() + "：" + bucket.getDocCount());
            Aggregations aggregations1 = bucket.getAggregations();
            if (aggregations1 != null) {
                Stats statsMetric = aggregations1.get("stats_metric");
                System.out.println("平均价格：" + statsMetric.getAvg());
                System.out.println("最大价格：" + statsMetric.getMax());
                System.out.println("最小价格：" + statsMetric.getMin());
            }
        });
    }

4、作业

Elasticsearch的基本语法我们已经学完，足以应对大多数搜索业务需求了。接下来大家就可以基于学习的知识实现商品搜索的业务了。

在昨天的作业中要求大家拆分一个独立的微服务：search-service，在这个微服务中实现搜索数据的导入、商品数据库数据与elasticsearch索引库数据的同步。

接下来的搜索功能也要在search-service服务中实现。

4.1、实现搜索接口

在黑马商城的搜索页面，输入关键字，点击搜索时，会发现前端会发起查询商品的请求：

请求的接口信息如下：

  • 请求方式：GET
  • 请求路径：/search/list
  • 请求参数：
    • key：搜索关键字
    • pageNo：页码
    • pageSize：每页大小
    • sortBy：排序字段
    • isAsc：是否升序
    • category：分类
    • brand：品牌
    • minPrice：价格最小值
    • maxPrice：价格最大值

4.1.1、SearchController

修改 com.hmall.search.controller.SearchController 代码如下：

 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

package com.hmall.search.controller;

import com.hmall.search.domain.po.ItemDoc;
import com.hmall.search.domain.query.ItemPageQuery;
import com.hmall.search.domain.vo.PageVO;
import com.hmall.search.service.ISearchService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Api(tags = "搜索相关接口")
@RestController
@RequestMapping("/search")
@RequiredArgsConstructor
public class SearchController {

    private final ISearchService searchService;

    @ApiOperation("搜索商品")
    @GetMapping("/list")
    public PageVO<ItemDoc> search(ItemPageQuery query) {
        return searchService.search(query);
    }
}

4.1.2、ISearchService

修改 com.hmall.search.service.ISearchService 代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package com.hmall.search.service;

import com.hmall.search.domain.po.ItemDoc;
import com.hmall.search.domain.query.ItemPageQuery;
import com.hmall.search.domain.vo.PageVO;

public interface ISearchService {
    void saveItemById(Long itemId);

    void deleteItemById(Long itemId);

    PageVO<ItemDoc> search(ItemPageQuery query);
}

4.1.3、SearchServiceImpl

新增 com.hmall.search.service.impl.SearchServiceImpl 搜索方法代码如下：

 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

    @Override
    public PageVO<ItemDoc> search(ItemPageQuery query) {
        PageVO<ItemDoc> pageVO = PageVO.empty(0L, 0L);
        try {
            //1、创建查询请求
            SearchRequest request = new SearchRequest(INDEX_NAME);
            //2、设置查询及各类参数
            //创建bool查询
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            //设置搜索关键字
            boolean isHighlight = false;
            if (StrUtil.isNotBlank(query.getKey())) {
                boolQuery.must(QueryBuilders.matchQuery("name", query.getKey()));

                //只有搜索了关键字才高亮
                isHighlight = true;
            }
            //设置分类过滤查询
            if (StrUtil.isNotBlank(query.getCategory())) {
                boolQuery.filter(QueryBuilders.termQuery("category", query.getCategory()));
            }
            //设置品牌过滤查询
            if (StrUtil.isNotBlank(query.getBrand())) {
                boolQuery.filter(QueryBuilders.termQuery("brand", query.getBrand()));
            }
            //设置价格过滤查询
            if (query.getMinPrice() != null) {
                boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(query.getMinPrice()));
             }
             if (query.getMaxPrice() != null) {
                boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(query.getMaxPrice()));
             }
            if (isHighlight) {
                //设置高亮
                request.source().highlighter(SearchSourceBuilder.highlight()
                        .field("name")
                        .preTags("<em>")
                        .postTags("</em>")
                );
            }
            //设置分页
            int pageNo = query.getPageNo();
            int pageSize = query.getPageSize();
            request.source().from((pageNo - 1) * pageSize).size(pageSize);
            //设置排序
            if (StrUtil.isNotBlank(query.getSortBy())) {
                request.source().sort(query.getSortBy(), query.getIsAsc() ? SortOrder.ASC : SortOrder.DESC);
            } else {
                searchRequest.source().sort("updateTime", SortOrder.DESC);
            }
            //设置查询对象
            request.source().query(boolQuery);
            //3、发送请求
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            //4、解析响应结果
            SearchHits hits = response.getHits();
            //总记录数
            long total = hits.getTotalHits().value;
            pageVO.setTotal(total);
            //通过页大小和总记录数计算总页数
            long pages = (total % pageSize == 0) ? (total / pageSize) : (total / pageSize + 1);
            pageVO.setPages(pages);

            List<ItemDoc> itemDocList = new ArrayList<>(pageSize);
            for (SearchHit hit : hits.getHits()) {
                ItemDoc itemDoc = JSONUtil.toBean(hit.getSourceAsString(), ItemDoc.class);
                //处理高亮
                if (isHighlight) {
                    HighlightField highlightField = hit.getHighlightFields().get("name");
                    if (highlightField != null) {
                        String name = highlightField.getFragments()[0].string();
                        itemDoc.setName(name);
                    }
                }
                itemDocList.add(itemDoc);
            }
            pageVO.setList(itemDocList);

            return pageVO;
        } catch (IOException e) {
            throw new RuntimeException("查询es中商品失败！", e);
        }
    }

4.2、过滤条件聚合

搜索页面的过滤项目前是写死的：

但是大家思考一下，随着搜索条件的变化，过滤条件展示的过滤项是不是应该跟着变化。

例如搜索电视，那么搜索结果中展示的肯定只有电视，而此时过滤条件中的分类就不能还出现手机、拉杆箱等内容。过滤条件的品牌中就不能出现与电视无关的品牌。而是应该展示搜索结果中存在的分类和品牌。

那么问题来，我们怎么知道搜索结果中存在哪些分类和品牌呢？

大家应该能想到，就是利用聚合，而且是带有限定条件的聚合。用户搜索的条件是什么，我们在对分类、品牌聚合时的条件也就是什么，这样就能统计出搜索结果中包含的分类、品牌了。

修改 hmall-nginx\html\hmall-portal\search.html 这个页面的第 142 行；将 true 修改为 false。修改后：

再次搜索时，前端已经发出了请求，尝试搜索栏中除价格以外的过滤项：

接口信息如下：

  • 请求方式：POST
  • 请求路径：/search/filters
  • 请求参数：
    • key：搜索关键字
    • pageNo：页码
    • pageSize：每页大小
    • sortBy：排序字段
    • isAsc：是否升序
    • category：分类
    • brand：品牌
    • minPrice：价格最小值
    • maxPrice：价格最大值

可见参数与搜索参数一致，不过这里大家可以忽略分页和排序参数。

返回值参考这个格式：

1
2
3
4

{
  "category": ["手机", "曲面电视", "拉杆箱", "休闲鞋", "休闲鞋", "硬盘", "真皮包"],
  "brand": ["希捷", "小米", "华为", "oppo", "新秀丽", "Apple","锤子"]
}

4.2.1、SearchController

修改 com.hmall.search.controller.SearchController 新增如下方法：

1
2
3
4
5

    @ApiOperation("搜索商品分类、品牌列表")
    @PostMapping("/filters")
    public Map<String, List<String>> filters(@RequestBody ItemPageQuery query) {
        return searchService.filter(query);
    }

4.2.2、ISearchService

修改 com.hmall.search.service.ISearchService 新增如下方法：

1

Map<String, List<String>> filters(ItemPageQuery query);

4.2.3、SearchServiceImpl

修改 com.hmall.search.service.impl.SearchServiceImpl 新增如下方法：

 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

    @Override
    public Map<String, List<String>> filters(ItemPageQuery query) {
        try {
            //只有当分类或品牌没有选择的时才有必要去查对应的数据
            if (StrUtil.isBlank(query.getCategory()) || StrUtil.isBlank(query.getBrand())) {
                Map<String, List<String>> resultMap = new HashMap<>();
                //1、创建查询请求
                SearchRequest request = new SearchRequest(INDEX_NAME);
                //2、设置参数
                //是否需要查询分类聚合数据
                boolean isNeedCategoryAgg = true;
                //是否需要查询品牌聚合数据
                boolean isNeedBrandAgg = true;
                //设置搜索关键字
                BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
                if (StrUtil.isNotBlank(query.getKey())) {
                    boolQuery.must(QueryBuilders.matchQuery("name", query.getKey()));
                }
                if (StrUtil.isNotBlank(query.getCategory())) {
                    boolQuery.filter(QueryBuilders.termQuery("category", query.getCategory()));
                    isNeedCategoryAgg = false;
                }
                if (StrUtil.isNotBlank(query.getBrand())) {
                    boolQuery.filter(QueryBuilders.termQuery("brand", query.getBrand()));
                    isNeedBrandAgg = false;
                }
                if (query.getMinPrice() != null) {
                    boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(query.getMinPrice()));
                }
                if (query.getMaxPrice() != null) {
                    boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(query.getMaxPrice()));
                }
                request.source().query(boolQuery);

                //设置不返回文档
                request.source().size(0);

                //设置分类聚合
                if (isNeedCategoryAgg) {
                    TermsAggregationBuilder aggregationBuilder = AggregationBuilders.terms("category_agg").field("category").size(20);
                    request.source().aggregation(aggregationBuilder);
                }
                //设置品牌聚合
                if (isNeedBrandAgg) {
                    TermsAggregationBuilder aggregationBuilder = AggregationBuilders.terms("brand_agg").field("brand").size(20);
                    request.source().aggregation(aggregationBuilder);
                }

                //3、发送请求
                SearchResponse response = client.search(request, RequestOptions.DEFAULT);
                //4、解析响应结果
                Aggregations aggregations = response.getAggregations();
                Terms categoryAgg = aggregations.get("category_agg");
                if (categoryAgg != null) {
                    List<String> categoryList = new ArrayList<>();
                    for (Terms.Bucket bucket : categoryAgg.getBuckets()) {
                        categoryList.add(bucket.getKeyAsString());
                    }
                    resultMap.put("category", categoryList);
                }
                Terms brandAgg = aggregations.get("brand_agg");
                if (brandAgg != null) {
                    List<String> brandList = new ArrayList<>();
                    for (Terms.Bucket bucket : brandAgg.getBuckets()) {
                        brandList.add(bucket.getKeyAsString());
                    }
                    resultMap.put("brand", brandList);
                }
                return resultMap;
            }
        } catch (IOException e) {
            System.out.println("查询分类、品牌聚合数据失败！" + e);
        }
        return CollUtils.emptyMap();
    }

4.3、竞价排名（了解）

elasticsearch的默认排序规则是按照相关性打分排序，而这个打分是可以通过API来控制的。详情可以参考复合查询中的算分函数查询（1.3.1小节）

对应的JavaAPI可以参考文档：

https://www.elastic.co/guide/en/elasticsearch/client/java-api/7.12/java-compound-queries.html

在商品的数据库表中，已经设计了isAD字段来标记广告商品，请利用function_score查询在原本搜索的结果基础上，让这些isAD字段值为true的商品排名到最前面。

修改 com.hmall.search.service.impl.SearchServiceImpl#search 方法的如下部分：

© 2017 - 2025 Example Person
使用 Hugo 构建
主题 Stack 由 Jimmy 设计