【ElasticSearch】学习使用DSL和RestClient编写查询语句

文章目录

  • DSL和RestClient的学习
    • 前言
    • 1、DSL查询文档
      • 1.1 查询分类
      • 1.2 全文检索查询
        • 1.21 全文检索概述
        • 1.2.2 基本使用
      • 1.3 精确查询
        • 1.3.1 term查询
        • 1.3.2 range查询
      • 1.4 地理坐标查询
        • 1.4.1 geo_bounding_box查询
        • 1.4.2 geo_distance查询
      • 1.5 复合查询
        • 1.5.1 常见相关性算法
        • 1.5.2 算分函数查询
        • 1.5.3 布尔查询
    • 2、搜索结果处理
      • 2.1 排序
        • 2.1.1 普通字段排序
        • 2.1.2 地理坐标排序
      • 2.2 分页
      • 2.3 高亮
    • 小结
    • 3、RestClient查询文档
      • 3.1 快速入门
      • 3.2 match查询
      • 3.3 精确查询
      • 3.4 布尔查询
      • 3.5 排序和分页
      • 3.6 高亮

DSL和RestClient的学习

前言

众所周知ElasticSearch是一个著名分布式搜索引擎，既然是搜索引擎，那么查询操作就很常见，而本文将介绍如何通过DSL和RestClient实现查询语句的编写，我相信通过本文的学习，你将很快掌握ElasticSearch中常见的查询和聚合操作，同时了解如何对搜索结果的排序和分页，以及前端搜索高亮的实现逻辑。
PS：由于作者水平有限，如果文中存在错误、描述不当的的地方，还请您能够及时指出，作者将及时改正，同时如果文章存在侵权的地方，也请你及时告知，作者将立即删除予以更正
推荐阅读：

  • ElasticSearch_学习专栏
  • 初识ElasticSearch-CSDN博客
  • ElasticSearch中常见的分词器介绍-CSDN博客

1、DSL查询文档

DSL全称 Domain Specific Language，翻译过来就是 特定领域语言，不同领域的DSL语法都是不同的，比如数据库领域的DSL就是 SQL、写作领域的DSL就说 LaTeX，而本文中所讲的DSL也是特指ElasticSearch中的DSL，它是一种类似于 JSON 格式的语句，我们使用它可以实现查询和聚合等一系列操作

1.1 查询分类

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：

  • 查询所有：查询出所有数据，一般测试用。例如：match_all

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

    • match_query
    • multi_match_query

  • 精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：

    • ids
    • range
    • term

  • 地理（geo）查询：根据经纬度查询。例如：

    • geo_distance
    • geo_bounding_box

  • 复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：

    • bool
    • function_score

查询的语法基本一致：

GET /indexName/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}

示例

我们以查询所有为例，其中：

  • 查询类型为match_all
  • 没有查询条件
// 查询所有
GET /indexName/_search
{
  "query": {
    "match_all": {
    }
  }
}

其它查询无非就是查询类型、查询条件的变化。

1.2 全文检索查询

1.21 全文检索概述

  • 什么是全文检索？

    全文检索（Full Text Search）是指对文本中的内容进行实时搜索和相关性匹配。在ES中可以使用全文检索对索引中的文本进行搜索，这种搜索不只是搜索特定的字段或关键字匹配，还使用了一些复杂的算法进行文本分析和相关性计算，以找到最相关的结果。

  • 全文检索的特点

    • 高效性：全文检索技术能够快速返回与查询相关的数据，尤其是在大数据量的情况下，较传统的基于关键词的搜索方法要更迅捷高效。
    • 全面性：全文检索技术涵盖数据库中所有的文本信息，能够搜索到文档内容中的所有单词，而不仅仅是部分关键词，因此精度较高。
    • 可扩展性：全文检索技术能够在高并发和大数据量的情况下，保持稳定和快速响应，因此能够适应不断改进和扩展的需求。
    • 智能性：全文检索技术在数据查询时能够使用一些智能算法，如tf-idf、倒排索引等，对结果进行更加精确的匹配，提高查询的质量。
    • 自然语言处理：全文检索技术能够对自然语言的输入进行处理，进行词义的分析与理解，进而更好地理解用户的意图。

  • 全文检索的优缺点

    • 优点
      • 精度较高：全文检索技术能够涵盖数据库中所有的文本信息，能够搜索到内容中的所有单词，因此精度较高。
      • 高效性：全文检索技术能够快速返回与查询相关的数据，较传统的关键词搜索方法要更迅捷高效。
      • 可扩展性：全文检索技术能够在高并发和大数据量的情况下，保持稳定和快速响应，因此能够适应不断改进和扩展的需求。
      • 智能性：全文检索技术能够使用一些智能算法，如tf-idf、倒排索引等，对结果进行更加精确的匹配，提高查询的质量。
      • 自然语言处理：全文检索技术能够对自然语言的输入进行处理，进行词义的分析与理解，进而更好地理解用户的意图。
    • 缺点
      • 误差率：全文检索技术可能会返回一些不相关的结果，特别是在文本内容较为相似的情况下，误差率会更高。
      • 字段限制：全文检索技术主要是针对文本信息的，而在其他类型的数据，如二进制数据和图像等，效果并不理想，因此应用范围受到一定限制。
      • 配置和管理：全文检索需要进行系统的配置和管理，包括索引建立、数据更新、搜索结果的分析等，因此需要专业的知识和技能作为支持。

  • 全文检索的应用场景

    • 搜索引擎：搜索引擎是全文检索技术最典型的应用场景之一，能够对互联网上的信息进行高效检索，如Google、Bing、Baidu等。
    • 电商平台：电商平台中的商品信息往往非常丰富，全文检索可以实现搜索商品的名称、描述、型号等，使用户更快速地找到所需要的商品。
    • 成功案例与知识库：全文检索技术可以帮助用户在数据库中搜索与他们需要解决的问题相关的信息，如在IT支持中搜索帮助文档等。
    • 社交网络与博客：全文检索可以实现在社交网络和博客平台搜索文章的内容，如在微博和微信中搜索相关话题的文章，提供给用户更符合需求的内容。
    • 科学文献与图书馆：全文检索技术可以在图书馆和文献数据库中帮助用户检索相关文本信息，如SCI、IEEE等。
    • 人力资源管理：全文检索可以用于搜索并筛选简历，提高人力资源管理的效率和准确率。

  • 全文检索的流程

    • 对用户搜索的内容做分词，得到词条
    • 根据词条去倒排索引库中匹配，得到文档id
    • 根据文档id找到文档，返回给用户
