微服务开发与实战Day09

一、DSL查询

Elasticsearch提供了DSL（Domain Specific Language）查询，就是以JSON格式来定义查询条件。类似这样：

DSL查询可以分为两大类：

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

在查询以后，还可以对查询的结果做处理，包括：

排序：按照1个或多个字段值做排序
分页：根据from和size做分页，类似MySQL
高亮：对搜索结果中的关键字添加特殊样式，使其更加醒目
复合：对搜索结果做数据统计以形成报表

1. 快速入门

基于DSL的查询语法如下：

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

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

# 查询所有
GET /items/_search
{"query": {"match_all": {}}
}

查询结果：

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

2. 叶子查询

Query DSL | Elasticsearch Guide [7.12] | Elastic

叶子查询还可以进一步细分，常见的有：

全文检索（full text）查询：利用分词器对用户输入内容分词，然后去词表列表中匹配。例如：

match_query
multi_match_query

精确查询：不对用户输入内容分词，直接精确匹配，一般是查找keyword、数值、日期、布尔等类型。例如：

ids
range
term

地理（geo）查询：用于搜索地理位置，搜索方式很多。例如：

geo_distance
geo_bounding_box

2.1 全文检索查询：

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

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

例如，

# match查询
GET /items/_search
{"query": {"match": {"name": "女式牛仔裤"}}
}

multi_macth查询：与match查询类似，只不过允许同时查询多个字段，参与查询字段越多，查询性能越差，语法：

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

例如，

# multi_match查询
GET /items/_search
{"query": {"multi_match": {"query": "女式牛仔裤","fields": ["name", "category"]}}
}

2.2 精确查询

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

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

例如，

# term查询
GET /items/_search
{"query": {"term": {"brand": {"value": "德亚"}}}
}

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

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

例如，

# range查询
GET /items/_search
{"query": {"range": {"price": {"gte": 50000,"lte": 100000}}}
}

ids查询：根据id集合进行查询，语法：

GET /{索引库名}/_search
{"query": {"ids": {"value": ["id值1", "id值2"]}}}
}

例如，

# ids查询
GET /items/_search
{"query": {"ids": {"values": ["613359", "627719"]}}
}

3. 复合查询

Compound queries | Elasticsearch Guide [7.12] | Elastic

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

第一类：基于逻辑运算组合叶子查询，实现组合条件，例如：

bool

第二类：基于某种算法修改查询时的文档相关性算分，从而改变文档排名。例如：

function_score
dis_max

3.1 bool查询

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

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

bool查询的语法如下：

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，那么可以这样写：

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

3.2 算分函数查询

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

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

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

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

要想人为控制相关性算分，就需要利用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的运行流程如下：

①根据原始条件查询搜索文档，并且计算相关性算分，称为原始算分（query score）
②根据过滤条件，过滤文档
③符合过滤条件的文档，基于算分函数运算，得到函数算分（function score）
④将原始算分（query score）和函数算分（function score）基于运算模式做运算，得到最终结果，作为相关性算分。

因此，其中的关键点是：

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

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

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

对应的代码如下：

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

4. 排序和分页

排序

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

语法：

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

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

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

分页

基础分页

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

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

语法：

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

深度分页

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。查询数据时需要汇总各个分片的数据。

假如我们需要查询第100页数据，每页查10条：

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

实现思路：

①对数据排序
②找出第990~1000名

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

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

由此可知，当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。因此elasticsearch会禁止from+ size 超过10000的请求。

针对深度分页，ES提供了两种解决方案：Paginate search results | Elasticsearch Guide [7.12] | Elastic

rsearch after：分页式需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式

优点：没有查询上限，支持深度分页
缺点：只能向后逐页查询，不能随机翻页
场景：数据迁移、手机滚动查询

scroll：原理将排序数据形成快照，保存在内存。官方已经不推荐使用。

5. 高亮显示

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

实现高亮的思路就是：

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

基本语法如下：

