在上一篇文章中,我们已经导入了大量数据到 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,但是响应结果中并不会包含索引库中的所有文档,而是仅有 10 条。这是因为处于安全考虑,elasticsearch 设置了默认的查询页数。

1.2.叶子查询

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

如图:

这里列举一些常见的,例如:

  • 全文检索查询(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**),返回结果时按照分值降序排列。

例如,我们搜索 “手机”,结果如下:

从 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 /hotel/_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
GET /items/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"price": {
"order": "desc"
}
}
]
}

1.5.分页

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

1.5.1.基础分页

elasticsearch 中通过修改 fromsize 参数来控制要返回的分页结果:

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

类似于 mysql 中的 limit ?, ?

官方文档如下:https://www.elastic.co/guide/en/elasticsearch/reference/7.12/paginate-search-results.html

语法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
GET /items/_search
{
"query": {
"match_all": {}
},
"from": 0, // 分页开始的位置,默认为0
"size": 10, // 每页文档数量,默认10
"sort": [
{
"price": {
"order": "desc"
}
}
]
}

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> 标签
  • <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:查询条件
  • fromsize:分页条件
  • 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 参数。其中包含了 querysortfromsizehighlight 等所有功能:

另一个是 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 结果,从外到内,逐层解析)

完整代码如下:

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
@Test
void testMatchAll() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
request.source().query(QueryBuilders.matchAllQuery());
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}

private void handleResponse(SearchResponse response) {
SearchHits searchHits = response.getHits();
// 1.获取总条数
long total = searchHits.getTotalHits().value;
System.out.println("共搜索到" + total + "条数据");
// 2.遍历结果数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
// 3.得到_source,也就是原始json文档
String source = hit.getSourceAsString();
// 4.反序列化并打印
ItemDoc item = JSONUtil.toBean(source, ItemDoc.class);
System.out.println(item);
}
}

2.2.叶子查询

所有的查询条件都是由 QueryBuilders 来构建的,叶子查询也不例外。因此整套代码中变化的部分仅仅是 query 条件构造的方式,其它不动。

例如 match 查询:

1
2
3
4
5
6
7
8
9
10
11
@Test
void testMatch() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 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
@Test
void testMultiMatch() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 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
@Test
void testRange() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
request.source().query(QueryBuilders.rangeQuery("price").gte(10000).lte(30000));
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}

还有 term 查询:

1
2
3
4
5
6
7
8
9
10
11
@Test
void testTerm() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 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
@Test
void testBool() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
// 2.1.准备bool查询
BoolQueryBuilder bool = QueryBuilders.boolQuery();
// 2.2.关键字搜索
bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 2.3.品牌过滤
bool.filter(QueryBuilders.termQuery("brand", "德亚"));
// 2.4.价格过滤
bool.filter(QueryBuilders.rangeQuery("price").lte(30000));
request.source().query(bool);
// 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
@Test
void testPageAndSort() throws IOException {
int pageNo = 1, pageSize = 5;

// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
// 2.1.搜索条件参数
request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 2.2.排序参数
request.source().sort("price", SortOrder.ASC);
// 2.3.分页参数
request.source().from((pageNo - 1) * pageSize).size(pageSize);
// 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
19
@Test
void testHighlight() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
// 2.1.query条件
request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 2.2.高亮条件
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 步:从结果中获取 _sourcehit.getSourceAsString(),这部分是非高亮结果,json 字符串。还需要反序列为 ItemDoc 对象
  • 5 步:获取高亮结果。hit.getHighlightFields(),返回值是一个 Map,key 是高亮字段名称,值是 HighlightField 对象,代表高亮值
  • 5.1 步:从 Map 中根据高亮字段名称,获取高亮字段值对象 HighlightField
  • 5.2 步:从 HighlightField 中获取 Fragments,并且转为字符串。这部分就是真正的高亮字符串了
  • 最后:用高亮的结果替换 ItemDoc 中的非高亮结果

完整代码如下:

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
private void handleResponse(SearchResponse response) {
SearchHits searchHits = response.getHits();
// 1.获取总条数
long total = searchHits.getTotalHits().value;
System.out.println("共搜索到" + total + "条数据");
// 2.遍历结果数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
// 3.得到_source,也就是原始json文档
String source = hit.getSourceAsString();
// 4.反序列化
ItemDoc item = JSONUtil.toBean(source, ItemDoc.class);
// 5.获取高亮结果
Map<String, HighlightField> hfs = hit.getHighlightFields();
if (CollUtils.isNotEmpty(hfs)) {
// 5.1.有高亮结果,获取name的高亮结果
HighlightField hf = hfs.get("name");
if (hf != null) {
// 5.2.获取第一个高亮结果片段,就是商品名称的高亮值
String hfName = hf.getFragments()[0].string();
item.setName(hfName);
}
}
System.out.println(item);
}
}

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:同时求 maxminavgsum
  • 管道(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
28
29
30
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
{
"took" : 2,
"timed_out" : false,
"hits" : {
"total" : {
"value" : 13,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"brand_agg" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [
{
"key" : "华为",
"doc_count" : 7
},
{
"key" : "Apple",
"doc_count" : 5
},
{
"key" : "小米",
"doc_count" : 1
}
]
}
}
}

可以看到,结果中只剩下 3 个品牌了。

3.1.3.Metric 聚合

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

这就要用到 Metric 聚合了,例如 stat 聚合,就可以同时获取 minmaxavg 等结果。

语法如下:

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
GET /items/_search
{
"query": {
"bool": {
"filter": [
{
"term": {
"category": "手机"
}
},
{
"range": {
"price": {
"gte": 300000
}
}
}
]
}
},
"size": 0,
"aggs": {
"brand_agg": {
"terms": {
"field": "brand",
"size": 20
},
"aggs": {
"stats_meric": {
"stats": {
"field": "price"
}
}
}
}
}
}

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

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

  • stats_meric:聚合名称
    • 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
@Test
void testAgg() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.准备请求参数
BoolQueryBuilder bool = QueryBuilders.boolQuery()
.filter(QueryBuilders.termQuery("category", "手机"))
.filter(QueryBuilders.rangeQuery("price").gte(300000));
request.source().query(bool).size(0);
// 3.聚合参数
request.source().aggregation(
AggregationBuilders.terms("brand_agg").field("brand").size(5)
);
// 4.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 5.解析聚合结果
Aggregations aggregations = response.getAggregations();
// 5.1.获取品牌聚合
Terms brandTerms = aggregations.get("brand_agg");
// 5.2.获取聚合中的桶
List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
// 5.3.遍历桶内数据
for (Terms.Bucket bucket : buckets) {
// 5.4.获取桶内key
String brand = bucket.getKeyAsString();
System.out.print("brand = " + brand);
long count = bucket.getDocCount();
System.out.println("; count = " + count);
}
}