1.2.2 基本使用

常见的全文检索查询包括：

  • match查询：单字段查询
  • multi_match查询：多字段查询，任意一个字段符合条件就算符合查询条件

match查询语法如下：

GET /indexName/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  }
}

mulit_match语法如下：

GET /indexName/_search
{
  "query": {
    "multi_match": {
      "query": "TEXT",
      "fields": ["FIELD1", " FIELD12"]
    }
  }
}

示例

示例一：

演示match_all查询，查询索引库中所有的文档

# 查询索引库中所有的文档
POST hotel/_search
{
  "query": {
    "match_all": {}
  }
}

image-20230519192238156

或者这么写

# 查询索引库中所有字段包含 "外滩" 这个词的文档
POST hotel/_search
{
  "query": {
    "match": {
      "all":"外滩"
    }
  }
}

image-20230519192559889

image-20230519193106948

示例二：

演示mulit_match查询

GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "外滩如家",
      "fields": [
        "brand",
        "name",
        "business"
      ]
    }
  }
}

image-20230519192633440

可以看到，两种查询结果是一样的，为什么？

因为我们将brand、name、business值都利用copy_to复制到了all字段中。因此你根据三个字段搜索，和根据all字段搜索效果当然一样了。但是，搜索字段越多，对查询性能影响越大，因此建议采用copy_to，然后单字段查询的方式。关于copy to的使用可以参考上一章节的RestClient初体验

1.3 精确查询

在 Elasticsearch 中，精确查询通常是指完全匹配指定关键词的查询，它与全文检索不同，全文检索会在文档的所有字段中搜索包含给定关键词的文本

精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。常见的有：

  • term：根据词条精确值查询，一般搜索keyword类型、数值类型、布尔类型、日期类型字段
  • range：根据值的范围查询，可以是数值、日期的范围
1.3.1 term查询
  • term查询：根据词条精确匹配，
  • range查询：根据数值范围查询，

因为精确查询的字段搜是不分词的字段，因此查询的条件也必须是不分词的词条。查询时，用户输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多，反而搜索不到数据。

基本语法：

// term查询
GET /indexName/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": "VALUE"
      }
    }
  }
}

示例

示例一：

当我搜索的是精确词条时，能正确查询出结果

# term查询
GET /hotel/_search
{
  "query": {
    "term": {
      "city": {
        "value": "上海"
      }
    }
  }
}

image-20230519193655287

示例二：

当我搜索的内容不是词条，而是多个词语形成的短语时，反而搜索不到

# term查询
GET /hotel/_search
{
  "query": {
    "term": {
      "city": {
        "value": "杭州上海"
      }
    }
  }
}

image-20230519193843117

1.3.2 range查询

范围查询，一般应用在对数值类型做范围过滤的时候。比如做价格范围过滤

基本语法：

// range查询
GET /indexName/_search
{
  "query": {
    "range": {
      "FIELD": {
        "gte": 10, // 这里的gte代表大于等于，gt则代表大于
        "lte": 20 // lte代表小于等于，lt则代表小于
      }
    }
  }
}

示例：

# 查询价格在1000~3000之间的
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 1000,
        "lte": 3000
      }
    }
  }
}

备注：上面的范围是 1000<=price<=3000，如果将e去掉，变成 gt 和 lt，则范围是 1000<price<3000

image-20230519194006468

1.4 地理坐标查询

所谓的地理坐标查询，其实就是根据经纬度查询

官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/geo-queries.html

  • 常见的使用场景包括：

    • 携程：搜索我附近的酒店

    • 滴滴：搜索我附近的出租车

    • 微信：搜索我附近的人

  • ES中地理坐标查询有两类：

    • geo_shape查询：它可以让我们在地理空间地图上画出任意形状的图形，比如圆、矩形、多边形、线段、点等。我们可以根据这些形状过滤出一定范围内的文档。
    • geo_distance查询：该查询可以让我们针对某个经纬度点，查找指定距离（公里、英里等）内的所有文档。
1.4.1 geo_bounding_box查询

geo_bounding_box查询称为矩形范围查询，查询坐标落在某个矩形范围的所有文档，通常用于查询某个地理位置附近的信息，或者过滤出位于一个特定区域内的信息

