Elasticsearch复习笔记

细心的莽夫2025-04-24 22:22

文章目录

ES 基础

为什么用 Elasticsearch

搜索功能基于数据库模糊查询实现

  • 查询效率低：数据库模糊查询随着表数据量的增多，查询性能的下降会非常明显

    • 而搜索引擎的性能则不会随着数据增多而下降太多。

  • 功能单一：匹配搜索条件苛刻必须包含搜索关键字。

    • 而搜索引擎用户输入出现个别错字，或者用拼音搜索、同义词搜索都能正确匹配到数据

搜索引擎排行

初识和安装

概述

Elasticsearch是由elastic公司开发的一套搜索引擎技术，它是elastic技术栈中的一部分。完整的技术栈包括：

  • Elasticsearch：用于数据存储、计算和搜索
  • Logstash/Beats：用于数据收集
  • Kibana：用于数据可视化
    ,

整套技术栈被称为ELK，经常用来做日志收集、系统监控和状态分析等等

整套技术栈的核心就是用来存储、搜索、计算的Elasticsearch

我们要安装的内容包含2部分：

  • elasticsearch：存储、搜索和运算
  • kibana：图形化展示
    .

首先Elasticsearch不用多说，是提供核心的数据存储、搜索、分析功能的。

.
然后是Kibana，Elasticsearch对外提供的是Restful风格的API，任何操作都可以通过发送http请求来完成。不过http请求的方式、路径、还有请求参数的格式都有严格的规范。这些规范我们肯定记不住，因此我们要借助于Kibana这个服务。

.
Kibana是elastic公司提供的用于操作Elasticsearch的可视化控制台。它的功能非常强大，包括：

  • 对Elasticsearch数据的搜索、展示
  • 对Elasticsearch数据的统计、聚合，并形成图形化报表、图形
  • 对Elasticsearch的集群状态监控
  • 它还提供了一个开发控制台（DevTools），在其中对Elasticsearch的Restful的API接口提供了语法提示

安装 elasticsearch

注意，这里我们采用的是elasticsearch的7.12.1版本，由于8以上版本的JavaAPI变化很大，在企业中应用并不广泛，企业中应用较多的还是8以下的版本。

shell 复制代码 
docker run -d \
  --name es \
  -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
  -e "discovery.type=single-node" \
  -v es-data:/usr/share/elasticsearch/data \
  -v es-plugins:/usr/share/elasticsearch/plugins \
  --privileged \
  --network heima \
  -p 9200:9200 \
  -p 9300:9300 \
  elasticsearch:7.12.1

安装完成访问9200端口，即可看到响应的Elasticsearch服务的基本信息

安装 Kibana

shell 复制代码 
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=heima \
-p 5601:5601  \
kibana:7.12.1

安装完成后，直接访问5601端口，即可看到控制台页面

然后选中Dev tools，进入开发工具页面

倒排索引

elasticsearch之所以有如此高性能的搜索表现，正是得益于底层的倒排索引技术。

倒排索引的概念是基于MySQL这样的正向索引而言的。

正向索引

id title price
1 小米手机 3499
2 华为手机 4999
3 华为小米充电器 49
4 小米手环 49
... ... ...
sql 复制代码 
select * from tb_goods where title like '%手机%';

id字段已经创建了索引，由于索引底层采用了B+树结构，因此我们根据id搜索的速度会非常快。但是其他字段例如title，只在叶子节点上存在。

因此要根据title搜索的时候只能遍历树中的每一个叶子节点，判断title数据是否符合要求。

步骤

  • 检查到搜索条件为like '%手机%'，需要找到title中包含手机的数据
  • 逐条遍历每行数据（每个叶子节点），比如第1次拿到id为1的数据
  • 判断数据中的title字段值是否符合条件
  • 如果符合则放入结果集，不符合则丢弃
  • 回到步骤1

综上，根据id精确匹配时，可以走索引，查询效率较高。而当搜索条件为模糊匹配时，由于索引无法生效，导致从索引查询退化为全表扫描，效率很差。

因此，正向索引适合于根据索引字段的精确搜索，不适合基于部分词条的模糊匹配。

而倒排索引恰好解决的就是根据部分词条模糊匹配的问题。

倒排索引

  • 文档（Document）：用来搜索的数据，其中的每一条数据就是一个文档。例如一个网页、一个商品信息
  • 词条（Term）：对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条

创建倒排索引是对正向索引的一种特殊处理和应用，流程如下：

  • 将每一个文档的数据利用分词算法根据语义拆分，得到一个个词条
  • 创建表，每行数据包括词条、词条所在文档id、位置等信息
  • 因为词条唯一性，可以给词条创建正向索引

正向索引

id（索引） title price
1 小米手机 3499
2 华为手机 4999
3 华为小米充电器 49
4 小米手环 49
... ... ...

