ElasticSearch学习笔记

🕗 发布于 2024-09-22 19:11 elasticsearch 学习笔记

笔记目录

一、Elasticsearch简述🎇
二、使用Docker安装Elasticsearch及相关工具配置🎋
三、Elasticsearch核心概念🎍
四、Ik分词器🎊
五、Rest风格说明🎪
六、构建复杂查询🎢
七、SpringBoot集成ES✨
- 7.1 操作索引API
- 7.2 操作文档API

一、Elasticsearch简述🎇

Elaticsearch，简称为es，es是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据；本身扩展性很好可以扩展到上百台服务器，处理PB级别的数据。es也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTfuIAPI来隐藏Lucene的复杂性，从而让全文搜索变得简单。

Elasticsearch的主要特点

全文搜索：它最擅长的是全文搜索。比如，你在一个网站上搜索关键词，Elasticsearch 就能非常快地给出包含这些关键词的内容。
分布式设计：数据可以分布存储在多台服务器上，这样即使有一台服务器故障，其他服务器也能继续工作，不会影响整体性能。
实时搜索：Elasticsearch 支持实时数据插入和搜索，数据存储后几乎立即就可以被搜索到。
RESTful API：它使用基于HTTP的RESTful API，这意味着你可以通过网络请求（比如发送 HTTP 请求）与 Elasticsearch 进行交互，查询数据或者存储数据。
强大的查询能力：除了简单的关键词搜索，它还能进行复杂的数据查询和分析，比如聚合分析、过滤等。

二、使用Docker安装Elasticsearch及相关工具配置🎋

本文基于docker搭建Elasticsearch

创建网络

 docker network create es-net

拉取elasticsearch镜像

docker pull elasticsearch:7.12.1

运行elasticsearch容器

docker run -d --name es -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" -e "discovery.type=single-node" -v E:\ElasticSerach\volume:/usr/share/elasticsearch  --privileged --network es-net -p 9200:9200 -p 9300:9300 elasticsearch:7.12.1

命令解释：

-e “ES_JAVA_OPTS=-Xms512m -Xmx512m”:
- -e 用于设置环境变量。在这里，ES_JAVA_OPTS 设置了 Elasticsearch 的 Java 虚拟机（JVM）选项。
- -Xms512m 和 -Xmx512m 分别设置了 JVM 的初始堆大小和最大堆大小为 512MB。
-e “discovery.type=single-node”:
- 这也是一个环境变量，设置 Elasticsearch 的发现类型为单节点模式。这意味着该实例将作为单个节点运行，而不是集群模式。
-v E:\ElasticSerach\volume:/usr/share/elasticsearch（主机目录可自行替换）:
- -v 用于挂载卷，将主机上的目录（E:\ElasticSerach\volume）挂载到容器内的 /usr/share/elasticsearch 目录。这使得数据可以在容器重启或删除后保留。
–privileged:
- 这个选项给予容器额外的权限，允许它执行一些需要特权的操作。通常在需要访问主机资源时使用。
–network es-net:
- 这部分指定容器连接到名为 es-net 的 Docker 网络，允许与其他容器进行通信。
- -p 9200:9200 -p 9300:9300:
- -p 用于将主机的端口映射到容器的端口。这里将主机的 9200 端口映射到容器的 9200 端口（用于 HTTP API），将主机的 9300 端口映射到容器的 9300 端口（用于集群内部通信）。
elasticsearch:7.12.1:
- 这是要运行的镜像名称和标签，指定使用 Elasticsearch 的 7.12.1 版本。