查询时，需要指定矩形的左上、右下两个点的坐标，然后画出一个矩形，落在该矩形内的都是符合条件的点

image-20230520115957587

基本语法：

# geo_bounding_box查询
GET /indexName/_search
{
  "query": {
    "geo_bounding_box": {
      "FIELD": {
        "top_left": { # 左上点
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": { # 右下点
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}
1.4.2 geo_distance查询

geo_distance查询称作附近查询，也叫做距离查询：查询到指定中心点小于某个距离值的所有文档。这种查询方式通常用于搜索附近的实体，如酒店、餐厅、商店等

换句话来说，在地图上找一个点作为圆心，以指定距离为半径，画一个圆，落在圆内的坐标都算符合条件：

image-20230520120347108

基本语法：

// geo_distance 查询
GET /indexName/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "FIELD": "31.21,121.5" // 圆心
    }
  }
}

示例：

我们先搜索陆家嘴附近15km的酒店

# geo_distance 查询陆家嘴附近的酒店
GET /hotel/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km",
      "location": "13.21, 121.5"
    }
  }
}

image-20230520120543900

然后把半径缩短到3公里：

image-20230520120605042

可以发现，搜索到的酒店数量减少到了5家！

1.5 复合查询

复合（compound）查询：复合查询可以将其它简单查询组合起来，实现更复杂的搜索逻辑。常见的有两种：

  • fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名
  • bool query：布尔查询，利用逻辑关系组合多个其它的查询，实现复杂搜索
1.5.1 常见相关性算法

当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列（分值越高，排名越靠前）。在elasticsearch中，早期使用的打分算法是TF-IDF算法，公式如下：

TF-IDF（Term Frequency-Inverse Document Frequency，词频-逆文档频率）算法是一种常用于信息检索和文本挖掘的算法。

在 TF-IDF 算法中，每个文档中的每个词都会被赋予一个权重值，该权重值由两部分构成：词频和逆文档频率。

  • 词频：指的是一个词在文档中出现的次数。在TF-IDF中，一个词出现的次数越多，它的权重值就越高。

  • 逆文档频率：指的是一个词在所有文档中出现的次数。如果一个词在许多文档中出现，说明它对区分文档的重要性不高，权重值较低。如果一个词在较少的文档中出现，说明它对区分文档的重要性较高，权重值较高。因此，逆文档频率越高，它的权重值就越大。

T F ( 词条频率 ) = 词条出现次数 文档中词条总数 I D F ( 逆文档频率 ) = l o g 文档总数 包含词条的文档总数 + 1 s c o r e = ∑ i n T F ( 词条频率 ) ∗ I D F ( 逆文档频率 ) \begin{align} &TF(词条频率)=\frac{词条出现次数}{文档中词条总数} \\ &IDF(逆文档频率)=log\frac{文档总数}{包含词条的文档总数+1} \\ &score=\sum^{n}_{i}{TF(词条频率)}*{IDF(逆文档频率)} \end{align} ​TF(词条频率)=文档中词条总数词条出现次数​IDF(逆文档频率)=log包含词条的文档总数+1文档总数​score=i∑n​TF(词条频率)∗IDF(逆文档频率)​​

备注：TF中，词的TF越大，表示该词在文档中的重要性越高；IDF中，IDF越大，表示该词在文档中的重要性越高。IDF中加1是为了避免该词汇在所有文档中都没有出现的情况（即分母为0）。

早期一般是直接计算 IF ，作为相关性得分，例如：如果一个文档中“apple”这个词出现了8次，而文档中总共出现了100个单词，则“apple”这个词的IF为：IF(apple) = 8 / 100 = 0.08。IF越大，表示该词在文档中的重要性越高。但是，IF的计算没有考虑到该词在整个文集中的出现情况，如果某个词汇在所有文档中都频繁出现，那么它的IF就会偏低，而这种词汇有可能是一些常用单词，如“the”、“and”等。所以就需要使用 TF-IDF 算法 计算相关性得分，但是IDF受词条出现频率影响较大，

BM25算法是一种常用于信息检索中的文本相似度算法，它是基于TF-IDF算法的基础上进行改进后得到的。

BM25算法主要的改进在于引入了两个调整因子，即k和b。其中，k是控制文档长度对得分的影响程度的参数，一般取值2；b是控制文档中词频对得分的影响程度的参数，一般取值0.75。相比于传统的TF-IDF算法，BM25在信息检索排名时更加准确和有效，具有更好的性能。

在后来的5.1版本升级中，elasticsearch将算法改进为BM25算法，公式如下：

s o c r e ( Q , d ) = ∑ i n l o g ( 1 + N − n + 0.5 n + 0.5 ) ∗ f i f i + k 1 ∗ ( 1 − b + b ∗ d l a v g d l ) socre(Q,d)=\sum^{n}_{i}log(1+\frac{N-n+0.5}{n+0.5})*\frac{f_i}{f_i+k_1*(1-b+b*\frac{dl}{avgdl})} socre(Q,d)=∑in​log(1+n+0.5N−n+0.5​)∗fi​+k1​∗(1−b+b∗avgdldl​)fi​​

TF-IDF算法有一各缺陷，就是词条频率越高，文档得分也会越高，单个词条对文档影响较大。而BM25则会让单个词条的算分有一个上限，曲线更加平滑：

