Elasticsearch用法

安晴晚风2024-08-26 8:20

💥 该系列属于【SpringBoot基础】专栏，如您需查看其他SpringBoot相关文章，请您点击左边的连接

目录

一、初识elasticsearch

[1. 安装Elasticsearch和Kibana](#1. 安装Elasticsearch和Kibana)

[2. 倒排索引](#2. 倒排索引)

[3. IK分词器](#3. IK分词器)

[4. 基础概念](#4. 基础概念)

二、索引库操作

[1. Mapping映射属性](#1. Mapping映射属性)

[2. 索引库的CRUD](#2. 索引库的CRUD)

三、文档操作

[1. 新增文档POST](#1. 新增文档POST)

[2. 查询文档GET](#2. 查询文档GET)

[3. 删除文档DELETE](#3. 删除文档DELETE)

[4. 修改文档](#4. 修改文档)

[5. 批处理](#5. 批处理)

[6. 总结](#6. 总结)

四、RestAPI

[1. 初始化RestClient](#1. 初始化RestClient)

[2. 索引库操作](#2. 索引库操作)

[3. 文档操作](#3. 文档操作)

五、DSL查询

[1. 快速入门](#1. 快速入门)

[2. 叶子查询](#2. 叶子查询)

[3. 复合查询](#3. 复合查询)

[4. 排序](#4. 排序)

[5. 分页](#5. 分页)

（1）简单分页

（2）深度分页

[6. 高亮](#6. 高亮)

六、RestClient查询

[1. 快速入门](#1. 快速入门)

（1）发送请求

（2）解析响应结果

（3）完整代码

[2. 叶子查询](#2. 叶子查询)

[3. 复合查询](#3. 复合查询)

[4. 排序和分页](#4. 排序和分页)

[5. 高亮](#5. 高亮)

七、聚合

[1. DSL语法](#1. DSL语法)

[2. RestClient实现聚合](#2. RestClient实现聚合)

Elasticsearch结合Kibana、Logstash、Beats，是一整套技术栈，被叫做ELK。被广泛应用在日志数据分析、实时监控等领域。

一、初识elasticsearch

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

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

  • 对Elasticsearch数据的搜索、展示

  • 对Elasticsearch数据的统计、聚合，并形成图形化报表、图形

  • 对Elasticsearch的集群状态监控

  • 它还提供了一个开发控制台（DevTools），在其中对Elasticsearch的Restful的API接口提供了语法提示

1. 安装Elasticsearch和Kibana

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

bash 复制代码 
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

访问http://192.168.88.128:9200/，即可看到响应的Elasticsearch服务的基本信息：

下面的Docker命令，即可部署Kibana：

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

安装完成后，直接访问http://192.168.88.128:5601，即可看到控制台页面：

选择Explore on my own之后，进入主页面：

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

2. 倒排索引

（1）正向索引

其中的id字段已经创建了索引，由于索引底层采用了B+树结构，因此我们根据id搜索的速度会非常快。

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

例如title，只在叶子节点上存在。搜索的时候只能遍历树中的每一个叶子节点，判断title数据是否符合要求。

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

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

（2）倒排索引

倒排索引中有两个非常重要的概念：

  • 文档（Document）：用来搜索的数据，其中的每一条数据就是一个文档。例如一个网页、一个商品信息

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

流程描述：

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

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

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

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

（3）正向索引和倒排索引优缺点

正向索引：

  • 优点：

    • 可以给多个字段创建索引

    • 根据索引字段搜索、排序速度非常快

  • 缺点：

    • 根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。

倒排索引：

  • 优点：

    • 根据词条搜索、模糊搜索时，速度非常快

  • 缺点：

    • 只能给词条创建索引，而不是字段

    • 无法根据字段做排序

3. IK分词器

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

（1）安装IK分词器

在线安装

运行一个命令即可：

bash 复制代码 
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容器：

bash 复制代码 
docker restart es

（2）使用IK分词器

IK分词器包含两种模式：

  • ik_smart：智能语义切分

  • ik_max_word：最细粒度切分

测试Elasticsearch官方提供的标准分词器：

bash 复制代码 
POST /_analyze
{
  "analyzer": "standard",
  "text": "学习java太棒了"
}

语法说明：

  • POST：请求方式
  • /_analyze：请求路径，这里省略了http://192.168.150.101:9200，有kibana帮我们补充
  • analyzer：分词器类型，这里是默认的standard分词器
  • text：要分词的内容

再测试ik_smart分词器：

bash 复制代码 
POST /_analyze
{
  "analyzer": "ik_smart",
  "text": "黑马程序员学习java太棒了"
}

再测试ik_max_word分词器：

更细粒度

（3）拓展词典

随着互联网的发展，"造词运动"也越发的频繁。出现了很多新的词语，在原有的词汇列表中并不存在。比如："泰裤辣"，"鸡你太美" 等。

想正确分词，IK分词器的词库也需要不断的更新，IK分词器提供了扩展词汇的功能。

1）打开IK分词器config目录：

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

2）在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>
        <!--用户可以在这里配置自己的扩展字典 *** 添加扩展词典-->
        <entry key="ext_dict">ext.dic</entry>
</properties>

3）在IK分词器的config目录新建一个 ext.dic:

4）重启elasticsearch

bash 复制代码 
docker restart es

4. 基础概念

（1）文档和字段

elasticsearch是面向**文档（Document）**存储的。

文档数据会被序列化为json格式后存储在elasticsearch中。

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

（2）索引和映射

所有文档都散乱存放显然非常混乱，也不方便管理。要将类型相同的文档集中在一起管理，称为索引（Index） 。索引就是相同类型的文档的集合。

映射（mapping）：索引中文档的字段约束信息，类似表的结构约束。

（3）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

ES和Mysql两者各自有自己的擅长之处：

  • Mysql：擅长事务类型操作，可以确保数据的安全和一致性

  • Elasticsearch：擅长海量数据的搜索、分析、计算

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

  • 对安全性要求较高的写操作，使用mysql实现

  • 对查询性能要求较高的搜索需求，使用elasticsearch实现

二、索引库操作

1. Mapping映射属性

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

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

    • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）

    • 数值：long、integer、short、byte、double、float、

    • 布尔：boolean

    • 日期：date

    • 对象：object

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

  • analyzer：使用哪种分词器

  • properties：该字段的子字段

例如下面的json文档：

bash 复制代码 
{
    "age": 21,
    "weight": 52.1,
    "isMarried": false,
    "info": "黑马程序员Java讲师",
    "email": "zy@itcast.cn",
    "score": [99.1, 99.5, 98.9],
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

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

字段名 字段类型 类型说明 是否 参与搜索 是否 参与分词 分词器
age integer 整数 √ × ------
weight float 浮点数 √ × ------
isMarried boolean 布尔 √ × ------
info text 字符串，但需要分词 √ √ IK
email keyword 字符串，但是不分词 × × ------
score float 只看数组中元素类型 √ × ------
name firstName keyword 字符串，但是不分词 √ × ------
name lastName keyword 字符串，但是不分词 √ × ------

2. 索引库的CRUD

由于Elasticsearch采用的是Restful风格的API，因此其请求方式和路径相对都比较规范，而且请求参数也都采用JSON风格。我们直接基于Kibana的DevTools来编写请求做测试，由于有语法提示，会非常方便。

（1）创建索引库和映射PUT

基本语法：

  • 请求方式：PUT

  • 请求路径：/索引库名，可以自定义

  • 请求参数：mapping映射

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

（2）查询索引库GET

基本语法：

  • 请求方式：GET

  • 请求路径：/索引库名

  • 请求参数：无

bash 复制代码 
GET /索引库名 
#示例：GET /hmall

（3）修改索引库PUT

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

示例：

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

（4）删除索引库DELETE

语法：

  • 请求方式：DELETE

  • 请求路径：/索引库名

  • 请求参数：无

bash 复制代码 
DELETE /索引库名
#示例：DELETE /heima

（5）总结

索引库操作有哪些？

  • 创建索引库：PUT /索引库名

  • 查询索引库：GET /索引库名

  • 删除索引库：DELETE /索引库名

  • 修改索引库，添加字段：PUT /索引库名/_mapping

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

三、文档操作

1. 新增文档POST

语法：

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

示例：

bash 复制代码 
POST /heima/_doc/1
{
    "info": "黑马程序员Java讲师",
    "email": "zy@itcast.cn",
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

2. 查询文档GET

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

语法：

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

示例：

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

查看结果：

3. 删除文档DELETE

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

语法：

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

示例：

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

结果：

4. 修改文档

修改有两种方式：

  • 全量修改：直接覆盖原来的文档

  • 局部修改：修改文档中的部分字段

（1）全量修改PUT

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

  • 根据指定的id删除文档

  • 新增一个相同id的文档

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

语法：

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

示例：

bash 复制代码 
PUT /heima/_doc/1
{
    "info": "黑马程序员高级Java讲师",
    "email": "zy@itcast.cn",
    "name": {
        "firstName": "云",
        "lastName": "赵"
    }
}

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

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

（2）局部修改POST

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

语法：

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

示例：

bash 复制代码 
POST /heima/_update/1
{
  "doc": {
    "email": "ZhaoYun@itcast.cn"
  }
}

执行结果：

5. 批处理

批处理采用POST请求，基本语法如下：

bash 复制代码 
POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "create" : { "_index" : "test", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

  • index代表新增操作

    • _index：指定索引库名

    • _id指定要操作的文档id

    • { "field1" : "value1" }：则是要新增的文档内容

  • delete代表删除操作

    • _index：指定索引库名

    • _id指定要操作的文档id

  • update代表更新操作

    • _index：指定索引库名

    • _id指定要操作的文档id

    • { "doc" : {"field2" : "value2"} }：要更新的文档字段

示例，批量新增：

bash 复制代码 
POST /_bulk
{"index": {"_index":"heima", "_id": "3"}}
{"info": "黑马程序员C++讲师", "email": "ww@itcast.cn", "name":{"firstName": "五", "lastName":"王"}}
{"index": {"_index":"heima", "_id": "4"}}
{"info": "黑马程序员前端讲师", "email": "zhangsan@itcast.cn", "name":{"firstName": "三", "lastName":"张"}}

批量删除：

bash 复制代码 
POST /_bulk
{"delete":{"_index":"heima", "_id": "3"}}
{"delete":{"_index":"heima", "_id": "4"}}

6. 总结

四、RestAPI

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

1. 初始化RestClient

（1）引入依赖

在黑马上次的item-service模块（商品搜索模块）中引入es的RestHighLevelClient依赖：

XML 复制代码 
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

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

XML 复制代码 
  <properties>
      <maven.compiler.source>11</maven.compiler.source>
      <maven.compiler.target>11</maven.compiler.target>
      <elasticsearch.version>7.12.1</elasticsearch.version>
  </properties>

（2）初始化RestHighLevelClient

java 复制代码 
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
        HttpHost.create("http://192.168.88.128:9200")
));

（3）单元测试示例

这里为了单元测试方便，我们创建一个测试类IndexTest，然后将初始化的代码编写在@BeforeEach方法中：

java 复制代码 
public class IndexTest {

    private RestHighLevelClient client;

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

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

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

2. 索引库操作

（1）创建索引库

Mapping映射

  • 搜索过滤字段

    • 分类

    • 品牌

    • 价格

  • 排序字段

    • 默认：按照更新时间降序排序

    • 销量

    • 价格

  • 展示字段

    • 商品id：用于点击后跳转

    • 图片地址

    • 是否是广告推广商品

    • 名称

    • 价格

    • 评价数量

    • 销量

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

index默认是true，表示要参与搜索；id虽然是bigint类型，但是通常用keyword类型

bash 复制代码 
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",
        "index": false
      },
      "isAD":{
        "type": "boolean"
      },
      "updateTime":{
        "type": "date"
      }
    }
  }
}
创建索引

具体代码如下：

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

（2）删除索引库

在Request对象上。流程如下：

  • 1）创建Request对象。这次是DeleteIndexRequest对象

  • 2）准备参数。这里是无参，因此省略

  • 3）发送请求。改用delete方法

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

（3）查询索引库

  • 1）创建Request对象。这次是GetIndexRequest对象

  • 2）准备参数。这里是无参，直接省略

  • 3）发送请求。改用get方法

java 复制代码 
@Test
void testExistsIndex() throws IOException {
    // 1.创建Request对象
    GetIndexRequest request = new GetIndexRequest("items");
    // 2.发送请求
    client.indices().get(request, RequestOptions.DEFAULT);
}

3. 文档操作

（1）新增文档

语法：

思路：可以将实体类转换为json

准备实体类：

定义一个新的DTO：

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

（2）查询文档

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();
    
    ItemDoc itemDoc = JSONUtil.toBean(json, ItemDoc.class);
    System.out.println("itemDoc= " + ItemDoc);
}

（3）删除文档

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

（4）修改文档

全量修改

再次写入id一样的文档，就会删除旧文档，添加新文档。与新增的JavaAPl一致。

局部修改

仅仅修改items的两个属性值

java 复制代码 
@Test
void testUpdateDocument() throws IOException {
    // 1.准备Request
    UpdateRequest request = new UpdateRequest("items", "100002644680");
    // 2.准备请求参数
    request.doc(
            "price", 58800,
            "commentCount", 1
    );
    // 3.发送请求
    client.update(request, RequestOptions.DEFAULT);
}

（5）批处理

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

  • 创建Request，但这次用的是BulkRequest

  • 准备请求参数

  • 发送请求，这次要用到client.bulk()方法

批量新增功能示例：

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)); //查询第pageNo页
        // 非空校验
        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查询

1. 快速入门

查询的语法结构：

java 复制代码 
GET /{索引库名}/_search
{
  "query": {
    "查询类型": {
      // .. 查询条件
    }
  }
}

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

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

执行结果如下：

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

2. 叶子查询

叶子查询的类型也可以做进一步细分，常见的有：

（1）全文检索查询

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

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

示例：

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

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

（2）精确查询

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

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

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

示例：

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

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

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

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

  • gte：大于等于

  • gt：大于

  • lte：小于等于

  • lt：小于

示例：

再看下ids查询：

3. 复合查询

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

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

    • bool

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

    • function_score

    • dis_max

bool查询

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

  • must：必须匹配每个子查询，类似"与"

  • should：选择性匹配子查询，类似"或"

  • must_not：必须不匹配，不参与算分，类似"非"

  • filter：必须匹配，不参与算分

bool查询的语法如下：

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

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

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

4. 排序

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

我们按照商品价格排序：

bash 复制代码 
GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": "desc"
    }
  ]
}

5. 分页

（1）简单分页

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

  • from：从第几个文档开始

  • size：总共查询几个文档

类似于mysql中的limit ?, ?

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

（2）深度分页

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。

这种存储方式比较有利于数据扩展，但给分页带来了一些麻烦。比如一个索引库中有100000条数据，分别存储到4个分片，每个分片25000条数据。现在每页查询10条，查询第99页。

从实现思路来分析，肯定是将所有数据排序，找出前1000名，截取其中的990~1000的部分。我们只能在每一个分片上都找出排名前1000的数据，然后汇总到一起，重新排序，才能找出整个索引库中真正的前1000名，此时截取990~1000的数据即可。

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

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

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

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

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

  • scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。

6. 高亮

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

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

  • 高亮词条都被加了<em>标签

  • <em>标签都添加了红色样式

基本语法如下：

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

六、RestClient查询

1. 快速入门

（1）发送请求

（2）解析响应结果

（3）完整代码

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

2. 叶子查询

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

3. 复合查询

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

4. 排序和分页

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

5. 高亮

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）可以让我们极其方便的实现对数据的统计、分析、运算。

聚合常见的有三类：

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

    • TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组

    • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组

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

    • Avg：求平均值

    • Max：求最大值

    • Min：求最小值

    • Stats：同时求max、min、avg、sum等

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

1. DSL语法

（1）Bucket聚合

也就是group by category

bash 复制代码 
GET /items/_search
{
  "size": 0, 
  "aggs": {
    "category_agg": {
      "terms": {
        "field": "category",
        "size": 20
      }
    }
  }
}

来看下查询的结果：

（2）带条件聚合

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

bash 复制代码 
GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "category": "手机"
          }
        },
        {
          "range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0, 
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

（3）Metric聚合

现在我们需要对桶内的商品做运算，获取每个品牌价格的最小值、最大值、平均值。

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

bash 复制代码 
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聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。

2. RestClient实现聚合

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);
    }
}
相关推荐
it噩梦13 小时前
elasticsearch中使用fuzzy查询
elasticsearch
喝醉酒的小白15 小时前
Elasticsearch相关知识@1
大数据·elasticsearch·搜索引擎
小小工匠17 小时前
ElasticSearch - 深入解析 Elasticsearch Composite Aggregation 的分页与去重机制
elasticsearch·composite·after_key·桶聚合分页
风_流沙17 小时前
java 对ElasticSearch数据库操作封装工具类（对你是否适用嘞）
java·数据库·elasticsearch
TGB-Earnest18 小时前
【py脚本+logstash+es实现自动化检测工具】
大数据·elasticsearch·自动化
woshiabc1111 天前
windows安装Elasticsearch及增删改查操作
大数据·elasticsearch·搜索引擎
arnold661 天前
探索 ElasticSearch：性能优化之道
大数据·elasticsearch·性能优化
成长的小牛2331 天前
es使用knn向量检索中numCandidates和k应该如何配比更合适
大数据·elasticsearch·搜索引擎
Elastic 中国社区官方博客1 天前
Elasticsearch：什么是查询语言？
大数据·数据库·elasticsearch·搜索引擎·oracle
启明真纳1 天前
elasticache备份
运维·elasticsearch·云原生·kubernetes
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