【Elasticsearch】Elasticsearch的查询

DSL查询

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

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

基础语句

1. GET /{索引库名}
2. /_search
3. {
4.   "query": {
5.     "查询类型": {
6.       // .. 查询条件
7.     }
9.   }
11. }

复制代码

说明：

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

例如，我们以最简朴的无条件查询为例，无条件查询的类型是：match_all，因此其查询语句如下：
GET /items/_search
{
“query”: {
“match_all”: {

1. }

复制代码

}

}

由于match_all无条件，以是条件位置不写即可。
实行结果如下：

固然是match_all，但是相应结果中并不会包罗索引库中的所有文档，而是仅有10条。这是因为处于安全考虑，elasticsearch设置了默认的查询页数。
叶子查询

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

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

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

全文检索查询

官方文档
match

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

1. GET /{索引库名}
2. /_search{  "query": {    "match": {      "字段名": "搜索条件"    }
3.   }
4. }

复制代码

multi_match

与match类似的还有multi_match，区别在于可以同时对多个字段搜索，而且多个字段都要满足，语法示例：

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

复制代码

match和multi_match的区别是什么？

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

精确查询

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

• id
  
• price
  
• 城市
  
• 地名
  
• 人名
  等等，作为一个整体才有含义的字段。
  详情可以查看官方文档：
  官方文档
  

term

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

1. GET /{索引库名}
2. /_search{  "query": {    "term": {      "字段名": {        "value": "搜索条件"      }
3.     }
4.   }
5. }

复制代码

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

range

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

1. GET /{索引库名}
2. /_search{  "query": {    "range": {      "字段名": {        "gte": {最小值}
3. ,        "lte": {最大值}
4.       }
5.     }
6.   }
7. }

复制代码

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

• gte：大于等于
  
• gt：大于
  
• lte：小于等于
  
• lt：小于
  示例：
  
  
  
  精确查询常见的有哪些？
  
• term查询：根据词条精确匹配，一样平常搜索keyword类型、数值类型、布尔类型、日期类型字段
  
• range查询：根据数值范围查询，可以是数值、日期的范围
  

复合查询

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

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

算分函数查询

当我们使用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. GET /hotel/_search{  "query": {    "function_score": {      "query": {  .... }
2. , // 原始查询，可以是任意条件      "functions": [ // 算分函数        {          "filter": { // 满足的条件，品牌必须是Iphone            "term": {              "brand": "Iphone"            }
3.           }
4. ,          "weight": 10 // 算分权重为2        }
5.       ],      "boost_mode": "multipy" // 加权模式，求乘积    }
6.   }
7. }

复制代码

示例：

1. GET /items/_search{  "query": {    "function_score": {      "query":{        "match": {          "name": "手机"        }
2.       }
3. ,      "functions": [         {          "filter": {             "term": {              "brand": "Apple"            }
4.           }
5. ,          "weight": 10         }
6.       ]         }
7.   }
8. }

复制代码

后续待详细补充 各种类型
bool查询

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

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

1. GET /items/_search{  "query": {    "bool": {      "must": [        {"match": {"name": "手机"}
2. }
3.       ],      "should": [        {"term": {"brand": { "value": "vivo" }
4. }
5. }
6. ,        {"term": {"brand": { "value": "小米" }
7. }
8. }
9.       ],      "must_not": [        {"range": {"price": {"gte": 2500}
10. }
11. }
12.       ],      "filter": [        {"range": {"price": {"lte": 1000}
13. }
14. }
15.       ]    }
16.   }
17. }

复制代码

出于性能考虑，与搜索关键字无关的查询尽量接纳must_not或filter逻辑运算，制止参与相关性算分。
例如商城的搜索页面：
其中输入框的搜索条件肯定要参与相关性算分，可以接纳match。但是代价范围过滤、品牌过滤、分类过滤等尽量接纳filter，不要参与相关性算分。
好比，我们要搜索手机，但品牌必须是华为，代价必须是900~1599，那么可以这样写：