容器运行成功后，访问本地9200(http://localhost:9200/)端口，会出现以下json文本

{
  "name": "36aaa71ec269",
  "cluster_name": "docker-cluster",
  "cluster_uuid": "xMJHFh66RYWE3Lok_H5SXw",
  "version": {
    "number": "7.12.1",
    "build_flavor": "default",
    "build_type": "docker",
    "build_hash": "3186837139b9c6b6d23c3200870651f10d3343b7",
    "build_date": "2021-04-20T20:56:39.040728659Z",
    "build_snapshot": false,
    "lucene_version": "8.8.0",
    "minimum_wire_compatibility_version": "6.8.0",
    "minimum_index_compatibility_version": "6.0.0-beta1"
  },
  "tagline": "You Know, for Search"
}

拉取kibana镜像

Kibana 是一个开源的数据可视化和分析工具，通常与 Elasticsearch 一起使用，可以可视化Elasticsearch 中的数据

 docker pull kibana:7.12.1

运行kibana容器

#此处网络需要和上文创建的网络保持一致，这样Kibana和elasticsearch才能在同一网络下
docker run -d --name kibana -e ELASTICSEARCH_HOSTS=http://es:9200 --network=es-net -p 5601:5601 kibana:7.12.1

访问本地5601端口，可进入可视化界面，其自带dev tools

拉取elasticsearch-head镜像

docker pull mobz/elasticsearch-head:5

创建elasticsearch-head容器

docker create --name elasticsearch-head --network es-net -p 9100:9100 mobz/elasticsearch-head:5

修改elasticsearch的配置

注意：是修改elasticsearch容器的配置，此处是因为elasticsearch和elasticsearch-head存在跨域问题。

进入elasticsearch容器

记得修改为自己的容器号

docker exec -it 36aaa71ec269 /bin/bash

vi config/elasticsearch.yml
#添加以下配置
http.cors.enabled: true
http.cors.allow-origin: "*"

访问本地9200端口

三、Elasticsearch核心概念🎍

Elasticsearch是面向文档

维度	Elasticsearch	关系型数据库（MySQL、PostgreSQL）
基本单位	索引（Index）	数据库（Database）
数据结构	文档（Document）	表（Table）
记录单位	文档（Document）	行（Row）
属性单位	字段（Field）	列（Column）
数据存储方式	JSON 格式（NoSQL，非结构化）	关系型表结构（结构化数据）
查询语言	查询 DSL（Domain-Specific Language）	SQL（Structured Query Language）
数据关系	不支持直接的表间关系（如外键）	支持（如外键、联结操作）
扩展性	水平扩展（分片，适用于海量数据）	垂直扩展（增加硬件资源）
适用场景	全文搜索、日志分析、实时数据查询	事务处理、数据分析、多表联结查询
索引	每个字段都会自动建立倒排索引	可自定义索引，通常单列、多列索引
事务支持	不支持 ACID 事务（仅部分操作有原子性）	支持 ACID 事务
数据一致性	最终一致性	强一致性
灵活性	无需预定义数据模式，可动态添加字段	必须预定义数据表的结构
聚合操作	支持复杂的聚合和统计操作	支持 SQL 聚合查询（如 GROUP BY）
数据更新	部分更新时，整个文档需要重新索引	可直接更新行中的某个字段
全文搜索	内置强大的全文搜索功能	需要额外配置，通常性能较低
复制与分片	支持内置的分片和副本机制	需要手动配置主从复制
高可用性	自动分片和副本，天然支持高可用	通过主从复制和集群架构实现

物理设计：
elasticsearch在后台把每个索引划分成多个分片，每分分片可以在集群中的不同服务器间迁移。

一台实例就是一个集群

逻辑涉及：

一个索引类型中，包含多个文档，比如说文档1，文档2。当我们索引一篇文档时，可以通过这样的一各顺序找到它：索引—>类型—>文档ID，通过这个组合我们就能索引到某个具体的文档。注意：ID不必是整数，实际上它是个字符串。

文档

文档是 Elasticsearch 中存储数据的基本单位，相当于关系型数据库中的一行记录。它以 JSON 格式表示，包含一组相关的字段，用来描述某个实体，如一个用户的信息。文档结构非常灵活，可以包含简单字段（如文本、数字）或复杂的嵌套对象和数组，不需要预先固定格式。每个文档存储在一个索引中，并拥有唯一的 ID。为了高效查询，Elasticsearch 使用映射来定义文档中字段的属性。

类型（7版本已废弃）

在早期版本的 Elasticsearch（6.x 及之前），类型（Type） 是一个用于区分同一索引中不同数据类别的概念。它类似于关系型数据库中的表，可以在一个索引中存储多种不同结构的文档。例如，一个索引可以包含两种类型的文档：user 和 order，分别用来存储用户信息和订单信息。

每个文档都会被分配一个类型，使得同一索引中可以存储多种不同结构的数据。然而，所有类型共享同一个索引的存储空间，这带来了以下问题：

字段冲突：如果不同类型中的字段名称相同但数据类型不同（例如，name字段在 User 类型中是字符串，而在 Order 类型中是数字），会导致存储和查询的冲突。
复杂性：底层存储中，一个索引只能有一个倒排索引和数据结构。类型之间的混合会使数据管理复杂化。

索引

类比为一个数据库

索引（Index） 在 Elasticsearch 中是一个用于组织和存储数据的逻辑结构。它包含一组具有相似特征的文档，并为这些文档创建一个倒排索引，从而支持快速、高效的搜索和分析。索引就像一本书的目录，帮助 Elasticsearch 快速找到相关的数据。每个索引都有一个唯一的名称，用于在存储和查询时进行标识。

索引是映射类型的容器，elasticsearch中的索引是一个非常大的文档集合。索引存储了映射类型的字段和其他设置。然后它们被存储到了各个分片上了。

物理设计：节点和分片是如何工作

一个集群至少有一个节点，而一个节点就是一个elasricsearch进程，节点可以有多个索引默认的，如果你创建索引，那么索引将会有个5个分片（primaryshard，又称主分片）构成的，每一个主分片会有一个副本（replica shard，又称复制分片）

上图是一个有3个节点的集群，可以看到主分片和对应的复制分片都不会在同一个节点内，这样有利于某个节点挂掉了，数据也不至于丢失。实际上，一个分片是一个Lucene索，一个包含倒排索引的文件目录，倒排索引的结构使得elasticsearch在不扫描全部文档的情况下，就能告诉你哪些文档包含特定的关键字。

倒排索引

elasticsearch使用的是一种称为倒排索引的结构，采用Lucene倒排索作为底层，这种结构适用于快速的全文搜索，一个索引由文档中所有不重复的列表构成，对于每一个词，都有一个包含它的文档列表。例如，现在有两个文档，每个文档包含如下内容。

Study every day，good good up to forever #文档1包含的内容
To forever，study every day，good good up #文档2包含的内容

为了创建倒排索引，我们首先要将每个文档拆分成独立的词（或称为词条或者tokens），然后创建一个包含所有不重复的词条的排序列表，然后列出每个词条出现在哪个文档：

term	doc_1	doc_2
Study	√	×
To	×	×
every	√	√
forever	√	√
day	√	√
study	×	√
good	√	√
every	√	×
to	√	√
up	×	√

四、Ik分词器🎊

什么是ik分词器

分词：即把一段中文或者别的划分成一个个的关键字，我们在搜索时候会把自己的信息进行分词，会把数据库中或者索引库中的数据进行分词，然后进行一个匹配操作，默认的中文分词是将每个字看成一个词，比如“你好世界”会被分为"你"、“好”、“世”、"界”，这显然是不符合要求的，所以我们需要安装中文分词器ik来解决这个问题。

Ik提供了两个分词算法：ik_smart和ik_max_word，其中ik_smart为最少切分，ik_max_word为最细粒度划分。

ik分词器-Github下载地址

将下载的ik分词器下载后并解压至es挂载的es-plugins目录下，并重启es容器

在kibana中使用

ik_smart为最少切分

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "世界人民大团结万岁"
}