image-20230520131424997

1.5.2 算分函数查询

根据相关度打分是比较合理的需求，但合理的不一定是产品经理需要的。以百度为例，你搜索的结果中，并不是相关度越高排名越靠前，而是谁掏的钱多排名就越靠前。如果要想认为控制相关性算分，就需要利用elasticsearch中的function_score 查询了。

基本语法：

image-20230520131715553

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）基于运算模式做运算，得到最终结果，作为相关性算分。

因此，其中的关键点是：

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

function score query定义的三要素是什么？

  • 过滤条件：哪些文档要加分
  • 算分函数：如何计算function score
  • 加权方式：function score 与 query score如何运算

示例：

给“如家”这个品牌的酒店排名靠前一些

# 采用ES默认算分规则
GET /hotel/_search
{
  "query":{
    "function_score": {
      "query": {
        "match": {
          "all": "外滩"
        }
      }
    }
  }
}

image-20230520132518723

image-20230520132855898

GET /hotel/_search
{
  "query":{
    "function_score": {
      "query": {
        "match": {
          "all": "外滩"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "如家"
            }
          },
          "weight": 10 
        }
      ],
      "boost_mode":"sum"
    }
  }
}

image-20230520133001101

1.5.3 布尔查询

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

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

比如在搜索酒店时，除了关键字搜索外，我们还可能根据品牌、价格、城市等字段做过滤：

image-20210721193822848

每一个不同的字段，其查询的条件、方式都不一样，必须是多个不同的查询，而要组合这些查询，就必须用bool查询了。

需要注意的是，搜索时，参与打分的字段越多，查询的性能也越差。因此这种多条件查询时，建议这样做：

  • 搜索框的关键字搜索，是全文检索查询，使用must查询，参与算分
  • 其它过滤条件，采用filter查询。不参与算分

语法示例

GET /hotel/_search
{
  "query": {
    "bool": {
      // 酒店必须是在上海
      "must": [
        {"term": {"city": "上海" }}
      ],
      // 酒店品牌是 皇冠假日或者华美达两个其中的一个
      "should": [
        {"term": {"brand": "皇冠假日" }},
        {"term": {"brand": "华美达" }}
      ],
      // 酒店价格不能小于500
      "must_not": [
        { "range": { "price": { "lte": 500 } }}
      ],
      // 酒店算分大于45
      "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": "如家"
          }
        }
      ],
      # 价格不高于400 即：price<=400
      "must_not": [
        {
          "range": {
            "price": {
              "gt": 400
            }
          }
        }
      ],
      # 坐标31.21, 121.5周围10km范围内
      "filter": [
        {
          "geo_distance": {
            "distance": "10km",
            "location": {
              "lat": 31.21,
              "lon": 121.5
            }
          }
        }
      ]
    }
  }
}

注意：如果将filter中地址过滤的DSL放到must中，会影响算法，虽然最终文档数量是一致的，但是参与算法的字段越多，性能越低

2、搜索结果处理

ES中，搜索的结果可以按照用户指定的方式去处理或展示。

2.1 排序

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

2.1.1 普通字段排序

keyword、数值、日期类型排序的语法基本一致。

语法：

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "FIELD": "desc"  // 排序字段、排序方式ASC、DESC
    }
  ]
}

备注：排序条件是一个数组，也就是可以写多个排序条件。按照声明的顺序，当第一个条件相等时，再按照第二个条件排序，以此类推

示例：

店数据按照用户评价（score)降序排序，评价相同的按照价格(price)升序排序

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "score": {
        "order":"desc"
      }
    },
    {
      "price":"asc"
    }
    ]
}
2.1.2 地理坐标排序

基本语法：

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance" : {
          "FIELD" : "纬度，经度", // 文档中geo_point类型的字段名、目标坐标点
          "order" : "asc", // 排序方式
          "unit" : "km" // 排序的距离单位
      }
    }
  ]
}

这个查询的含义是：

  • 指定一个坐标，作为目标点
  • 计算每一个文档中，指定字段（必须是geo_point类型）的坐标 到目标点的距离是多少
  • 根据距离排序

示例

需求描述：实现对酒店数据按照到你的位置坐标的距离升序排序

提示：获取你的位置的经纬度的方式：https://lbs.amap.com/demo/jsapi-v2/example/map/click-to-get-lnglat/

假设我的位置是：31.034661，121.612282，寻找我周围距离最近的酒店

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance": {
        "location": {
          "lat": 31.034661,
          "lon": 121.612282
        },
        "order": "asc",
        "unit": "km"
      }
    }
  ]
}

image-20230520140901555

2.2 分页

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

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

类似于mysql中的limit ?, ?