倒排索引

词条（索引） 文档id
小米 1，3，4
手机 1，2
华为 2，3
充电器 3
手环 4

倒排索引流程

  • 用户输入条件"华为手机"进行搜索。

  • 对用户输入条件分词，得到词条：华为、手机。

  • 拿着词条在倒排索引中查找（由于词条有索引，查询效率很高），即可得到包含词条的文档id：1、2、3。

  • 拿着文档id到正向索引中查找具体文档即可（由于id也有索引，查询效率也很高）。

虽然要先查询倒排索引，再查询倒排索引，但是无论是词条、还是文档id都建立了索引，查询速度非常快！无需全表扫描。

正向和倒排

  • 正向索引是最传统的，根据id索引的方式。但根据词条查询时，必须先逐条获取每个文档，然后判断文档中是否包含所需要的词条，是根据文档找词条的过程。
    • 优点：
      • 可以给多个字段创建索引
      • 根据索引字段搜索、排序速度非常快
    • 缺点：
      • 根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。
  • 而倒排索引则相反，是先找到用户要搜索的词条，根据词条得到保护词条的文档的id，然后根据id获取文档。是根据词条找文档的过程。
  • 优点：
    • 根据词条搜索、模糊搜索时，速度非常快
  • 缺点：
    • 只能给词条创建索引，而不是字段
    • 无法根据字段做排序

基础概念

文档和字段

elasticsearch是面向文档（Document）存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中 。因此，原本数据库中的一行数据就是ES中的一个JSON文档；而数据库中每行数据都包含很多列，这些列就转换为JSON文档中的字段（Field）。

索引和映射

随着业务发展，需要在es中存储的文档也会越来越多，比如有商品的文档、用户的文档、订单文档等等。所有文档都散乱存放显然非常混乱，也不方便管理。因此，我们要将类型相同的文档集中在一起管理，称为索引（Index）。

  • 所有用户文档，就可以组织在一起，称为用户的索引；
  • 所有商品的文档，可以组织在一起，称为商品的索引；
  • 所有订单的文档，可以组织在一起，称为订单的索引；

因此，我们可以把索引当做是数据库中的表。

数据库的表会有约束信息，用来定义表的结构、字段的名称、类型等信息。因此，索引库中就有映射（mapping），是索引中文档的字段约束信息，类似表的结构约束。

MySQL 和 elasticsearch

MySQL Elasticsearch 说明
Table Index 索引(index)，就是文档的集合，类似数据库的表(table)
Row Document 文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式
Column Field 字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）
Schema Mapping Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）
SQL DSL DSL是 elasticsearch 提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD

总结

  • Mysql：擅长事务类型操作，可以确保数据的安全和一致性
  • Elasticsearch：擅长海量数据的搜索、分析、计算

因此在企业中，往往是两者结合使用：

  • 对安全性要求较高的写操作，使用mysql实现
  • 对查询性能要求较高的搜索需求，使用elasticsearch实现
  • 两者再基于某种方式，实现数据的同步，保证一致性

IK 分词器

Elasticsearch的关键就是倒排索引，而倒排索引依赖于对文档内容的分词，而分词则需要高效、精准的分词算法，IK分词器就是这样一个中文分词算法。

安装 IK 分词器

  • 方式一：在线安装
shell 复制代码 
docker exec -it es ./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip
shell 复制代码 
docker restart es
  • 方式二：离线安装

版本要和 es 对应

github.com

elasticsearch-analysis-ik-7.12.1

shell 复制代码 
#查看之前安装的es的 plugins 数据卷挂载目录
docker volume inspect es-plugins
shell 复制代码 
#然后 cd 进去 吧 IK 分词器拖进去
cd /var/lib/docker/volumes/es-plugins/_data

使用 IK 分词器

IK分词器包含两种模式：

  • ik_smart：智能语义切分
  • ik_max_word：最细粒度切分

Kibana的DevTools上来测试分词器，首先测试Elasticsearch官方提供的标准分词器

json 复制代码 
POST /_analyze
{
  "analyzer": "standard",
  "text": "黑马程序员学习java太棒了"
}
json 复制代码 
{
  "tokens" : [
    {
      "token" : "黑",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "马",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    },
    {
      "token" : "程",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "<IDEOGRAPHIC>",
      "position" : 2
    },
    {
      "token" : "序",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "<IDEOGRAPHIC>",
      "position" : 3
    },
    {
      "token" : "员",
      "start_offset" : 4,
      "end_offset" : 5,
      "type" : "<IDEOGRAPHIC>",
      "position" : 4
    },
    {
      "token" : "学",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "<IDEOGRAPHIC>",
      "position" : 5
    },
    {
      "token" : "习",
      "start_offset" : 6,
      "end_offset" : 7,
      "type" : "<IDEOGRAPHIC>",
      "position" : 6
    },
    {
      "token" : "java",
      "start_offset" : 7,
      "end_offset" : 11,
      "type" : "<ALPHANUM>",
      "position" : 7
    },
    {
      "token" : "太",
      "start_offset" : 11,
      "end_offset" : 12,
      "type" : "<IDEOGRAPHIC>",
      "position" : 8
    },
    {
      "token" : "棒",
      "start_offset" : 12,
      "end_offset" : 13,
      "type" : "<IDEOGRAPHIC>",
      "position" : 9
    },
    {
      "token" : "了",
      "start_offset" : 13,
      "end_offset" : 14,
      "type" : "<IDEOGRAPHIC>",
      "position" : 10
    }
  ]
}

