Elasticsearch高级篇

高级篇

我们已经导入了大量数据到elasticsearch中，实现了商品数据的存储。不过查询商品数据时依然采用的是根据id查询，而非模糊搜索。

我们来研究下elasticsearch的数据搜索功能。Elasticsearch提供了基于JSON的DSL（Domain Specific Language）语句来定义查询条件，其JavaAPI就是在组织DSL条件。

1.DSL查询

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

复合查询（Compound query clauses）：以逻辑方式组合多个叶子查询或者更改叶子查询的行为方式。

叶子查询（Leaf query clauses）：一般是在特定的字段里查询特定值，属于简单查询，很少单独使用。

1.1.快速入门

我们依然在Kibana的DevTools中学习查询的DSL语法。首先来看查询的语法结构：

说明：

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

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

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

这个例子是一个最基础的无条件查询，使用 match_all，相当于 SQL 中的 SELECT * FROM table。

⚠️：默认返回前 10 条记录，可以通过 size 参数设置更多返回结果。

执行结果如下：

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

1.2.叶子查询

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

[Query DSL | Elasticsearch Guide 7.12] | Elastic

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

• 全文检索查询（Full Text Queries）

  ：利用分词器对用户输入搜索条件先分词，得到词条，然后再利用倒排索引搜索词条。例如：

  • match：
  • multi_match

• 精确查询（Term-level queries）

  ：不对用户输入搜索条件分词，根据字段内容精确值匹配。但只能查找keyword、数值、日期、boolean类型的字段。例如：

  • ids
  • term
  • range

• 地理坐标查询

  ：

  用于搜索地理位置，搜索方式很多，例如：

  • geo_bounding_box：按矩形搜索
  • geo_distance：按点和半径搜索

• …略

1.2.1.全文检索查询（Full Text Queries）

全文检索的种类也很多，详情可以参考官方文档：

[Full text queries | Elasticsearch Guide 7.12] | Elastic

原理：分词器先对搜索条件进行分词，然后匹配倒排索引。

类型	用途说明
match	匹配单个字段，支持分词
multi_match	匹配多个字段，任一字段命中即可

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

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

示例：

2.与match类似的还有multi_match，区别在于可以同时对多个字段搜索，而且多个字段其中之一满足即可，语法示例：

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

示例：

1.2.2.精确查询（Term-level Queries）

原理：不分词，直接匹配输入值，适合 keyword、数字、日期、boolean 等字段。

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

• id
• price
• 城市
• 地名
• 人名

等等，作为一个整体才有含义的字段。

详情可以查看官方文档：

[Term-level queries | Elasticsearch Guide 7.12] | Elastic

类型	用途说明
term	精确匹配一个值
terms	精确匹配多个值之一
ids	根据 id 查询
range	范围查询（适用于数字、日期）

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

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

示例：

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

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

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

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

• gte：大于等于
• gt：大于
• lte：小于等于
• lt：小于

示例：

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

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

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

• gte：大于等于
• gt：大于
• lte：小于等于
• lt：小于

示例：

总结对比

类型	分词？	精度	适合字段	示例用途
match	✅	模糊	text（分词字段）	文章搜索
term	❌	精确	keyword、数字等	状态码、用户名
range	❌	精确	数值、时间	价格、日期筛选
multi_match	✅	模糊	多个 text 字段	多字段搜索

1.3.复合查询

复合查询大致分为两类：

类别	说明	示例
组合逻辑条件	用逻辑运算组合多个叶子查询	bool
控制文档相关性得分	修改搜索结果文档的相关性得分 _score	function_score, dis_max

其它复合查询及相关语法可以参考官方文档：

[Compound queries | Elasticsearch Guide 7.12] | Elastic

1.3.1.算分函数查询

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

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

例如：页面搜索steam第一个确实steam游戏管家

基本语法：

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": {
    "function_score": {
      "query": {...},             // 原始查询（计算原始得分）
      "functions": [              // 算分函数数组
        {
          "filter": {...},        // 过滤条件，哪些文档应用函数
          "weight": 10            // 算分函数结果（此处为常量）
        }
      ],
      "boost_mode": "multiply"    // 原始得分 × 函数得分
    }
  }
}

function score的运行流程如下：

• 原始查询：用 BM25 计算 _score，称为原始得分 query score
• 过滤条件：只对满足条件的文档重新打分
• 算分函数：对符合条件的文档执行函数打分 function score
• 得分合并：根据 boost_mode 决定如何合并两个得分（如乘法、替换、求和）

