day08-Elasticsearch

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

day08-Elasticsearch

目标

  • 理解倒排索引原理 🍐 ❤️
  • 会使用 IK 分词器 ✏️
  • 理解索引库 Mapping 映射的属性含义 🍐 ❤️
  • 能创建索引库及映射 ✏️
  • 能实现文档的 CRUD ✏️

知识储备

  1. 使用过mysql的模糊查询关键字 like
  2. 能理解数据库中的索引的作用
  3. 使用百度搜索过词汇

1.初识 elasticsearch

elasticsearch

Elasticsearch 是一个基于 Apache Lucene 库实现的，Restful 风格的，分布式搜索和数据分析引擎。基于倒排索引技术，实现了高性能的全文检索和数据分析功能。官方网站如下：https://www.elastic.co/cn/open in new window

本章我们就一起来初步了解一下 Elasticsearch 的基本原理和一些基础概念。

1.1.倒排索引

倒排索引

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

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

1.正向索引

我们先来回顾一下正向索引。

例如有一张名为 tb_goods 的表：

idtitleprice
1小米手机3499
2华为手机4999
3华为小米充电器49
4小米手环49
.........

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

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

比如用户的 SQL 语句为：

select * from tb_goods where title like '%手机%';

那搜索的大概流程如图：

说明：

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

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

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

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

总结

那么两者方式的优缺点是什么呢？

  • 正向索引是最传统的，根据 id 索引的方式。但根据词条查询时，必须先逐条获取每个文档，然后判断文档中是否包含所需要的词条，是根据文档找词条的过程。
  • 而倒排索引则相反，是先找到用户要搜索的词条，根据词条得到保护词条的文档的 id，然后根据 id 获取文档。是根据词条找文档的过程。

正向索引：

  • 优点：
    • 可以给多个字段创建索引
    • 根据索引字段搜索、排序速度非常快
  • 缺点：
    • 根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。

倒排索引：

  • 优点：
    • 根据词条搜索、模糊搜索时，速度非常快
  • 缺点：
    • 只能给词条创建索引，而不是字段
    • 无法根据字段做排序

课堂作业

  1. 正向索引和倒排索引的区别？以及优缺点？🎤

1.2.基础概念

elasticsearch 中有很多独有的概念，与 mysql 中略有差别，但也有相似之处。 🎯

基础概念

1.文档和字段

elasticsearch 是面向 文档（Document） 存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为 json 格式后存储在 elasticsearch 中： image

因此，原本数据库中的一行数据就是 ES 中的一个 JSON 文档；而数据库中每行数据都包含很多列，这些列就转换为 JSON 文档中的字段（Field）。

mysql 与 elasticsearch

我们统一的把 mysql 与 elasticsearch 的概念做一下对比：

MySQLElasticsearch说明
TableIndex索引(index)，就是文档的集合，类似数据库的表(table)
RowDocument文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是 JSON 格式
ColumnField字段（Field），就是 JSON 文档中的字段，类似数据库中的列（Column）
SchemaMappingMapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）
SQLDSLDSL 是 elasticsearch 提供的 JSON 风格的请求语句，用来操作 elasticsearch，实现 CRUD
点击查看图解
点击查看图解

❓那是不是说，我们学习了 elasticsearch 就不再需要 mysql 了呢？ ❓

并不是如此，两者各自有自己的擅长之处：

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

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

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

总结

课堂作业

  1. elasticsearch 中有哪些独有的概念？ 分别什么含义？🎤
  2. es这么好用，是不是企业中可以弃用Mysql了？🎤 ❓

1.4.安装

安装

学习ES，要安装的内容包含 3 部分：

  • elasticsearch

Elasticsearch是提供核心的数据存储、搜索、分析功能的。

  • kibana

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

  • ik分词器

IK分词是一款国人作者林良益开发的相对简单的中文分词器，基于java语言开发的轻量级的中文分词工具包