分页查询的常见实现方案以及优缺点：

  • from + size：

    • 优点：支持随机翻页
    • 缺点：深度分页问题，默认查询上限（from + size）是10000
    • 场景：百度、京东、谷歌、淘宝这样的随机翻页搜索

  • after search：

    • 优点：没有查询上限（单次查询的size不超过10000）
    • 缺点：只能向后逐页查询，不支持随机翻页
    • 场景：没有随机翻页需求的搜索，例如手机向下滚动翻页

  • scroll：

    • 优点：没有查询上限（单次查询的size不超过10000）
    • 缺点：会有额外内存消耗，并且搜索结果是非实时的
    • 场景：海量数据的获取和迁移。从ES7.1开始不推荐，建议用 after search方案。

  • 基本的分页

    语法

    GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
  ]
}

  • 深度分页问题

    ES中的深度分页问题指的是当需要获取大量数据时，通过使用 from 和 size 进行分页时，如果 from 的值很大，可能会导致查询变慢，甚至引起内存溢出等问题。

    原因如下：

    1. 随着 from 值的逐渐增大，查询时需要扫描更多的文档，耗费的时间也就越来越多，查询性能会变得很低，甚至超出阈值。

    2. 同时需要查询的文档数量也会随着 from 值的增大而增加，如果文档数量很大，超过了 Elasticsearch 可以处理的范围，就可能引起内存溢出等问题。

    为了解决深度分页问题，通常可以采取以下的方式：

    1. 尽量减少使用深度分页，如果必须分页，则尽量将分页操作放在查询条件语句的后面。

    2. 使用 scroll 机制进行查询，在第一次查询时将搜索上下文保存下来，然后可以使用 scroll_id 进行下一次查询，这样可以有效地解决大量数据的查询问题。

    3. 采用分布式查询，将原始数据拆分到多个索引或分片中，然后进行并行查询操作，可以大大提升查询性能。

    总之，深度分页的性能问题是 Elasticsearch 中的一大难点，在实际开发中需要注意避免，尽可能采用一些可优化的技术，提升 Elasticsearch 的查询性能。

    现在，我要查询990~1000的数据，查询逻辑要这么写：

    GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 990, // 分页起始位置，默认是从0开始
  "size": 10, // 分页大小，每页展示的文档数
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    }
  ]
}

    image-20230520143858685

    这里是查询990开始的数据，也就是 第990~第1000条 数据。不过，elasticsearch内部分页时，必须先查询 0~1000条，然后截取其中的990 ~ 1000的这10条。查询TOP1000，如果es是单点模式，这并无太大影响。

    image-20230520143211456

    但是elasticsearch将来大概率是集群，例如我集群有5个节点，我要查询TOP1000的数据，并不是每个节点查询200条就可以了。

    因为节点A的TOP200，在另一个节点可能排到10000名以外了。因此要想获取整个集群的TOP1000，必须先查询出每个节点的TOP1000，汇总结果后，重新排名，重新截取TOP1000。

    image-20230520143224237

    那如果我要查询9900~10000的数据呢？是不是要先查询TOP10000呢？那每个节点都要查询10000条？汇总到内存中？

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

    针对深度分页，ES提供了两种解决方案，详情见官方文档：

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

      缺点：只能往后查，不能往前查（翻页只能往后翻）

    • scroll：原理将排序后的文档id形成快照，保存在内存。官方已经不推荐使用。

      缺点：内存占用大，数据不一致问题（无法查询到实时数据）

    image-20230520144006650

2.3 高亮

  • 什么是高亮显示呢？

    我们在百度，京东搜索时，关键字会变成红色，比较醒目，这叫高亮显示：

    image-20230520144457443

    高亮显示的实现分为两步：

    • Step1：给文档中的所有关键字都添加一个标签，例如<em>标签
    • Step2：页面给<em>标签编写CSS样式

基本语法：

GET /hotel/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT" // 查询条件，高亮一定要使用全文检索查询
    }
  },
  "highlight": {
    "fields": { // 指定要高亮的字段
      "FIELD": {
        "pre_tags": "<em>",  // 用来标记高亮字段的前置标签
        "post_tags": "</em>" // 用来标记高亮字段的后置标签
      }
    }
  }
}

注意：

  • 高亮是对关键字高亮，因此搜索条件必须带有关键字，而不能是范围这样的查询。
  • 默认情况下，高亮的字段，必须与搜索指定的字段一致，否则无法高亮
  • 如果要对非搜索字段高亮，则需要添加一个属性required_field_match=false

示例

查询如家酒店，将所有搜索到的"如家"进行高亮显示

image-20230520145100854

GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}

image-20230520145236179

小结

查询的DSL是一个大的JSON对象，包含下列属性：

  • query：查询条件
  • from和size：分页条件
  • sort：排序条件
  • highlight：高亮条件

image-20230520145517964

3、RestClient查询文档

本小节将使用 JavaRestHighLevelClient 实现前面的 DSL 语句

3.1 快速入门

前置知识

RestClient提供两个重要的API，一个是request.source()，其中包含了查询、排序、分页、高亮等所有功能：

image-20230520200612378

另一个是QueryBuilders，其中包含match、term、function_score、bool等各种查询：

image-20230520200619784

RestClient查询到的结果是JSON格式，如果我们想要获取其中的数据，我们需要通过解析JSON：

image-20230520200858493

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文档数据

示例

  • Step1：搭建环境

    略……参考RestClient初体验

  • Step2：编写代码

        /**
     * 查询索引库中所有的文档
     */
    @Test
    public void testMatchAll() throws IOException {
        // 准备Request对象（参数为要查询的索引库）
        SearchRequest request = new SearchRequest("hotel");
        // 准备DSL
        request.source().query(QueryBuilders.matchAllQuery());
        // 发送请求
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);

        // 解析查询结果
        System.out.println(response);
        handleResponse(response);
    }

    /**
     * 解析查询到的文档数据
     * 将查询到的文档反序列化为HotelDoc对象
     */
    private void handleResponse(SearchResponse response) {
        // 解析响应
        SearchHits searchHits = response.getHits();
        // 获取总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("共搜索到" + total + "条数据");
        // 获取文档数组
        SearchHit[] hits = searchHits.getHits();
        // 遍历文档数组，将其反序列化为HotelDoc对象
        for (SearchHit hit : hits) {
            // 获取文档source
            String json = hit.getSourceAsString();
            // 反序列化
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            System.out.println("hotelDoc = " + hotelDoc);
        }
    }

  • Step3：测试

    image-20230520201202262

    备注：前面讲过，ES默认只展示10条记录，所以这里搜索到了201条，但是最终解析出来的只有10条