因此，其中的关键点是：

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

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

实现逻辑：

步骤	内容
原始查询	搜索所有手机
过滤条件	brand = IPhone
算分函数	weight = 10
合并模式	multiply（原始得分 × 10）

对应代码如下：

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": "手机"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "brand": "Iphone"
            }
          },
          "weight": 10
        }
      ],
      "boost_mode": "multiply"
    }
  }
}

1.3.2.bool查询

bool查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。它的本质是：

用多种逻辑关系组合多个查询子句，控制哪些文档匹配，哪些文档得分。

bool查询支持的逻辑运算有：

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

bool查询的语法如下：

{
  "query": {
    "bool": {
      "must": [         // 必须匹配所有的子查询（类似 AND）
        {"match": {"name": "手机"}}
      ],
      "should": [       // 选择性匹配任意一个子查询（类似 OR）
        {"term": {"brand": "vivo"}},
        {"term": {"brand": "小米"}}
      ],
      "must_not": [     // 必须不匹配（类似 NOT），**不参与算分**
        {"range": {"price": {"gte": 2500}}}
      ],
      "filter": [       // 必须匹配，但不参与算分
        {"range": {"price": {"lte": 1000}}}
      ]
    }
  }
}

例如黑马商城的搜索页面：

类型	建议用法	是否参与算分
输入框	must	✅ 是
品牌选择	filter	❌ 否
分类选择	filter	❌ 否
价格区间	filter	❌ 否
排除高价	must_not	❌ 否

比如，我们要搜索手机，但品牌必须是华为，价格必须是900~1599，那么可以这样写：

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

• must 中匹配关键词 “手机”
• filter 中品牌和价格的约束，不参与算分，提升查询效率

关键词	匹配要求	是否参与算分	类比逻辑	典型用途
must	必须匹配	✅ 参与 _score	AND	主查询条件，例如关键词
should	匹配任意即可	✅ 参与 _score	OR	加分项、推荐项
must_not	不能匹配	❌ 不参与算分	NOT	排除项，例如黑名单、价格上限
filter	必须匹配	❌ 不参与算分	AND	过滤项，例如分类、价格区间

1.4.排序

elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。

不能对所有字段排序，比如以下类型就不能排序：

字段类型	是否支持排序	说明
text（分词）	❌ 不支持	被分析器切分，不支持排序
keyword	✅ 支持	原始不分词字符串
数值类型（int等）	✅ 支持	常用于排序（价格、权重等）
日期类型	✅ 支持	比如发布时间、更新时间等
地理坐标类型	✅ 支持	可用于地理距离排序（更复杂）

详细说明可以参考官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/sort-search-results.html

语法说明：

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

sort: 是一个数组，支持多字段排序（按优先级逐层排序）

order: 可以是 "asc"（升序） 或 "desc"（降序）

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

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

这个查询会把所有 items 索引中的商品按 price 字段从高到低排列。

1.5.分页

Elasticsearch 分页查询机制

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

1.5.1.基础分页

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

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

类似于mysql中的limit ?, ?

官方文档如下：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/paginate-search-results.html

语法如下：

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

1.5.2.深度分页

当你查询比如 第 1000 页，每页 10 条，那就是 from=9990, size=10，这就需要从每个分片中取出前 10000 条 数据，然后汇总后排序、再取 9990~10000 的部分，对内存和 CPU 开销巨大！

因此 Elasticsearch 默认限制：

from + size <= 10000，否则报错。

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

针对深度分页，elasticsearch提供了两种解决方案：

• search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。
• scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。

总结：

深度分页是 Elasticsearch 的性能陷阱，分页方式要结合实际业务场景合理选用。

大多数情况下，我们采用普通分页就可以了。查看百度、京东等网站，会发现其分页都有限制。例如百度最多支持77页，每页不足20条。京东最多100页，每页最多60条。

因此，一般我们采用限制分页深度的方式即可，无需实现深度分页。

1.6.高亮

1.6.1.高亮原理

什么是高亮显示呢？

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

• 高亮词条都被加了<em>标签
• <em>标签都添加了红色样式

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

因此词条的高亮标签肯定是由服务端提供数据的时候已经加上的。

因此实现高亮的思路就是：

• 用户输入搜索关键字
• 服务端通过 Elasticsearch 执行搜索（如 match 查询）
• ES 会在匹配的字段中把关键字用 <em> 包裹
• 前端拿到数据后展示，并通过样式控制 <em> 的表现

1.6.2.实现高亮

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