GET /{索引库名}/_search
{"query": {"match": {"搜索字段": "搜索关键字"}},"highlight": {"fields": {  // 指定要高亮的字段"高亮字段名称": {"pre_tags": "<em>",  // 高亮的前置标签"post_tags": "</em>"  // 高亮的后置标签}}}
}

例如，

# 高亮
GET /items/_search
{"query": {"match": {"name": "脱脂牛奶"}},"highlight": {"fields": {"name": {"pre_tags": "<em>","post_tags": "</em>"}}}
}

二、JavaRestClient查询

1. 快速入门

数据搜索的Java代码分为两部分：

构建并发起请求
解析查询结果

1.1 构建并发起请求

代码解读：

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

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

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

示例：

    @Testvoid testMatchAll() throws IOException {// 1. 创建request对象SearchRequest request = new SearchRequest("items");// 2. 配置request参数request.source().query(QueryBuilders.matchAllQuery());// 3. 发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);System.out.println("response = " + response);}

1.2 解析查询结果

解析查询结果的API：

完整代码：

@Test
void testMatchAll() throws IOException {// 1.创建RequestSearchRequest 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. 构建查询条件

在JavaRestAPI中，所有类型的query查询条件都是由QueryBuilders来构建的：

全文检索的查询条件构造API如下：

match查询：

@Test
void testMatch() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

multi_match查询：

@Test
void testMultiMatch() throws IOException {// 1.创建RequestSearchRequest request = new SearchRequest("items");// 2.组织请求参数request.source().query(QueryBuilders.multiMatchQuery("脱脂牛奶", "name", "category"));// 3.发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4.解析响应handleResponse(response);
}

精确查询的查询条件构造API如下：

range查询：

@Test
void testRange() throws IOException {// 1.创建RequestSearchRequest 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查询：

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

复合查询也是由QueryBuilders来构建，以bool查询为例：

案例：构建复杂条件的搜索

需求：利用JavaRestClient实现搜索功能，条件如下：

搜索关键字为脱脂牛奶
品牌必须为德亚
价格必须低于300元

@Test
void testBool() throws IOException {// 1.创建RequestSearchRequest 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);
}

3. 排序和分页

与query类似，排序和分页参数都是基于request.source()来设置：

@Test
void testPageAndSort() throws IOException {int pageNo = 1, pageSize = 5;// 1.创建RequestSearchRequest 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);
}

4. 高亮显示

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

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

高亮显示的条件构造API如下：

示例代码：

@Test
void testHighlight() throws IOException {// 1.创建RequestSearchRequest 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.解析响应parseResponseResult(response);
}

高亮显示的结果解析API如下：

完整代码：

    @Testvoid testHighlight() throws IOException {int pageNo = 1, pageSize = 5;// 1. 创建RequestSearchRequest request = new SearchRequest("items");// 2. 组织请求参数// 2.1 搜索条件参数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. 解析响应parseResponseResult(response);}private static void parseResponseResult(SearchResponse response) {SearchHits searchHits = response.getHits();// 4.1 总条数long total = searchHits.getTotalHits().value;System.out.println("total = " + total);// 4.2 命中的数据SearchHit[] hits = searchHits.getHits();for (SearchHit hit : hits) {// 4.2.1 获取source结果String json = hit.getSourceAsString();// 4.2.2 转为ItemDocItemDoc doc = JSONUtil.toBean(json, ItemDoc.class);// 4.3 处理高亮结果Map<String, HighlightField> hfs = hit.getHighlightFields();if(hfs != null && !hfs.isEmpty()) {// 4.3.1 根据高亮字段名获取高亮结果HighlightField hf = hfs.get("name");// 4.3.2 获取高亮结果，覆盖非高亮结果String hfName = hf.getFragments()[0].string();doc.setName(hfName);}System.out.println("doc = " + doc);}}
}

三、数据聚合

聚合（aggregations）：可以实现对文档数据的统计、分析、运算。聚合常见的三类：

桶（Bucket）聚合：用来对文档做分组

TermAggregation：按照文档字段值分组
Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组

度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等

Avg：求平均值
Max：求最大值
Min：求最小值
Stats：同时求max、min、avg、sum等

管道（pipeline）聚合：其他聚合的结果为基础做聚合

注意，参与聚合的字段必须是KeyWord、数值、日期、布尔等类型的字段。

1. DSL聚合

1.1 桶（Bucket）聚合

基本语法：

GET /items/_search
{"query": {"match_all": {}}, // 可以省略"size": 0, // 设置size为0，结果中不包含文档，只包含聚合结果"aggs": { // 定义聚合"category_agg": {  // 给聚合起个名字"terms": {  // 聚合的类型，按照品牌值聚合，所以选择term"field": "category",  // 参与聚合的字段"size": 20  // 希望获取的聚合结果数量}}}
}

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

示例：

# Bucket聚合
GET /items/_search
{"size": 0,"aggs": {"cate_agg": {"terms": {"field": "category","size": 5}},"brand_agg": {"terms": {"field": "brand","size": 5}}}
}

结果：

{"took" : 101,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 10000,"relation" : "gte"},"max_score" : null,"hits" : [ ]},"aggregations" : {"brand_agg" : {"doc_count_error_upper_bound" : 0,"sum_other_doc_count" : 73002,"buckets" : [{"key" : "华为","doc_count" : 7145},{"key" : "南极人","doc_count" : 2432},{"key" : "奥古狮登","doc_count" : 2035},{"key" : "森马","doc_count" : 2005},{"key" : "恒源祥","doc_count" : 1856}]},"cate_agg" : {"doc_count_error_upper_bound" : 0,"sum_other_doc_count" : 7583,"buckets" : [{"key" : "休闲鞋","doc_count" : 20612},{"key" : "牛仔裤","doc_count" : 19611},{"key" : "老花镜","doc_count" : 16222},{"key" : "拉杆箱","doc_count" : 14347},{"key" : "手机","doc_count" : 10100}]}}
}

案例2：默认情况下，Bucket聚合是对索引库的所有文档做聚合，我们可以限定要聚合的文档范围，只要添加query条件即可。

例如，我们想知道价格高于3000元的手机品牌有哪些：

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

结果：

{"took" : 4,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 14,"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" : 4},{"key" : "小米","doc_count" : 2},{"key" : "三星","doc_count" : 1}]}}
}