代码操作

1.4.1.安装 elasticsearch

通过下面的 Docker 命令即可安装单机版本的 elasticsearch：

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 hmall \
  -p 9200:9200 \
  -p 9300:9300 \
  elasticsearch:7.12.1

注意：

  1. 这里我们采用的是 elasticsearch 的 7.12.1 版本，由于 8 以上版本的 JavaAPI 变化很大，在企业中应用并不广泛，企业中应用较多的还是 8 以下的版本。
  2. 内存最小设置512M ，默认是1gb，集群需要4G，最好是8G，如果是学生的云主机内存可能跑不起来 如果拉取镜像困难，可以直接导入课前资料提供的镜像 tar 包：
# 加载镜像
docker load -i 镜像名字

# 查看镜像
docker images

安装完成后，访问 9200 端口，如：http://192.168.138.135:9200/，即可看到响应的open in new window Elasticsearch 服务的基本信息：

image
image

总结

课堂作业

  1. 安装Elasticsearch，内存设置为64M，可以吗？
  2. Kibana有什么作用？🎤

1.5.IK 分词器

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

分词器

IK分词全名为IK Analyzer

IK分词是一款国人作者林良益开发的相对简单的中文分词器，IKAnalyzer 是一个开源的，基于java语言开发的轻量级的中文分词工具包。

  1. 从2006年12月推出1.0版开始，IKAnalyzer已经推出 了3个大版本。
  2. 最初，它是以开源项目 Lucene为应用主体的，结合词典分词和文法分析算法的中文分词组件。
  3. 新版本的IKAnalyzer3.0则发展为 面向Java的公用分词组件，独立于Lucene项目，同时提供了对Lucene的默认优化实现。

IK 这个名字是来源于暗黑破坏神2这款游戏，它是游戏中武器装备的名字。刚好林良益在做这个分词器的时候，也在玩这款游戏，而且刚好打到这个装备，很开心。想想 Java 也是开发人员在开发的过程中正好在喝咖啡，所以就叫了 Java 这个名字。所以那时候也在想，给这个分词器命名的话，我就把它命名为 Immortal King，中文名叫不朽之王open in new window，是那个装备的名称，这个名字就是这么来的。

操作

相关信息

  1. 安装ik
  2. 使用ik
  3. 拓展词典

1.安装 IK 分词器

方案一：在线安装

运行一个命令即可：

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

然后重启 es 容器：

docker restart es

方案二：离线安装 课堂建议

如果网速较差 ，也可以选择离线安装。

首先，查看之前安装的 Elasticsearch 容器的 plugins 数据卷目录：

docker volume inspect es-plugins

结果如下：

[
    {
        "CreatedAt": "2024-11-06T10:06:34+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/es-plugins/_data",
        "Name": "es-plugins",
        "Options": null,
        "Scope": "local"
    }
]

可以看到 elasticsearch 的插件挂载到了 /var/lib/docker/volumes/es-plugins/_data 这个目录。我们需要把 IK 分词器上传至这个目录。

找到课前资料提供的 ik 分词器插件，课前资料提供了 7.12.1 版本的 ik 分词器压缩文件，你需要对其解压改名为：ik文件夹：

然后上传至虚拟机的 /var/lib/docker/volumes/es-plugins/_data 这个目录：

最后，重启 es 容器：

docker restart es

总结

分词器的作用是什么？

  • 创建倒排索引时，对文档分词
  • 用户搜索时，对输入的内容分词

IK 分词器有几种模式？

  • ik_smart：智能切分，粗粒度，
  • ik_max_word：最细切分，细粒度

IK 分词器如何拓展词条？如何停用词条？

  • 利用 config 目录的 IkAnalyzer.cfg.xml 文件添加拓展词典和停用词典
  • 在词典中添加拓展词条或者停用词条

