一、DSL查询文档
本章目标
- 文本检索：match_all、match、multi_match
- 精确查询：term、range
- 地理坐标查询：geo_distance
- 复合查询：function_score、bool
1. 说明
查询语法：
GET /索引库名/_search { "query": {}, #放查询条件 "sort": [], #放排序条件 "from": 起始索引, #放分页的起始索引 "size": 查询数量, #放分页的查询几条 "highlight": {}, #放高亮字段 "aggs": {}, #放聚合分组条件 "suggest": {} #放搜索提示条件 }1.1 查询功能分类
Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：
查询所有：查询出所有数据，一般测试用。例如：match_all
全文本检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：
match
multi_match
精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：
range
term
地理（geo）查询：根据经纬度查询。例如：
geo_distance
geo_bounding_box
复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：
bool
function_score
1.2 查询语法说明
查询的语法基本一致：
GET /索引名称/_search { "query": { "查询类型": { "查询条件": "条件值" } } }我们以查询所有为例，其中：
查询类型为match_all
没有查询条件
# 查询所有 GET /索引名称/_search { "query": { "match_all": { } } }其它查询无非就是查询类型、查询条件的变化
2. 文本检索
全文检索查询的基本流程如下：
对用户搜索的内容做分词，得到词条
根据词条去倒排索引库中匹配，得到文档id
根据文档id找到文档，返回给用户
比较常用的场景包括：
商城的输入框搜索
百度输入框搜索
例如京东：
因为是拿着词条去匹配，因此参与搜索的字段也必须是可分词的text类型的字段。
语法
常见的全文检索查询包括：
match查询：单字段查询
multi_match查询：多字段查询，任意一个字段符合条件就算符合查询条件。注意：字段越多，性能越差
match
match查询语法如下：
GET /索引名称/_search { "query": { "match": { "字段": "搜索值" } } }mulit_match
mulit_match语法如下：
GET /索引名称/_search { "query": { "multi_match": { "query": "搜索值", "fields": ["字段1", "字段2", ...] } } }示例
#match 单字段检索 GET /hotel/_search { "query": { "match": { "all": "北京如家" } } } #multi_match多字段检查 GET /hotel/_search { "query": { "multi_match": { "query": "北京如家", "fields": ["name", "brand", "business"] } } }注意
多字段检索的性能问题：使用多字段检索时，字段越多，检索的性能越差
解决方案：使用
copy_to，把多个字段值拷贝到一个字段里，对这个字段用match检索，可以达到同样效果，而且效率更高
3. 精确查询
精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。常见的有：
term：根据词条精确值查询
因为精确查询是不分词的，所有查询的条件也必须是不分词的词条。查询时，用户输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多，反而搜索不到数据。
range：根据值的范围查询
范围查询，一般应用在对数值类型做范围过滤的时候。比如做价格范围过滤。
语法
term查询
# term查询 GET /indexName/_search { "query": { "term": { "字段": { "value": "值" } } } }range查询
# range查询 GET /indexName/_search { "query": { "range": { "字段": { "gte": 10, # 这里的gte代表大于等于，gt则代表大于 "lte": 20 # lte代表小于等于，lt则代表小于 } } } }示例
# 1. term词条匹配。不分词，必须精确匹配。 查询“如家”品牌的酒店 GET /hotel/_search { "query": { "term": { "brand": { "value": "如家" } } } } # 2. range范围匹配。查询price价格在300~500之间的酒店 GET /hotel/_search { "query": { "range": { "price": { "gte": 300, "lte": 500 } } } }
4. 地理坐标查询
所谓的地理坐标查询，其实就是根据经纬度查询，官方文档：Geo queries | Elasticsearch Guide [8.7] | Elastic
常见的使用场景包括：
携程：搜索我附近的酒店
滴滴：搜索我附近的出租车
微信：搜索我附近的人
附近的酒店：
附近的车：
语法
矩形范围查询【了解】
矩形范围查询，也就是
geo_bounding_box查询，查询坐标落在某个矩形范围的所有文档：
查询时，需要指定矩形的左上、右下两个点的坐标，然后画出一个矩形，落在该矩形内的都是符合条件的点。
语法如下：
# geo_bounding_box查询 GET /indexName/_search { "query": { "geo_bounding_box": { "字段": { "top_left": { # 左上点 "lat": 31.1, #纬度 "lon": 121.5 #经度 }, "bottom_right": { # 右下点 "lat": 30.9, #纬度 "lon": 121.7 #经度 } } } } }附近查询
附近查询，也叫做距离查询（geo_distance）：查询到指定中心点小于某个距离值的所有文档。
换句话来说，在地图上找一个点作为圆心，以指定距离为半径，画一个圆，落在圆内的坐标都算符合条件：
语法说明：
# geo_distance 查询 GET /索引名称/_search { "query": { "geo_distance": { "distance": "15km", # 查询半径 "字段": "31.21,121.5" # 圆心点的经纬度坐标 } } }示例
# 1. 矩形范围查询。 划一个矩形区域，搜索区域内的数据。 需要指定矩形的左上角坐标和右下角坐标 GET /hotel/_search { "query": { "geo_bounding_box": { "location":{ "top_left":{ "lat": 31.1, "lon": 121.5 }, "bottom_right":{ "lat": 30.9, "lon": 121.7 } } } } } # 2. 附近查询（圆形范围查询）。划一个圆形区域，搜索区域内的数据。需要指定圆心坐标和半径距离 GET /hotel/_search { "query": { "geo_distance": { "distance": "15km", #半径。单位：km千米，m米 "location": "31.21, 121.5" #圆心坐标 } } }
5. 复合查询
复合（compound）查询：复合查询可以将其它简单查询组合起来，实现更复杂的搜索逻辑。常见的有两种：
fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名
bool query：布尔查询，利用逻辑关系组合多个其它的查询，实现复杂搜索
相关性计算
当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列。
例如，我们搜索 "虹桥如家"，结果如下：
[ { "_score" : 17.850193, "_source" : { "name" : "虹桥如家酒店真不错", } }, { "_score" : 12.259849, "_source" : { "name" : "外滩如家酒店真不错", } }, { "_score" : 11.91091, "_source" : { "name" : "迪士尼如家酒店真不错", } } ]在elasticsearch中，早期使用的打分算法是TF-IDF算法，公式如下：
在后来的5.1版本升级中，elasticsearch将算法改进为BM25算法，公式如下：
TF-IDF算法有一个缺陷，就是词条频率越高，文档得分也会越高，单个词条对文档影响较大。而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）基于运算模式做运算，得到最终结果，作为相关性算分。
因此，其中的关键点是：
过滤条件：决定哪些文档的算分被修改
算分函数：决定函数算分的算法
运算模式：决定最终算分结果
示例
需求：给“如家”这个品牌的酒店排名靠前一些
翻译一下这个需求，转换为之前说的四个要点：
原始条件：不确定，可以任意变化
过滤条件：brand = "如家"
算分函数：可以简单粗暴，直接给固定的算分结果，weight
运算模式：比如求和
因此最终的DSL语句如下：
#不添加算法函数，原始检索。如家酒店的相关性得分并不高 GET /hotel/_search { "query": { "match": { "all": "北京酒店" } } } #使用算法函数，所有品牌为“如家”的酒店，在原始相关性得分基础上+10，最终相关性得分高了很多 GET /hotel/_search { "query": { "function_score": { "query": { "match": { "all": "北京酒店" } }, "functions": [ { "filter": {"term": {"brand": "如家"}}, "weight": 10 } ], "boost_mode": "sum" } } }不添加算法函数，原始检索。如家酒店的相关性得分并不高
使用算法函数，所有品牌为“如家”的酒店，在原始相关性得分基础上+10，最终相关性得分高了很多
布尔查询
布尔查询是一个或多个查询子句的组合，每一个子句就是一个子查询。子查询的组合方式有：
must：必须匹配每个子查询，类似“与”，会影响算分（常用于搜索框里的文本检索）
filter：必须匹配，不参与算分，只是对搜索结果做再过滤
should：选择性匹配子查询，类似“或”
must_not：必须不匹配，不参与算分，类似“非”
比如在搜索酒店时，除了关键字搜索外，我们还可能根据品牌、价格、城市等字段做过滤：
每一个不同的字段，其查询的条件、方式都不一样，必须是多个不同的查询，而要组合这些查询，就必须用bool查询了。
需要注意的是，搜索时，参与打分的字段越多，查询的性能也越差。因此这种多条件查询时，建议这样做：
搜索框的关键字搜索，是全文检索查询，使用must查询，参与算分
其它过滤条件，采用filter查询。不参与算分
语法
GET /hotel/_search { "query": { "bool": { "must": [ {"term": {"city": "上海" }} ], "should": [ {"term": {"brand": "皇冠假日" }}, {"term": {"brand": "华美达" }} ], "must_not": [ { "range": { "price": { "lte": 500 } }} ], "filter": [ { "range": {"score": { "gte": 45 } }} ] } } }示例
需求：搜索名字包含“如家”，价格不高于400，在坐标31.21,121.5周围10km范围内的酒店。
分析：
名称搜索，属于全文检索查询，应该参与算分。放到must中
价格不高于400，用range查询，属于过滤条件，不参与算分。放到must_not中
周围10km范围内，用geo_distance查询，属于过滤条件，不参与算分。放到filter中
GET /hotel/_search { "query": { "bool": { "must": [ { "match": { "name": "如家" } } ], "must_not": [ { "range": { "price": { "gte": 400 } } } ], "filter": { "geo_distance": { "distance": "10km", "location": { "lat": 31.21, "lon": 121.5 } } } } } }
6. 小结
二、DSL处理结果
本章目标
- 掌握es的排序和分页
- 掌握es的高亮
1. 排序
elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。可以排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。
普通字段排序
keyword、数值、日期类型排序的语法基本一致。
语法
GET /索引库名/_search { "query":{ "match_all":{} }, "sort":[ {"字段1":{"order": "排序规则"}}, #排序规则：DESC，ASC ... {"字段2":{"order": "排序规则"}} ] }示例
需求描述：酒店数据按照用户评价（score)降序排序，评价相同的按照价格(price)升序排序
GET /hotel/_search { "query": { "match": { "all": "北京如家" } }, "sort": [ { "score": { "order": "desc" }, "price": { "order": "asc" } } ] }地理坐标排序
地理坐标排序略有不同。
语法
GET /索引名称/_search { "query": { "match_all": {} }, "sort": [ { "_geo_distance" : { "字段" : "纬度, 经度", # 文档中geo_point类型的字段名、目标坐标点 "order" : "asc", # 排序方式 "unit" : "km" # 排序的距离单位 } } ] }这个查询的含义是：
指定一个坐标，作为目标点
计算每一个文档中，指定字段（必须是geo_point类型）的坐标 到目标点的距离是多少
根据距离排序
示例
需求描述：实现对酒店数据按照到你的位置坐标的距离升序排序
提示：获取你的位置的经纬度的方式：获取鼠标点击经纬度-地图属性-示例中心-JS API 2.0 示例 | 高德地图API
假设我的位置是：31.034661, 121.612282，寻找我周围距离最近的酒店。
GET /hotel/_search { "query": { "match_all": {} }, "sort": [ { "_geo_distance": { "location": { "lat": 31.034, "lon": 121.612 }, "unit": "km", "order": "asc" } } ] }
练习
查询北京酒店，按照评分降序排列，如果评分相同，则按照价格升序排列
查询所有酒店，按照与你的距离升序排列
2. 分页
基本分页
elasticsearch的分页与mysql数据库非常相似，都是指定两个值
from：起始索引
size：查询几条
语法
GET /索引库名/_search { "query":{ "match_all":{} }, "from": 起始索引, "size": 查询几条 }示例
#分页查询：每页2条，查询第1页（从索引0开始，查询2条） GET /product/_search { "query": { "match_all": {} }, "from": 0, "size": 2 }结果
{ "took" : 0, "timed_out" : false, "_shards" : { "total" : 1, "successful" : 1, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : { "value" : 6, "relation" : "eq" }, "max_score" : 1.0, "hits" : [ { "_index" : "product", "_type" : "_doc", "_id" : "1", "_score" : 1.0, "_source" : { "title" : "小米手机", "images" : "http://image.leyou.com/12479122.jpg", "price" : 2999, "brand" : "小米" } }, { "_index" : "product", "_type" : "_doc", "_id" : "2", "_score" : 1.0, "_source" : { "title" : "华为手机", "images" : "http://image.leyou.com/12479122.jpg", "price" : 3999, "brand" : "华为" } } ] } }深度分页
深度分页问题
假如现在要查询990~1000的数据，查询逻辑要这么写：
GET /hotel/_search { "query": { "match_all": {} }, "from": 990, # 分页开始的位置，默认为0 "size": 10, # 期望获取的文档总数 "sort": [ {"price": "asc"} ] }这里是查询990开始的数据，也就是 第990~第1000条 数据。
单节点es的分页查询逻辑
elasticsearch内部分页时，必须先查询 0~1000条，然后截取其中的990 ~ 1000的这10条：
查询TOP1000，如果es是单点模式，这并无太大影响。
深度分页解决方案【拓展了解】
但是elasticsearch将来一定是集群，例如我集群有5个节点，我要查询TOP1000的数据，并不是每个节点查询200条就可以了：因为节点A的TOP200，在另一个节点可能排到10000名以外了。
因此要想获取整个集群的TOP1000，必须先查询出每个节点的TOP1000，汇总结果后，重新排名，重新截取TOP1000。
那如果我要查询9900~10000的数据呢？是不是要先查询TOP10000呢？那每个节点都要查询10000条？汇总到内存中？ 当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力，因此elasticsearch会禁止from+ size 超过10000的请求。
深度分页解决方案【拓展了解】
针对深度分页，ES提供了两种解决方案，官方文档：
search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。
scroll：原理将排序后的文档id形成快照，保存在内存。官方已经不推荐使用。
第一次查询
下一次查询
注意
要保证排序值是唯一不重复的，否则分页时可能会漏掉数据。
期望结果：
第一次查询：最后一条数据的排序值是 score=47，price=245。 score=47，price=245的数据只有一条
下一次查询：查询 score=47，price=245之后的数据，没有任何问题
但是如果：
score=45，price=245的数据有多条，假定为doc1、doc2
第一次查询第一页时，顺序是doc1、doc2，这一页刚好查询到了doc1
查询下一页时，顺序是doc2、doc1，从第2条开始，查询到了doc1
最终就漏掉了doc2
解决方案：
建议保证排序条件值不重复，就不会出现上面的问题了
例如：以score降序、price升序、
_id降序。_id是文档的唯一标识，是不重复的
3. 高亮
注意：
默认情况下，要求 检索字段 和 高亮字段 必须是同一个
如果检索字段与高亮字段不是同一个：需要添加
require_field_match，设置为false
高亮：就是在搜索结果中，把搜索的关键字突出显示。
原理：
在搜索结果中，把关键字使用特定的标签标记出来
在页面上，给这些标签添加CSS样式
高亮的最终效果实现，需要结合前端代码。而我们能做的，就是使用特定的标签把搜索结果中关键字标记出来
语法
高亮是对关键字高亮，因此搜索条件必须带有关键字，而不能是范围这样的查询。
默认情况下，高亮的字段，必须与搜索指定的字段一致，否则无法高亮
如果要对非搜索字段高亮，则需要添加一个属性：
required_field_match=false
GET /索引库名/_search { "query":{ "match":{ "字段": "值" } }, "highlight":{ "fields":{ "高亮字段1":{ "pre_tags":"开始标签", "post_tags":"结束标签" }, "高亮字段2":{ "pre_tags":"开始标签", "post_tags":"结束标签" }, "required_field_match": "false" } } }示例
GET /hotel/_search { "query": { "match": { "all": "北京酒店" } }, "highlight": { "fields": { "name":{ "pre_tags": "<em>", "post_tags": "</em>" } }, "require_field_match": "false" } }
4. 小结
1. 排序：sort
POST /hotel/_search
{
"sort":[
{
"字段名":{
"order": "排序规则"
}
},
{
"_geo_distance":{
"坐标字段": "中间点坐标，格式 纬度,经度",
"order": "排序规则",
"unit": "km"
}
},
{...}
]
}
2. 分页： from起始索引, size查询数量
起始索引 = (页码-1) * 查询数量
POST /hotel/_searc
{
"from": 0,
"size": 5
}
3. 高亮：highlight
POST /hotel/_search
{
"query":{
"match": {
"字段名": "字段值"
}
},
"highlight":{
"fields":{
"高亮字段名":{
"pre_tags": "<em>",
"post_tags": "</em>"
}
}
}
}
三、RestClient查询
文档的查询同样适用昨天学习的 RestHighLevelClient对象，基本步骤包括：
发起请求，得到响应
需要先准备SearchRequest对象，构建请求参数
处理响应，得到结果
可在Kibana里执行DSL命令，看着执行结果编写这部分代码
1.快速入门
我们以match_all查询为例，查询酒店并把结果输出到控制台上
API说明
发起请求得到响应
SearchRequest：用于封装检索参数
searchRequest对象.source()提供了构造检索参数的一系列方法：searchRequest对象.source() .query(检索条件) //可以使用QueryBuilders构造各种不同类型的查询条件 .sort(排序) .from(起始索引).size(查询数量) .highlighter(高亮);* `QueryBuilders`提供了一系列方法，用于构造不同类型的查询条件，常用的有： * `QueryBuilders.matchAllQuery()`：查询全部 * `QueryBuilders.matchQuery("字段", 值)`：match查询条件 * `QueryBuilders.multiMatchQuery(值, "字段1", "字段2", ...)`：multi_match查询条件 * `QueryBuilders.termQuery("字段", 值)`：term查询条件 * `QueryBuilders.rangeQuery("字段").gte(值1).lte(值2)`：range查询条件 * `QueryBuilders.geoDistanceQuery("字段").distance(距离,长度单位)`：geo_distance查询条件 * `QueryBuilders.functionScoreQuery()`：算分函数查询 * `QueryBuilders.boolQuery().must(..).should(..).mustNot(..).filter(..)`：bool查询条件 * `client.search(SearchRequest request, RequestOptions options)`：发起请求进行检索
处理响应得到结果
查询所有：
client.search()方法返回的结果是一个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文档数据示例代码
完整代码示例：public class Demo01 { private RestHighLevelClient client; @Test public void testMatchAll() throws IOException { //1. 构造SearchRequest对象。构造参数：索引库名 SearchRequest request = new SearchRequest("hotel"); //2. 设置查询信息 request.source().query(QueryBuilders.matchAllQuery()); //3. 发起请求，得到响应 SearchResponse response = client.search(request, RequestOptions.DEFAULT); //4. 处理响应，得到结果 SearchHits result = response.getHits(); // 总数量 long total = result.getTotalHits().value; System.out.println("总数量：" + total); // 列表 SearchHit[] hits = result.getHits(); for (SearchHit hit : hits) { System.out.println(hit.getSourceAsString()); } } @Before public void init(){ client = new RestHighLevelClient(RestClient.builder(new HttpHost("localhost", 9200))); } @After public void destroy() throws IOException { client.close(); } }查询所有：
@SpringBootApplication @MapperScan("com.esrestapi.mapper") public class HotelApplication { public static void main(String[] args) { SpringApplication.run(HotelApplication.class,args); } @Bean public RestHighLevelClient esClient(){ return new RestHighLevelClient(RestClient.builder( new HttpHost("localhost",9200) )); } } ------------------------------------------------------------------------- @SpringBootTest public class Demo01SearchTest { @Autowired private RestHighLevelClient esClient; @Test public void testSearch() throws IOException { SearchRequest request = new SearchRequest("hotel"); //match_all request.source().query(QueryBuilders.matchAllQuery()); //发请求到ES，执行搜索，得到搜索结果 SearchResponse response = esClient.search(request, RequestOptions.DEFAULT); //处理结果 long total = response.getHits().getTotalHits().value; System.out.println("total = " + total); SearchHit[] hits = response.getHits().getHits(); for (SearchHit hit : hits) { HotelDoc doc = JSON.parseObject(hit.getSourceAsString(), HotelDoc.class); System.out.println("doc = " + doc); } } }
2.match查询
3.精确查询
4.布尔查询
5. 算分函数
6.排序、分页
7.高亮
四、旅游案例