1.2 度量（Metric）聚合

除了对数据分组（Bucket）之外，我们还可以对每个Bucket内的数据进一步做数据计算和统计。

例如，我们想知道手机有哪些品牌，每个品牌的价格最小值、最大值、平均值。

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"}}}}}
}

结果：

{"took" : 4,"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,"stats_meric" : {"count" : 7,"min" : 628900.0,"max" : 688000.0,"avg" : 653871.4285714285,"sum" : 4577100.0}},{"key" : "华为","doc_count" : 2,"stats_meric" : {"count" : 2,"min" : 429400.0,"max" : 544000.0,"avg" : 486700.0,"sum" : 973400.0}},{"key" : "三星","doc_count" : 1,"stats_meric" : {"count" : 1,"min" : 474200.0,"max" : 474200.0,"avg" : 474200.0,"sum" : 474200.0}},{"key" : "小米","doc_count" : 1,"stats_meric" : {"count" : 1,"min" : 889400.0,"max" : 889400.0,"avg" : 889400.0,"sum" : 889400.0}}]}}
}

2. RestClient聚合

我们以品牌聚合为例：

结果解析：

完整代码：

    @Testvoid testAgg() throws IOException {// 1. 创建RequestSearchRequest request = new SearchRequest("items");// 2. 组织请求参数// 2.1 分页request.source().size(0);// 2.2 聚合条件String brandAggName = "brandAgg";request.source().aggregation(AggregationBuilders.terms(brandAggName).field("brand").size(10));// 3. 发送请求SearchResponse response = client.search(request, RequestOptions.DEFAULT);// 4. 解析响应// 4.1 解析聚合结果Aggregations aggregations = response.getAggregations();// 4.2 根据名称获取聚合结果Terms brandTerms = aggregations.get("brandAgg");// 4.3 获取桶List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();// 4.4 遍历for (Terms.Bucket bucket : buckets) {// 4.4.1 获取key，也就是品牌信息String brandName = bucket.getKeyAsString();System.out.println("brand = " + brandName);}}

结果：