#分词结果
{
  "tokens" : [
    {
      "token" : "世界人民",
      "start_offset" : 0,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "大团结",
      "start_offset" : 4,
      "end_offset" : 7,
      "type" : "CN_WORD",
      "position" : 1
    },
    {
      "token" : "万岁",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 2
    }
  ]
}

ik_max_word为最细粒度划分

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "世界人民大团结万岁"
}

#分词结果
{
  "tokens" : [
    {
      "token" : "世界人民",
      "start_offset" : 0,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 0
    },
    {
      "token" : "世界人",
      "start_offset" : 0,
      "end_offset" : 3,
      "type" : "CN_WORD",
      "position" : 1
    },
    {
      "token" : "世界",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "人民",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 3
    },
    {
      "token" : "大团结",
      "start_offset" : 4,
      "end_offset" : 7,
      "type" : "CN_WORD",
      "position" : 4
    },
    {
      "token" : "大团",
      "start_offset" : 4,
      "end_offset" : 6,
      "type" : "CN_WORD",
      "position" : 5
    },
    {
      "token" : "团结",
      "start_offset" : 5,
      "end_offset" : 7,
      "type" : "CN_WORD",
      "position" : 6
    },
    {
      "token" : "万岁",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 7
    },
    {
      "token" : "万",
      "start_offset" : 7,
      "end_offset" : 8,
      "type" : "TYPE_CNUM",
      "position" : 8
    },
    {
      "token" : "岁",
      "start_offset" : 8,
      "end_offset" : 9,
      "type" : "COUNT",
      "position" : 9
    }
  ]
}