基本语法如下：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "搜索字段": "搜索关键字"
    }
  },
  "highlight": {
    "fields": {
      "高亮字段名称": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

注意：

条件	说明
查询类型	必须是 全文检索类型，如 match、multi_match
字段类型	高亮字段必须是 text 类型（可分词）
默认行为	只有搜索字段和高亮字段一致才会高亮
特殊设置	若想搜索字段和高亮字段不一致，需加 required_field_match: false

示例：

1.7总结

返回结果示意

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

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

2.RestClient查询

这部分讲的是如何通过 Java 的 RestHighLevelClient API 实现对 Elasticsearch 的文档查询，核心是模拟 Kibana 中的 DSL 查询，但用 Java 代码方式实现。

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

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

2.1.快速入门

之前说过，由于Elasticsearch对外暴露的接口都是Restful风格的接口，因此JavaAPI调用就是在发送Http请求。而我们核心要做的就是利用利用Java代码组织请求参数，解析响应结果。

这个参数的格式完全参考DSL查询语句的JSON结构，因此我们在学习的过程中，会不断的把JavaAPI与DSL语句对比。大家在学习记忆的过程中，也应该这样对比学习。

DSL 示例	Java API 构建
match_all 查询	QueryBuilders.matchAllQuery()
带分页的查询	request.source().from(x).size(y)
带排序的查询	request.source().sort("field", SortOrder)
高亮查询	HighlightBuilder 构造高亮规则

2.1.1.发送请求

首先以match_all查询为例，其DSL和JavaAPI的对比如图：

代码解读：

• 第一步，创建SearchRequest对象，指定索引库名

• 第二步，利用

  request.source()

  构建DSL，DSL中可以包含查询、分页、排序、高亮等

  • query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL

• 第三步，利用client.search()发送请求，得到响应

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

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

2.1.2.解析响应结果

在发送请求以后，得到了响应结果SearchResponse，这个类的结构与我们在kibana中看到的响应结果JSON结构完全一致：

{
    "took" : 0,
    "timed_out" : false,
    "hits" : {
        "total" : {
            "value" : 2,
            "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
            {
                "_index" : "heima",
                "_type" : "_doc",
                "_id" : "1",
                "_score" : 1.0,
                "_source" : {
                "info" : "Java讲师",
                "name" : "赵云"
                }
            }
        ]
    }
}

因此，我们解析SearchResponse的代码就是在解析这个JSON结果，对比如下：

// 4.解析响应结果
SearchHits hits = search.getHits();
hits.forEach(e -> {    
String sourceAsString = e.getSourceAsString();    ItemDoc item = JSON.parseObject(sourceAsString, ItemDoc.class);    
System.out.println("item = " + item);});

代码解读：

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

2.1.3.总结

文档搜索的基本步骤是：

1. 创建SearchRequest对象

2. 准备

   request.source()

   ，也就是DSL。

   1. QueryBuilders来构建查询条件
   2. 传入request.source() 的query()方法

3. 发送请求，得到结果

4. 解析结果（参考JSON结果，从外到内，逐层解析）

完整代码如下：

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

小结

步骤	说明
创建请求	new SearchRequest("索引名")
构造查询	request.source().query(...)
发送请求	client.search(request, ...)
解析结果	从 SearchHits 提取每个文档 _source

接下来讲解如何使用 Java API 实现 Elasticsearch 中的两种查询方式：叶子查询 和 复合查询，核心是通过 QueryBuilders 来构建查询条件，然后发送请求获取结果。

2.2.叶子查询

叶子查询是最基本的查询方式，它直接作用于某个字段的值，不涉及多层组合。

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

例如match查询：

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

还有range查询：

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

2.3.复合查询

复合查询是将多个查询组合到一起的方式，常用 bool、function_score 等。

复合查询也是由QueryBuilders来构建

算分的代码示例：

@Test
void testFunctionScore() throws IOException {
    // 1. 创建 Request 对象    
SearchRequest request = new SearchRequest("items"); 
   // 2. 构建 Function Score 查询    
// 2.1 创建Function Score查询   
 FunctionScoreQueryBuilder functionScoreQuery = QueryBuilders.functionScoreQuery(            QueryBuilders.matchQuery("name", "手机"), 
// 基础查询            
new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{                   
 // 添加过滤条件函数：品牌为华为时权重x10                   
 new FunctionScoreQueryBuilder.FilterFunctionBuilder(                            QueryBuilders.termQuery("brand", "华为"),  
// 过滤条件                           
 ScoreFunctionBuilders.weightFactorFunction(10) // 权重 )    }    ).boostMode(CombineFunction.MULTIPLY); 
// 分数计算模式    
// 2.2 将查询加入请求    
request.source().query(functionScoreQuery);   
 // 3. 发送请求   
 SearchResponse response = client.search(request, RequestOptions.DEFAULT);    
// 4. 解析响应    
handleResponse(response);}

以bool查询为例，DSL和JavaAPI的对比如图：

完整代码如下：

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

查询方式	QueryBuilders 示例	特点
matchQuery	matchQuery("name", "牛奶")	分词模糊匹配
multiMatch	multiMatchQuery("牛奶", "name", "category")	多字段模糊匹配
termQuery	termQuery("brand", "华为")	精确匹配，适用于 keyword
rangeQuery	rangeQuery("price").gte(100).lte(300)	数值/时间范围匹配
boolQuery	must + filter 等组合查询	多条件组合
functionScore	functionScoreQuery(...).boostMode(...)	加权评分

接下来讲解如何通过 Java API 实现 Elasticsearch 的 排序、分页和高亮查询

2.4.排序和分页

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

完整示例代码：

@Test
void testPageAndSort() throws IOException {
    int pageNo = 1, pageSize = 5;

    // 1.创建Request
    SearchRequest 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);
}

2.5.高亮

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

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

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

示例代码如下：

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

再来看结果解析，文档解析的部分不变，主要是高亮内容需要单独解析出来，其DSL和JavaAPI的对比如图：

代码解读：

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

完整代码如下：

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

功能	JavaAPI写法示例	说明
分页	from(x).size(y)	from 是起始偏移，size 是每页大小
排序	.sort("字段", SortOrder.ASC/DESC)	指定排序字段及顺序
高亮	.highlighter(SearchSourceBuilder.highlight()...)	高亮字段需独立解析并替换
高亮结果获取	getHighlightFields().get("字段").getFragments()	取出高亮片段并替换进原始字段

3.数据聚合

这部分内容讲解的是 Elasticsearch 中的数据聚合（Aggregations），它是 ES 非常强大的功能之一，允许我们像写 SQL 的 GROUP BY 一样，对数据做分组、统计、计算，非常适合做报表分析和数据洞察。

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

• 什么品牌的手机最受欢迎？
• 这些手机的平均价格、最高价格、最低价格？
• 这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

官方文档：

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations.html

聚合常见的有三类：

• 桶（

  Bucket

  ）

  聚合：用来对文档做分组

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

• 度量（

  Metric

  ）

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

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

• **管道（pipeline）**聚合：其它聚合的结果为基础做进一步运算

聚合的三大类型

聚合类型	英文名	作用	示例
桶聚合	Bucket	分组	按品牌分类、按日期分组
度量聚合	Metric	计算	最大价格、平均价格
管道聚合	Pipeline	基于其它聚合结果再计算	最大值差值、百分比变化

**注意：**参加聚合的字段必须是keyword、日期、数值、布尔类型

3.1.DSL实现聚合

与之前的搜索功能类似，我们依然先学习DSL的语法，再学习JavaAPI.

3.1.1.Bucket聚合

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

基本语法如下：

GET /items/_search
{
  "size": 0, 
  "aggs": {
    "category_agg": {
      "terms": {
        "field": "category",
        "size": 20
      }
    }
  }
}

语法说明：

• size：设置size为0，就是每页查0条，则结果中就不包含文档，只包含聚合

• aggs
  ：定义聚合
  
  - ```
    category_agg
  
    ：聚合名称，自定义，但不能重复
  
    - ```
      terms
      
  ：聚合的类型，按分类聚合，所以用
      term
      
        - `field`：按照哪个字段聚合（如 `category`）
        - `size`：希望返回的聚合结果的最大数量（最多返回多少个桶）
  
  来看下查询的结果：
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-386-1024x806.png)
  
  #### 3.1.2.带条件聚合
  
  例子：统计价格 > 3000 的手机品牌有哪些
  
  默认情况下，Bucket聚合是对索引库的所有文档做聚合，例如我们统计商品中所有的品牌，结果如下：
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-387-1024x641.png)
  
  可以看到统计出的品牌非常多。
  
  但真实场景下，我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？
  
  我们需要从需求中分析出搜索查询的条件和聚合的目标：
  
  - 搜索查询条件：
    - 价格高于3000
    - 必须是手机
  - 聚合目标：统计的是品牌，肯定是对brand字段做term聚合
  
  语法如下：
  

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

❗️注意：query 用于限定参与聚合的文档范围。

聚合结果如下：

{
“took” : 2,
“timed_out” : false,
“hits” : {
“total” : {
“value” : 13,
“relation” : “eq”
},
“max_score” : null,
“hits” : [ ]
},
“aggregations” : {
“brand_agg” : {
“doc_count_error_upper_bound” : 0,
“sum_other_doc_count” : 0,
“buckets” : [
{
“key” : “华为”,
“doc_count” : 7
},
{
“key” : “Apple”,
“doc_count” : 5
},
{
“key” : “小米”,
“doc_count” : 1
}
]
}
}
}

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

#### 3.1.3.Metric聚合

例子：每个品牌的手机价格最大值、最小值、平均值

这就要用到`Metric`聚合了，例如`stat`s聚合，就可以同时获取`min`、`max`、`avg`等结果。

语法如下：

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

- `brand_agg` 是外层的 **分组（桶聚合）**
- `stats_metric` 是对每个桶里的文档做 **统计（度量聚合）**

结果会返回每个品牌下的最小值、最大值、平均值、总和、计数。

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

- ```
  stats_meric

：聚合名称

• stats
  ：聚合类型，stats是
  metric
      聚合的一种
  
      - `field`：聚合字段，这里选择`price`，统计价格
  
  由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值。
  
  结果如下：
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-388-1024x943.png)
  
  另外，我们还可以让聚合按照每个品牌的价格平均值排序：
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-390.png)
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-389-1024x609.png)
  
  聚合使用注意点
  
  | 项目     | 说明                                    |
  | -------- | --------------------------------------- |
  | aggs     | 聚合顶层关键字，和 query 同级           |
  | 必须字段 | 聚合名称、聚合类型、聚合字段            |
  | 类型限制 | 只能用 keyword、数值、布尔、日期字段    |
  | 子聚合   | 可用于桶中进一步聚合，比如 `桶 -> 度量` |
  
  #### 3.1.4.总结
  
  aggs代表聚合，与query同级，此时query的作用是？
  
  - 限定聚合的的文档范围
  
  聚合必须的三要素：
  
  - 聚合名称
  - 聚合类型
  - 聚合字段
  
  聚合可配置属性有：
  
  - size：指定聚合结果数量（聚合结果有多个桶，size可以选择保留多少个桶）
  - order：指定聚合结果排序方式
  - field：指定聚合字段
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-391.png)
  
  ### 3.2.RestClient实现聚合
  
  可以看到在DSL中，`aggs`聚合条件与`query`条件是同一级别，都属于查询JSON参数。因此依然是利用`request.source()`方法来设置。
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-394.png)
  
  不过聚合条件的要利用`AggregationBuilders`这个工具类来构造。DSL与JavaAPI的语法对比如下：
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-392-1024x452.png)
  
  聚合结果与搜索文档同一级别，因此需要单独获取和解析。具体解析语法如下：
  
  ![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-393-1024x519.png)
  
  完整代码如下：
  

@Test
void testAgg() throws IOException {
// 1. 创建请求对象，指定索引
SearchRequest request = new SearchRequest(“items”);

// 2. 构建 bool 查询条件（只查询“手机”且价格大于等于 300000）
BoolQueryBuilder bool = QueryBuilders.boolQuery()
    .filter(QueryBuilders.termQuery("category", "手机"))
    .filter(QueryBuilders.rangeQuery("price").gte(300000));
request.source().query(bool).size(0); // 不需要文档内容，只要聚合结果

// 3. 添加聚合条件：按 brand 字段分组聚合，取前5个
request.source().aggregation(
    AggregationBuilders.terms("brand_agg").field("brand").size(5)
);

// 4. 执行查询
SearchResponse response = client.search(request, RequestOptions.DEFAULT);

// 5. 获取聚合结果
Aggregations aggregations = response.getAggregations();
Terms brandTerms = aggregations.get("brand_agg"); // 根据名称取聚合结果

// 6. 遍历每个桶，获取 brand 值和文档数
for (Terms.Bucket bucket : brandTerms.getBuckets()) {
    String brand = bucket.getKeyAsString(); // 分组 key
    long count = bucket.getDocCount();      // 每组文档数
    System.out.println("brand = " + brand + "; count = " + count);
}

}

![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-395.png)

![img](https://www.legendkiller.xyz/wp-content/uploads/2025/08/image-396.png)

## 高级篇完

## 完结