1. GET /items/_search{  "query": {    "bool": {      "must": [        {"match": {"name": "手机"}
2. }
3.       ],      "filter": [        {"term": {"brand": { "value": "华为" }
4. }
5. }
6. ,        {"range": {"price": {"gte": 90.00, "lt": 1599.00}
7. }
8. }
9.       ]    }
10.   }
11. }

复制代码

排序

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

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

复制代码

示例，我们按照商品代价排序：

1. GET /items/_search{  "query": {    "match_all": {}
2.   }
3. ,  "sort": [    {      "price": {        "order": "desc"      }
4.     }
5.   ]}

复制代码

分页

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

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

• from：从第几个文档开始
  
• size：统共查询几个文档
  类似于mysql中的limit ?, ?
  官方文档如下：
  官方文档
  语法如下：
  

1. GET /items/_search{  "query": {    "match_all": {}
2.   }
3. ,  "from": 0, // 分页开始的位置，默以为0  "size": 10,  // 每页文档数目，默认10  "sort": [    {      "price": {        "order": "desc"      }
4.     }
5.   ]}

复制代码

深度分页

elasticsearch的数据一样平常会接纳分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。这种存储方式比力有利于数据扩展，但给分页带来了一些贫苦。
好比一个索引库中有100000条数据，分别存储到4个分片，每个分片25000条数据。现在每页查询10条，查询第99页。那么分页查询的条件如下：

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

复制代码

从语句来分析，要查询第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形成快照，保存下来，基于快照做分页。官方已经不保举使用。
  

详情见文档：
官方文档
总结：
大多数情况下，我们接纳平常分页就可以了。查看百度、京东等网站，会发现其分页都有限定。例如百度最多支持77页，每页不足20条。京东最多100页，每页最多60条。
因此，一样平常我们接纳限定分页深度的方式即可，无需实现深度分页。
高亮

高亮原理

什么是高亮表现呢？
我们在百度，京东搜索时，关键字会变成赤色，比力醒目，这叫高亮表现：

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

• 高亮词条都被加了标签
  
• 标签都添加了赤色样式
  

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

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

实现高亮

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

1. GET /{索引库名}
2. /_search{  "query": {    "match": {      "搜索字段": "搜索关键字"    }
3.   }
4. ,  "highlight": {    "fields": {      "高亮字段名称": {        "pre_tags": "<em>",        "post_tags": "</em>"      }
5.     }
6.   }
7. }

复制代码

注意：

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

示例：

RestClient查询

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

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

基础查询

Elasticsearch的RestAPI
叶子查询

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

1.    @Test
2.     void testSearch() throws IOException {
3.         //1.创建request对象
4.         SearchRequest request = new SearchRequest("items");
5.         //2.配置request 参数
6.         request.source().query(QueryBuilders.matchQuery("name","手机"));
7.         //3.发送请求
8.         SearchResponse response= client.search(request, RequestOptions.DEFAULT);
9.         //4.解析结果
10.         handleResponse(response);
11.     }

复制代码

再好比multi_match查询：

1.     @Test
2.     void testSearch() throws IOException {
3.         //1.创建request对象
4.         SearchRequest request = new SearchRequest("items");
5.         //2.配置request 参数
6.         request.source().query(QueryBuilders.multiMatchQuery("手机","name", "category"));
7.         //3.发送请求
8.         SearchResponse response= client.search(request, RequestOptions.DEFAULT);
9.         //4.解析结果
10.         handleResponse(response);
11.     }

复制代码

还有range查询：

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

复制代码

还有term查询：

1. @Test
2. void testTerm() throws IOException {
3.     // 1.创建Request
4.     SearchRequest request = new SearchRequest("items");
5.     // 2.组织请求参数
6.     request.source().query(QueryBuilders.termQuery("brand", "华为"));
7.     // 3.发送请求
8.     SearchResponse response = client.search(request, RequestOptions.DEFAULT);
9.     // 4.解析响应
10.     handleResponse(response);
11. }

复制代码

复合查询

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

完备代码如下：