自定义ik分词器配置

创建自定义词典test.dic

测试

ik_smart为最少切分

ik_max_word为最细粒度划分

此处笑的像个两百斤的孩子变成了一个完整的词语。

五、Rest风格说明🎪

RESTful 是一种基于 REST（Representational State Transfer，表述性状态转移）架构风格的设计原则，通常用于设计网络服务的 API。RESTful 的核心理念是通过 HTTP 协议进行通信，将系统的资源进行统一的表示，并通过不同的 HTTP 方法来操作这些资源。

Method	URL地址	描述
PUT	localhost:9200/索引名称/类型名称/文档id	创建文档（指定文档id）
POST	localhost:9200/索引名称/类型名称	创建文档（随机文档id）
POST	localhost:9200/索引名称/类型名称/文档id/_update	修改文档
DELETE	localhost:9200/索引名称/类型名称/文档id	删除文档
GET	localhost:9200/索引名称/类型名称/文档id	查询文档通过文档id
POST	localhost:9200/索引名称/类型名称/_search	查询所有数据

创建索引

查询索引

更新索引

删除索引

六、构建复杂查询🎢

查询的参数体使用json构建

普通查询

GET /test/_search
{
  "query": {
    "match": {
      "name": "testname2"
    }
  }
}

#查询结果
{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 0.9808291,
    "hits" : [
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.9808291,
        "_source" : {
          "name" : "testname2",
          "age" : 32,
          "tags" : [
            1,
            4,
            5,
            6
          ]
        }
      }
    ]
  }
}

模糊查询

GET /test/_search
{
  "query": {
    "fuzzy": {
      "name": {
        "value": "testname"
      }
    }
  }
}

#查询结果
{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 3,
      "relation" : "eq"
    },
    "max_score" : 0.9808291,
    "hits" : [
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.9808291,
        "_source" : {
          "name" : "testname",
          "age" : 22,
          "tag" : [
            1,
            2,
            3,
            4,
            5,
            6
          ]
        }
      },
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.8582256,
        "_source" : {
          "name" : "testname2",
          "age" : 32,
          "tags" : [
            1,
            4,
            5,
            6
          ]
        }
      },
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.8582256,
        "_source" : {
          "name" : "testname3",
          "age" : 42,
          "tags" : [
            1,
            4,
            5
          ]
        }
      }
    ]
  }
}

通过前缀模糊查询，并且指定需要查询的字段类似（select name,age from xxxx），且根据年龄将结果倒序，且进行分页

GET /test/_search
{
  "query": {
    "prefix": {
      "name": {
        "value": "test"
      }
    }
  },
  "_source": ["name","age"],
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ],
  "from": 0,
  "size": 3
}

#查询结果
{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 3,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : null,
        "_source" : {
          "name" : "testname3",
          "age" : 42
        },
        "sort" : [
          42
        ]
      },
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : null,
        "_source" : {
          "name" : "testname2",
          "age" : 32
        },
        "sort" : [
          32
        ]
      },
      {
        "_index" : "test",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : null,
        "_source" : {
          "name" : "testname",
          "age" : 22
        },
        "sort" : [
          22
        ]
      }
    ]
  }
}

参数解释：

GET /test/_search

这表示对索引 test 进行搜索查询。

“query”: { “prefix”: { “name”: { “value”: “test” } } }

prefix 查询：搜索以指定前缀开头的文档。这种查询会匹配 name 字段中以 “test” 开头的值。例如，如果文档中有 name 字段的值是 “test123”、“testing” 等，它们都会被匹配到。
“name”：这是要匹配前缀的字段名称。
“value”: “test”：指定前缀值为 “test”。

“_source”: [“name”, “age”]

这个部分用来指定返回结果中包含的字段。此处只会返回 name 和 age 字段，其他字段将被省略。

“sort”: [ { “age”: { “order”: “desc” } } ]