拓展词典

随着互联网的发展，"造词运动"也越发的频繁。出现了很多新的词语，在原有的词汇列表中并不存在。IK分词器无法对这些词汇分词，

  • 打开IK分词器config目录

注意，如果采用在线安装的通过，默认是没有config目录的

  • 在IKAnalyzer.cfg.xml配置文件内容添加
xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
        <comment>IK Analyzer 扩展配置</comment>
        <!--用户可以在这里配置自己的扩展字典 添加扩展词典-->
    	<!--这里会在 config 目录寻找 ext.dic-->
        <entry key="ext_dict">ext.dic</entry> 
</properties>
  • 在IK分词器的config目录新建一个 ext.dic
java 复制代码 
传智播客
泰裤辣
  • 重启elasticsearch
shell 复制代码 
docker restart es

ES 索引库操作

Mapping 映射属性

  • Index 就是是否参与搜索，默认是 true 不想参与搜索手动写 false
  • analyzer 不必须。一般只有字符串用到

例如

ES 索引库的 CRUD

由于Elasticsearch采用的是Restful风格的API，因此其请求方式和路径相对都比较规范，而且请求参数也都采用JSON风格。

我们直接基于Kibana的DevTools来编写请求做测试，由于有语法提示，会非常方便。

创建索引库和映射

基本语法：

  • 请求方式：PUT
  • 请求路径：/索引库名，可以自定义
  • 请求参数：mapping映射

语法

elm 复制代码 
PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
  }
}

示例

elm 复制代码 
# PUT /heima
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "name":{
        "properties": {
          "firstName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

查询索引库

基本语法：

  • 请求方式：GET
  • 请求路径：/索引库名
  • 请求参数：无

格式

elm 复制代码 
GET /索引库名

示例

elm 复制代码 
GET /heima

修改索引库

倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库一旦创建，无法修改mapping。

虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。因此修改索引库能做的就是向索引库中添加新字段，或者更新索引库的基础属性。

语法

elm 复制代码 
PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}

示例

elm 复制代码 
PUT /heima/_mapping
{
  "properties": {
    "age":{
      "type": "integer"
    }
  }
}

删除索引库

语法：

  • 请求方式：DELETE
  • 请求路径：/索引库名
  • 请求参数：无

格式

elm 复制代码 
DELETE /索引库名

示例

elm 复制代码 
DELETE /heima

总结

  • 创建索引库：PUT /索引库名
  • 查询索引库：GET /索引库名
  • 删除索引库：DELETE /索引库名
  • 修改索引库，添加字段：PUT /索引库名/_mapping

可以看到，对索引库的操作基本遵循的Restful的风格，因此API接口非常统一，方便记忆。

ES 文档的 CRUD

新增文档

语法

elm 复制代码 
POST /索引库名/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
}

示例

elm 复制代码 
POST /heima/_doc/1
{
    "info": "黑马程序员Java讲师",
    "email": "[email protected]",
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

响应

查询文档

根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把文档id带上。

语法

elm 复制代码 
GET /{索引库名称}/_doc/{id}

示例

elm 复制代码 
GET /heima/_doc/1

结果

删除文档

删除使用DELETE请求，同样，需要根据id进行删除

语法

elm 复制代码 
DELETE /{索引库名}/_doc/id值

示例

ELm 复制代码 
DELETE /heima/_doc/1

结果

修改文档

全量修改

全量修改是覆盖原来的文档，其本质是两步操作：

  • 根据指定的id删除文档
  • 新增一个相同id的文档

**注意：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。

语法

elm 复制代码 
PUT /{索引库名}/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}

示例

elm 复制代码 
PUT /heima/_doc/1
{
    "info": "黑马程序员高级Java讲师",
    "email": "[email protected]",
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

结果

由于id为1的文档已经被删除，所以第一次执行时，得到的反馈是created

所以如果执行第2次时，得到的反馈则是updated

局部修改

局部修改是只修改指定id匹配的文档中的部分字段。

语法

elm 复制代码 
POST /{索引库名}/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}

示例

elm 复制代码 
POST /heima/_update/1
{
  "doc": {
    "email": "[email protected]"
  }
}

