day09-Elasticsearch02

YangeIT大约 28 分钟高级服务框架es

day09-Elasticsearch02

目标

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

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

因此，我们先学习 DSL 的查询语法，然后再基于 DSL 来对照学习 JavaAPI，就会事半功倍。

知识储备

  1. 安装好了es
  2. 准备好了8w数据
  3. 使用过dsl语句

1.DSL 查询

查询分类

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

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

1.1.快速入门

快速入门

🎯掌握基本的查询语结构

我们依然在 Kibana 的 DevTools 中学习查询的 DSL 语法。

查询的语法结构：

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

说明：

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

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

GET /items/_search
{
  "query": {
    "match_all": {
      
    }
  }
}

由于 match_all 无条件，所以条件位置不写即可。

执行结果如下：

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

总结

课堂作业

  1. 查询语句中的_search能修改吗？🎤
  2. 默认返回的数据有少条？🎤

1.2.叶子查询

叶子查询

叶子查询的类型也可以做进一步细分，详情大家可以查看官方文档： https://www.elastic.co/guide/en/elasticsearch/reference/7.12/query-dsl.htmlopen in new window

image
image

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

  • 全文检索查询（Full Text Queries）：利用分词器对用户输入搜索条件先分词，得到词条，然后再利用倒排索引搜索词条。例如：

    • match：
    • multi_match

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

    • ids
    • term
    • range

  • 地理坐标查询： 用于搜索地理位置，搜索方式很多，例如：

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

  • ...略

操作

1.全文检索查询

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

https://www.elastic.co/guide/en/elasticsearch/reference/7.12/full-text-queries.htmlopen in new window

image
image
1️⃣ 单字段匹配

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

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

示例：查询name包含华为的数据

GET /items/_search
{
  "query": {
    "match": {
      "name": "华为"
    }
  }
}
image
image
2️⃣ 多个字段搜索

与 match 类似的还有 multi_match，区别在于可以同时对多个字段搜索，而且多个字段都要满足，语法示例：

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

示例：👇

GET /items/_search
{
  "query": {
    "multi_match": {
      "query": "华为",
      "fields": ["name", "brand"]
    }
  }
}
image
image

总结

课堂作业

  1. 范围查询使用什么查询？🎤
  2. 词条查询会进行分词吗？有哪些应用场景？🎤

1.3.复合查询

复合查询

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

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

    • bool

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

    • function_score
    • dis_max

其它复合查询及相关语法可以参考官方文档： https://www.elastic.co/guide/en/elasticsearch/reference/7.12/compound-queries.htmlopen in new window

image
image

代码操作

1.bool 查询

bool 查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。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}}}
      ]
    }
  }
}

总结

课堂作业

  1. 图中搜索关键字采用什么运算，要用相关性算分吗？，过滤条件参与算分吗？🎤 image

1.4.排序

排序

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

详细说明可以参考官方文档： https://www.elastic.co/guide/en/elasticsearch/reference/7.12/sort-search-results.htmlopen in new windowimage

语法说明：

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

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

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

1.5.分页

分页

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

代码操作

1.基础分页

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

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

类似于 mysql 中的 limit ?, ?

官方文档如下： https://www.elastic.co/guide/en/elasticsearch/reference/7.12/paginate-search-results.htmlopen in new window

image
image

语法如下：

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

1.6.高亮

高亮

什么是高亮显示呢？

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

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

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

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

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

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

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

代码操作

2.实现高亮

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

基本语法如下：

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

匹配字段和高亮字段建议一致

image
image

总结

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

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

课堂作业

  1. 参考上述步骤，练习一下🎤

2.RestClient 查询

背景

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

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

2.1.快速入门

快速入门

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

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

代码操作

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，其中包含了我们学习过的各种叶子查询、复合查询等：

总结

文档搜索的基本步骤是：

  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.反序列化并打印
        ItemDTO item = JSONUtil.toBean(source, ItemDTO.class);
        System.out.println(item);
    }
}

课堂作业

  1. 参考上述步骤，练习一下？🎤

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);
}

2.3.复合查询

复合查询

复合查询也是由 QueryBuilders 来构建，我们以 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);
}

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

完整代码如下：

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.反序列化
        ItemDTO item = JSONUtil.toBean(source, ItemDTO.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);
    }
}

3.数据聚合

数据聚合

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

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

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

官方文档： https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations.htmlopen in new windowimage

聚合常见的有三类：

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

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

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

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

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

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

代码操作

实现聚合操作

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

  1. Bucket 聚合
  2. 带条件聚合

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：参与聚合的字段名称
        • size：希望返回的聚合结果的最大数量