3.2 match查询

全文检索的match和multi_match查询与match_all的API基本一致。差别是查询条件，也就是query的部分

image-20230520201529774

示例一：match查询

    /**
     * match查询，查询索引库中all字段含有如家字段的文档
     * @throws IOException
     */
    @Test
    public void testMatch() throws IOException {
        // 准备Request
        SearchRequest request = new SearchRequest("hotel");
        // 准备DSL
        request.source().query(QueryBuilders.matchQuery("all", "如家"));
        // 发送请求
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        // 解析响应
        handleResponse(response);
    }

示例二：multiMathc查询

    /**
     * multiMatch查询
     */
    @Test
    public void testMultiMatch() throws IOException {
        // 准备Request
        SearchRequest request = new SearchRequest("hotel");

        // 准备DSL
        // 单字段查询（查询hotel索引库中all字段中含有”如家“词条的文档）
        request.source().query(QueryBuilders.multiMatchQuery("all", "如家"));
        // 多字段查询（查询hotel索引库中name和brand字段中含有”如家“词条的文档）
        request.source().query(QueryBuilders.multiMatchQuery("如家", "name", "brand"));

        // 发送请求
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        // 解析响应
        handleResponse(response);
    }

3.3 精确查询

精确查询主要是两者：

  • term：词条精确匹配
  • range：范围查询

与之前的查询相比，差异同样在查询条件，其它都一样

    /**
     * 精确查询
     */
    @Test
    public void testTermAndRange() throws IOException {
        // 准备Request
        SearchRequest request = new SearchRequest("hotel");

        // 准备DSL
        // term查询（查询hotel索引库中city为“上海”的文档）
        request.source().query(QueryBuilders.termQuery("city", "上海"));
        // range查询（查询hotel索引库中符合 100<=price<=150 条件的文档）
        request.source().query(QueryBuilders.rangeQuery("price").gte(100).lte(150));

        // 发送请求
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        // 解析响应
        handleResponse(response);
    }

3.4 布尔查询

布尔查询是用must、must_not、filter等方式组合其它查询

image-20230520202959911

可以看到，API与其它查询的差别同样是在查询条件的构建，QueryBuilders，结果解析等其他代码完全不变。

    /**
     * bool查询
     */
    @Test
    public void testBool() throws IOException {
        // 准备Request
        SearchRequest request = new SearchRequest("hotel");

        // 准备DSL
//        // 准备BooleanQuery
//        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//        // 添加term（城市必须是杭州）
//        boolQuery.must(QueryBuilders.termQuery("city", "杭州"));
//        // 添加range（价格<=250）
//        boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));
//        request.source().query(boolQuery);
        // 上面的代码可以使用链接编程
        request.source().query(QueryBuilders.boolQuery()
                .must(QueryBuilders.termQuery("city", "杭州"))
                .filter(QueryBuilders.rangeQuery("price").lte(250)));

        // 发送请求
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        // 解析响应
        handleResponse(response);
    }

3.5 排序和分页

搜索结果的排序和分页是与query同级的参数，因此同样是使用request.source()来设置。

对应的API如下：

image-20230520203640970

    /**
     * 分页和排序
     */
    @Test
    public void testPageAndSort() throws IOException {
        // 准备Request
        SearchRequest request = new SearchRequest("hotel");

        // 准备DSL
        // 页码，每页大小
        int page = 1, size = 5;
//        // query（查询所有文档）
//        request.source().query(QueryBuilders.matchAllQuery());
//        // 排序 sort（根据price升序排序，值越小越靠前）
//        request.source().sort("price", SortOrder.ASC);
//        // 分页 from、size
//        request.source().from((page - 1) * size).size(5);
        // 上面的代码可以使用链式编程来写（更加优雅）
        request.source().query(QueryBuilders.matchAllQuery())
                .sort("price", SortOrder.ASC)
                .from((page-1)*size).size(5);

        // 发送请求
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        // 解析响应
        handleResponse(response);
    }

3.6 高亮

高亮的代码与之前代码差异较大，有两点：

  • 查询的DSL：其中除了查询条件，还需要添加高亮条件，同样是与query同级。
  • 结果解析：结果除了要解析_source文档数据，还要解析高亮结果

高亮请求的构建API如下：

image-20230520204258644

注意：

  1. 高亮查询必须使用全文检索查询，并且要有搜索关键字
  2. 高亮的结果与查询的文档结果默认是分离的，并不在一起，因此解析高亮的代码需要额外处理