课堂作业

  1. 分词器的作用是什么？？🎤
  2. IK 分词器有几种模式？ 有什么区别？？🎤
  3. IK 分词器如何拓展词条？如何停用词条？？🎤

2.索引库操作

Index 就类似数据库表，Mapping 映射就类似表的结构。我们要向 es 中存储数据，必须先创建 Index 和 Mapping 🎯

2.1.Mapping 映射属性

Mapping映射属性

Mapping 是对索引库中文档的约束，常见的 Mapping 属性包括：

  • type：字段数据类型，常见的简单类型有：

    • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip 地址）
    • 数值：long、integer、short、byte、double、float、
    • 布尔：boolean
    • 日期：date
    • 对象：object

  • index：是否创建索引，默认为 true

  • analyzer：使用哪种分词器

  • properties：该字段的子字段

例如下面的 json 文档：

{
    "age": 21,
    "weight": 52.1,
    "isMarried": false,
    "info": "Java讲师",
    "email": "zy@itcast.cn",
    "score": [99.1, 99.5, 98.9],
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

对应的每个字段映射（Mapping）：

字段名字段类型类型说明是否参与搜索是否参与分词分词器
ageinteger整数- [x]- [ ]——
weightfloat浮点数- [x]- [ ]——
isMarriedboolean布尔- [x]- [ ]——
infotext字符串，但需要分词- [x]- [x]IK
emailkeyword字符串，但是不分词- [ ]- [ ]——
scorefloat只看数组中元素类型- [x]- [ ]——
namefirstNamekeyword字符串，但是不分词- [x]- [ ]——
lastNamekeyword字符串，但是不分词- [x]- [ ]——

总结

课堂作业

  1. Mapping是什么？🎤
  2. type中的keyword是什么意思？有什么应用场景🎤

2.2.索引库的 CRUD

索引库的CRUD

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

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

操作

步骤

  1. 创建索引库和映射
  2. 查询索引库
  3. 修改索引库
  4. 删除索引库

1.创建索引库和映射

基本语法：

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

格式：

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

ik_smart分词器

示例：

PUT /heima
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "name":{
        "properties": {
          "firstName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

heima:索引库名称

输入：GET /heima 查看

image
image

总结

索引库操作有哪些？

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

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

课堂作业

  1. 索引库操作有哪些？🎤
  2. 索引库一旦创建，无法修改 mapping,为什么？

3.文档操作

3.1文档的CURD

文档操作

有了索引库，接下来就可以向索引库中添加数据了。

Elasticsearch 中的数据其实就是 JSON 风格的文档。操作文档自然保护 增、删、改、查 等几种常见操作，我们分别来学习。🎯

操作

步骤

  1. 新增文档
  2. 查询文档
  3. 删除文档
  4. 修改文档
  5. 批处理

3.1.新增文档

语法：

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

示例：

POST /heima/_doc/1
{
    "info": "Java讲师",
    "email": "huyan@itcast.cn",
    "name": {
        "firstName": "焱",
        "lastName": "哥"
    }
}

响应：

image
image

总结

文档操作有哪些？

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

课堂作业

  1. 文档操作有哪些？🎤
  2. 全量修改和局部修改有区别吗？

4.RestAPI

4.0.初始化 RestClient

初始化RestClient

ES 官方提供了各种不同语言的客户端，用来操作 ES。这些客户端的本质就是组装 DSL 语句，通过 http 请求发送给 ES。

官方文档地址：https://www.elastic.co/guide/en/elasticsearch/client/index.htmlopen in new window

由于 ES 目前最新版本是 8.8，提供了全新版本的客户端，老版本的客户端已经被标记为过时。而我们采用的是 7.12 版本，因此只能使用老版本客户端：

然后选择 7.12 版本，HighLevelRestClient 版本：

代码操作

流程

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

image
image

1）在 item-service 模块中引入 es 的 RestHighLevelClient 依赖：

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

2）因为 SpringBoot 默认的 ES 版本是 7.17.10，所以我们需要覆盖默认的 ES 版本：

<properties>
      <maven.compiler.source>11</maven.compiler.source>
      <maven.compiler.target>11</maven.compiler.target>
      <elasticsearch.version>7.12.1</elasticsearch.version>
  </properties>

4.1.创建索引库

创建索引库

由于要实现对商品搜索，所以我们需要将商品添加到 Elasticsearch 中，不过需要根据搜索业务的需求来设定索引库结构，而不是一股脑的把 MySQL 数据写入 Elasticsearch.

代码操作

核心步骤

  1. 分析Mapping映射
  2. 编写代码

1.Mapping映射

搜索页面的效果如图所示：

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

  • 搜索过滤字段

    • 分类
    • 品牌
    • 价格

  • 排序字段

    • 默认：按照更新时间降序排序
    • 销量
    • 价格

  • 展示字段

    • 商品 id：用于点击后跳转
    • 图片地址
    • 是否是广告推广商品
    • 名称
    • 价格
    • 评价数量
    • 销量

对应的商品表结构如下，索引库无关字段已经划掉：

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

字段名字段类型类型说明是否参与搜索是否参与分词分词器
idlong长整数- [x]- [ ]——
nametext字符串，参与分词搜索- [x]- [x]IK
priceinteger以分为单位，所以是整数- [x]- [ ]——
stockinteger字符串，但需要分词- [x]- [ ]——
imagekeyword字符串，但是不分词- [ ]- [ ]——
categorykeyword字符串，但是不分词- [x]- [ ]——
brandkeyword字符串，但是不分词- [x]- [ ]——
soldinteger销量，整数- [x]- [ ]——
commentCountinteger销量，整数- [x]- [ ]——
isADboolean布尔类型- [x]- [ ]——
updateTimeDate更新时间- [x]- [ ]——

因此，最终我们的索引库文档结构应该是这样：

PUT /items
{
  "mappings": {
    "properties": {
      "id": {
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "price":{
        "type": "integer"
      },
      "stock":{
        "type": "integer"
      },
      "image":{
        "type": "keyword",
        "index": false
      },
      "category":{
        "type": "keyword"
      },
      "brand":{
        "type": "keyword"
      },
      "sold":{
        "type": "integer"
      },
      "commentCount":{
        "type": "integer"
      },
      "isAD":{
        "type": "boolean"
      },
      "updateTime":{
        "type": "date"
      }
    }
  }
}

4.2.删除和判断索引库是否存在

删除和判断索引库是否存在

删除索引库的请求非常简单：

DELETE /items

与创建索引库相比：

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

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

  • 1）创建 Request 对象。这次是 DeleteIndexRequest 对象
  • 2）准备参数。这里是无参，因此省略
  • 3）发送请求。改用 delete 方法

在 item-service 中的 IndexTest 测试类中，编写单元测试，实现删除索引：

@Test
void testDeleteIndex() throws IOException {
    // 1.创建Request对象
    DeleteIndexRequest request = new DeleteIndexRequest("items");
    // 2.发送请求
    client.indices().delete(request, RequestOptions.DEFAULT);
}
image
image

总结

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

索引库操作的基本步骤：

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

课堂作业

  1. 参考上述步骤，完成练习 ✏️

5.RestClient 操作文档

5.1.新增文档

新增文档

我们需要将数据库中的商品信息导入 elasticsearch 中，而不是造假数据了。🎯

代码操作

索引库准备好以后，就可以操作文档了。为了与索引库操作分离，我们再次创建一个测试类，做两件事情：

  • 初始化 RestHighLevelClient
  • 我们的商品数据在数据库，需要利用 IHotelService 去查询，所以注入这个接口
package com.hmall.item.es;


import java.io.IOException;

@SpringBootTest(properties = "spring.profiles.active=local")
public class DocumentTest {

    private RestHighLevelClient client;
    @Autowired
    private IItemService itemService;

    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.138.135:9200")
        ));
    }
    
    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }
}