结果

批处理

语法

elm 复制代码 
POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } } 批量新增doc文档
{ "field1" : "value1" }

{ "delete" : { "_index" : "test", "_id" : "2" } } 批量删除 doc 文档

{ "create" : { "_index" : "test", "_id" : "3" } } 批量创造 doc 文档
{ "field1" : "value3" }

{ "update" : {"_id" : "1", "_index" : "test"} } 批量修改 doc 字段
{ "doc" : {"field2" : "value2"} }
  • 批量新增
elm 复制代码 
POST /_bulk
{"index": {"_index":"heima", "_id": "3"}}
{"info": "黑马程序员C++讲师", "email": "[email protected]", "name":{"firstName": "五", "lastName":"王"}}
{"index": {"_index":"heima", "_id": "4"}}
{"info": "黑马程序员前端讲师", "email": "[email protected]", "name":{"firstName": "三", "lastName":"张"}}
  • 批量删除
elm 复制代码 
POST /_bulk
{"delete":{"_index":"heima", "_id": "3"}}
{"delete":{"_index":"heima", "_id": "4"}}

总结

  • 创建文档：POST /{索引库名}/_doc/文档id { json文档 }
  • 查询文档：GET /{索引库名}/_doc/文档id
  • 删除文档：DELETE /{索引库名}/_doc/文档id
  • 修改文档：
    • 全量修改：PUT /{索引库名}/_doc/文档id { json文档 }
    • 局部修改：POST /{索引库名}/_update/文档id { "doc": {字段}}

RestClient 的ES 索引库操作

初始化 RestClient

在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。

  • 引入 RestHighLevelClient 依赖
xml 复制代码 
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>
  • 因为SpringBoot默认的ES版本是7.17.10，所以我们需要覆盖默认的ES版本
xml 复制代码 
  <properties>
      <elasticsearch.version>7.12.1</elasticsearch.version>
  </properties>
  • 初始化 RestHighLevelClient
java 复制代码 
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
        HttpHost.create("http://192.168.88.130:9200")
));
java 复制代码 
public class IndexTest {

    private RestHighLevelClient client;

    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.150.101:9200")
        ));
    }

    @Test
    void testConnect() {
        System.out.println(client);
    }

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }
}

基于业务场景分析 Mapping

搜索页面的效果如图所示

实现搜索功能需要的字段包括三大部分：

  • 搜索过滤字段
    • 分类
    • 品牌
    • 价格
  • 排序字段
    • 默认：按照更新时间降序排序
    • 销量
    • 价格
  • 展示字段
    • 商品id：用于点击后跳转
    • 图片地址
    • 是否是广告推广商品
    • 名称
    • 价格
    • 评价数量
    • 销量

结合数据库表结构，以上字段对应的mapping映射属性如下

索引库操作

创建索引库

  • 创建Request对象。
    • 因为是创建索引库的操作，因此Request是CreateIndexRequest。
  • 添加请求参数
    • 其实就是Json格式的Mapping映射参数。因为json字符串很长，这里是定义了静态字符串常量MAPPING_TEMPLATE，让代码看起来更加优雅。
  • 发送请求
    • client. indices()方法的返回值是IndicesClient类型，封装了所有与索引库操作有关的方法。例如创建索引、删除索引、判断索引是否存在等

示例

java 复制代码 
@Test
void testCreateIndex() throws IOException {
    // 1.创建Request对象
    CreateIndexRequest request = new CreateIndexRequest("items");
    // 2.准备请求参数
    request.source(MAPPING_TEMPLATE, XContentType.JSON);
    // 3.发送请求
    client.indices().create(request, RequestOptions.DEFAULT);
}

static final String MAPPING_TEMPLATE = "{\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"id\": {\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"name\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      },\n" +
            "      \"price\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"stock\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"image\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"category\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"brand\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"sold\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"commentCount\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"isAD\":{\n" +
            "        \"type\": \"boolean\"\n" +
            "      },\n" +
            "      \"updateTime\":{\n" +
            "        \"type\": \"date\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";

删除索引库

删除索引库的请求

ELM 复制代码 
DELETE /hotel

与创建索引库相比：

  • 请求方式从PUT变为DELTE
  • 请求路径不变
  • 无请求参数

所以代码的差异，注意体现在Request对象上。流程如下：

  • 创建Request对象。这次是DeleteIndexRequest对象
  • 准备参数。这里是无参，因此省略
  • 发送请求。改用delete方法
java 复制代码 
@Test
void testDeleteIndex() throws IOException {
    // 1.创建Request对象
    DeleteIndexRequest request = new DeleteIndexRequest("items");
    // 2.发送请求
    client.indices().delete(request, RequestOptions.DEFAULT);
}

判断索引库是否存在（查询）

判断索引库是否存在，本质就是查询，对应的请求语句是