image-20230520205156525

    /**
     * 高亮
     */
    @Test
    public void testHighlight() throws IOException {
        // 准备Request
        SearchRequest request = new SearchRequest("hotel");

        // 准备DSL
//        // query（查询all字段中含有“如家”词条的文档）
//        request.source().query(QueryBuilders.matchQuery("all", "如家"));
//        // 高亮（高亮展示name字段，并且设置不需要进行字段匹配，默认是true，严格进行字段匹配）
//        request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
        // 上面代码进行链式编程
        request.source().query(QueryBuilders.matchQuery("all", "如家"))
                .highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));

        // 发送请求
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        // 解析响应
        handleHighlightResponse(response);
    }

    /**
     * 处理高良后返回的结果
     */
    private void handleHighlightResponse(SearchResponse response) {
        // 解析响应
        SearchHits searchHits = response.getHits();
        // 获取总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("共搜索到" + total + "条数据");
        // 文档数组
        SearchHit[] hits = searchHits.getHits();
        // 遍历
        for (SearchHit hit : hits) {
            // 获取文档source
            String json = hit.getSourceAsString();
            // 反序列化
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            // 获取高亮结果
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if (!CollectionUtils.isEmpty(highlightFields)) {
                // 防止空指针：!(highlightFields == null || highlightFields.size == 0)
                // 根据字段名获取高亮结果
                HighlightField highlightField = highlightFields.get("name");
                if (highlightField != null) {
                    // 获取高亮值
                    String name = highlightField.getFragments()[0].string();
                    // 覆盖非高亮结果
                    hotelDoc.setName(name);
                }
            }
            System.out.println("hotelDoc = " + hotelDoc);
        }
    }

image-20230520205809091

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/134285.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ArcGIS进阶：栅格计算器里的Con函数使用方法

ArcGIS进阶：栅格计算器里的Con函数使用方法

本实验操作为水土保持功能重要性评价&#xff1a; 所用到的数据包括&#xff1a;土地利用类型数据&#xff08;矢量&#xff09;、植被覆盖度数据&#xff08;矢量&#xff09;和地形坡度数据&#xff08;栅格&#xff09;。 由于实验数据较少&#xff0c;其思路也较为简单&a…
阅读更多...
讯飞录音笔误删除WAV录音文件恢复成功案例

讯飞录音笔误删除WAV录音文件恢复成功案例

讯飞录音笔删除恢复的难点 难点一&#xff0c;电脑无法识别为普通电脑盘符。这个是厂家系统设计上的问题&#xff0c;本博文不涉及。 难点二&#xff0c;一般恢复后播放有间隙性噪音问题。这个是数据碎片问题&#xff0c;是本博文的关注点。 大多数情况下&#xff0c;讯飞录…
阅读更多...
钉钉统计部门个人请假次数go

钉钉统计部门个人请假次数go

前言 最近小组需要统计部门各种请假次数&#xff0c;写了一个方法&#xff0c;第一次实战中用到递归函数&#xff0c;简单记录一下。 效果展示 这些数据不需要返回json&#xff0c;这里这样是为了方便测试。可以通过这些数据完成其它的操作。 功能实现 钉钉服务端调试工具A…
阅读更多...
【java进阶】集合的三种遍历(迭代器、增强for、Lambda)

【java进阶】集合的三种遍历(迭代器、增强for、Lambda)

目录 一、先谈集合&#xff1a; 二、单列集合的三种遍历方式 迭代器遍历 增强for遍历 Lambda表达式遍历 一、先谈集合&#xff1a; &#x1f525;那我们平常用for循环依赖下标遍历不行嘛&#xff0c;这就与集合的分类有关了。 集合的体系结构&#xff1a; collection是单…
阅读更多...
【论文笔记】Denoising Diffusion Probabilistic Models

【论文笔记】Denoising Diffusion Probabilistic Models

Pre Knowledge 1.条件概率的一般形式 P ( A , B ) P ( B ∣ A ) P ( A ) P(A,B)P(B|A)P(A) P(A,B)P(B∣A)P(A) P ( A , B , C ) P ( C ∣ B , A ) P ( B , A ) P ( C ∣ B , A ) P ( B ∣ A ) P ( A ) P(A,B,C)P(C|B,A)P(B,A)P(C|B,A)P(B|A)P(A) P(A,B,C)P(C∣B,A)P(B,A)P…
阅读更多...
[游戏中的图形学实时渲染技术] Part1 实时阴影技术

[游戏中的图形学实时渲染技术] Part1 实时阴影技术

原理篇&#xff1a; 常见的渲染方程如下&#xff1a; 在不考虑自发光项与考虑阴影对于着色结果的影响之后可以将方程变化为如下形式&#xff1a; 如果射线在到达光源前击中了其他物体时&#xff0c;就认为这条来自光源的光线对着色点没有贡献。 利用上述渲染方程进行正确的着…
阅读更多...
使用MybatisPlus时出现的java.lang.NullPointerException异常~

使用MybatisPlus时出现的java.lang.NullPointerException异常~

错误描述如下所示&#xff1a; 错误原因&#xff1a;Junit的导包错误 单元测试的包有如下所示两个 我们应该根据springboot的版本进行选择&#xff0c; 在Spring Boot 2.2.X以后使用import org.junit.jupiter.api.Test Junit5 在Spring Boot 2.2.x之前使用import org.junit.T…
阅读更多...
基于SSM的校园二手物品交易平台设计与实现

基于SSM的校园二手物品交易平台设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
高防IP是什么？有什么优势？

高防IP是什么？有什么优势？