5.2.查询文档

查询文档

我们以根据 id 查询文档为例

语法说明

查询的请求语句如下：

GET /{索引库名}/_doc/{id}

与之前的流程类似，代码大概分 2 步：

  • 创建 Request 对象
  • 准备请求参数，这里是无参，直接省略
  • 发送请求

不过查询的目的是得到结果，解析为 ItemDTO，还要再加一步对结果的解析。示例代码如下：

可以看到，响应结果是一个 JSON，其中文档放在一个 _source 属性中，因此解析就是拿到 _source，反序列化为 Java 对象即可。

其它代码与之前类似，流程如下：

  • 1）准备 Request 对象。这次是查询，所以是 GetRequest
  • 2）发送请求，得到结果。因为是查询，这里调用 client.get() 方法
  • 3）解析结果，就是对 JSON 做反序列化

代码操作

在 item-service 的 DocumentTest 测试类中，编写单元测试：

@Test
void testGetDocumentById() throws IOException {
    // 1.准备Request对象
    GetRequest request = new GetRequest("items").id("584394");
    // 2.发送请求
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    // 3.获取响应结果中的source
    String json = response.getSourceAsString();

    ItemDTOES itemDTO = JSONUtil.toBean(json, ItemDTOES.class);
    System.out.println("itemDTO = " + itemDTO);
}
image
image

