1. 先搞懂查询结果:你的数据“体检报告”
刚开始用 Elasticsearch 做查询,最让人懵的可能不是怎么写查询语句,而是拿到那一大坨 JSON 结果后,完全看不懂每个字段是啥意思。这感觉就像拿到一份全英文的体检报告,每个词都认识,但连起来就不知道身体到底好不好了。别急,咱们先来把这份“体检报告”的每一项都拆开看明白。
当你执行一个最简单的空搜索(比如 GET /your_index/_search),你会得到一个类似下面的结果。我结合自己踩过的坑,给你翻译一下:
{
"took": 5,
"timed_out": false,
"_shards": {
"total": 3,
"successful": 3,
"skipped": 0,
"failed": 0
},
"hits": {
"total": {
"value": 21798,
"relation": "eq"
},
"max_score": 1.0,
"hits": [
{
"_index": "your_index",
"_type": "_doc",
"_id": "1",
"_score": 1.0,
"_source": {
"orderNo": "202310270001",
"amount": 299.9,
"createTime": "2023-10-27T10:00:00Z"
// ... 你的文档所有原始字段都在这里
}
}
]
}
}
took(耗时): 这个数字单位是毫秒,表示 ES 处理你这个请求花了多久。我刚开始总以为它包含了网络传输时间,其实不是,它只算 ES 服务器内部搜索的时间。如果这个值突然飙升,那很可能你的查询需要优化,或者集群压力大了。timed_out(是否超时): 默认情况下,查询不会超时。但如果你的查询太复杂或者数据量巨大,你可以手动设置超时时间。如果这里显示true,那返回的结果可能是不完整的。_shards(分片信息): 这是理解 ES 分布式特性的关键。total是你索引的总分片数(主分片+副本分片)。successful是成功参与搜索的分片数,如果它小于total,说明有部分分片可能因为节点宕机等原因没响应,但搜索依然成功了(只要还有分片活着)。failed为 0 是最理想的状态。hits(命中文档): 这是我们最关心的部分。total.value: 匹配到的文档总数。这是做分页时必须用到的关键数字。注意,在数据量极大时,为了性能,ES 可能返回一个近似值(relation为gte),如果需要精确值,需要在查询中设置"track_total_hits": true,但这会有性能代价,我一般只在后台管理统计时用。max_score: 本次查询结果中,最高的相关性评分。如果你用了match这类全文检索,这个值能帮你判断整体匹配质量。hits数组: 这里就是具体的文档列表了,默认按_score降序排列,只返回前10条。_index,_type,_id: 文档的“身份证”信息。_score: 相关性分数。这是全文搜索的精华,分数越高,代表文档与你的搜索意图越相关。但像term、filter这种精确查询或过滤,是不计算分数的,所以这里会是null或者一个固定值。_source: 文档的原始内容,就是你存进去的所有字段。这里有个实战技巧:如果文档字段很多很大,但你只需要其中几个,一定要用_source过滤来减少网络传输和序列化开销,比如"_source": ["orderNo", "amount"]。
理解这份“报告”,你就能对查询的健康状况和结果有效性有个基本判断了。接下来,咱们就从最简单的查询开始上手。
2. 入门三板斧:match, term, range
刚开始写查询,别想着一口吃成胖子。掌握最常用的三种查询,就能解决80%的基础需求。我把它们叫做“入门三板斧”。
2.1 match查询:像百度一样搜全文
match 查询是 ES 里最常用、最“聪明”的查询。它会对你的搜索词进行分词,然后用分好的词去倒排索引里找。这非常适合用来做全文搜索,比如商品名称、文章内容搜索。
GET /products/_search
{
"query": {
"match": {
"description": "无线蓝牙降噪耳机"
}
}
}
上面这个查询,ES 会先用分词器(比如默认的 standard,或你配置的 ik)把“无线蓝牙降噪耳机”拆分成可能是【无线】、【蓝牙】、【降噪】、【耳机】这几个词条。然后,它会去找 description 字段里包含这些词条中任何一个的文档。这相当于一个 OR 的逻辑。
那如果我想要所有词条都必须出现呢?用 operator 参数:
GET /products/_search
{
"query": {
"match": {
"description": {
"query": "无线蓝牙降噪耳机",
"operator": "and" // 要求所有分词结果都必须出现
}
}
}
}
这就像搜索“无线 AND 蓝牙 AND 降噪 AND 耳机”,结果会更精确,但可能也会漏掉一些相关文档。我个人的经验是,在电商搜索框这种场景,默认的 or 逻辑用户体验更好;在后台系统做精确筛选时,可以用 and。
2.2 term查询:精确匹配,一锤定音
term 查询用于对未分词的字段做精确匹配。它不会对搜索词做任何处理,直接拿整个词去索引里找。这常用于匹配 keyword 类型字段、数字、日期、枚举值等。
GET /orders/_search
{
"query": {
"term": {
"status": "PAID" // 精确匹配状态为“已支付”的订单
}
}
}
这里有个超级大坑,我踩过好几次! 如果你对一个 text 类型的字段(比如 productName)使用 term 查询,很可能会搜不到东西。因为 text 字段会被分词存储。你存的是“华为手机”,但分词后变成了“华为”和“手机”。你用 term 去查“华为手机”,ES 去找完整的“华为手机”这个词条,当然找不到。所以,做精确匹配时,确保字段类型是 keyword,或者使用 text 字段的 .keyword 子字段(多字段映射特性)。
// 正确做法:使用 .keyword 子字段进行精确匹配
GET /products/_search
{
"query": {
"term": {
"productName.keyword": "华为 Mate 60 Pro"
}
}
}
2.3 terms查询:一人得道,鸡犬升天
terms 是 term 的复数形式,相当于 SQL 里的 IN 语句。一次性能匹配多个值,只要文档的字段值出现在你给的列表里,就算命中。
GET /users/_search
{
"query": {
"terms": {
"city": ["北京", "上海", "深圳", "广州"] // 用户城市在这四个之中的
}
}
}
这个查询在过滤分类、标签、地区等场景下非常高效。
2.4 range查询:划定你的势力范围
range 查询用于范围匹配,支持数字、日期甚至字符串(按字典序)。它的参数非常直观:
gt: 大于gte: 大于等于lt: 小于lte: 小于等于
GET /logs/_search
{
"query": {
"range": {
"responseTime": {
"gte": 100,
"lt": 500
}
}
}
}
日期范围查询是另一个高频场景,格式必须符合 ES 能识别的日期格式:
GET /orders/_search
{
"query": {
"range": {
"createTime": {
"gte": "2023-10-01",
"lte": "2023-10-31",
"format": "yyyy-MM-dd" // 明确指定格式是个好习惯
}
}
}
}
掌握了这“三板斧”,你已经能应付很多日常查询了。但现实需求往往更复杂,我们需要把多个条件组合起来。
3. 布尔组合:must, should, must_not, filter 的排列艺术
当你的查询条件不止一个时,bool 查询就是你最强大的武器。它允许你通过逻辑组合(must=且,should=或,must_not=非)来构建复杂的查询。我把它理解成乐高积木,用几个简单的块搭出复杂的结构。
3.1 理解四个核心子句
一个标准的 bool 查询结构如下:
GET /articles/_search
{
"query": {
"bool": {
"must": [ // 必须满足,类似 AND,参与算分
{ "match": { "title": "Elasticsearch" } }
],
"must_not": [ // 必须不满足,类似 NOT,不参与算分
{ "term": { "status": "draft" } }
],
"should": [ // 应该满足,类似 OR,参与算分
{ "match": { "tags": "入门" } },
{ "match": { "tags": "实战" } }
],
"filter": [ // 必须满足,类似 AND,但不参与算分,性能高
{ "range": { "publishDate": { "gte": "2023-01-01" } } }
]
}
}
}
must(必须): 所有条件都必须满足,文档才会被返回。它会影响_score。should(应该): 满足其中任意一个或多个条件即可。它也会影响_score,满足的should子句越多,分数通常越高。这里有个关键点:如果bool查询里同时有must或filter,那么should就变成了“加分项”,不是必须的。如果想让should在must存在时也至少满足一个,需要设置"minimum_should_match": 1。must_not(必须不): 文档不能匹配这些条件。它不参与算分,纯粹是过滤。filter(过滤): 文档必须匹配这些条件。它和must的关键区别在于:filter不计算相关性分数,并且结果可以被缓存。这带来了巨大的性能优势。
3.2 为什么 filter 比 must 快?缓存的力量
这是面试常考点,也是性能优化的关键。filter 上下文只关心“是”或“否”,不关心“有多好”。因此,ES 可以跳过耗时的评分计算过程。更重要的是,ES 会为 filter 子句的结果构建一个叫 bitset 的位图缓存。
想象一下,你有一个过滤条件 status: "ACTIVE"。ES 会遍历所有文档,为每个文档生成一个标记:1(活跃)或 0(不活跃)。这个位图(bitset)很小,可以高效地缓存在内存里。下次再有完全相同的 filter 查询过来,ES 直接复用这个位图,不用再去翻庞大的倒排索引了。而 must 因为要算分,每次都得重新计算。
所以,一个黄金法则就是:所有不需要相关性评分的条件,都应该放在 filter 里。比如状态过滤、时间范围过滤、分类过滤等。
3.3 一个实战案例:商品搜索
假设我们要构建一个电商商品搜索:
- 必须包含关键词“手机”(全文搜索)。
- 品牌必须是“华为”或“小米”(精确匹配)。
- 价格必须在1000到5000元之间(范围过滤)。
- 必须上架(状态过滤)。
- 如果商品有“官方旗舰店”标签,或者好评率大于98%,就给它加分(提升排名)。
用 bool 查询可以清晰地表达:
GET /products/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"name": "手机"
}
}
],
"filter": [ // 精确匹配和范围过滤,不参与算分,性能高
{
"terms": {
"brand.keyword": ["华为", "小米"]
}
},
{
"range": {
"price": {
"gte": 1000,
"lte": 5000
}
}
},
{
"term": {
"status": "ON_SHELF"
}
}
],
"should": [ // 加分项,满足则提升排名
{
"term": {
"tags.keyword": "官方旗舰店"
}
},
{
"range": {
"goodRatingRate": {
"gt": 0.98
}
}
}
],
"minimum_should_match": 0 // 因为有must和filter,should不是必须的
}
}
}
通过 bool 查询,我们可以把复杂的业务逻辑清晰地翻译成 ES 能理解的查询语句,并且兼顾了性能和相关性排序。
4. 高级查询技巧:解决复杂场景
基础查询和布尔组合能解决大部分问题,但有些特殊场景需要更高级的工具。这里介绍两个我项目中常用的高级查询。
4.1 dis_max:在多字段中寻找“最佳匹配”
有时候,我们想同时在多个字段里搜索同一个词,比如在文章的“标题”和“内容”里搜“人工智能”。你可能会想到用 bool 的 should:
{
"query": {
"bool": {
"should": [
{ "match": { "title": "人工智能" } },
{ "match": { "content": "人工智能" } }
]
}
}
}
这没问题,但算分方式可能不符合预期。ES 会把两个字段的分数加起来作为最终分数。如果一个文档标题匹配度极高(得高分),内容只是稍微提了一下(得低分),另一个文档标题和内容匹配度都很中等(两个中等分),加起来的总分可能后者更高。但我们往往更希望标题匹配度极高的那个文档排在前面。
这时就需要 dis_max (Disjunction Max Query,分离最大化查询)。它会在多个查询中,只取分数最高的那个作为最终分数,而不是求和。
GET /articles/_search
{
"query": {
"dis_max": {
"queries": [
{ "match": { "title": "人工智能" } },
{ "match": { "content": "人工智能" } }
],
"tie_breaker": 0.3
}
}
}
queries: 包含多个子查询的数组。tie_breaker(打破平局者): 一个0到1之间的小数。最终分数 = 最高分 +tie_breaker* 其他匹配查询的分数。如果设为0,就是只取最高分;如果设为1,就退化成了分数求和。通常设置一个0.1~0.4的值,能在突出最佳匹配的同时,适当考虑其他字段的匹配度。
4.2 boosting query:给查询条件加上“权重”
另一个常见需求是:我们希望某些条件更重要。比如搜索员工,名字匹配的权重应该远高于部门匹配。boosting query 可以做到这一点,但它不是直接加权,而是通过“降权”来实现。
GET /employees/_search
{
"query": {
"boosting": {
"positive": {
"should": [
{ "match": { "name": "张三" } },
{ "match": { "department": "技术部" } }
]
},
"negative": {
"term": {
"status": "离职"
}
},
"negative_boost": 0.2
}
}
}
positive: 基础查询,匹配到的文档都会返回。negative: 负面查询。如果一个文档同时匹配了positive和negative,那么它的分数会被惩罚。negative_boost: 惩罚系数。匹配了负面查询的文档,其最终分数 = 原始分数 *negative_boost(这里就是乘以0.2)。
在上面的例子里,所有员工都会被搜索,但状态是“离职”的员工,其排名会大幅下降。这比用 must_not 直接过滤掉更灵活,因为“离职”员工的信息仍然能看到,只是排在后面。
5. 分页与排序:高效获取你想要的数据
查询结果往往很多,我们不可能一次性全拉回来。分页是必备技能,但 ES 的分页有它的特殊性。
5.1 基础分页:from + size
最直接的分页方式,和 SQL 的 LIMIT offset, size 很像。
GET /logs/_search
{
"from": 20, // 从第20条开始(0-based)
"size": 10, // 取10条
"query": { "match_all": {} }
}
但是,这里有性能陷阱! from + size 的分页方式,在深度分页时(比如 from=10000)效率极低。因为 ES 需要从每个分片上先取出 10000+10 条数据,在协调节点汇总排序后,再给你第10000到10009条。数据量一大,内存和CPU消耗都非常恐怖。ES 默认限制 from + size 不能超过 10000。对于深度分页,需要用下面介绍的 search_after。
5.2 滚动查询:search_after
search_after 是处理深度分页的推荐方式。它需要一个排序字段组合(通常至少包含一个唯一值字段,如 _id),并利用上一次查询最后一条记录的结果来获取下一页。
// 第一页
GET /orders/_search
{
"size": 100,
"sort": [
{ "createTime": "desc" },
{ "_id": "asc" } // 确保排序唯一性
],
"query": { ... }
}
// 假设第一页最后一条结果的排序值是 ["2023-10-27T10:00:00.000Z", "order_100"]
// 第二页请求
GET /orders/_search
{
"size": 100,
"sort": [
{ "createTime": "desc" },
{ "_id": "asc" }
],
"search_after": ["2023-10-27T10:00:00.000Z", "order_100"], // 关键在这里
"query": { ... }
}
search_after 的原理类似于书签,它不关心前面有多少页,只从“书签”处开始往后拿数据,性能远优于 from + size。但它不支持跳页,只能一页一页顺序往下翻,非常适合后台数据导出、无限滚动加载等场景。
5.3 排序:不止按分数
默认情况下,结果按 _score 降序排列。但我们可以自定义排序规则:
GET /products/_search
{
"sort": [
{ "price": { "order": "asc" } }, // 按价格升序
{ "_score": { "order": "desc" } }, // 再按相关性降序
{ "stock": { "order": "desc", "missing": "_last" } } // 库存降序,无库存字段的排最后
],
"query": { ... }
}
对于 text 字段,如果需要排序,通常要使用其 .keyword 子字段,因为分词后的 text 字段无法进行有意义的排序。
6. 聚合分析:让数据开口说话
聚合(Aggregation)是 ES 的杀手锏之一,它能让你对数据进行多维度的统计分析,而不仅仅是检索文档。聚合主要分两大类:指标聚合 和 桶聚合。
6.1 指标聚合:计算统计值
指标聚合类似于 SQL 的 AVG(), SUM(), MAX(), MIN(), COUNT() 等函数。
GET /orders/_search
{
"size": 0, // 不关心具体文档,只返回聚合结果
"aggs": { // aggregation 的缩写
"total_sales": {
"sum": { // 求和
"field": "amount"
}
},
"avg_order_value": {
"avg": { // 求平均值
"field": "amount"
}
},
"max_amount": {
"max": { // 求最大值
"field": "amount"
}
},
"order_count": {
"value_count": { // 计数
"field": "orderNo.keyword"
}
}
}
}
6.2 桶聚合:数据分组与下钻
桶聚合将文档分配到不同的“桶”中,类似于 SQL 的 GROUP BY。最常用的是 terms 聚合。
// 按城市分组,统计订单数量和销售总额
GET /orders/_search
{
"size": 0,
"aggs": {
"sales_by_city": { // 第一个聚合:按城市分桶
"terms": {
"field": "city.keyword",
"size": 10 // 返回前10个城市
},
"aggs": { // 在桶内再进行子聚合:计算每个城市的销售额
"city_total_sales": {
"sum": {
"field": "amount"
}
}
}
}
}
}
这个查询会返回一个列表,显示每个城市的订单数(默认按文档数降序),以及每个城市的销售总额。这就是典型的“分组统计”。
6.3 一个综合实战案例:电商数据仪表盘
假设我们要为电商后台做一个仪表盘,需要以下数据:
- 今日总销售额、总订单数。
- 按商品分类统计的销售额 Top 5。
- 按小时统计的订单趋势。
我们可以用一个查询搞定:
GET /orders/_search
{
"size": 0,
"query": {
"range": {
"createTime": {
"gte": "now-1d/d", // 从昨天零点开始
"lt": "now/d" // 到今天零点(即最近24小时)
}
}
},
"aggs": {
"total_stats": { // 总指标
"stats": { // stats聚合一次性返回 count, min, max, avg, sum
"field": "amount"
}
},
"top_categories": { // 按分类分桶
"terms": {
"field": "categoryName.keyword",
"size": 5,
"order": { "category_sales": "desc" } // 按子聚合的销售额降序排
},
"aggs": {
"category_sales": {
"sum": { "field": "amount" }
}
}
},
"orders_by_hour": { // 按小时分桶(日期直方图)
"date_histogram": {
"field": "createTime",
"calendar_interval": "hour",
"format": "HH:mm",
"min_doc_count": 0 // 即使某个小时没订单,也返回0
},
"aggs": {
"hourly_sales": {
"sum": { "field": "amount" }
}
}
}
}
}
这个查询充分利用了 ES 聚合的强大能力,通过一次请求就获取了多层级的分析数据,避免了在应用层进行多次查询和复杂的数据拼接,极大地提升了后台数据报表的性能和开发效率。
从我自己的经验来看,从理解查询结果开始,到熟练运用布尔组合和聚合分析,是一个循序渐进的过程。刚开始写复杂的 bool 查询和嵌套聚合可能会觉得头大,但多写几次,多结合 Kibana 的 Dev Tools 去调试和查看结果,慢慢就会找到感觉。记住,ES 的查询 DSL 虽然看起来复杂,但其设计思想非常贴近我们的自然逻辑。把它当成搭积木,先拆解业务需求,再选择合适的“积木块”组合起来,你就能驾驭它了。
3707



被折叠的 条评论
为什么被折叠?