一.高防IP的概念 高防IP是指高防机房所提供的IP段&#xff0c;一种付费增值服务&#xff0c;主要是针对网络中的DDoS攻击进行保护。用户可以通过配置高防IP&#xff0c;把域名解析到高防IP上&#xff0c;引流攻击流量&#xff0c;确保源站的稳定可靠。 二.高防IP的原理 高防I…
阅读更多...
k8s 裸金属集群部署metalLB软负载均衡 —— 筑梦之路

k8s 裸金属集群部署metalLB软负载均衡 —— 筑梦之路

metalLB 官方网站 Repo&#xff1a;https://github.com/metallb/metallb 官网&#xff1a;https://metallb.universe.tf/installation metalLB解决什么问题&#xff1f; MetalLB 是一个用于裸机 Kubernetes 集群的负载均衡器实现&#xff0c;使用标准路由协议。 k8s 并没有为裸…
阅读更多...
CSS特效006：绘制不断跳动的心形

CSS特效006：绘制不断跳动的心形

css实战中&#xff0c;怎么绘制不断跳动的心形呢&#xff1f; 绘图的时候主要用到了transform: rotate(-45deg); transform-origin: 0 100%; transform: rotate(45deg); transform-origin: 100% 100%; 动画使用keyframes 时间上为infinite。 效果图 源代码 /* * Author: 大剑…
阅读更多...
两数之和问题

两数之和问题

题目描述 给定一个整数数组 nums 和一个整数目标值 target&#xff0c;请你在该数组中找出和为目标值 target 的那 两个 整数&#xff0c;并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是&#xff0c;数组中同一个元素在答案里不能重复出现。 你可以按任意顺…
阅读更多...
[头歌]第1关：动态学生信息管理

[头歌]第1关：动态学生信息管理

题目&#xff1a; C 面向对象 _ STL 的应用 (educoder.net) 考点&#xff1a; 1.自定义排序 bool cmp 2.如何使用find和erase来找到学生类里面的指定姓名的人并将其从动态数组中删除。 3.find要找的是学生类里面的成员变量而非单纯的直接找值&#xff0c;应如何实现 &…
阅读更多...
dcat admin 各种问题

dcat admin 各种问题

样式问题 如何根据条件给表格数据栏添加背景色 use Illuminate\Support\Collection;protected function grid(){return Grid::make(new BookArticle(), function (Grid $grid) {... 其他代码// Collection的完整路径&#xff1a;Illuminate\Support\Collection;$grid->row…
阅读更多...
Python 使用tkinter复刻Windows记事本UI和菜单功能（二）

Python 使用tkinter复刻Windows记事本UI和菜单功能（二）

上一篇&#xff1a;Python tkinter实现复刻Windows记事本UI和菜单的文本编辑器&#xff08;一&#xff09;-CSDN博客 下一篇&#xff1a;敬请耐心等待&#xff0c;如发现BUG以及建议&#xff0c;请在评论区发表&#xff0c;谢谢&#xff01; 相对上一篇文章&#xff0c;本篇文…
阅读更多...
数字化仪的超声波应用

数字化仪的超声波应用

超声波是频率大于人类听觉范围上限的声学声压&#xff08;声学&#xff09;波。超声波设备的工作频率为 20 kHz 至几千 MHz。表 1 总结了一些更常见的超声波应用的特征。每个应用中使用的频率范围都反映了实际情况下的平衡。提高工作频率可以通过提高分辨率来检测较小的伪影&am…
阅读更多...
JAVA集合学习

JAVA集合学习

一、结构 List和Set继承了Collection接口&#xff0c;Collection继承了Iterable Object类是所有类的根类&#xff0c;包括集合类&#xff0c;集合类中的元素通常是对象&#xff0c;继承了Object类中的一些基本方法&#xff0c;例如toString()、equals()、hashCode()。 Collect…
阅读更多...
时间序列预测实战(九)PyTorch实现LSTM-ARIMA融合移动平均进行长期预测

时间序列预测实战(九)PyTorch实现LSTM-ARIMA融合移动平均进行长期预测

一、本文介绍 本文带来的是利用传统时间序列预测模型ARIMA(注意&#xff1a;ARIMA模型不属于机器学习)和利用PyTorch实现深度学习模型LSTM进行融合进行预测&#xff0c;主要思想是->先利用ARIMA先和移动平均结合处理数据的线性部分&#xff08;例如趋势和季节性&#xff09…
阅读更多...
【mysql】将逗号分割的字段内容转换为多行并group by

【mysql】将逗号分割的字段内容转换为多行并group by

先说需求&#xff1a; 公司想让我通过mysql导出一个报表&#xff0c;内容为公司每个人参加会议的次数&#xff0c;现在有一个会议表fusion_meeting&#xff0c;正常的逻辑是通过人员直接group by就可以得出结果&#xff0c;但是我们的参会人是通过逗号分割这种方式存在一个字段…
阅读更多...
【MySQL基本功系列】第二篇 InnoDB事务提交过程深度解析

【MySQL基本功系列】第二篇 InnoDB事务提交过程深度解析

通过上一篇博文&#xff0c;我们简要了解了MySQL的运行逻辑&#xff0c;从用户请求到最终将数据写入磁盘的整个过程。 当数据写入磁盘时&#xff0c;存储引擎扮演着关键的角色&#xff0c;它负责实际的数据存储和检索。 在MySQL中&#xff0c;有多个存储引擎可供选择&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023