elm 复制代码 
GET /hotel

因此与删除的Java代码流程是类似的，流程如下：

  • 创建Request对象。这次是GetIndexRequest对象
  • 准备参数。这里是无参，直接省略
  • 发送请求。改用exists方法
java 复制代码 
@Test
void testExistsIndex() throws IOException {
    // 1.创建Request对象
    GetIndexRequest request = new GetIndexRequest("items");
    // 2.发送请求
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    // 3.输出
    System.err.println(exists ? "索引库已经存在！" : "索引库不存在！");
}

总结

JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。

索引库操作的基本步骤：

  • 初始化RestHighLevelClient
  • 创建XxxIndexRequest。XXX 是Create、Get、Delete
  • 准备请求参数（ Create时需要，其它是无参，可以省略）
  • 发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete

文档操作

新增文档

语法

  • 创建Request对象，这里是IndexRequest，因为添加文档就是创建倒排索引的过程
  • 准备请求参数，本例中就是Json文档
  • 发送请求

变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。

elm 复制代码 
POST /{索引库名}/_doc/1
{
    "name": "Jack",
    "age": 21
}
举例

我们可以定义PO 然后利用 BeanUtils 赋值。转成 JSON 进行修改。 索引库结构与数据库结构还存在一些差异，因此我们要定义一个索引库结构对应的实体。

  • 根据id查询商品数据Item
  • 将Item封装为ItemDoc
  • 将ItemDoc序列化为JSON
  • 创建IndexRequest，指定索引库名和id
  • 准备请求参数，也就是JSON文档
  • 发送请求
java 复制代码 
package com.hmall.item.domain.po;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.time.LocalDateTime;

@Data
@ApiModel(description = "索引库实体")
public class ItemDoc{

    @ApiModelProperty("商品id")
    private String id;

    @ApiModelProperty("商品名称")
    private String name;

    @ApiModelProperty("价格（分）")
    private Integer price;

    @ApiModelProperty("商品图片")
    private String image;

    @ApiModelProperty("类目名称")
    private String category;

    @ApiModelProperty("品牌名称")
    private String brand;

    @ApiModelProperty("销量")
    private Integer sold;

    @ApiModelProperty("评论数")
    private Integer commentCount;

    @ApiModelProperty("是否是推广广告，true/false")
    private Boolean isAD;

    @ApiModelProperty("更新时间")
    private LocalDateTime updateTime;
}
java 复制代码 
@Test
void testAddDocument() throws IOException {
    // 1.根据id查询商品数据
    Item item = itemService.getById(100002644680L);
    // 2.转换为文档类型
    ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
    // 3.将ItemDTO转json
    String doc = JSONUtil.toJsonStr(itemDoc);

    // 1.准备Request对象
    IndexRequest request = new IndexRequest("items").id(itemDoc.getId());
    // 2.准备Json文档
    request.source(doc, XContentType.JSON);
    // 3.发送请求
    client.index(request, RequestOptions.DEFAULT);
}

查询文档

语法

  • 创建Request对象
  • 准备请求参数，这里是无参，直接省略
  • 发送请求
elm 复制代码 
GET /{索引库名}/_doc/{id}
举例
  • 准备Request对象。这次是查询，所以是GetRequest
  • 发送请求，得到结果。因为是查询，这里调用client.get()方法
  • 解析结果，就是对JSON做反序列化
    • 响应结果是一个JSON，其中文档放在一个_source属性中，因此解析就是拿到_source，反序列化为Java对象即可
java 复制代码 
@Test
void testGetDocumentById() throws IOException {
    // 1.准备Request对象
    GetRequest request = new GetRequest("items").id("100002644680");
    // 2.发送请求
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    // 3.获取响应结果中的source
    String json = response.getSourceAsString();
    
    //转为 Java对象
    ItemDoc itemDoc = JSONUtil.toBean(json, ItemDoc.class);
    System.out.println("itemDoc= " + ItemDoc);
}

删除文档

语法

  • 准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id
  • 准备参数，无参，直接省略
  • 发送请求。因为是删除，所以是client.delete()方法
elm 复制代码 
DELETE /hotel/_doc/{id}
java 复制代码 
@Test
void testDeleteDocument() throws IOException {
    // 1.准备Request，两个参数，第一个是索引库名，第二个是文档id
    DeleteRequest request = new DeleteRequest("item", "100002644680");
    // 2.发送请求
    client.delete(request, RequestOptions.DEFAULT);
}

修改文档

全量修改

本质是先根据id删除，再新增

在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：

  • 如果新增时，ID已经存在，则修改
  • 如果新增时，ID不存在，则新增
  • 简单来说就是新增文档再写一次就行
局部修改

修改文档中的指定字段值

语法

  • 准备Request对象。这次是修改，所以是UpdateRequest
  • 准备参数。也就是JSON文档，里面包含要修改的字段
  • 更新文档。这里调用client.update()方法