用于排序查询结果。
“age”：按照 age 字段进行排序。
“order”: “desc”：表示降序排序，值越大的文档排在前面。

“from”: 0, “size”: 3

“from”：表示从第几条数据开始返回，类似于分页查询的起始位置。0 表示从第一条数据开始。
“size”：表示返回的文档数量。此处设置为 3，即最多返回 3 条匹配的文档。

七、SpringBoot集成ES✨

7.1 操作索引API

ES-client的Java集成文档

创建工程并引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>es-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>es-demo</name>
    <description>es-demo</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.12.RELEASE</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.40</version>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
    </dependencies>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.example.esdemo.EsDemoApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

创建配置类

@Configuration
public class ESClientConfig {
    @Bean
    public RestHighLevelClient highLevelClient() {
        return new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http")));
    }
}

单元测试操作索引的API

@SpringBootTest
class EsDemoApplicationTests {
    @Autowired
    RestHighLevelClient esClient;
    /**
     * 索引名称
     */
    private final String INDEX_NAME = "test_index";

    /**
     * 创建索引
     */
    @Test
    void testCreateIndex() throws IOException {
        CreateIndexRequest testIndex = new CreateIndexRequest(INDEX_NAME);
        CreateIndexResponse createIndexResponse = esClient.indices().create(testIndex, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }

    /**
     * 获取索引
     */
    @Test
    void testGetIndex() throws IOException {
        GetIndexRequest getIndexRequest = new GetIndexRequest(INDEX_NAME);
        //判断索引是否存在
        boolean exists = esClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        if (exists) {
            GetIndexResponse getIndexResponse = esClient.indices().get(getIndexRequest, RequestOptions.DEFAULT);
            System.out.println(true);
            System.out.println(getIndexResponse);
        } else {
            System.out.println(false);
        }
    }

    /**
     * 删除索引
     */
    @Test
    void testDeleteIndex() throws IOException {
        AcknowledgedResponse testIndex = esClient.indices().delete(new DeleteIndexRequest(INDEX_NAME), RequestOptions.DEFAULT);
        System.out.println(testIndex.isAcknowledged());
    }
}

7.2 操作文档API

/**
 * @Author YZK
 * @Date 2024/9/22
 * @Desc
 */
@SpringBootTest
public class EsDemoApplicationDocTests {
    @Autowired
    RestHighLevelClient esClient;
    /**
     * 索引名称
     */
    private final String INDEX_NAME = "test_index";


    /**
     * 添加文档
     */
    @Test
    void testAddDocument() throws IOException {
        Document document = new Document("2", "内容2", "标题2");
        IndexRequest indexRequest = new IndexRequest(INDEX_NAME);
        //Put /test_index/_doc/1
        indexRequest.id(document.getId());
        indexRequest.timeout(TimeValue.timeValueSeconds(1));
        String jsonString = JSON.toJSONString(document);
        indexRequest.source(jsonString, XContentType.JSON);
        //客户端发送请求
        IndexResponse indexResponse = esClient.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println(indexResponse.toString());
        System.out.println(indexResponse.status());
    }

    /**
     * 获取文档的信息
     */
    @Test
    void testGetDocument() throws IOException {
        GetRequest getRequest = new GetRequest(INDEX_NAME, "1");
        GetResponse getResponse = esClient.get(getRequest, RequestOptions.DEFAULT);
        System.out.println(getResponse.getSourceAsString());
        System.out.println(getResponse);
    }

    /**
     * 全量搜索文档信息并分页
     */
    @Test
    void testSearchDocument() throws IOException {
        SearchRequest searchRequest = new SearchRequest("test_index");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery())
                .from(0)
                .size(1);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = esClient.search(searchRequest, RequestOptions.DEFAULT);
        searchResponse.getHits().forEach(item -> System.out.println(item.getSourceAsMap()));
    }