1. @Test
2. void testBool() throws IOException {
3.     // 1.创建Request
4.     SearchRequest request = new SearchRequest("items");
5.     // 2.组织请求参数
6.     // 2.1.准备bool查询
7.     BoolQueryBuilder bool = QueryBuilders.boolQuery();
8.     // 2.2.关键字搜索
9.     bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶"));
10.     // 2.3.品牌过滤
11.     bool.filter(QueryBuilders.termQuery("brand", "德亚"));
12.     // 2.4.价格过滤
13.     bool.filter(QueryBuilders.rangeQuery("price").lte(30000));
14.     request.source().query(bool);
15.     // 3.发送请求
16.     SearchResponse response = client.search(request, RequestOptions.DEFAULT);
17.     // 4.解析响应
18.     handleResponse(response);
19. }

复制代码

排序和分页

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

完备示例代码：

1. @Test
2. void testPageAndSort() throws IOException {
3.     int pageNo = 1, pageSize = 5;
5.     // 1.创建Request
6.     SearchRequest request = new SearchRequest("items");
7.     // 2.组织请求参数
8.     // 2.1.搜索条件参数
9.     request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
10.     // 2.2.排序参数
11.     request.source().sort("price", SortOrder.ASC);
12.     // 2.3.分页参数
13.     request.source().from((pageNo - 1) * pageSize).size(pageSize);
14.     // 3.发送请求
15.     SearchResponse response = client.search(request, RequestOptions.DEFAULT);
16.     // 4.解析响应
17.     handleResponse(response);
18. }

复制代码

高亮

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

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

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

1. @Test
2. void testHighlight() throws IOException {
3.     // 1.创建Request
4.     SearchRequest request = new SearchRequest("items");
5.     // 2.组织请求参数
6.     // 2.1.query条件
7.     request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
8.     // 2.2.高亮条件
9.     request.source().highlighter(
10.             SearchSourceBuilder.highlight()
11.                     .field("name")
12.                     .preTags("<em>")
13.                     .postTags("</em>")
14.     );
15.     // 3.发送请求
16.     SearchResponse response = client.search(request, RequestOptions.DEFAULT);
17.     // 4.解析响应
18.     handleResponse(response);
19. }

复制代码

再来看结果解析，文档解析的部分稳定，重要是高亮内容需要单独解析出来，其DSL和JavaAPI的对好比图：

代码解读：

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

1. 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);            }
2.         }
3.         System.out.println(item);    }
4. }

复制代码

数据聚合

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

• 什么品牌的手机最受接待？
  
• 这些手机的平均代价、最高代价、最低代价？
  
• 这些手机每月的贩卖情况怎样？
  实现这些统计功能的比数据库的sql要方便的多，而且查询速率非常快，可以实现近及时搜索结果。
  官方文档：
  官方文档
  聚合常见的有三类：
  
• 桶（Bucket）聚合：用来对文档做分组
  
• TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
  
• Date Histogram：按照日期蹊径分组，例如一周为一组，或者一月为一组
  
• 度量（Metric）聚合：用以计算一些值，好比：最大值、最小值、平均值等
  
• Avg：求平均值
  
• Max：求最大值
  
• Min：求最小值
  
• Stats：同时求max、min、avg、sum等
  
• 管道（pipeline）聚合：其它聚合的结果为基础做进一步运算
  

注意：到场聚合的字段必须是keyword、日期、数值、布尔类型
DSL实现聚合

Bucket聚合

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

1. GET /items/_search{  "size": 0,   "aggs": {    "category_agg": {      "terms": {        "field": "category",        "size": 20      }
2.     }
3.   }
4. }

复制代码

语法说明：

• size：设置size为0，就是每页查0条，则结果中就不包罗文档，只包罗聚合
  
• aggs：定义聚合
  
  
  
  • category_agg：聚合名称，自定义，但不能重复
    
    
    
    • terms：聚合的类型，按分类聚合，以是用term
      
      
      
      • field：参与聚合的字段名称
        
      • size：盼望返回的聚合结果的最大数目
        注：size是查数据时需要返回的每页的大小，每页大小默认是10，返回十条数据，这里给0的目的是制止返回聚合结果也返回搜索的文档数据结果返回出来，假如不想看搜索的文档数据，仅仅只想做聚合的情况下就增加了网络传输的负担，以是这里是0.
        
        
        
        
      
      
    
    
  
  