elm 复制代码 
POST /{索引库名}/_update/{id}
{
  "doc": {
    "字段名": "字段值",
    "字段名": "字段值"
  }
}

批处理

在之前的案例中，我们都是操作单个文档。而数据库中的商品数据实际会达到数十万条，某些项目中可能达到数百万条。

我们如果要将这些数据导入索引库，肯定不能逐条导入，而是采用批处理方案。常见的方案有：

  • 利用Logstash批量导入
    • 需要安装Logstash
    • 对数据的再加工能力较弱
    • 无需编码，但要学习编写Logstash导入配置
  • 利用JavaAPI批量导入
    • 需要编码，但基于JavaAPI，学习成本低
    • 更加灵活，可以任意对数据做再加工处理后写入索引库

语法介绍

  • 创建Request，但这次用的是BulkRequest
  • 准备请求参数
  • 发送请求，这次要用到client.bulk()方法

BulkRequest本身其实并没有请求参数，其本质就是将多个普通的CRUD请求组合在一起发送。例如：

  • 批量新增文档，就是给每个文档创建一个IndexRequest请求，然后封装到BulkRequest中，一起发出。
  • 批量删除，就是创建N个DeleteRequest请求，然后封装到BulkRequest，一起发出

因此BulkRequest中提供了add方法，用以添加其它CRUD的请求

可以看到，能添加的请求有：

  • IndexRequest，也就是新增
  • UpdateRequest，也就是修改
  • DeleteRequest，也就是删除

因此Bulk中添加了多个IndexRequest，就是批量新增功能了。示例：

java 复制代码 
@Test
void testBulk() throws IOException {
    // 1.创建Request
    BulkRequest request = new BulkRequest();
    // 2.准备请求参数
    request.add(new IndexRequest("items").id("1").source("json doc1", XContentType.JSON));
    request.add(new IndexRequest("items").id("2").source("json doc2", XContentType.JSON));
    // 3.发送请求
    client.bulk(request, RequestOptions.DEFAULT);
}
举例

当我们要导入商品数据时，由于商品数量达到数十万，因此不可能一次性全部导入。建议采用循环遍历方式，每次导入1000条左右的数据。

java 复制代码 
@Test
void testLoadItemDocs() throws IOException {
    // 分页查询商品数据
    int pageNo = 1;
    int size = 1000;
    while (true) {
        Page<Item> page = itemService.lambdaQuery().eq(Item::getStatus, 1).page(new Page<Item>(pageNo, size));
        // 非空校验
        List<Item> items = page.getRecords();
        if (CollUtils.isEmpty(items)) {
            return;
        }
        log.info("加载第{}页数据，共{}条", pageNo, items.size());
        
        
        // 1.创建Request
        BulkRequest request = new BulkRequest("items");
        // 2.准备参数，添加多个新增的Request
        for (Item item : items) {
            // 2.1.转换为文档类型ItemDTO
            ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
            // 2.2.创建新增文档的Request对象
            request.add(new IndexRequest()
                            .id(itemDoc.getId())
                            .source(JSONUtil.toJsonStr(itemDoc), XContentType.JSON));
        }
        // 3.发送请求
        client.bulk(request, RequestOptions.DEFAULT);

        // 翻页
        pageNo++;
    }
}

DSL 查询

DSL 查询概述

DSL 快速入门

语法结构

说明：

  • GET /{索引库名}/_search：其中的_search是固定路径，不能修改
elm 复制代码 
GET /{索引库名}/_search
{
  "query": {
    "查询类型": {
      // .. 查询条件
    }
  }
}

举例

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

java 复制代码 
GET /items/_search
{
  "query": {
    "match_all": {
      
    }
  }
}

DSL 叶子查询

概述

默认按照文档的关联度打分，决定显示顺序

全文检索查询

match

match 查询是一种常用的全文检索查询，它会将查询字符串进行分词处理，然后在指定的字段中查找匹配的分词。

elm 复制代码 
GET /{索引库名}/_search
{
  "query": {
    "match": {
      "字段名": "搜索条件"
    }
  }
}
multi_match

区别在于可以同时对多个字段搜索，而且多个字段都要满足

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

精确查询

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

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

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

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

term

match 查询会对查询字符串进行分词处理，然后查找匹配的分词；而 term 查询不会对查询字符串分词，它会直接在倒排索引里查找与查询词完全相同的项。

elm 复制代码 
GET /{索引库名}/_search
{
  "query": {
    "term": {
      "字段名": {
        "value": "搜索条件"
      }
    }
  }
}
range

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

  • gte：大于等于
  • gt：大于
  • lte：小于等于
  • lt：小于