来看下查询的结果：

总结

aggs 代表聚合，与 query 同级，此时 query 的作用是？

  • 限定聚合的的文档范围

聚合必须的三要素：

  • 聚合名称
  • 聚合类型
  • 聚合字段

聚合可配置属性有：

  • size：指定聚合结果数量
  • order：指定聚合结果排序方式
  • field：指定聚合字段

课堂作业

  1. 聚合必须的三要素是哪些？🎤

3.2.RestClient 实现聚合

前言

可以看到在 DSL 中，aggs 聚合条件与 query 条件是同一级别，都属于查询 JSON 参数。因此依然是利用 request.source() 方法来设置。

不过聚合条件的要利用 AggregationBuilders 这个工具类来构造。DSL 与 JavaAPI 的语法对比如下：

聚合结果与搜索文档同一级别，因此需要单独获取和解析。具体解析语法如下：

代码操作

完整代码如下：

@Test
void testAgg() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.准备请求参数
    BoolQueryBuilder bool = QueryBuilders.boolQuery()
            .filter(QueryBuilders.termQuery("category", "手机"))
            .filter(QueryBuilders.rangeQuery("price").gte(300000));
    request.source().query(bool).size(0);
    // 3.聚合参数
    request.source().aggregation(
            AggregationBuilders.terms("brand_agg").field("brand").size(5)
    );
    // 4.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 5.解析聚合结果
    Aggregations aggregations = response.getAggregations();
    // 5.1.获取品牌聚合
    Terms brandTerms = aggregations.get("brand_agg");
    // 5.2.获取聚合中的桶
    List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
    // 5.3.遍历桶内数据
    for (Terms.Bucket bucket : buckets) {
        // 5.4.获取桶内key
        String brand = bucket.getKeyAsString();
        System.out.print("brand = " + brand);
        long count = bucket.getDocCount();
        System.out.println("; count = " + count);
    }
}

4.作业

Elasticsearch 的基本语法我们已经学完，足以应对大多数搜索业务需求了。接下来大家就可以基于学习的知识实现商品搜索的业务了。

在昨天的作业中要求大家拆分一个独立的微服务：search-service，在这个微服务中实现搜索数据的导入、商品数据库数据与 elasticsearch 索引库数据的同步。

接下来的搜索功能也要在 search-service 服务中实现。

4.1.实现搜索接口

在黑马商城的搜索页面，输入关键字，点击搜索时，会发现前端会发起查询商品的请求：

请求的接口信息如下：

  • 请求方式：GET

  • 请求路径：/search/list

  • 请求参数：

    • key：搜索关键字
    • pageNo：页码
    • pageSize：每页大小
    • sortBy：排序字段
    • isAsc：是否升序
    • category：分类
    • brand：品牌
    • minPrice：价格最小值
    • maxPrice：价格最大值

请求参数可以参考原本 item-service 中 com.hmall.item.controller.SearchController 类中的基于数据库查询的接口：

4.2.过滤条件聚合

搜索页面的过滤项目前是写死的：

但是大家思考一下，随着搜索条件的变化，过滤条件展示的过滤项是不是应该跟着变化。

例如搜索 电视，那么搜索结果中展示的肯定只有电视，而此时过滤条件中的分类就不能还出现手机、拉杆箱等内容。过滤条件的品牌中就不能出现与电视无关的品牌。而是应该展示搜索结果中存在的分类和品牌。

那么问题来，我们怎么知道搜索结果中存在哪些分类和品牌呢？

大家应该能想到，就是利用聚合，而且是带有限定条件的聚合。用户搜索的条件是什么，我们在对分类、品牌聚合时的条件也就是什么，这样就能统计出搜索结果中包含的分类、品牌了。

事实上，搜索时，前端已经发出了请求，尝试搜索栏中除价格以外的过滤项：

由于采用的是 POST 请求，所以参数在请求体中：

接口信息如下：

  • 请求方式：POST

  • 请求路径：/search/filters

  • 请求参数：

    • key：搜索关键字
    • pageNo：页码
    • pageSize：每页大小
    • sortBy：排序字段
    • isAsc：是否升序
    • category：分类
    • brand：品牌
    • minPrice：价格最小值
    • maxPrice：价格最大值

可见参数与搜索参数一致，不过这里大家可以忽略分页和排序参数。

返回值参考这个格式：

{
  "category": ["手机", "曲面电视", "拉杆箱", "休闲鞋", "休闲鞋", "硬盘", "真皮包"],
  "brand": ["希捷", "小米", "华为", "oppo", "新秀丽", "Apple","锤子"]
}
焱哥的博客
Copyright © 2025 YangeIT