带条件聚合

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

可以看到统计出的品牌非常多。
但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。
例如，我想知道代价高于3000元的手机品牌有哪些，该怎么统计呢？
我们需要从需求中分析出搜索查询的条件和聚合的目的：

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

语法如下：

1. GET /items/_search{  "query": {    "bool": {      "filter": [        {          "term": {            "category": "手机"          }
2.         }
3. ,        {          "range": {            "price": {              "gte": 300000            }
4.           }
5.         }
6.       ]    }
7.   }
8. ,   "size": 0,   "aggs": {    "brand_agg": {      "terms": {        "field": "brand",        "size": 20      }
9.     }
10.   }
11. }

复制代码

结果:

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

复制代码

可以看到，结果中只剩下3个品牌了。
Metric聚合

现在我们需要对桶内的商品做运算，获取每个品牌代价的最小值、最大值、平均值。
这就要用到Metric聚合了，例如stat聚合，就可以同时获取min、max、avg等结果。
语法如下：

1. GET /items/_search{  "query": {    "bool": {      "filter": [        {          "term": {            "category": "手机"          }
2.         }
3. ,        {          "range": {            "price": {              "gte": 300000            }
4.           }
5.         }
6.       ]    }
7.   }
8. ,   "size": 0,   "aggs": {    "brand_agg": {      "terms": {        "field": "brand",        "size": 20      }
9. ,      "aggs": {        "stats_meric": {          "stats": {            "field": "price"          }
10.         }
11.       }
12.     }
13.   }
14. }

复制代码

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

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

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

1. {  "took" : 15,  "timed_out" : false,  "_shards" : {    "total" : 1,    "successful" : 1,    "skipped" : 0,    "failed" : 0  }
2. ,  "hits" : {    "total" : {      "value" : 11,      "relation" : "eq"    }
3. ,    "max_score" : null,    "hits" : [ ]  }
4. ,  "aggregations" : {    "brand_agg" : {      "doc_count_error_upper_bound" : 0,      "sum_other_doc_count" : 0,      "buckets" : [        {          "key" : "Apple",          "doc_count" : 7,          "stats_meric" : {            "count" : 7,            "min" : 628900.0,            "max" : 688000.0,            "avg" : 653871.4285714285,            "sum" : 4577100.0          }
5.         }
6. ,        {          "key" : "华为",   --品牌代价统计          "doc_count" : 2,          "stats_meric" : {            "count" : 2,            "min" : 429400.0,            "max" : 544000.0,            "avg" : 486700.0,            "sum" : 973400.0          }
7.         }
8. ,        {          "key" : "三星",          "doc_count" : 1,          "stats_meric" : {            "count" : 1,            "min" : 474200.0,            "max" : 474200.0,            "avg" : 474200.0,            "sum" : 474200.0          }
9.         }
10. ,        {          "key" : "小米",          "doc_count" : 1,          "stats_meric" : {            "count" : 1,            "min" : 889400.0,            "max" : 889400.0,            "avg" : 889400.0,            "sum" : 889400.0          }
11.         }
12.       ]    }
13.   }
14. }

复制代码

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

总结

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

• 限定聚合的的文档范围
  聚合必须的三要素：
  
• 聚合名称
  
• 聚合类型
  
• 聚合字段
  聚合可设置属性有：
  
• size：指定聚合结果数目
  
• order：指定聚合结果排序方式
  
• field：指定聚合字段
  

RestClient实现聚合

可以看到在DSL中，aggs聚合条件与query条件是同一级别，都属于查询JSON参数。因此依然是使用request.source()方法来设置。
不外聚合条件的要使用AggregationBuilders这个工具类来构造。DSL与JavaAPI的语法对好比下：

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

完备代码如下：

1. @Testvoid 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);    }
2. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告