elm 复制代码 
GET /{索引库名}/_search
{
  "query": {
    "range": {
      "字段名": {
        "gte": {最小值},
        "lte": {最大值}
      }
    }
  }
}

DSL 复合查询

概述

bool 查询

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

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

出于性能考虑，与搜索关键字无关的查询尽量采用must_not或filter逻辑运算，避免参与相关性算分。

elm 复制代码 
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}}}
      ]
    }
  }
}

举例

其中输入框的搜索条件肯定要参与相关性算分，可以采用match。但是价格范围过滤、品牌过滤、分类过滤等尽量采用filter，不要参与相关性算分。

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

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

DSL 排序和分页

概述

排序

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

语法

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

举例

我们按照商品价格排序

elm 复制代码 
GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
 	  "sold": {
	  	"order": "asc" //价格一样就按照卖的数量排序
      }
    }
  ]
}

分页

基础分页

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

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

类似于mysql中的limit ?, ?

语法

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

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。这种存储方式比较有利于数据扩展，但给分页带来了一些麻烦。

比如一个索引库中有100000条数据，分别存储到4个分片，每个分片25000条数据。现在每页查询10条，查询第99页。那么分页查询的条件如下：

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

从语句来分析，要查询第990~1000名的数据。

从实现思路来分析，肯定是将所有数据排序，找出前1000名，截取其中的990~1000的部分。但问题来了，我们如何才能找到所有数据中的前1000名呢？

要知道每一片的数据都不一样，第1片上的第900-1000，在另1个节点上并不一定依然是900-1000名。所以我们只能在每一个分片上都找出排名前1000的数据，然后汇总到一起，重新排序，才能找出整个索引库中真正的前1000名，此时截取990~1000的数据即可。

试想一下，假如我们现在要查询的是第999页数据呢，是不是要找第9990~10000的数据，那岂不是需要把每个分片中的前10000名数据都查询出来，汇总在一起，在内存中排序？如果查询的分页深度更深呢，需要一次检索的数据岂不是更多？

由此可知，当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。

因此elasticsearch会禁止from+ size 超过10000的请求。

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

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

总结

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

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

DSL 高亮

概述

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

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

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

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

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

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

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

实现高亮

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

  • 搜索必须有查询条件，而且是全文检索类型的查询条件，例如match
  • 参与高亮的字段必须是text类型的字段
  • 默认情况下参与高亮的字段要与搜索字段一致，除非添加：required_field_match=false
elm 复制代码 
GET /{索引库名}/_search
{
  "query": {
    "match": {
      "搜索字段": "搜索关键字"
    }
  },
  "highlight": {
    "fields": {
      "高亮字段名称": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

DSL 总结

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

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

RestClient 的 DSL

快速入门

发送请求

  • 第一步，创建SearchRequest对象，指定索引库名
  • 第二步，利用request.source()构建DSL，DSL中可以包含查询、分页、排序、高亮等
  • query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL
  • 第三步，利用client.search()发送请求，得到响应

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

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

解析响应结果

在发送请求以后，得到了响应结果SearchResponse，这个类的结构与我们在kibana中看到的响应结果JSON结构完全一致因此，我们解析SearchResponse的代码就是在解析这个JSON结果，对比如下

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

完整代码和总结

文档搜索的基本步骤是：

  1. 创建SearchRequest对象
  2. 准备request.source()，也就是DSL。
    1. QueryBuilders来构建查询条件
    2. 传入request.source() 的query()方法
  3. 发送请求，得到结果
  4. 解析结果（参考JSON结果，从外到内，逐层解析）
java 复制代码 
   @Test
    void testMatchAll() throws IOException {
        // 1.创建 request 对象
        SearchRequest request = new SearchRequest("items");
        // 2.配置 request 参数
        request.source()
                .query(QueryBuilders.matchAllQuery());

        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        // 4.解析结果
        SearchHits searchHits = response.getHits();
        // 4.1.总条数
        long total = searchHits.getTotalHits().value;
        System.out.println(total);

        // 4.2.命中数据
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            // 4.2.1 获取 source 结果
            String json = hit.getSourceAsString();
            // 4.2.2. 转为 ItemDoc
            ItemDoc doc = JSONUtil.toBean(json, ItemDoc.class);
            System.out.println(doc);
        }
    }

叶子查询

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

  • match 查询
java 复制代码 
@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 查询
java 复制代码 
@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 查询
java 复制代码 
@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 查询
java 复制代码 
@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);
}

复合查询

复合查询也是由QueryBuilders来构建，我们以bool查询为例，DSL和JavaAPI的对比如图：

java 复制代码 
@Test
void testBool() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    
    // 2.组织 DSL 查询参数
    request.source()
        	 .query(QueryBuilders.boolQuery()
             .must(QueryBuilders.matchQuery("name", "脱脂牛奶"))
             .filter(QueryBuilders.termQuery("brand", "德亚"))
             .filter(QueryBuilders.rangeQuery("prive").lt(30000))
     );

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