5.3.删除文档和修改文档

删除文档和修改文档

删除文档

删除的请求语句如下：

DELETE /hotel/_doc/{id}

与查询相比，仅仅是请求方式从 DELETE 变成 GET，可以想象 Java 代码应该依然是 2 步走：

  • 1）准备 Request 对象，因为是删除，这次是 DeleteRequest 对象。要指定索引库名和 id
  • 2）准备参数，无参，直接省略
  • 3）发送请求。因为是删除，所以是 client.delete() 方法

在 item-service 的 DocumentTest 测试类中，编写单元测试：

@Test
void testDeleteDocument() throws IOException {
    // 1.准备Request，两个参数，第一个是索引库名，第二个是文档id
    DeleteRequest request = new DeleteRequest("items", "584394");
    // 2.发送请求
    client.delete(request, RequestOptions.DEFAULT);
}
image
image

总结

课堂作业

  1. 参考上述代码，练习练习🎤

5.5.批量导入文档

批量导入文档

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

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

  • 利用 Logstash 批量导入

    • 需要安装 Logstash
    • 对数据的再加工能力较弱
    • 无需编码，但要学习编写 Logstash 导入配置

  • 利用 JavaAPI 批量导入

    • 需要编码，但基于 JavaAPI，学习成本低
    • 更加灵活，可以任意对数据做再加工处理后写入索引库

接下来，我们就学习下如何利用 JavaAPI 实现批量文档导入。

代码操作

1.语法说明

批处理与前面讲的文档的 CRUD 步骤基本一致：

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

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

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

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

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

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

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

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

总结

文档操作的基本步骤：

  • 初始化 RestHighLevelClient

  • 创建 XxxRequest。

    • XXX 是 Index、Get、Update、Delete、Bulk

  • 准备参数（Index、Update、Bulk 时需要）

  • 发送请求。

    • 调用 RestHighLevelClient#.xxx() 方法，xxx 是 index、get、update、delete、bulk

  • 解析结果（Get 时需要）

课堂作业

  1. 参考上述步骤练习练习🎤

6.作业

6.1.服务拆分

搜索业务并发压力可能会比较高，目前与商品服务在一起，不方便后期优化。

需求：创建一个新的微服务，命名为 search-service，将搜索相关功能抽取到这个微服务中

6.2.商品查询接口

在 item-service 服务中提供一个根据 id 查询商品的功能，并编写对应的 FeignClient

焱哥的博客
Copyright © 2025 YangeIT