    /**
     * 精确搜索文档
     */
    @Test
    void testSearchTrimDocument() throws IOException {
        SearchRequest searchRequest = new SearchRequest("test_index");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.termQuery("id","3"));
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = esClient.search(searchRequest, RequestOptions.DEFAULT);
        searchResponse.getHits().forEach(item -> System.out.println(item.getSourceAsMap()));
    }

    /**
     * 更新文档信息
     */
    @Test
    void testUpdateDocument() throws IOException {
        Document document = new Document("1", "更新内容", "更新标题");
        UpdateRequest updateRequest = new UpdateRequest("test_index", "1");
        updateRequest.doc(JSON.toJSONString(document), XContentType.JSON);
        UpdateResponse updateResponse = esClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(updateResponse.status());
    }

    /**
     * 删除文档信息
     */
    @Test
    void testDeleteDocument() throws IOException {
        DeleteRequest deleteRequest = new DeleteRequest("test_index", "2");
        DeleteResponse deleteResponse = esClient.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(deleteResponse.status());
    }

    /**
     * 批量插入数据
     */
    @Test
    void testBatchInsert() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        List<Document> documentList=new ArrayList<>();
        documentList.add(new Document("3", "内容3", "标题3"));
        documentList.add(new Document("4", "内容4", "标题4"));
        documentList.forEach(item -> bulkRequest.add(new IndexRequest(INDEX_NAME)
                //不指定id就会生成随机id
                .id(item.getId())
                .source(JSON.toJSONString(item), XContentType.JSON)));
        BulkResponse bulkResponse = esClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulkResponse.status());
    }
}

原文地址：https://blog.csdn.net/m0_50281408/article/details/142440297

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：OceanBase迁移工具说明
下一篇：论 JAVA 集合框架中接口与类的关系

docker安装minio、使用springboot集成minio同时创建并设置minio桶仅可读
其中请自行修改用户名、密码、挂载目录和对应的端口与映射（密码至少需要9位，否则启动报错）其中9001是后台服务的端口。
阅读更多2024-11-16
『VUE』27. 透传属性与inheritAttrs（详细图文注释）
『VUE』27. 透传属性与inheritAttrs（详细图文注释）
阅读更多2024-11-16
PostgreSQL物化视图详解
随着数据库规模的增大和查询复杂性的提高，数据库查询的性能问题变得越来越突出。为了优化查询性能，数据库系统引入了物化视图的概念。物化视图是一种预先计算和存储的查询结果，它可以在需要时直接提供查询结果，而
阅读更多2024-11-16
每日一题之进制转换
对于给定的十进制整数N（N<100000），将1到N（含N）之间的每个整数转成十六进制，求转换后的所有十六进制数中含A的总个数。提示：某个数的16进制含A的个数可以参照下面的例子：对于整数42
阅读更多2024-11-16
web与网络编程
通常使用的网络(包括互联网)都是在TCP/IP协议族的基础上运作的。而HTTP属于它内部的一个。
阅读更多2024-11-16
塑料薄膜厂需要用到哪些自动化备件
此外，根据塑料薄膜厂的具体需求和规模，还可能需要其他特定的自动化备件，如自动化流水线、全自动分切机、自动测试机等。在选择备件时，塑料薄膜厂应优先考虑备件的质量、耐用性、兼容性和售后服务等因素，以确保备
阅读更多2024-11-16
实验二：Docker存储配置与管理
非持久化数据是不需要保存的那些数据，容器本地存储中的数据就属于这种类型。容器创建时会创建非持久化存储，这是容器全部文件和文件系统保存的地方。默认情况下，在容器内创建的所有文件都存储在可写容器层，文件系
阅读更多2024-11-16
git本地分支推送到远程和远程pull到本地
在推送到远程仓库之前，你也可能想要先执行 git fetch 和 git pull 以确保你的本地分支是最新的。要将本地分支推送到远程仓库的某个分支（可以是同名的分支，也可以是不同名的分支），你可以使
阅读更多2024-11-16
大模型时代，呼叫中心的呼入机器人系统如何建设？
作者：开源呼叫中心系统 FreeIPCC，Github地址：https://github.com/lihaiya/freeipcc呼叫中心呼入机器人系统的建设是一个涉及多个环节和领域的综合性工程。
阅读更多2024-11-16
HTTP/2新型DDoS攻击：技术深度剖析与防御指南
在智能化演进和互联网技术高速发展的背景下，黑客攻击手段不断翻新，DDoS攻击的强度、频率和复杂度也随之持续攀升。金融、政务、互联网等多个领域及其关键基础设施正面临着前所未有的DDoS攻击威胁。
阅读更多2024-11-16