排序和分页

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

java 复制代码 
 @Test
    void testSortAndPage() throws IOException {

        // 0. 模拟前端传递的分页参数
        int pageNo = 1, pageSize = 5;

        // 1.创建 request 对象
        SearchRequest request = new SearchRequest("items");

        // 2.组织 DSL 查询参数
        // 2.1.query 条件
        request.source().query(QueryBuilders.matchAllQuery());
        // 2.2.分页
        request.source().from((pageNo-1) * pageSize).size(pageSize);
        // 2.3 排序
        request.source()
                .sort("sold", SortOrder.DESC)
                .sort("price", SortOrder.ASC);


        // 3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        parseResponse(response);
    }

高亮

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

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

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

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

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

完整代码

java 复制代码 
@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);
}

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

数据聚合

聚合概述

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

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

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

聚合常见的有三类：

  • 桶（ Bucket）聚合：用来对文档做分组
  • TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
  • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
  • 度量（ Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
  • Avg：求平均值
  • Max：求最大值
  • Min：求最小值
  • Stats：同时求max、min、avg、sum等
  • 管道（ pipeline）聚合：其它聚合的结果为基础做进一步运算

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

Bucket 聚合

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

基本语法

  • size：设置size为0，就是每页查0条，则结果中就不包含文档，只包含聚合
  • aggs：定义聚合
    • category_agg：聚合名称，自定义，但不能重复
      • terms：聚合的类型，按分类聚合，所以用term
        • field：参与聚合的字段名称
        • size：希望返回的聚合结果的最大数量
elm 复制代码 
GET /items/_search
{
  "size": 0, 
  "aggs": {
    "category_agg": {
      "terms": {
        "field": "category",
        "size": 20
      }
    }
  }
}

带条件的聚合

默认情况下，Bucket聚合是对索引库的所有文档做聚合，例如我们统计商品中所有的品牌，结果如下

可以看到统计出的品牌非常多。

但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。

带条件聚合

例如，我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？

我们需要从需求中分析出搜索查询的条件和聚合的目标：

  • 搜索查询条件：
    • 价格高于3000
    • 必须是手机
  • 聚合目标：统计的是品牌，肯定是对brand字段做term聚合
java 复制代码 
GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "category": "手机"
          }
        },
        {
          "range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0, 
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

结果

elm 复制代码 
{
  "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
        }
      ]
    }
  }
}

Metric 聚合

我们统计了价格高于3000的手机品牌，形成了一个个桶。现在我们需要对桶内的商品做运算，获取每个品牌价格的最小值、最大值、平均值。

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

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

  • stats_meric：聚合名称
    • stats：聚合类型，stats是metric聚合的一种
      • field：聚合字段，这里选择price，统计价格

由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值。

elm 复制代码 
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"
          }
        }
      }
    }
  }
}
  • 另外，我们还可以让聚合按照每个品牌的价格平均值排序

RestClient 聚合

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

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

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

java 复制代码 
@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);
    }
}
相关推荐
Warren989 分钟前
Java面试八股Spring篇(4500字)
java·开发语言·spring boot·后端·spring·面试
我爱写代码？14 分钟前
MapReduce架构-打包运行
大数据·spark
晚秋大魔王15 分钟前
OpenHarmony 开源鸿蒙南向开发——linux下使用make交叉编译第三方库——gnutls
java·开发语言
胡子发芽17 分钟前
面试题：请解释Java中的垃圾回收机制（Garbage Collection, GC），并讨论不同的垃圾回收算法及其优缺点
java·jvm
HappyAcmen20 分钟前
线代第二章矩阵第九、十节：初等变换、矩阵的标准形、阶梯形与行最简阶梯形、初等矩阵
笔记·学习·线性代数·矩阵
下雨天u25 分钟前
maven dependencyManagement标签作用
java·数据库·maven
背帆26 分钟前
go的interface接口底层实现
开发语言·后端·golang
lil44x_31 分钟前
嵌入式学习笔记DAY21（双向链表、Makefile)
笔记·学习
顾子茵1 小时前
c++从入门到精通（四）--动态内存，模板与泛型编程
java·开发语言·c++
码农飞哥1 小时前
互联网大厂Java求职面试实战：Spring Boot到微服务全景解析
java·spring boot·微服务·maven·hibernate·技术栈·面试技巧
热门推荐
01YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】02KGG转MP3工具|非KGM文件|解密音频03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05Coze扣子平台完整体验和实践（附国内和国际版对比）06DeepSeek各版本说明与优缺点分析07【解决】Android Gradle Sync 报错 Could not read workspace metadata08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09苍穹外卖面试总结10深度学习基础--ResNet网络的讲解，ResNet50的复现(pytorch)以及用复现的ResNet50做鸟类图像分类