Elasticsearch笔记

我就是我 2023-10-14 01:12 47阅读 0赞

![在这里插入图片描述][920cf7a65f621d257c14f01976c30679.jpeg_pic_center]

> 迈向光明之路，必定荆棘丛生。

#### 文章目录 ####

*  一、Elasticsearch概述
 *  二、初识ES倒排索引
 *   *  1. 正向索引
     *  2. 倒排索引
 *  三、ES环境搭建
 *   *  1. 安装单机版ES
     *  2. 安装Kibana
     *  3. 安装ik分词器
     *   *  3.1 在线安装ik插件
         *  3.2.离线安装ik插件（推荐方式）
         *  3.3 自定义词典
 *  四、ES核心概念
 *  五、ES基本操作（DSL）
 *   *  1. DSL介绍
     *  2. 索引库相关操作
     *   *  2.1 创建索引库
         *  2.2 查看所有索引库
         *  2.3 查看指定索引库
         *  2.4 删除索引库
     *  3. 文档相关操作
     *   *  3.1 创建文档
         *  3.2 查询文档
         *  3.3 修改文档
         *  3.4 修改指定字段的值
         *  3.5 删除文档
         *  3.6 批量操作
         *   *  3.6.1 批量创建文档
             *  3.6.2 批量删除文档
         *  3.7 Mapping映射
         *   *  3.7.1 查看映射
             *  3.7.2 Mapping映射的常见属性
             *  3.7.3 创建索引库和映射
 *  六、ES高级查询（DSL）
 *   *  1. 查询所有（match\_all）
     *  2. 匹配查询（match）
     *  3. 多字段匹配（multi\_match）
     *  4. 前缀匹配(prefix)
     *  5. 关键字精确查询（term）
     *  6. 多个关键字精确查询（terms）
     *  7. 范围查询（range）
     *  8 返回指定字段（\_source）
     *  9. 组合查询（bool）
     *   *  9.1 must（并且）
         *  9.2 should（或者）
         *  9.3 must\_not（非）
         *  9.4 filter
     *  10. 聚合查询（aggs）
     *   *  10.1 max
         *  10.2 min
         *  10.3 avg
         *  10.4 sum
         *  10.5 stats
         *  10.6 terms（分组）
     *  11. 分页查询（from、size）
     *  12. 高亮查询（highlight）
     *  13. 近似查询（fuzzy）
 *  七、Java操作ES
 *   *  1. API介绍
     *  2. 使用RestHighLevelClient操作ES
     *   *  2.1 环境准备
         *  2.2 索引库相关操作
         *   *  2.2.1 创建索引库
             *  2.2.2 获取所引库
             *  2.2.3 删除索引库
         *  2.3 文档相关操作
         *   *  2.3.1 数据准备
             *  2.3.2 添加文档
             *  2.3.3 修改文档
             *  2.3.4 根据id查询文档
             *  2.3.5 删除文档
             *  2.3.6 批量新增
         *  2.4 高级查询
         *   *  2.4.1 查询所有文档
             *  2.4.2 匹配查询
             *  2.4.3 高亮查询
             *  2.4.4 聚合查询
     *  3. 使用Spring Data Elasticsearch 操作ES
     *   *  3.1 Spring Data概述
         *  3.2 Spring Data Elasticsearch 概述
         *  3.3 环境准备
         *  3.4 使用ElasticsearchRestTemplate操作ES
         *   *  3.4.1 添加文档
             *  3.4.2 根据ID查询文档
             *  3.4.3 修改文档
             *  3.4.4 删除文档
             *  3.4.5 查询所有文档
             *  3.4.6 高亮查询
             *  3.4.7 分页查询
             *  3.4.8 聚合查询
         *  3.5 使用ElasticsearchRepository接口操作ES

## 一、Elasticsearch概述 ##

--------------------

![在这里插入图片描述][aee5ed04ae87454fa3f86e8d11ccb352.png]

Elasticsearch（简称ES）是一个分布式、RESTful 风格的搜索引擎、数据分析引擎。ES底层是基于Apache Lucene搜索引擎库实现的，但是ES的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。ES可以提供实时的数据存储和检索能力，并且拥有很好的可扩展性。它可以扩展到上百台服务器，处理PB级别的数据（海量数据—千万级以上）。

ES被广泛应用于各种场景，例如：搜索引擎、日志管理、电商推荐、监控和报告等。其强大的搜索和分析能力使得数据的处理变得简单、高效和可扩展。

官网地址：https://www.elastic.co/cn/elasticsearch/

> 数据库搜索存在的问题：

1、常见数据库特点：

*  MySQL：事务
 *  Redis：内存/读写效率高
 *  MongoDB：最接近关系型的nosql
 *  Elasticsearch：分布式搜索引擎，提供了Restful接口，ES也可以看做分布式文档数据库（通过DSL语句操作ES）。

2、普通数据库可以实现搜索，为什么还要用ES？

*  海量数据搜索效率低（逐行扫描方式）
    
     *  解决方案：针对要搜索的字段建立索引、对数据库进行分库分表处理（查询效率提升了，但是添加效率会受到影响）
 *  搜索数据不够全面。例如MySQL模糊查询：like %联想电脑% （只能搜索包含联想电脑的内容，没有实现分词效果）

![在这里插入图片描述][a058022e3eb54a84bfba2962d3c4ed48.png]![在这里插入图片描述][1264df6bfbc34ed2a8b630e7210312df.png]

> Lucene、ElasticSearch相关概述：

1、Lucene介绍：

*  Lucene是基于Java语言开发的搜索引擎类库，是Apache基金会的顶级项目，由DougCutting于1999年研发。
 *  官网地址：https://lucene.apache.org/
 *  优点：易扩展、高性能（基于倒排索引）。
 *  缺点：只限于Java语言开发、学习曲线陡峭、不支持水平扩展（搭集群）。

2、ElasticSearch介绍：

*  2004年Shay Banon基于Lucene开发了Compass。
 *  2010年Shay Banon重写了Compass，取名为ElasticSearch。
 *  官网地址：https://www.elastic.co/products/elasticsearch
 *  目前最新版本：7.17.9、8.8.2（本文以7.12.1为例）
 *  相比Lucene，ElasticSearch具备下列优势：
    
     *  支持分布式，可水平扩展。
     *  提供Restful接口，可被任何语言调用。

> ElasticSearch小故事：

![在这里插入图片描述][4d6516ae01aa4653aca63f0a00b9cfb9.png]

多年前，一个刚结婚不久的失业开发者Shay Banon（谢巴农），由于妻子要去伦敦学厨师，他便跟着去了。在他找工作的过程中，为了给妻子构建一个食谱的搜索引擎，于是他开始使用Lucene进行尝试。

直接基于Lucene工作会比较困难，所以Shay开始抽象Lucene代码以便Java程序员可以在应用中添加搜索功能。他发布了他的第一个开源项目，叫做“Compass”。

后来Shay找到一份工作，这份工作处在高性能和内存数据网格的分布式环境中，因此高性能的、实时的、分布式的搜索引擎也是理所当然需要的。于是他决定闭门造车重写Compass库使其成为一个独立的服务叫做ElasticSearch。

第一个公开版本出现在2010年2月，在那之后ElasticSearch已经成为Github上最受欢迎的项目之一，代码贡献者超过300人。一家主营Elasticsearch的公司就此成立（Elastic），他们一边提供商业支持一边开发新功能，不过Elasticsearch将永远开源且对所有人可用。

而Shay的妻子依旧等待着她的食谱搜索引擎……

> ES 与 Apache Solr 搜索引擎对比：

1、ES基本是开箱即用，非常简单。Solr安装略微复杂。

2、Solr 利用 Zookeeper 进行分布式管理，而 Elasticsearch 自身带有分布式协调管理功能。

3、Solr 支持更多格式的数据，比如JSON、XML、CSV，而 Elasticsearch 仅支持json文件格式。

4、Solr 官方提供的功能更多，而 Elasticsearch 本身更注重于核心功能，高级功能多有第三方插件提供，例如图形化界面需要kibana友好支撑。

5、Solr 查询快，但更新索引时慢（即插入删除慢），用于电商等查询多的应用；

*  ES建立索引快（即查询慢），即实时性查询快，用于facebook新浪等搜索。
 *  Solr 是传统搜索应用的有力解决方案，但 Elasticsearch 更适用于新兴的实时搜索应用。

6、Solr比较成熟，有一个更大，更成熟的用户、开发和贡献者社区，而 Elasticsearch相对开发维护者较少，更新太快，学习使用成本较高。

目前比较知名的搜索引擎技术排名：https://db-engines.com/en/ranking/search+engine

## 二、初识ES倒排索引 ##

--------------------

> ES基于倒排索引提高查询效率。

### 1. 正向索引 ###

--------------------

正向索引：建立文档id和词之间的对应关系。

![在这里插入图片描述][54c10100b40d447daa5bcc4507bbcf65.png]

在正向索引中，每个文档都会维护一个关键词列表，记录了该文档包含的所有关键词。当用户发起搜索时，搜索引擎会遍历索引库中的所有文档，并检查每个文档的关键词列表，找出匹配程度最高的文档。

存在的问题：如果正向索引中的数据量较大，就需要遍历所有文档才能找到匹配的结果，效率比较低。为了提高搜索效率，搜索引擎通常使用倒排索引来加速搜索过程。

### 2. 倒排索引 ###

--------------------

倒排索引：也称之为反向索引，建立单词和文档id之间的对应关系。即把文档→单词的形式变为单词→文档的形式。（借助于分词器）

![在这里插入图片描述][e745a65de2494f04bec194b226401e23.png]

倒排索引建立过程：先对数据（文档）进行分词，得到一个个的词条，然后将词条与文档id的对应关系保存起来。

那有了ES以后就不需要数据库了嘛？

*  ES主要实现数据的搜索，并且ES还不支持事务，因此要保证数据一致性，还需要结合关系型数据库使用。

![在这里插入图片描述][28ced553c476406f96250af387b58ae3.png]

## 三、ES环境搭建 ##

--------------------

> 基于Docker安装单机版ES。（ES版本为7.12.1）

### 1. 安装单机版ES ###

--------------------

1、创建Docker网络（也就是一个标识，创建网络的目的是让es和kibana容器互联）

# 创建一个网络
    docker network create es-net
    
    #查看docker本机的网络
    docker network  ls 
    
    #删除网络
    # docker network rm es-net

![在这里插入图片描述][22491441bb05457c93f9f82a73a385dc.png]

2、下载elasticsearch镜像。(这个镜像体积非常大，接近1个G)

docker pull elasticsearch:7.12.1

![在这里插入图片描述][760df4bbb3654f11b027a981883417ec.png]

下载成功后，别忘了导出镜像，方便以后使用。

docker save -o es.tar elasticsearch:7.12.1

3、启动es容器（单机版es）

![在这里插入图片描述][34ecba8ef0784ed7b960b5a46e8a7cbb.png]

docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
    -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
    -e "discovery.type=single-node" \
    -e TZ=Asia/Shanghai \
    -v es-data:/usr/share/elasticsearch/data \
    -v es-plugins:/usr/share/elasticsearch/plugins \
    --network es-net \
    --privileged \
    --restart=always \
    -d elasticsearch:7.12.1

*  `-e "cluster.name=es-docker-cluster"`：设置集群名称。
 *  `-e "http.host=0.0.0.0"`：监听的地址，可以外网访问。
 *  `-e "ES_JAVA_OPTS=-Xms512m -Xmx512m"`：设置容器内存大小。
 *  `-e "discovery.type=single-node"`：非集群模式。
 *  `-v es-data:/usr/share/elasticsearch/data`：挂载es数据目录。
 *  `-v es-logs:/usr/share/elasticsearch/logs`：挂载es日志目录。
 *  `-v es-plugins:/usr/share/elasticsearch/plugins`：挂载es插件目录。
 *  `--privileged`：授予数据卷访问权。
 *  `--network es-net` ：加入一个名为es-net的网络中。
 *  `-p 9200:9200`：端口映射配置， 9200是es与外部机器通讯的端口，9300是es集群节点之间通讯的端口。

4、浏览器测试访问：http://192.168.150.123:9200/

![在这里插入图片描述][74387f8064d1455f8bed67c187006ad1.png]

### 2. 安装Kibana ###

--------------------

Kibana是一个开源的数据分析可视化平台，主要和ElasticSearch搭配使用。

可以对ES索引库中的数据进行可视化(柱状图、饼状图、散点图等)的数据展示，在Kibana中也提供了开发者工具（devtools），我们可以直接编写DSL脚本请求ES的restful接口操作ES。

DSL(Domain Specific Language)领域专用语言，Elasticsearch提供了基于JSON的DSL来定义查询。

> Kibana是ES的可视化工具，帮助用户实时分析和数据可视化，通过界面可以更方便学习ES。安装Kibana时要与ES版本保持一致。

1、下载镜像（与ES版本保持一致）

docker pull kibana:7.12.1

![在这里插入图片描述][4d8e08013a5c486390e5301b6dc84a07.png]

2、启动kibana容器

docker run -d \
    --name kibana \
    -e ELASTICSEARCH_HOSTS=http://elasticsearch:9200 \
    --network=es-net \
    -p 5601:5601  \
    kibana:7.12.1

*  `--network es-net` ：加入一个名为es-net的网络中，与elasticsearch在同一个网络中。
 *  `-e ELASTICSEARCH_HOSTS=http://es容器名:9200"`：设置elasticsearch的访问地址，因为kibana已经与elasticsearch容器在同一个网络，因此可以用容器名直接访问elasticsearch。
 *  `-p 5601:5601`：kibana容器外部访问端口。

kibana启动一般比较慢，需要多等待一会，可以通过命令查看是否启动成功：

docker logs -f kibana

![在这里插入图片描述][48251c2ed4a24a14a80690c67a6b837e.png]

3、浏览器测试访问：http://192.168.150.123:5601/（点击Explore on my own：独自探索）

![在这里插入图片描述][0674ca7a590a4460b38b970b70e48348.png]

![在这里插入图片描述][eae39109a445434eb082710efbeedbab.png]

DevTools：在这个界面中可以编写DSL（DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD）。并且对DSL语句有自动补全功能。  
![在这里插入图片描述][f8b123b51b70408fa91bc46749d5b26f.png]

示例：使用默认的标准分词器（StandardAnalyzer），按词切分，对中文不太友好。

# 使用默认的标准分词器分词
    GET /_analyze
    {
        
      "analyzer":"standard",
      "text":"小米手机"
    }

![在这里插入图片描述][05b6fdc4d71343d58371971afdceaa67.png]

### 3. 安装ik分词器 ###

--------------------

> IK分词器：一款开源的中文分词器。项目地址：https://github.com/medcl/elasticsearch-analysis-ik

#### 3.1 在线安装ik插件 ####

--------------------

![在这里插入图片描述][306292a809d9436fade4c48eb23e6c99.png]

# 进入es容器内部
    docker exec -it elasticsearch /bin/bash
    
    # 在线下载ik分词器插件并安装
    ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip
    
    #退出容器
    exit
    
    #重启es容器
    docker restart elasticsearch

#### 3.2.离线安装ik插件（推荐方式） ####

--------------------

1、下载ik分词器插件：https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip

![在这里插入图片描述][bcb09b0de1e14a8bb82ba02745595c6a.png]

然后将文件解压缩，修改文件夹名为：ik

![在这里插入图片描述][38827c6cc33c43c3aea3878217a5640c.png]

2、查看数据卷目录

安装插件需要知道es的plugins目录位置，而我们在启动容器时配置了挂载数据卷，所以通过下面命令查看即可:

# 查看es-plugins数据卷的详细信息
    docker volume inspect es-plugins

显示结果：

说明plugins目录被挂载到了：`/var/lib/docker/volumes/es-plugins/_data`这个目录。

3、将ik分词器上传到es容器的插件数据卷中： `/var/lib/docker/volumes/es-plugins/_data`  
![在这里插入图片描述][2e0ce5d2e6a94f67b92e54a99ea68452.png]

![在这里插入图片描述][d000726aed27446bb0f2e71ce8ffd6c6.png]

4、重启容器

# 4、重启容器
    docker restart elasticsearch

5、测试ik分词器：

IK分词器提供了两种分词算法：

*  `ik_smart`：粗粒度分词，分出的词比较少。
 *  `ik_max_word`：细粒度分词，分出的词比较多。

示例1：测试ik分词器ik\_max\_word细粒度分词

GET /_analyze
    {
        
      "text": "中华人民共和国",
      "analyzer": "ik_max_word"
    }

执行结果：

{
        
      "tokens" : [
        {
        
          "token" : "中华人民共和国",
          "start_offset" : 0,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 0
        },
        {
        
          "token" : "中华人民",
          "start_offset" : 0,
          "end_offset" : 4,
          "type" : "CN_WORD",
          "position" : 1
        },
        {
        
          "token" : "中华",
          "start_offset" : 0,
          "end_offset" : 2,
          "type" : "CN_WORD",
          "position" : 2
        },
        {
        
          "token" : "华人",
          "start_offset" : 1,
          "end_offset" : 3,
          "type" : "CN_WORD",
          "position" : 3
        },
        {
        
          "token" : "人民共和国",
          "start_offset" : 2,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 4
        },
        {
        
          "token" : "人民",
          "start_offset" : 2,
          "end_offset" : 4,
          "type" : "CN_WORD",
          "position" : 5
        },
        {
        
          "token" : "共和国",
          "start_offset" : 4,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 6
        },
        {
        
          "token" : "共和",
          "start_offset" : 4,
          "end_offset" : 6,
          "type" : "CN_WORD",
          "position" : 7
        },
        {
        
          "token" : "国",
          "start_offset" : 6,
          "end_offset" : 7,
          "type" : "CN_CHAR",
          "position" : 8
        }
      ]
    }

示例2：测试ik分词器ik\_smart粗粒度分词

GET /_analyze
    {
        
      "text": "中华人民共和国",
      "analyzer": "ik_smart"
    }

执行结果：

{
        
      "tokens" : [
        {
        
          "token" : "中华人民共和国",
          "start_offset" : 0,
          "end_offset" : 7,
          "type" : "CN_WORD",
          "position" : 0
        }
      ]
    }

#### 3.3 自定义词典 ####

--------------------

IK分词器之所以可以对中文进行合理的分词，是因为在IK分词器中提供了一个中文词典（extra\_main.dic），在这个词典中定义了很多的词。

![在这里插入图片描述][a6466d2eebde46168fb746a536043420.png]![在这里插入图片描述][46b40177643b48769404327e3ceacf48.png]

但是IK分词器并不能把所有的词全部考虑进去，比如网络热词：内卷、躺平、奥利给等。

因此为了满足开发的一些特殊化的需求，此时就需要自定义词典，可以自定义两类词典：

*  扩展词词典：定义自定义的词
 *  停用词词典：定义不希望出现的词

操作如下：

1、在/var/lib/docker/volumes/es-plugins/\_data/ik/config目录下创建一个ext.dic文件

# 创建自定义词
    cat << EOF > ext.dic
    奥利给
    笑不活
    EOF

![在这里插入图片描述][c11c53cd7c0449a98969d179c1a0c27d.png]

2、修改IKAnalyzer.cfg.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>
             
            <entry key="ext_stopwords">stopword.dic</entry>
            
            
            
            
    </properties>

![在这里插入图片描述][50c5e586edcc4312aa0e6c23b3aa13bf.png]

3、重启es容器

docker restart elasticsearch

4、测试：

GET /_analyze
    {
        
      "analyzer":"ik_max_word",
      "text":"加油奥利给"
    }

执行结果：

![在这里插入图片描述][edb76b0217804893b347dff753cefaba.png]

ok，扩展词典已经配置成功了。

## 四、ES核心概念 ##

--------------------

ES和关系型数据库相关概念对比：

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

![在这里插入图片描述][17c997c182734f669b36889c5bc45ff1.png]

Elasticsearch是面向文档型数据库，一条数据在这里就是一个文档，用JSON作为文档序列化的格式，比如下面这条用户数据：

{
        
        "name" :     "John",
        "sex" :      "Male",
        "age" :      25,
        "birthDate": "1990/05/01",
        "about" :    "I love to go rock climbing",
        "interests": [ "sports", "music" ]
    }

在一个索引库中，你可以定义一种或多种类型（文档集合）。

一个类型（Type）是索引的一个逻辑上的分类或分区，用于对文档进行组织和分类。每个索引可以包含多个类型，而每个类型又可以包含多个文档。类型的语义完全由你来定义，它可以代表不同的实体、数据类型或者业务逻辑。例如，如果你有一个名为 “products” 的索引，你可以定义不同的类型来表示不同种类的产品，如"electronics"、 “clothing”、"books"等。

通常，会为具有一组共同字段的文档定义一个类型。

不同版本的ES，类型会有一些变化：

<table> 
 <thead> 
  <tr> 
   <th>版本</th> 
   <th>Type</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>5.x</td> 
   <td>支持多种type</td> 
  </tr> 
  <tr> 
   <td>6.x</td> 
   <td>只能有一种type</td> 
  </tr> 
  <tr> 
   <td>7.x</td> 
   <td>默认不再支持自定义索引类型（默认类型为：_doc）</td> 
  </tr> 
 </tbody> 
</table>

## 五、ES基本操作（DSL） ##

--------------------

### 1. DSL介绍 ###

--------------------

DSL（Domain Specific Language）：领域专用语言，Elasticsearch提供了基于JSON的DSL来定义查询。

文档地址：https://www.elastic.co/guide/en/elasticsearch/reference/7.12/query-dsl.html

![在这里插入图片描述][0a7203c321214366b050ce6f868f8373.png]

### 2. 索引库相关操作 ###

--------------------

#### 2.1 创建索引库 ####

--------------------

语法: `PUT /{索引名称}`

PUT /my_index
    
    执行结果:
    {
        
      "acknowledged" : true,
      "shards_acknowledged" : true,
      "index" : "my_index"
    }

![在这里插入图片描述][1ba7e099b5284e4cadf99ebef98b7e46.png]

#### 2.2 查看所有索引库 ####

--------------------

语法: `GET /_cat/indices?v`  
![在这里插入图片描述][3371bb35db2b40638a54caaf080a495b.png]

#### 2.3 查看指定索引库 ####

--------------------

语法: `GET /{索引名称}`

GET /my_index
    
    执行结果:
    {
        
      "my_index" : {
        
        "aliases" : {
         },
        "mappings" : {
         },
        "settings" : {
        
          "index" : {
        
            "creation_date" : "1633499968211",
            "number_of_shards" : "1",
            "number_of_replicas" : "1",
            "uuid" : "bclHUdHrS4W80qxnj3NP0A",
            "version" : {
        
              "created" : "7080099"
            },
            "provided_name" : "my_index"
          }
        }
      }
    }

![在这里插入图片描述][f7d2aa61239a493bad40a0f4261297a0.png]

lasticsearch在默认情况下为每个索引创建了两个分片（一个主，一个备份），可以在创建索引库时指定分片个数。

#### 2.4 删除索引库 ####

--------------------

语法: `DELETE /{索引名称}`

DELETE /my_index
    
    执行结果:
    {
        
      "acknowledged" : true
    }

![在这里插入图片描述][9eb15a3a83ce45cea4727380e8f7e22f.png]

> 小节：

*  创建索引库：PUT /索引库名
 *  查询索引库：GET /索引库名
 *  删除索引库：DELETE /索引库名

### 3. 文档相关操作 ###

--------------------

#### 3.1 创建文档 ####

--------------------

语法格式如下：

PUT /{
        索引名称}/类型/{
        id}
    {
        
    	jsonbody
    }

在ES7以后的版本中，关于类型使用默认的值：**\_doc**

#创建文档
    PUT /my_index/_doc/1
    {
        
      "title": "小米手机",
      "category": "小米",
      "images": "http://www.gulixueyuan.com/xm.jpg",
      "price": 3999
    }
    
    返回结果:
    {
        
      "_index" : "my_index",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "result" : "created",
      "_shards" : {
        
        "total" : 2,
        "successful" : 1,
        "failed" : 0
      },
      "_seq_no" : 0,
      "_primary_term" : 1
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MghBptiu-1690304845291)(assets/image-20230719180214808.png)\]

#### 3.2 查询文档 ####

--------------------

① 根据id查询索引库下的文档：`GET /{索引名称}/{类型}/{id}`

# 查询id为1的文档
    GET /my_index/_doc/1
    
    返回结果:
    {
        
      "_index" : "my_index",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 1,
      "_seq_no" : 0,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        
        "title" : "小米手机",
        "category" : "小米",
        "images" : "http://www.gulixueyuan.com/xm.jpg",
        "price" : 3999
      }
    }

![在这里插入图片描述][1c3dfe41b5c642e095ffb28b047c00d2.png]

② 查索引库下的全部文档：

GET /{
        索引库名}/_search
    {
        
    	"query":{
        
    		"match_all":{
        }
    	}
    }

![在这里插入图片描述][180a7b316baf468e9b0f4c2f79bceb89.png]

#### 3.3 修改文档 ####

--------------------

语法格式如下:

PUT /{
        索引名称}/{
        类型}/{
        id}
    {
        
    	jsonbody
    }

PUT /my_index/_doc/1
    {
        
      "title": "华为手机",
      "category": "华为",
      "images": "http://www.gulixueyuan.com/xm.jpg"
    }

![在这里插入图片描述][5bfecca2c5464eb6978ffffeaffc2c66.png]

注意：修改文档是先根据id把文档删除掉，然后重新添加文档

#### 3.4 修改指定字段的值 ####

--------------------

语法格式如下: （注：这种更新只能使用post方式）

POST /{
        索引名称}/_update/{
        docId}
    {
        
      "doc": {
        
        "属性": "值"
      }
    }

示例：修改文档id为1的商品价格

POST /my_index/_update/1
    {
        
      "doc": {
        
        "price": 4500
      }
    }

![在这里插入图片描述][a65bb6ffa11045c1acfb365ee70d47ca.png]

#### 3.5 删除文档 ####

--------------------

语法: `DELETE /{索引名称}/{类型}/{id}`

# 创建文档
    PUT  /my_index/_doc/2
    {
        
      "title": "黑莓手机",
      "category": "黑莓",
      "images": "http://www.gulixueyuan.com/xm.jpg"
    }
    
    # 删除id为2的文档
    DELETE /my_index/_doc/2

![在这里插入图片描述][ceb8eab9e838468084803bbf85779306.png]

#### 3.6 批量操作 ####

--------------------

通用语法：

POST
    {
        "actionName":{
        "_index":"indexName", "_type":"typeName","_id":"id"}} 
    {
        "field1":"value1", "field2":"value2"}

actionName可以有CREATE、DELETE（批量添加or批量删除）等。

##### 3.6.1 批量创建文档 #####

--------------------

POST _bulk
    {
        "create":{
        "_index":"my_index","_id":2}}
    {
        "id":2,"title":"华为手机","category":"华为","images":"http://www.gulixueyuan.com/xm.jpg","price":5500}
    {
        "create":{
        "_index":"my_index","_id":3}}
    {
        "id":3,"title":"VIVO手机","category":"vivo","images":"http://www.gulixueyuan.com/xm.jpg","price":3600}

##### 3.6.2 批量删除文档 #####

--------------------

POST _bulk
    {
        "delete":{
        "_index":"my_index","_id":2}}
    {
        "delete":{
        "_index":"my_index","_id":3}}

> 小节：

*  创建文档：POST /\{索引库名\}/\_doc/文档id \{ jsonbody\}
 *  查询文档：GET /\{索引库名\}/\_doc/文档id
 *  删除文档：DELETE /\{索引库名\}/\_doc/文档id
 *  修改文档：
    
     *  全量修改：PUT /\{索引库名\}/\_doc/文档id \{ jsonbody \}
     *  增量修改(修改指定字段的值)：POST /\{索引库名\}/\_update/文档id \{ “doc”: \{字段\}\}
 *  批量创建、删除文档

#### 3.7 Mapping映射 ####

在ES中，Mapping映射是用来定义索引库中文档的结构和字段类型。它类似于关系型数据库中的表结构定义，可以设置每个字段的数据类型、分词器、索引选项等。（Mapping映射更接近于定义表结构而不是整个数据库结构）

在ES中可以不用先定义Mapping映射（即关系型数据库的表、字段等），如果插入文档时没有事先定义Mapping映射，它会根据文档字段的值自动推断出字段的类型，并生成相应的映射。

##### 3.7.1 查看映射 #####

--------------------

语法：`GET /{索引库名称}/_mapping`

GET /my_index/_mapping
    
    执行结果:
    {
        
      "my_index" : {
        
        "mappings" : {
        
          "properties" : {
              
            "category" : {
             //字段名称
              "type" : "text", //字段类型
            },
            "id" : {
        
              "type" : "long"
            },
            "images" : {
        
              "type" : "text",
            },
            "price" : {
        
              "type" : "long"
            }
          }
        }
      }
    }

##### 3.7.2 Mapping映射的常见属性 #####

--------------------

mapping是对索引库中文档的约束，mapping的常见属性有：

*  type：用于指定字段数据类型，常见的简单类型有：
    
     *  字符串：text（可分词的文本）、keyword（精确值， 例如：品牌、国家、ip地址，keyword不能分词）
     *  数值：long、integer、short、byte、double、float、…
     *  布尔：boolean
     *  日期：date
     *  对象：object
 *  index：是否为字段创建索引（倒排索引），默认为true
 *  analyzer：为指定字段配置分词器
 *  search\_analyzer：配置该字段在搜索的时候所使用的分词器(如果没有指定该分词器，那么搜索的时候使用analyzer所指定的分词器)
 *  properties：该字段的子字段

例如下面的json文档：

{
        
        "title": "海尔冰箱",
        "category": "海尔",
        "images": "http://www.haier.com/bx.jpg",
        "price": 1999
    }

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

1、title：字符串类型(text，可以分词)，需要索引（建立倒排索引提高查询效率）

2、category：字符串类型(keyword), 需要索引

3、images：字符串类型(keyword) , 不需要索引 （该字段只用于存储数据，不需要进行搜索）

4、price：integer类型， 需要索引

##### 3.7.3 创建索引库和映射 #####

--------------------

静态映射：就是可以事先定义好的映射，即手动配置映射，包含文档的各个字段类型、分词器等属性。

在Elasticsearch中，一旦索引创建后，字段的映射是固定的，默认情况下是不可更改的。（注意：重新创建索引会数据丢失）

创建索引和映射语法如下：

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

示例：创建索引库并配置字段映射

#创建索引库，并同时指定映射关系和分词器等属性
    PUT /my_index1
    {
        
      "mappings": {
          // 配置映射关系
        "properties": {
         // 配置文档的字段
          "id":{
        
            "type": "long",
            "index": true
          },
          "title": {
        
            "type": "text",
            "index": true,  // 建立索引
            "analyzer": "ik_max_word", //建立索引使用的分词器
            "search_analyzer": "ik_smart" 
          },
          "category": {
        
            "type": "keyword",
            "index": true
          },
          "images": {
        
            "type": "keyword",
            "index": false
          },
          "price": {
        
            "type": "integer",
            "index": true
          }
        }
      }
    }
    
    返回结果:
    {
        
      "acknowledged" : true,
      "shards_acknowledged" : true,
      "index" : "my_index"
    }

![在这里插入图片描述][1de02bb7a8204c8ea27f9f3a0e569bdb.png]

查看索引库：  
![在这里插入图片描述][6b608e9e7d9f4bacb7bfbf5ef9750822.png]

小节：

*  查看映射：GET /索引库名/\_mapping
 *  创建索引并指定映射(定义表结构)：PUT /索引库名\{mappings->properties->filed\}

## 六、ES高级查询（DSL） ##

--------------------

> DSL查询文档：https://www.elastic.co/guide/en/elasticsearch/reference/7.12/query-dsl.html

![在这里插入图片描述][d26630dc18824d5d8f586ab6fd832569.png]

准备数据：

# 创建索引库，并配置mapping映射
    PUT /product
    {
        
      "mappings": {
        
        "properties": {
        
          "id":{
        
            "type": "long",
            "index": true
          },
          "title": {
        
            "type": "text",
            "index": true,
            "analyzer": "ik_max_word",
            "search_analyzer": "ik_smart"
          },
          "category": {
        
            "type": "keyword",
            "index": true
          },
          "images": {
        
            "type": "keyword",
            "index": false
          },
          "price": {
        
            "type": "integer",
            "index": true
          }
        }
      }
    }
    
    
    # 批量插入文档
    POST _bulk
    {
        "create":{
        "_index":"product","_id":1}}
    {
        "id":1,"title":"华为笔记本电脑","category":"华为","images":"http://www.huawei.com/dn.jpg","price":5388}
    {
        "create":{
        "_index":"product","_id":2}}
    {
        "id":2,"title":"华为手机","category":"华为","images":"http://www.huawei.com/sj.jpg","price":5500}
    {
        "create":{
        "_index":"product","_id":3}}
    {
        "id":3,"title":"VIVO手机","category":"vivo","images":"http://www.vivo.com/sj.jpg","price":3600}

![在这里插入图片描述][4502ae2c70924ca6a808bb5bdd691af5.png]

### 1. 查询所有（match\_all） ###

--------------------

match\_all ：表示查询所有文档，一般测试用。（无条件查询，类似 select \* from table）

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

![加粗样式][c8a7da6330e6425481c69777fb9caee4.png]

### 2. 匹配查询（match） ###

--------------------

match：它可以根据指定的字段和搜索词进行匹配查询。(单字段)

match查询会对搜索的关键词进行**分词**处理，然后将各个词条从对应的倒排索引表中进行匹配。

match查询语法如下：

GET /{
        索引名称}/_search
    {
        
      "query": {
        
        "match": {
        
          "FIELD": "TEXT"
        }
      }
    }

示例：全文检索title字段

GET /product/_search
    {
        
      "query": {
        
        "match": {
        
          "title": "华为智能手机"   # 会对搜索的关键字进行分词，然后将各个词条从对应的倒排索引表中进行搜索
        }
      }
    }

对搜索关键字进行分词：华为，智能手机，智能，能手，手机。然后根据字段title的倒排索引表中进行匹配。  
![在这里插入图片描述][67991978532b41db988ccab478ec4bde.png]

### 3. 多字段匹配（multi\_match） ###

--------------------

multi\_match多字段匹配语法如下：

GET /{
        索引名称}/_search
    {
        
      "query": {
        
        "multi_match": {
        
          "query": "TEXT",
          "fields": ["FIELD1", " FIELD12"]
        }
      }
    }

示例：

GET /product/_search
    {
        
      "query": {
        
        "multi_match": {
        
          "query": "华为智能手机",
          "fields": ["title","category"]
        }
      }
    }

![在这里插入图片描述][f52b133b053f48679d9ac6b3cde199ac.png]

### 4. 前缀匹配(prefix) ###

--------------------

prefix前缀匹配语法如下：

GET /{
        索引名称}/_search
    {
        
      "query": {
        
        "prefix": {
        
          "FIELD": {
        
            "value": "指定前缀"
          }
        }
      }
    }

示例：查询字段title中以vivo开头的文档：（类似mysql中的 like ‘vivo%’）

GET /product/_search
    {
        
      "query": {
        
       "prefix": {
        
         "title": {
        
           "value": "vivo"  // 小写查询，大写无结果
         }
       }
      }
    }
    
    返回结果:
    {
        
      "took" : 11,
      "timed_out" : false,
      "_shards" : {
        
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        
        "total" : {
        
          "value" : 1,
          "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "3",
            "_score" : 1.0,
            "_source" : {
        
              "id" : 3,
              "title" : "VIVO手机",
              "category" : "vivo",
              "images" : "http://www.vivo.com/sj.jpg",
              "price" : 3600
            }
          }
        ]
      }
    }

![在这里插入图片描述][74372587b99841cebcaa154e4df1c5d6.png]

### 5. 关键字精确查询（term） ###

--------------------

因为精确查询的字段是不分词的（keyword），因此查询的条件也必须是**不分词**的词条。

精确查询要求输入的内容与字段的值完全一致才能匹配成功。如果用户输入的内容过多或与字段的值不完全一致，可能导致无法找到匹配的数据。

term查询语法如下：

GET /{
        索引名称}/_search
    {
        
      "query": {
        
        "term": {
        
          "FIELD": {
        
            "value": "VALUE"
          }
        }
      }
    }

示例1：根据title字段做精确查询

GET /product/_search
    {
        
      "query": {
        
       "term": {
        
         "title": {
        
           "value": "华为手机"
         }
       }
      }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sqIcuiPA-1690304845296)(assets/image-20230721165258197.png)\]

示例2：根据category字段做精确查询

GET /product/_search
    {
        
      "query": {
        
       "term": {
        
         "category": {
        
           "value": "华为"
         }
       }
      }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2uOvLhE1-1690304845296)(assets/image-20230722142451229.png)\]

### 6. 多个关键字精确查询（terms） ###

--------------------

terms 查询用于匹配多个关键字。我们使用 terms查询来匹配字段 `field` 的值是否与给定数组中的任何一个值相匹配。如果有匹配的文档，它们将被返回。

terms查询语法如下：

GET /{
        索引名称}/_search
    {
        
      "query": {
        
        "term": {
        
          "FIELD":[value1,value2]
        }
      }
    }

示例：根据title字段多个关键字精确查询 华为手机，华为

GET /product/_search
    {
        
      "query": {
        
       "terms": {
        
         "title": [
           "华为手机",
           "华为"
         ]
       }
      }
    }
    
    返回结果:
    {
        
      "took" : 0,
      "timed_out" : false,
      "_shards" : {
        
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        
        "total" : {
        
          "value" : 2,
          "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "1",
            "_score" : 1.0,
            "_source" : {
        
              "id" : 1,
              "title" : "华为笔记本电脑",
              "category" : "华为",
              "images" : "http://www.huawei.com/dn.jpg",
              "price" : 5388
            }
          },
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "2",
            "_score" : 1.0,
            "_source" : {
        
              "id" : 2,
              "title" : "华为手机",
              "category" : "华为",
              "images" : "http://www.huawei.com/sj.jpg",
              "price" : 5500
            }
          }
        ]
      }
    }

### 7. 范围查询（range） ###

--------------------

通过range查询限定字段查询的范围：

*  gte: 大于等于
 *  lte: 小于等于
 *  gt: 大于
 *  lt: 小于

range查询语法如下：

GET /{
        indexName}/_search
    {
        
      "query": {
        
        "range": {
        
          "FIELD": {
        
           	//范围条件
            "xxx":value
          }
        }
      }
    }

示例：查询价格为3000到5000的产品

GET /product/_search
    {
        
      "query": {
        
        "range": {
        
          "price": {
        
            "gte": 3000,
            "lte": 5000
          }
        }
      }
    }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cc01b8xJ-1690304845296)(assets/image-20230722172425023.png)\]

### 8 返回指定字段（\_source） ###

--------------------

通过`_source`属性来指定需要返回的字段。 它的位置与query属性平级。

返回指定字段语法：

GET /{
        索引库名称}/_search
    {
        
      "query": {
        },
      "_source": ["field1","field2"]
    }

示例：返回title和category字段数据（类似 select title,category from product where price between 3000 and 5000 ）

GET /product/_search
    {
        
      "query": {
        
          "range": {
        
            "price": {
        
              "gte": 3000,
              "lte": 5000
            }
          }
      },
      "_source": ["title","category"]
    }

![在这里插入图片描述][3b0776366a6b472cac2e5e85d8e0ad25.png]

### 9. 组合查询（bool） ###

--------------------

布尔查询是一个或多个查询子句的组合，每一个子句就是一个**子查询**。

以下是对四种布尔操作符的总结：（他们之间可以组合使用）

*  `must`: 所有条件都必须满足，即它们之间是 “与”（AND）关系。（会相关性算分）
 *  `should`: 至少有一个条件满足即可，即它们之间是 “或”（OR）关系。
 *  `must_not`: 所有条件都不能满足，即它们之间是 “非”（NOT）关系。
 *  `filter`: 该操作符和 `must` 的效果相同，但它不计算得分，仅用于过滤文档，因此效率更高。

示例：

GET /my_index/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
         "term": {
         "field1": "value1" } },
            {
         "range": {
         "field2": {
         "gte": 10, "lte": 20 } } }
          ],
          "should": [
            {
         "term": {
         "field3": "value3" } },
            {
         "term": {
         "field4": "value4" } }
          ],
          "must_not": [
            {
         "term": {
         "field5": "value5" } }
          ],
          "filter": [
            {
         "term": {
         "field6": "value6" } }
          ]
        }
      }
    }

在上面的示例中，`must` 布尔子句指定了字段 `field1` 的值必须是 “value1”，并且字段 `field2` 的值必须在 10 到 20 之间。

`should` 布尔子句指定了字段 `field3` 的值应该是 “value3”，或者字段 `field4` 的值应该是 “value4”，其中满足任意一个条件即可。

`must_not` 布尔子句指定了字段 `field5` 的值不能是 “value5”。

`filter` 布尔子句是一个与 `must` 相同的过滤条件，它也要求字段 `field6` 的值必须是 “value6”，但它不计算得分。

#### 9.1 must（并且） ####

--------------------

在ES中，你可以使用`must`关键字来表示查询条件的与操作。`must`子句中的所有条件都必须满足才能匹配文档。

语法如下：

GET /{索引库名称}/_search
    {
      "query": {
        "bool": {
          "must": [
            { 查询条件1 },
            { 查询条件2}
          ]
        }
      }
    }

示例：布尔查询title字段包含华为，并且价格在\[3000, 5000\]之间的数据

GET /product/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
        
              "match": {
        
                "title": "华为"
              }
            },
            {
        
              "range": {
        
                "price": {
        
                  "gte": 3000,
                  "lte": 5000
                }
              }
            }
          ]
        }
      }
    }

![在这里插入图片描述][5be60ade086443d5a1e0cd4dde7770a7.png]

#### 9.2 should（或者） ####

--------------------

示例：布尔查询title字段包含华为，或者价格在\[3000, 5000\]之间的数据

GET /product/_search
    {
        
      "query": {
        
        "bool": {
        
          "should": [
            {
        
              "match": {
        
                "title": "华为"
              }
            },
            {
        
              "range": {
        
                "price": {
        
                  "gte": 3000,
                  "lte": 5000
                }
              }
            }
          ]
        }
      }
    }
    
    返回结果:
    {
        
      "took" : 3,
      "timed_out" : false,
      "_shards" : {
        
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        
        "total" : {
        
          "value" : 3,
          "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "3",
            "_score" : 1.0,
            "_source" : {
        
              "id" : 3,
              "title" : "VIVO手机",
              "category" : "vivo",
              "images" : "http://www.vivo.com/sj.jpg",
              "price" : 3600
            }
          },
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "2",
            "_score" : 0.5619608,
            "_source" : {
        
              "id" : 2,
              "title" : "华为手机",
              "category" : "华为",
              "images" : "http://www.huawei.com/sj.jpg",
              "price" : 5500
            }
          },
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "1",
            "_score" : 0.35411233,
            "_source" : {
        
              "id" : 1,
              "title" : "华为笔记本电脑",
              "category" : "华为",
              "images" : "http://www.huawei.com/dn.jpg",
              "price" : 5388
            }
          }
        ]
      }
    }

#### 9.3 must\_not（非） ####

--------------------

must\_not：必须不匹配，**不参与算分**，类似“非”。

需求：布尔查询title字段不包含华为，并且价格在不在\[2000, 3000\]之间的数据

GET /product/_search
    {
        
      "query": {
        
        "bool": {
        
          "must_not": [
            {
        
              "match": {
        
                "title": "华为"
              }
            },
            {
        
              "range": {
        
                "price": {
        
                  "gte": 2000,
                  "lte": 3000
                }
              }
            }
          ]
        }
      }
    }
    
    
    返回结果:
    {
        
      "took" : 1,
      "timed_out" : false,
      "_shards" : {
        
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        
        "total" : {
        
          "value" : 1,
          "relation" : "eq"
        },
        "max_score" : 0.0,
        "hits" : [
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "3",
            "_score" : 0.0,
            "_source" : {
        
              "id" : 3,
              "title" : "VIVO手机",
              "category" : "vivo",
              "images" : "http://www.vivo.com/sj.jpg",
              "price" : 3600
            }
          }
        ]
      }
    }

#### 9.4 filter ####

--------------------

filter: 与must的效果相同（and），但它不计算得分，仅用于过滤文档，因此效率更高。（计算得分会影响查询性能）

**\_score的分值为0**

GET /product/_search
    {
        
      "query": {
        
        "bool": {
        
          "filter": [
            {
        
              "match": {
        
                "title": "华为"
              }
            }
          ]
        }
      }
    }
    
    返回结果:
    {
        
      "took" : 0,
      "timed_out" : false,
      "_shards" : {
        
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        
        "total" : {
        
          "value" : 2,
          "relation" : "eq"
        },
        "max_score" : 0.0,
        "hits" : [
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "1",
            "_score" : 0.0,
            "_source" : {
        
              "id" : 1,
              "title" : "华为笔记本电脑",
              "category" : "华为",
              "images" : "http://www.huawei.com/dn.jpg",
              "price" : 5388
            }
          },
          {
        
            "_index" : "product",
            "_type" : "_doc",
            "_id" : "2",
            "_score" : 0.0,
            "_source" : {
        
              "id" : 2,
              "title" : "华为手机",
              "category" : "华为",
              "images" : "http://www.huawei.com/sj.jpg",
              "price" : 5500
            }
          }
        ]
      }
    }

### 10. 聚合查询（aggs） ###

--------------------

Elasticsearch的聚合查询是一种强大的功能，可以对文档进行统计分析和数据聚合。聚合查询可以帮助你从大量的数据中提取有用的信息和洞察。它提供了许多不同类型的聚合，可以用于计算最大值、最小值、平均值、求和等等。

以下是一些常见的聚合类型：

1.  `avg`：计算一个字段的平均值。
2.  `sum`：计算一个字段的总和。
3.  `min`：找到一个字段的最小值。
4.  `max`：找到一个字段的最大值。
5.  `cardinality`：计数一个字段的唯一值数量。
6.  `stats`：计算一个字段的统计数据，包括最小值、最大值、平均值和总和。
7.  `extended_stats`：在 `stats` 的基础上，还提供方差、标准差和其他分位数等更详细的统计数据。
8.  `percentiles`：计算一个字段的百分位数。
9.  `bucket`（桶）聚合：将文档分组为不同的桶，并对每个桶内的文档应用其他聚合函数。

#### 10.1 max ####

--------------------

示例：计算 price字段的最大值。

GET /product/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "aggs": {
        
        "max_price": {
         //给聚合结果指定一个名字
          "max": {
        
            "field": "price"
          }
        }
      }
    }

![在这里插入图片描述][3497957ed3984c3fbe2a9b92d704ddde.png]

上面查询的结果携带着原始文档数据，我们可以通过设置 `"size"` 参数来控制聚合查询返回的文档数量。将 `"size"` 参数设置为 `0`，可以使查询只返回聚合结果，不返回原文档数据。(如果size为100，则表示返回前100个原文档)

GET /product/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "size": 0, 
      "aggs": {
        
        "max_price": {
        
          "max": {
        
            "field": "price"
          }
        }
      }
    }

![在这里插入图片描述][81ed6fca07b742f39d0756bacb5fbff3.png]

#### 10.2 min ####

--------------------

示例：计算 price字段的最小值。

GET /product/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "size": 0, 
      "aggs": {
        
        "min_price": {
        
          "min": {
        
            "field": "price"
          }
        }
      }
    }

![在这里插入图片描述][8c0192421bfd427f9381fd2a9ed4d5c8.png]

#### 10.3 avg ####

--------------------

示例：计算 price字段的平均值。

GET /product/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "size": 0, 
      "aggs": {
        
        "avg_price": {
        
          "avg": {
        
            "field": "price"
          }
        }
      }
    }

![在这里插入图片描述][28d75ef0df7e4e9484cbfc458e9675f5.png]

#### 10.4 sum ####

--------------------

示例：计算 price字段的总和。

GET /product/_search
    {
      "query": {
        "match_all": {}
      },
      "size": 0, 
      "aggs": {
        "sum_price": {
          "sum": {
            "field": "price"
          }
        }
      }
    }

![在这里插入图片描述][1c4de3e9e0d844ed8d69b375402132ee.png]

#### 10.5 stats ####

--------------------

stats聚合用于计算一个字段的统计数据，包括：最小值、最大值、求和、平均值和数据数量。

示例：统计price字段的数据

GET /product/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "size": 0, 
      "aggs": {
        
        "total_stats": {
        
          "stats": {
        
            "field": "price"
          }
        }
      }
    }

![在这里插入图片描述][9d2bcc116062417fb6e59294d78cc77a.png]

#### 10.6 terms（分组） ####

--------------------

terms（桶聚合）用于对字段进行分组统计（类似mysql中的group by）。它将文档按照指定字段的值进行分组，并计算每个分组的文档数量或其他指标。

示例：按照category分组，统计文档个数。（对比sql：select category,count(\*) as count from product group by category）

GET /product/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "size": 0, 
      "aggs": {
        
        "stats_price": {
        
          "terms": {
        
            "field": "category"
          }
        }
      }
    }

![在这里插入图片描述][a7662bf893654d90b6543fc8b00f659d.png]

示例：按照category字段进行分组，只拿到前两个分组数据，并对每组的price计算总和。

GET /product/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "size": 0, 
      "aggs": {
        
        "terms_category": {
        
          "terms": {
        
            "field": "category",
            "size": 2
          },
          "aggs": {
        
            "agg_sum": {
        
              "sum": {
        
              "field": "price"
              }
            }
          }
        }
      }
    }

![在这里插入图片描述][b617cea44418438c8c66f27255d0c1fe.png]

### 11. 分页查询（from、size） ###

--------------------

分页的两个关键属性：from、size。

*  from: 当前页的起始索引，默认从0开始。 from = (pageNum - 1) \* size
 *  size: 每页显示多少条

分页查询语法如下：

GET /{
        indexName}/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "from": 0, // 分页开始的位置，默认为0
      "size": 10, // 每页显示多少条
      "sort": [ //根据filed字段进行排序
        {
        "filed": "asc或desc"}
      ]
    }

示例：全文检索华为手机，然后对price字段做倒排序，并实现分页。

GET /product/_search
    {
        
      "query": {
        
        "match": {
        
          "title": "华为手机"
        }
      },
      "sort": [
        {
        
          "price": {
        
            "order": "desc"
          }
        }
      ],
      "from": 0,
      "size": 2
    }

![在这里插入图片描述][7d8568b079564837b9858c0cafce4a49.png]

### 12. 高亮查询（highlight） ###

--------------------

> 高亮原理：

比如我们在百度上搜索资料时，命中关键字的文档会变成红色，比较醒目，这就是高亮显示。  
![在这里插入图片描述][53b25add2fe840c6b610f60efef3d6d4.png]

高亮显示的实现分为两步：

1.  给文档中的所有关键字都添加一个标签，例如`<em>`标签；
2.  页面给`<em>`标签编写CSS样式。

> 在es中实现高亮：

高亮显示语法：

GET /hotel/_search
    {
        
      "query": {
        
        "match": {
        
          "FIELD": "TEXT" // 查询条件，高亮一定要使用全文检索查询
        }
      },
      "highlight": {
        
        "fields": {
         
          "FIELD": {
        // 指定要高亮的字段
            "pre_tags": "<em>",  // 用来标记高亮字段的前置标签
            "post_tags": "</em>" // 用来标记高亮字段的后置标签
          }
        }
      }
    }

示例：全文检索查询华为手机，对title字段进行高亮处理。

GET /product/_search
    {
        
      "query": {
        
        "match": {
        
          "title": "华为手机"
        }
      },
      "highlight": {
        
        "fields": {
        
          "title": {
        
            "pre_tags": "<em>",
            "post_tags":"</em>"
          }
        }
      }
    }

![在这里插入图片描述][605d021d20ec4040bfd0e6cc6bc513d8.png]

**注意：**

*  高亮是对关键字高亮，因此**搜索条件必须带有关键字**，而不能是范围这样的查询。
 *  默认情况下，**高亮的字段，必须与搜索指定的字段一致**，否则无法高亮。
 *  如果要对非搜索字段高亮，则需要在高亮字段中添加一个属性：`required_field_match=false`

![在这里插入图片描述][bd80030badee4bc3921c54386f40c444.png]

### 13. 近似查询（fuzzy） ###

--------------------

fuzzy查询是一种纠错查询，通常用于英文的纠错。它可以返回与搜索词相似的词的文档。

编辑距离是衡量两个词之间差异程度的指标，表示将一个词转换为另一个词所需的最小操作次数。

这些操作包括：

*  更改字符（box → fox）
 *  删除字符（black → lack）
 *  插入字符（sic → sick）
 *  转置两个相邻字符（act → cat）

在fuzzy查询中，我们可以通过调整fuzziness参数来修改编辑距离。默认值为AUTO（根据单词的长度匹配对应的编辑距离），fuzziness参数其它取值为0,1,2 表示最大编辑距离。

*  当单词长度为0到2之间时，必须精确匹配。编辑距离为0。（不会进行变化）
 *  当单词长度为3到5个字母时，最大编辑距离为1。（例如 hallo->hello）
 *  当单词长度大于5个字母时，最大编辑距离为2（最多允许两次编辑）。

示例：近似查询categroy字段值为vovo的文档

GET /product/_search
    {
        
      "query": {
        
        "fuzzy": {
        
          "category": {
        
            "value": "vovo", 
            "fuzziness": 1
          }
        }
      }
    }

![在这里插入图片描述][abe629c0e6cc461aa5ab7554ef5fb1a3.png]

## 七、Java操作ES ##

--------------------

### 1. API介绍 ###

--------------------

文档地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-getting-started.html

**（1）使用官网提供的API操作ES**: （RestHighLevelClient）

![在这里插入图片描述][39bf3d156eba49758d30b735d538301d.png]

maven坐标：

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

**（2）Spring Data ElasticSearch**: 是Spring针对ElasticSearch提供的一个模块，底层是对ES官方所提供的Java API进行了封装，用来简化ES的操作。

![在这里插入图片描述][dcf43e6f459a4680b0b48c54d5aef550.png]

maven坐标：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>

### 2. 使用RestHighLevelClient操作ES ###

--------------------

> RestHighLevelClient是ES官网提供的API。

#### 2.1 环境准备 ####

--------------------

1、创建maven项目

2、导入依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>cn.aopmin</groupId>
        <artifactId>RestHighLevelClient-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.4.5</version>
            <relativePath/> 
        </parent>
    
        <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </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-test</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.80</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <excludes>
                            <exclude>
                                <groupId>org.projectlombok</groupId>
                                <artifactId>lombok</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>

3、创建启动类：

package cn.aopmin;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class MyApp {
        
        public static void main(String[] args) {
        
            SpringApplication.run(MyApp.class, args);
        }
    }

4、在application.yml中配置ES:

spring:
      elasticsearch:
        rest:
          uris: http://192.168.150.123:9200 # 配置es服务器的地址

5、测试

package cn.aopmin.test;
    
    import org.elasticsearch.client.RestHighLevelClient;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.autoconfigure.web.client.RestClientTest;
    import org.springframework.boot.test.context.SpringBootTest;
    
    /**
     * 测试类
     * @author 白豆五
     * @version 2023/07/23
     * @since JDK8
     */
    @SpringBootTest
    public class ElasticSearchTest {
        
    
        @Autowired
        private RestHighLevelClient restHighLevelClient;
    
        @Test
        public void test() {
        
            System.out.println(restHighLevelClient);
        }
    }

![在这里插入图片描述][1686434a9b23447f885e6c1bdaf50937.png]

#### 2.2 索引库相关操作 ####

##### 2.2.1 创建索引库 #####

--------------------

package cn.aopmin.test;
    
    import lombok.extern.slf4j.Slf4j;
    import org.elasticsearch.client.RequestOptions;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.client.indices.CreateIndexRequest;
    import org.elasticsearch.client.indices.CreateIndexResponse;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.io.IOException;
    
    /**
     * 测试索引库相关操作
     *
     * @author 白豆五
     * @version 2023/07/23
     * @since JDK8
     */
    @SpringBootTest
    @Slf4j
    public class IndexTest {
        
    
        @Autowired
        private RestHighLevelClient restHighLevelClient;
    
        /**
         * 测试创建索引库
         */
        @Test
        public void testCreateIndex() throws IOException {
        
            // 1.拿到创建索引的请求对象，并指定索引名
            // org.elasticsearch.client.indices.CreateIndexRequest;
            CreateIndexRequest createIndexRequest = new CreateIndexRequest("goods");
    
            // 2.添加请求参数（内容是定义索引库的DSL语句,json格式）
            // 也可以把DSL语句提取到常量类中
            createIndexRequest.source("{\n" +
                    "  \"mappings\": {\n" +
                    "    \"properties\": {\n" +
                    "      \"id\":{\n" +
                    "        \"type\": \"long\",\n" +
                    "        \"index\": true\n" +
                    "      },\n" +
                    "      \"title\": {\n" +
                    "        \"type\": \"text\",\n" +
                    "        \"index\": true,\n" +
                    "        \"analyzer\": \"ik_max_word\",\n" +
                    "        \"search_analyzer\": \"ik_smart\"\n" +
                    "      },\n" +
                    "      \"category\": {\n" +
                    "        \"type\": \"keyword\",\n" +
                    "        \"index\": true\n" +
                    "      },\n" +
                    "      \"images\": {\n" +
                    "        \"type\": \"keyword\",\n" +
                    "        \"index\": false\n" +
                    "      },\n" +
                    "      \"price\": {\n" +
                    "        \"type\": \"integer\",\n" +
                    "        \"index\": true\n" +
                    "      }\n" +
                    "    }\n" +
                    "  }\n" +
                    "}", XContentType.JSON);
    
            // 3.发送请求
            // IndicesClient indices = restHighLevelClient.indices(); // 拿到操作索引的客户端
            // indices.create(createIndexRequest, RequestOptions.DEFAULT); // 执行创建索引的请求
            // CreateIndexResponse对象中包含了创建索引的返回结果
            CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
    
    
            // 4.输出结果
            log.info("索引名称：{}", createIndexResponse.index());
            log.info("操作是否成功：{}", createIndexResponse.isAcknowledged());
            log.info("分片是否被确认：{}", createIndexResponse.isShardsAcknowledged());
        }
    }

![在这里插入图片描述][99b1339b84f04ee7a8d0ea1a20b5ab64.png]![在这里插入图片描述][5215e87723a74c2c93be7ac680d8e535.png]

##### 2.2.2 获取所引库 #####

--------------------

/**
     * 测试获取索引库
     */
    @Test
    public void testGetIndex() throws IOException {
        
        // 1.创建Request对象
        GetIndexRequest getIndexRequest = new GetIndexRequest("goods");
        // 2.发起请求, exists()方法返回true表示索引库存在，false表示不存在
        boolean exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
        log.info("索引库是否存在：{}", exists);
    }

![在这里插入图片描述][c94dbd4c034f4b4b9c2477facd8e39a1.png]

##### 2.2.3 删除索引库 #####

--------------------

/**
     * 测试删除索引库
     */
    @Test
    public void testDeleteIndex() throws IOException {
        
        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("goods");
        AcknowledgedResponse response = restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
        System.out.println("索引库是否删除成功: "+response.isAcknowledged());
    }

![在这里插入图片描述][bc7a3372025442bea13cfdd0dfb9d619.png]

> 小节：

RestHighLevelClient操作ES索引库的流程基本类似。核心都是通过restHighLevelClient.indices()方法获取索引库的操作对象。

索引库操作的基本步骤如下：

*  依赖注入RestHighLevelClient。（Spring Data Elasticsearch依赖提供的）
 *  创建XxxIndexRequest。（Xxx是Create、Delete、Get。）
 *  准备DSL（ 只有在Create时需要准备DSL）
 *  发送请求。（调用RestHighLevelClient.indices().xxx()方法，xxx是create、exists、delete、get）

#### 2.3 文档相关操作 ####

--------------------

##### 2.3.1 数据准备 #####

--------------------

1、sql脚本：

CREATE DATABASE IF NOT EXISTS `es-db` DEFAULT CHARACTER SET utf8mb4;
    
    use `es-db`;
    
    CREATE TABLE `goods`
    (
        `id`       BIGINT(20) PRIMARY KEY AUTO_INCREMENT COMMENT '商品ID',
        `title`    VARCHAR(255) NOT NULL COMMENT '商品标题',
        `category` VARCHAR(32)  NOT NULL COMMENT '分类',
        `image`    VARCHAR(255) NOT NULL COMMENT '图片',
        `price`    INT(10)      NOT NULL COMMENT '价格'
    ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT '商品表';
    
    insert into goods values (1, '华为笔记本电脑', '华为', 'http://www.huawei.com/dn.jpg', 5388),
                             (2, '华为手机', '华为', 'http://www.huawei.com/sj.jpg', 5500),
                             (3, 'VIVO手机', 'vivo', 'http://www.vivo.com/sj.jpg', 3600);

2、引入mp相关依赖：

<dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

3、在application.yml中配置数据库：

spring:
      # 数据源配置
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql:///es-db?useSSL=false&serverTimezone=Asia/Shanghai
        username: root
        password: 123456
    
      # ES配置
      elasticsearch:
        rest:
          uris: http://192.168.150.123:9200 # 配置es服务器的地址

4、使用插件生成pojo、mappe、service基础代码

![在这里插入图片描述][4260dab903d4497c9d4975cb49ddcd3e.png]

1）数据源配置：

![在这里插入图片描述][59d9692b54d64e5e97b7d78eb1536b25.png]

2）使用代码生成器：

![在这里插入图片描述][709eabb9c8994bb998edda3617ab9668.png]

![在这里插入图片描述][5eea308dbbc74ff692320c56dad13bc4.png]

5、在启动类上配置mapper扫描：

package cn.aopmin;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @MapperScan("cn.aopmin.mapper") //mapper扫描
    @SpringBootApplication
    public class MyApp {
        
        public static void main(String[] args) {
        
            SpringApplication.run(MyApp.class, args);
        }
    }

##### 2.3.2 添加文档 #####

--------------------

package cn.aopmin.test;
    
    import cn.aopmin.pojo.Goods;
    import cn.aopmin.service.IGoodsService;
    import com.alibaba.fastjson.JSON;
    import org.elasticsearch.action.index.IndexRequest;
    import org.elasticsearch.action.index.IndexResponse;
    import org.elasticsearch.client.RequestOptions;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.junit.jupiter.api.Test;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import javax.annotation.Resource;
    import java.io.IOException;
    
    /**
     * @author 白豆五
     * @version 2023/07/23
     * @since JDK8
     */
    @SpringBootTest
    public class DocumentTest {
        
    
        @Resource
        private IGoodsService goodsService;
        @Resource
        private RestHighLevelClient client;
    
    
        /**
         * 测试创建文档
         */
        @Test
        public void testAddDocument() throws IOException {
        
            // 1.创建Request对象
            // IndexRequest: 创建文档的请求对象
            IndexRequest request = new IndexRequest("goods"); //指定索引库名称
            // 设置文档id,如果不设置的话，ES会自动生成一个唯一的字符串作为文档ID
            request.id("10");
    
            // 2.准备json文档数据
            // Java对象转JSON字符串
            String json = JSON.toJSONString(new Goods().setId(10L).setTitle("小辣椒手机").setCategory("小辣椒").setImage("https://xiaolajiao.cn").setPrice(1388));
            request.source(json, XContentType.JSON);
    
            // 3.发送请求创建文档
            IndexResponse response = client.index(request, RequestOptions.DEFAULT);
            // 输出结果
            System.out.println(response.getResult());
        }
    
    }

执行结果：  
![在这里插入图片描述][a2edb2fd22774dbbb64887a33cd27aca.png]![在这里插入图片描述][0b50e254d03b40f79ba163af56a6607f.png]

##### 2.3.3 修改文档 #####

--------------------

修改文档有两种方式：

*  全量修改：本质是先根据id删除，再新增（语法与插入文档类似）
 *  增量修改：修改文档中的指定字段值

/**
     * 测试修改文档
     */
    @Test
    public void testUpdateDocument() throws IOException {
        
        // 构建数据
        Goods goods = new Goods();
        goods.setPrice(999);
        String jsonString = JSON.toJSONString(goods);
    
        // 1.创建Request对象
        // UpdateRequest: 修改文档的请求对象。参数：索引库、文档id。如果文档id不存在，则会新增一个文档。
        UpdateRequest request = new UpdateRequest("goods", "10");
        // 2.准备Json文档,里面包含要修改的字段
        request.doc(jsonString, XContentType.JSON);
        // 3.发送请求
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        // 4.输出结果
        System.out.println(response.getResult());
    }

输出结果：

![在这里插入图片描述][97917c45072f42a8b89576df7e8ca4fa.png]  
![在这里插入图片描述][20d1a1f20f3048eb82d870424f711e5e.png]

##### 2.3.4 根据id查询文档 #####

--------------------

/**
     * 测试根据id查询文档
     */
    @Test
    public void testGetDocument() throws IOException {
        
        // 1.创建Request对象
        // DSL: GET /goods/_doc/10
        GetRequest request = new GetRequest("goods", "10");
        // 2.发送请求
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        // 3.输出文档内容
        System.out.println("_source: "+response.getSourceAsString());
    }

执行结果：

![在这里插入图片描述][18c8f7fed13d4218a5a4cea02c8c2bca.png]![在这里插入图片描述][087c0aaab37342579479655317503b0c.png]

##### 2.3.5 删除文档 #####

--------------------

/**
     * 测试根据id删除文档
     */
    @Test
    public void testDeleteDocument() throws IOException {
        
        // 1.创建Request对象
        // DSL: DELETE /goods/_doc/10
        DeleteRequest request = new DeleteRequest("goods", "10");
        // 2.发送请求
        client.delete(request, RequestOptions.DEFAULT);
    }

##### 2.3.6 批量新增 #####

--------------------

批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。

其中提供了一个add方法，用来添加其他Request请求：

*  IndexRequest，新增文档的请求
 *  UpdateRequest，修改文档的请求
 *  DeleteRequest，删除文档的请求

![在这里插入图片描述][17f718b356334f6e9f2fb44348a59dd2.png]

示例：将数据库中的数据添加到

/**
     * 测试批量新增
     */
    @Test
    public void testBulkAddDocument() throws IOException {
        
        // 准备数据
        List<Goods> goodsList = goodsService.list();
    
        // 1.创建Request对象
        // BulkRequest: 批量操作请求对象。可以批量执行增删改操作
        BulkRequest bulkRequest = new BulkRequest();
    
        // 2.准备参数：把多个IndexRequest添加到BulkRequest中
        goodsList.forEach(goods -> {
        
            //对象转Json字符串
            String json = JSON.toJSONString(goods);
            //创建单个请求对象
            /*
            IndexRequest request = new IndexRequest("goods");
            request.id(goods.getId().toString()); //文档id
            request.source(json, XContentType.JSON);//Josn文档内容
            bulkRequest.add(request);//放入批量请求对象中
            */
            // 简化写法
            bulkRequest.add(new IndexRequest("goods")
                    .id(goods.getId().toString())
                    .source(json, XContentType.JSON));
        });
    
        // 3.发送批处理请求
        BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
    }

![在这里插入图片描述][048ab318a0b24940a9b19bb9b35e68d0.png]  
批量新增操作步骤：

*  创建Request对象，这里是BulkRequest。
 *  准备参数。批处理的参数，把多个IndexRequest添加到BulkRequest中。
 *  发送批处理请求。调用的方法为client.bulk()方法。

stream流方式写法：

// 准备数据    
    List<Goods> goodsList = goodsService.list();    
      
    // 1.创建一个BulkRequest对象，用于批量操作请求，可以批量执行增删改操作    
    BulkRequest bulkRequest = new BulkRequest();    
     
    // 2.准备参数：把多个IndexRequest添加到BulkRequest中     
    // 使用Java 8的Stream API，将商品列表转化为包含IndexRequest对象的列表，并将其添加到BulkRequest中    
    bulkRequest.add(goodsList.stream()    
            .map(goods -> {
            
                // 将goods对象转化为Json字符串      
                String json = JSON.toJSONString(goods);    
                // 简化写法，创建IndexRequest对象并设置id和source     
                return new IndexRequest("goods")    
                        .id(goods.getId().toString())    
                        .source(json, XContentType.JSON);    
            })    
    	//收集成list集合  
            .collect(Collectors.toList()));  
      
    // 3.发送批处理请求，并将响应保存在response变量中    
    BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);

> 小节：

文档操作的基本步骤：

*  注入RestHighLevelClient对象
 *  创建XxxRequest。如 IndexRequest、GetRequest、UpdateRequest、DeleteRequest、BulkRequest
 *  准备参数（Index、Update、Bulk时需要提供）
 *  发送请求。调用RestHighLevelClient.xxx()方法，xxx是index、get、update、delete、bulk
 *  解析结果（Get时需要）

#### 2.4 高级查询 ####

--------------------

##### 2.4.1 查询所有文档 #####

--------------------

package cn.aopmin.test;
    
    import org.elasticsearch.action.search.SearchRequest;
    import org.elasticsearch.action.search.SearchResponse;
    import org.elasticsearch.client.RequestOptions;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.elasticsearch.search.SearchHit;
    import org.elasticsearch.search.SearchHits;
    import org.elasticsearch.search.builder.SearchSourceBuilder;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.io.IOException;
    
    /**
     * 高级查询
     *
     * @author 白豆五
     * @version 2023/07/24
     * @since JDK8
     */
    @SpringBootTest
    public class DSLTest {
        
    
        @Autowired
        private RestHighLevelClient restHighLevelClient;
    
        /**
         * 测试查询所有文档
         */
        @Test
        public void testMatchAll() throws IOException {
        
            // 1.构建SearchRequest对象
            SearchRequest searchRequest = new SearchRequest("my_index");
    
            // 2.创建一个SearchSourceBuilder对象,并设置查询条件
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.matchAllQuery());//matchAllQuery()查询所有
            // 设置查询条件
            searchRequest.source(searchSourceBuilder);
    
            // 3.发送请求,调用restHighLevelClient的search方法
            SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    
            // 4.解析响应结果
            // 从response对象中获取hits返回结果数据
            SearchHits responseHits = response.getHits();
            // 获取查询到的文档列表:hists[]
            SearchHit[] searchHits = responseHits.getHits();
            for (SearchHit searchHit : searchHits) {
        
                // 获取文档的原数据（json数据）
                String jsonData = searchHit.getSourceAsString();
                System.out.println(jsonData);
            }
        }
    }

返回结果：  
![在这里插入图片描述][4180c3e4918741fe938cef2acd7a1ad1.png]![在这里插入图片描述][247b6253429340bca5054b60e0c58c7c.png]

##### 2.4.2 匹配查询 #####

--------------------

/**
     * 测试匹配查询（全文检索，单字段）
     */
    @Test
    public void testMatch() throws IOException {
        
        // 1.构建SearchRequest对象
        SearchRequest searchRequest = new SearchRequest("goods");
    
        // 2.创建一个SearchSourceBuilder对象,并设置查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("title", "华为"));//matchQuery()匹配查询
        // 设置查询条件
        searchRequest.source(searchSourceBuilder);
    
        // 3.发送查询请求
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    
        // 4.解析响应结果
        // 从response对象中获取hits返回结果数据
        SearchHits responseHits = response.getHits();
        // 获取查询到的文档列表:hists[]
        SearchHit[] searchHits = responseHits.getHits();
        for (SearchHit searchHit : searchHits) {
        
            // 获取文档的原数据（json数据）
            String jsonData = searchHit.getSourceAsString();
            System.out.println(jsonData);
        }
    }

返回结果：  
![在这里插入图片描述][b25585cef5a943e39dcb47c919516a77.png]

##### 2.4.3 高亮查询 #####

--------------------

/**
     * 高亮查询
     */
    @Test
    public void testHighLight() throws IOException {
        
        // 1.构建SearchRequest对象
        SearchRequest searchRequest = new SearchRequest("goods");
    
        // 2.创建一个SearchSourceBuilder对象,并设置查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("title", "华为"));//matchQuery()匹配查询
    
        // 3.对searchSourceBuilder对象设置高亮参数
        HighlightBuilder highlighter = new HighlightBuilder();
        highlighter.field("title");//设置高亮字段
        highlighter.preTags("<em>");//设置高亮前缀
        highlighter.postTags("</em>");//设置高亮后缀
        searchSourceBuilder.highlighter(highlighter);
    
        // 4.设置查询条件
        searchRequest.source(searchSourceBuilder);
    
        // 5.发送查询请求
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    
        // 6.解析响应结果
        // 从response对象中获取hits返回结果数据
        SearchHits responseHits = response.getHits();
        // 获取查询到的文档列表:hists[]
        SearchHit[] searchHits = responseHits.getHits();
        for (SearchHit searchHit : searchHits) {
        
            // 获取文档数据
            String jsonData = searchHit.getSourceAsString();
            Goods goods = JSON.parseObject(jsonData, Goods.class);
    
            //  获取高亮数据
            Map<String, HighlightField> map = searchHit.getHighlightFields();
            if (map != null) {
        
                //获取高亮字段的值: 一个数组
                HighlightField highlightField = map.get("title");
                if (highlightField != null ) {
        
                    String title = highlightField.getFragments()[0].toString();
                    goods.setTitle(title);
                }
            }
            System.out.println(JSON.toJSONString(goods));
        }
    }

![在这里插入图片描述][9fd288137f864a0983803a761d235f09.png]![在这里插入图片描述][27cd629a17c34bf6a3ef262713a52a0a.png]

简化写法：

@Test
    public void testHighLight2() throws IOException {
        
        // 1.构建SearchRequest对象
        SearchRequest searchRequest = new SearchRequest("goods");
    
        // 2.准备DSL
         /*
        // 2.1设置查询条件
        searchRequest.source().query(QueryBuilders.matchQuery("title", "华为"));
        // 2.2设置高亮参数
        searchRequest.source().highlighter(new HighlightBuilder().field("title").preTags("<em>").postTags("</em>"));
        */
        searchRequest.source()
                // 设置查询条件
                .query(QueryBuilders.matchQuery("title", "华为"))
                // 设置高亮参数
                .highlighter(new HighlightBuilder().field("title").preTags("<em>").postTags("</em>"));
    
        // 3.发送查询请求
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    
        // 4.解析响应结果
        // 从response对象中获取hits返回结果数据
        SearchHits responseHits = response.getHits();
        // 获取查询到的文档数组:hists[]
        SearchHit[] searchHits = responseHits.getHits();
        // 4.1获取总条数
        long total = searchHits.length;
        System.out.println("共搜索到" + total + "条数据");
    
        for (SearchHit searchHit : searchHits) {
        
            // 4.2获取文档数据（_source）
            String jsonData = searchHit.getSourceAsString();
            Goods goods = JSON.parseObject(jsonData, Goods.class);
    
            // 4.3获取高亮数据
            Map<String, HighlightField> map = searchHit.getHighlightFields();
            if (map != null) {
        
                //根据字段名获取高亮结果
                HighlightField highlightField = map.get("title");
                if (highlightField != null) {
        
                    // 获取高亮值
                    String title = highlightField.getFragments()[0].toString();
                    // 覆盖内容
                    goods.setTitle(title);
                }
            }
            System.out.println(JSON.toJSONString(goods));
        }
    }

![在这里插入图片描述][06ca6a5121be4a3eb0641497198a7195.png]

这里面有两个关键的API，一个是`request.source()`，提供了查询、排序、分页、高亮等功能：

![在这里插入图片描述][f460e5fa905141a7b9a443560929831f.png]

另一个是`QueryBuilders`工具类，可以进行match、term、function\_score、bool等查询：  
![在这里插入图片描述][151364a4890041b384e52d0c10821675.png]

##### 2.4.4 聚合查询 #####

--------------------

/**
     * 测试聚合查询
     */
    @Test
    public void testAggs() throws IOException {
        
        // 1.创建Request对象
        SearchRequest request = new SearchRequest("goods");
        // 2.准备DSL
        // 2.1设置查询条件
        request.source().query(QueryBuilders.matchQuery("title", "华为"))
                .size(0) //不需要返回文档数据，只需要返回聚合结果
                // 2.2设置聚合参数
                .aggregation(AggregationBuilders.terms("group_category").field("category")) //根据category字段进行分组
                .aggregation(AggregationBuilders.avg("avg_price").field("price"));//根据price字段求平均值
    
        // 3.发起请求，获取响应结果
        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
        // 4.解析响应结果
        // 4.1获取聚合结果,Map<String, Aggregation>
        Aggregations aggregations = response.getAggregations();
        // 4.2获取group_category子聚合数据
        Terms terms = aggregations.get("group_category");
        terms.getBuckets().forEach(bucket -> {
        
            System.out.println("key:" + bucket.getKeyAsString());
            System.out.println("docCount:" + bucket.getDocCount());
        });
    
        // 4.3获取avg_price子聚合数据
        Avg avg = aggregations.get("avg_price");
        System.out.println("avg_price:" + avg.getValue());
    }

输出结果：

![在这里插入图片描述][10f19f6898704490a00ec1ca87ee4fb9.png]![在这里插入图片描述][c07a6e503cb947069f301bab8a67aa53.png]

### 3. 使用Spring Data Elasticsearch 操作ES ###

--------------------

> ElasticsearchRestTemplate是Spring Data Elasticsearch框架提供的API。

#### 3.1 Spring Data概述 ####

--------------------

Spring Data是Spring家族的一个子项目，其目的：用于简化持久层的开发（如 关系型数据库、非关系型数据库、索引库的访问），并且它提供统一的API以访问各种数据存储技术。

Spring Data可以极大的简化JPA（Java Persistence API，Java持久层API）的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD外，还包括如分页、排序等一些常用的功能。

SpringData提供了一些XxxTemplate对象，用于简化各种数据库的操作，如：

*  JdbcTemplate：JdbcTemplate是Spring Data对关系型数据库（如MySQL、Oracle等）进行操作的模板对象。它提供了一组方法，用于执行SQL语句、处理结果集、事务管理等。
 *  MongoTemplate：MongoTemplate是Spring Data对MongoDB进行操作的模板对象。它提供了一组方法，用于执行CRUD操作、查询、更新等。
 *  RedisTemplate：RedisTemplate是Spring Data对Redis进行操作的模板对象。它提供了一组方法，用于执行常见的Redis操作，如存储、获取、删除数据等。
 *  ElasticsearchRestTemplate：ElasticsearchRestTemplate是Spring Data对Elasticsearch进行操作的模板对象。它提供了一组方法，用于执行CRUD操作、搜索、聚合等。  
    ![在这里插入图片描述][f684885096e743038efa743d6b378f0a.png]

#### 3.2 Spring Data Elasticsearch 概述 ####

--------------------

Spring Data Elasticsearch基于Spring Data API对Elasticsearch进行了封装，使开发者能够更高效地使用Elasticsearch进行数据存储和搜索。

**Spring Data Elasticsearch版本选择：**（不同版本会存在差异）  
![在这里插入图片描述][bc4016be35ea415c8a4810ba56e257d2.png]

springboot2.3.x版本可以兼容elasticsearch7.x版本。

#### 3.3 环境准备 ####

--------------------

1、创建maven项目

2、导入依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>cn.aopmin</groupId>
        <artifactId>SpringDataElasticsearch-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.10.RELEASE</version>
            <relativePath/> 
        </parent>
    
        <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </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-test</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.80</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <excludes>
                            <exclude>
                                <groupId>org.projectlombok</groupId>
                                <artifactId>lombok</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

3、创建启动类：

package cn.aopmin;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class SpringDataElasticsearchApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(SpringDataElasticsearchApplication.class, args);
        }
    }

4、在application.yml中配ES:

spring:
      elasticsearch:
        rest:
          uris: http://192.168.150.123:9200 # 配置es服务器的地址

5、创建实体类：（通过注解与es进行绑定）

package cn.aopmin.pojo;
    
    import lombok.Data;
    import org.springframework.data.annotation.Id;
    import org.springframework.data.elasticsearch.annotations.Document;
    import org.springframework.data.elasticsearch.annotations.Field;
    import org.springframework.data.elasticsearch.annotations.FieldType;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Document(indexName = "product", // 索引库名称
            shards = 1, // 主分片个数
            replicas = 1 // 备份分片个数
    )
    public class Product {
        
    
        /**
         * 主键id
         */
        // ES主键id
        @Id
        private Long id;
    
        /**
         * 商品名称
         */
        // ES普通字段
        @Field(type = FieldType.Text, // 字段类型
                analyzer = "ik_max_word", // 建立索引用的分词器
                searchAnalyzer = "ik_smart", //查询时用的分词器
                store = true // 是否额外存储一份 （ES默认把文档字段存储在源文档_source中）
        )
        private String productName;
    
        /**
         * 库存数量
         */
        @Field(type = FieldType.Integer, store = true)
        private Integer store;
    
        /**
         * 价格
         */
        @Field(type = FieldType.Double, store = true)
        private Double price;
    }

注解含义：

1）@Document：作用在类，标记实体类为文档对象，一般有三个属性：

*  indexName：对应索引库名称
 *  shards：分片数量
 *  replicas：副本数量

2）@Id：作用在成员变量，标记一个字段作为id主键。

3）@Field：作用在成员变量，标记为文档的字段，并指定字段映射属性：

*  type：字段类型，取值是枚举：FieldType.xxx
 *  index：是否建立索引，布尔类型，默认是true
 *  store：是否存储，布尔类型，默认是false 不额外存储一份 （场景：只返回某个特定字段，此时可以提高查询效率。但是对写入效率会有影响）
 *  analyzer：分词器名称：ik\_max\_word（建立倒排索引时所使用的分词算法）

store 的意思是：是否在 _source 之外在独立存储一份（提高查询效率，对写入会有点影响）
    _source 表示源文档，当你索引数据的时候， elasticsearch 会保存一份源文档到 _source ，
    如果文档的某一字段设置了 store 为 yes (默认为 no)，这时候会在 _source 存储之外再为这个字段独立进行存储。
    
    这么做的目的主要是针对内容比较多的字段，放到 _source 返回的话，因为_source 是把所有字段保存为一份文档，命中后读取只需要一次 IO，包含内容特别多的字段会很占带宽影响性能。
    通常我们也不需要完整的内容返回(可能只关心某个字段)，这时候就没必要放到 _source 里一起返回了(当然也可以在查询时指定返回字段)。

6、测试

@SpringBootTest
    public class SpringDataElasticsearchTest {
        
    
        @Autowired
        private ElasticsearchRestTemplate elasticsearchRestTemplate;
    
        @Test
        public void test() {
        
            System.out.println(elasticsearchRestTemplate);
        }
    }

![在这里插入图片描述][7a47a4c5d8a94b19a5313b0a0c614428.png]

#### 3.4 使用ElasticsearchRestTemplate操作ES ####

--------------------

ElasticsearchRestTemplate是Spring Data Elasticsearch中所提供的一个操作ES的核心类，并且已经被Spring Boot实现了自动化配置。

ElasticsearchRestTemplate模板对象常用方法：

*  createIndex：创建索引
 *  deleteIndex：删除索引
 *  save：添加文档
 *  get：根据文档ID获取文档
 *  update：更新文档
 *  delete：根据文档ID删除文档
 *  search：执行查询操作
 *  exists：检查文档是否存在
 *  count：统计文档数量

##### 3.4.1 添加文档 #####

--------------------

package cn.aopmin.test;
    
    import cn.aopmin.pojo.Product;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
    
    /**
     * 测试使用ElasticsearchRestTemplate操作ES
     * @author 白豆五
     * @version 2023/07/25
     * @since JDK8
     */
    @SpringBootTest
    public class SpringDataElasticsearchTest {
    
        @Autowired
        private ElasticsearchRestTemplate elasticsearchRestTemplate;
    
        /**
         * 测试添加文档
         */
        @Test
        public void testAddDocument() {
            // 构造数据
            Product product = new Product();
            product.setId(1L);
            product.setProductName("华为手机");
            product.setStore(100);
            product.setPrice(5000.00);
    
            // 添加文档
            // 注意:不用提提前创建索引，Spring Data ES会根据实体类映射关系自动创建索引库
            elasticsearchRestTemplate.save(product);
        }
    }

![在这里插入图片描述][8a00ec3dbbbd4036bc9411a21867d855.png]

##### 3.4.2 根据ID查询文档 #####

--------------------

![在这里插入图片描述][121a14436d7b40bbaaa5c08ec2e89361.png]

/**
     * 测试查询文档
     */
    @Test
    public void testGetDocument() {
        
        // 查询文档
        // get方法:需要指定文档id和文档所在索引库的类型_class
        Product product = elasticsearchRestTemplate.get("1", Product.class);
        System.out.println(product);
    }

![在这里插入图片描述][205adce2a99643e094202fb06a3484b8.png]

##### 3.4.3 修改文档 #####

--------------------

/**
     * 测试修改文档
     */
    @Test
    public void testUpdateDocument() {
        
        // 准备数据
        Document document = Document.create();
        document.put("price", 1899);
    
        // 构造一个更新对象UpdateQuery
        // 参数1:文档id
        // 参数2:修改的文档数据
        UpdateQuery updateQuery = UpdateQuery.builder("1").withDocument(document).build();
    
        // 修改文档
        // 参数1:updateQuery对象
        // 参数2:指定文档所在的索引库
        elasticsearchRestTemplate.update(updateQuery, IndexCoordinates.of("product"));
    }

![在这里插入图片描述][ac5de477c6864b2eb89fedb791aa1ddf.png]

##### 3.4.4 删除文档 #####

--------------------

/**
     * 测试删除文档
     */
    @Test
    public void testDeleteDocument() {
        
        // 删除文档
        // delete方法:需要指定文档id和文档类型
        elasticsearchRestTemplate.delete("1", Product.class);
    }

![在这里插入图片描述][c9ec7a63b662459d83ae7ea795bdb5e0.png]

##### 3.4.5 查询所有文档 #####

--------------------

/**
     * 测试查询所有文档
     */
    @Test
    public void testMachAll() {
        
    
        // 构造NativeSearchQuery对象，封装查询条件
        NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery()).build();
    
        // 调用search方法进行查询,返回List<SearchHit<T>>
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(nativeSearchQuery, Product.class);
        List<SearchHit<Product>> list = searchHits.getSearchHits(); //get方法
        
        // 遍历文档
        // for (SearchHit<Product> hit : list) {
        
        //     Product product = hit.getContent();
        //     System.out.println(product);
        // }
        searchHits.stream().forEach(hit -> System.out.println(hit.getContent()));
    }

![在这里插入图片描述][9910ea8fdb0146959a6c45db1d385195.png]

![在这里插入图片描述][b0aa941fdb3044ebacbbd34424381cc2.png]

##### 3.4.6 高亮查询 #####

--------------------

/**
     * 测试高亮查询
     */
    @Test
    public void testHighlight() {
        
        // 构造高亮参数
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("productName"); // 设置高亮字段
        highlightBuilder.preTags("<em>"); // 设置高亮字段的前缀
        highlightBuilder.postTags("</em>"); // 设置高亮字段的后缀
    
    
        // 创建NativeSearchQuery对象，封装查询条件
        NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchQuery("productName", "华为"))
                .withHighlightBuilder(highlightBuilder) // 设置高亮参数
                .build();
    
        // 调用search方法进行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(nativeSearchQuery, Product.class);
    
        // 遍历操作
        searchHits.stream().forEach(productSearchHit -> System.out.println(productSearchHit));
    }

![在这里插入图片描述][210c5a9cb573406d8c741ec4c033a4ab.png]

##### 3.4.7 分页查询 #####

--------------------

/**
     * 测试分页查询
     */
    @Test
    public void testPage() {
        
        // 构造NativeSearchQuery对象，封装查询条件
        NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery())
                .withPageable(PageRequest.of(0, 2)) // 设置分页参数
                .build();
    
        // 调用search方法进行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(nativeSearchQuery, Product.class);
    
        // 遍历操作
        searchHits.stream().forEach(productSearchHit -> System.out.println(productSearchHit));
    }

##### 3.4.8 聚合查询 #####

--------------------

1、向Product实体类中添加新字段，类型设置为keyword(完整的单词，不进行分词)：

/**
     * 分类
     */
    @Field(type = FieldType.Keyword)
    private String category;

2、在kibana中执行DSL命令删除索引库：DELETE /product

3、添加数据

/**
     * 测试批量插入数据
     */
    @Test
    public void testBulkAddDocument() {
        
        // 准备数据
        Product product1 = new Product(1L, "华为手机", 200, 2000.00, "华为");
        Product product2 = new Product(2L, "华为笔记本电脑", 100, 5699.00, "华为");
        Product product3 = new Product(3L, "VIVO手机", 200, 3600.00, "vivo");
    
        // 构造IndexQuery对象
        List<IndexQuery> indexQueryList = new ArrayList<IndexQuery>();
        indexQueryList.add(new IndexQueryBuilder().withObject(product1).build());
        indexQueryList.add(new IndexQueryBuilder().withObject(product2).build());
        indexQueryList.add(new IndexQueryBuilder().withObject(product3).build());
    
        // 批量添加文档
        elasticsearchRestTemplate.createIndex(Product.class); // 创建索引库
        elasticsearchRestTemplate.putMapping(Product.class); // 创建映射关系
        elasticsearchRestTemplate.bulkIndex(indexQueryList, IndexCoordinates.of("product"));
    }

![在这里插入图片描述][5ef65eac6acc4c78a697fa31a1e043a1.png]

4、聚合查询（terms、sum）

/**
     * 测试聚合查询
     */
    @Test
    public void testAggs() {
        
        // 构造聚合查询对象
        AbstractAggregationBuilder aggregationBuilder = AggregationBuilders
                // 分组查询,size=2表示查询前两个分组
                .terms("group_category").field("category").size(2)
                // 子聚合查询
                .subAggregation(AggregationBuilders.sum("sum_price").field("price"));
    
        // 构造NativeSearchQuery条件查询对象
        NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery()) // 设置查询条件
                .addAggregation(aggregationBuilder) // 设置聚合查询参数
                // 各种查询条件....
                .build();
    
        // 调用search方法进行查询
        SearchHits<Product> searchHits = elasticsearchRestTemplate.search(nativeSearchQuery, Product.class);
        // 解析聚合结果
        Aggregations aggregations = searchHits.getAggregations();
        // 根据名称获取聚合结果
        Terms terms = aggregations.get("group_category");
        // 获取桶
        List<? extends Terms.Bucket> buckets = terms.getBuckets();
        // 遍历
        for (Terms.Bucket bucket : buckets) {
        
            //  获取分组的key
            String key = bucket.getKeyAsString();
            // 获取文档数量
            long docCount = bucket.getDocCount();
            //获取子聚合结果
            Sum sumPrice = bucket.getAggregations().get("sum_price");
            double value = sumPrice.getValue();
    
            System.out.println("分组名称: " + key);
            System.out.println("文档个数: " + docCount);
            System.out.println("总价格: " + value);
            System.out.println("----------------------");
    
        }
    }

![在这里插入图片描述][8260d41d9f004cad8beb84dd52e37635.png]![在这里插入图片描述][fbc0ac386fba4e718e6c23c555b7ef81.png]

#### 3.5 使用ElasticsearchRepository接口操作ES ####

--------------------

ElasticsearchRepository接口常用方法：

*  保存单个文档：`void save(T entity)`
 *  保存多个文档：`Iterable<T> saveAll(Iterable<T> entities)`
 *  根据 ID 获取文档：`Optional<T> findById(String id)`
 *  判断文档是否存在：`Boolean existsById(String id)`
 *  获取所有文档：`Iterable<T> findAll()`
    
     *  方法参数：Sort ：自定义排序
     *  方法参数：Pageable：分页对象
 *  获取多个ID 的文档：`Iterable<T> findAllById(Iterable<String> ids)`
 *  获取文档数量：`long count()`
 *  删除单个文档：`void deleteById(String id)`
 *  删除多个文档：`void deleteAll(Iterable<? extends T> entities)`
 *  删除所有文档：`void deleteAll()`
 *  条件查询：`search()`

定义持久层接口：

package cn.aopmin.dao;
    
    import cn.aopmin.pojo.Product;
    import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
    import org.springframework.stereotype.Repository;
    
    /**
     * 自定义接口去继承ElasticsearchRepository接口，实现对ES的操作
     * ElasticsearchRepository<Product, Long>  Product:实体类 Long:主键类型
     */
    @Repository
    public interface ProductRepository extends ElasticsearchRepository<Product, Long> {
        
    
    }

示例1：根据文档id查文档（findById）

package cn.aopmin.test;
    
    import cn.aopmin.dao.ProductRepository;
    import cn.aopmin.pojo.Product;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.util.Optional;
    
    /**
     * 测试ElasticsearchRepository接口
     * @author 白豆五
     * @version 2023/07/25
     * @since JDK8
     */
    @SpringBootTest
    public class ElasticsearchRepositoryTest {
        
    
        @Autowired
        private ProductRepository productRepository; //自定义持久层接口
    
        /**
         * 测试根据id查询文档
         */
        @Test
        public void test() {
        
            Optional<Product> optional = productRepository.findById(1L);
            Product product = optional.get();
            System.out.println(product);
        }
    }

![在这里插入图片描述][23fc05060502465988c8b86577623729.png]

示例2：查询所有（findAll）

/**
     * 测试查询所有文档
     */
    @Test
    public void testFindAll() {
        
        // 查询所有文档
        Iterable<Product> iterable = productRepository.findAll();
        //  遍历迭代器对象
        for (Product product : iterable) {
        
            System.out.println(product);
        }
    
        System.out.println("====================================");
    
        // 查询所有,对查询结果按照price字段进行排序
        Iterable<Product> iterable2 = productRepository.findAll(Sort.by(Sort.Direction.DESC, "price"));
        iterable2.forEach(System.out::println);
    }

![在这里插入图片描述][8677ffba355e463fa853f3d90ab8d59a.png]

示例3：条件查询（调用search方法，通过QueryBuilders构建查询条件）

/**
     * 测试条件查询
     */
    @Test
    public void testMatchAll(){
        
        Iterable<Product> iterable = productRepository.search(QueryBuilders.matchAllQuery());
        iterable.forEach(System.out::println);
    }

![在这里插入图片描述][af4383b738984d60949145ac1ef107a6.png]

示例4：分页查询

/**
     * 测试分页查询
     */
    @Test
    public void testPage() {
        
    
        // 分页对象
        Pageable Pageable = PageRequest.of(0, 2);
        
        // 分页查询
        // productRepository.search(QueryBuilders.matchAllQuery(), Pageable);
        Page<Product> page = productRepository.findAll(Pageable);
    
        // 获取总记录数
        System.out.println("total:" + page.getTotalElements());
    
        // 获取当前页码
        System.out.println("当前页码:" + (page.getNumber() + 1));
        // 获取总页数
        System.out.println("总页数:" + page.getTotalPages());
        // 获取当前页数据
        page.forEach(System.out::println);
    }

![在这里插入图片描述][3f7a59891b794e37a762e7a9b906233d.png]

示例5：自定义查询方法（findByXxx）

Spring Data 支持自定义查询方法，但是方法命名需要遵循一定的命名规范，这样SpringData框架才会根据方法名自动实现相关查询操作。

比如：findByName，表示根据字段name进行查询，它会自动帮你完成，无需写实现类。

方法命名规范：（参考：https://blog.csdn.net/hzj\_java/article/details/118096157）

![在这里插入图片描述][6ce2db1196b7404a8122b21cd130f57e.png]

① 在持久层接口中定义方法(方法名会自动提示)

@Repository
    public interface ProductRepository extends ElasticsearchRepository<Product, Long> {
        
        // 查询指定价格区间的文档
        public Iterable<Product> findByPriceBetween(Double begin, Double end);
    }

②测试

/**
     * 测试自定义查询
     */
    @Test
    public void testFindByPriceBetween() {
        
        Iterable<Product> iterable = productRepository.findByPriceBetween(1000.0, 3000.0);
        iterable.forEach(System.out::println);
    }

![在这里插入图片描述][efa4b62a52684ce7b5b856048cc2adbd.png]

> 小节：

操作es有两种技术方案：

方案一：使用原生API（RestHighLevelClient），可以更灵活地操作Elasticsearch。（底层代码）

方案二：使用Spring Data Elasticsearch，可以通过ElasticsearchRestTemplate和ElasticsearchRepository 接口操作ES。

*  ElasticsearchRestTemplate
 *  ElasticsearchRepository 接口
    
     *  使用默认的crud方法
     *  自定义查询方法 findByXxx

[920cf7a65f621d257c14f01976c30679.jpeg_pic_center]: https://img-blog.csdnimg.cn/img_convert/920cf7a65f621d257c14f01976c30679.jpeg#pic_center
[aee5ed04ae87454fa3f86e8d11ccb352.png]: https://img-blog.csdnimg.cn/aee5ed04ae87454fa3f86e8d11ccb352.png
[a058022e3eb54a84bfba2962d3c4ed48.png]: https://img-blog.csdnimg.cn/a058022e3eb54a84bfba2962d3c4ed48.png
[1264df6bfbc34ed2a8b630e7210312df.png]: https://img-blog.csdnimg.cn/1264df6bfbc34ed2a8b630e7210312df.png
[4d6516ae01aa4653aca63f0a00b9cfb9.png]: https://img-blog.csdnimg.cn/4d6516ae01aa4653aca63f0a00b9cfb9.png
[54c10100b40d447daa5bcc4507bbcf65.png]: https://img-blog.csdnimg.cn/54c10100b40d447daa5bcc4507bbcf65.png
[e745a65de2494f04bec194b226401e23.png]: https://img-blog.csdnimg.cn/e745a65de2494f04bec194b226401e23.png
[28ced553c476406f96250af387b58ae3.png]: https://img-blog.csdnimg.cn/28ced553c476406f96250af387b58ae3.png
[22491441bb05457c93f9f82a73a385dc.png]: https://img-blog.csdnimg.cn/22491441bb05457c93f9f82a73a385dc.png
[760df4bbb3654f11b027a981883417ec.png]: https://img-blog.csdnimg.cn/760df4bbb3654f11b027a981883417ec.png
[34ecba8ef0784ed7b960b5a46e8a7cbb.png]: https://img-blog.csdnimg.cn/34ecba8ef0784ed7b960b5a46e8a7cbb.png
[74387f8064d1455f8bed67c187006ad1.png]: https://img-blog.csdnimg.cn/74387f8064d1455f8bed67c187006ad1.png
[4d8e08013a5c486390e5301b6dc84a07.png]: https://img-blog.csdnimg.cn/4d8e08013a5c486390e5301b6dc84a07.png
[48251c2ed4a24a14a80690c67a6b837e.png]: https://img-blog.csdnimg.cn/48251c2ed4a24a14a80690c67a6b837e.png
[0674ca7a590a4460b38b970b70e48348.png]: https://img-blog.csdnimg.cn/0674ca7a590a4460b38b970b70e48348.png
[eae39109a445434eb082710efbeedbab.png]: https://img-blog.csdnimg.cn/eae39109a445434eb082710efbeedbab.png
[f8b123b51b70408fa91bc46749d5b26f.png]: https://img-blog.csdnimg.cn/f8b123b51b70408fa91bc46749d5b26f.png
[05b6fdc4d71343d58371971afdceaa67.png]: https://img-blog.csdnimg.cn/05b6fdc4d71343d58371971afdceaa67.png
[306292a809d9436fade4c48eb23e6c99.png]: https://img-blog.csdnimg.cn/306292a809d9436fade4c48eb23e6c99.png
[bcb09b0de1e14a8bb82ba02745595c6a.png]: https://img-blog.csdnimg.cn/bcb09b0de1e14a8bb82ba02745595c6a.png
[38827c6cc33c43c3aea3878217a5640c.png]: https://img-blog.csdnimg.cn/38827c6cc33c43c3aea3878217a5640c.png
[2e0ce5d2e6a94f67b92e54a99ea68452.png]: https://img-blog.csdnimg.cn/2e0ce5d2e6a94f67b92e54a99ea68452.png
[d000726aed27446bb0f2e71ce8ffd6c6.png]: https://img-blog.csdnimg.cn/d000726aed27446bb0f2e71ce8ffd6c6.png
[a6466d2eebde46168fb746a536043420.png]: https://img-blog.csdnimg.cn/a6466d2eebde46168fb746a536043420.png
[46b40177643b48769404327e3ceacf48.png]: https://img-blog.csdnimg.cn/46b40177643b48769404327e3ceacf48.png
[c11c53cd7c0449a98969d179c1a0c27d.png]: https://img-blog.csdnimg.cn/c11c53cd7c0449a98969d179c1a0c27d.png
[50c5e586edcc4312aa0e6c23b3aa13bf.png]: https://img-blog.csdnimg.cn/50c5e586edcc4312aa0e6c23b3aa13bf.png
[edb76b0217804893b347dff753cefaba.png]: https://img-blog.csdnimg.cn/edb76b0217804893b347dff753cefaba.png
[17c997c182734f669b36889c5bc45ff1.png]: https://img-blog.csdnimg.cn/17c997c182734f669b36889c5bc45ff1.png
[0a7203c321214366b050ce6f868f8373.png]: https://img-blog.csdnimg.cn/0a7203c321214366b050ce6f868f8373.png
[1ba7e099b5284e4cadf99ebef98b7e46.png]: https://img-blog.csdnimg.cn/1ba7e099b5284e4cadf99ebef98b7e46.png
[3371bb35db2b40638a54caaf080a495b.png]: https://img-blog.csdnimg.cn/3371bb35db2b40638a54caaf080a495b.png
[f7d2aa61239a493bad40a0f4261297a0.png]: https://img-blog.csdnimg.cn/f7d2aa61239a493bad40a0f4261297a0.png
[9eb15a3a83ce45cea4727380e8f7e22f.png]: https://img-blog.csdnimg.cn/9eb15a3a83ce45cea4727380e8f7e22f.png
[1c3dfe41b5c642e095ffb28b047c00d2.png]: https://img-blog.csdnimg.cn/1c3dfe41b5c642e095ffb28b047c00d2.png
[180a7b316baf468e9b0f4c2f79bceb89.png]: https://img-blog.csdnimg.cn/180a7b316baf468e9b0f4c2f79bceb89.png
[5bfecca2c5464eb6978ffffeaffc2c66.png]: https://img-blog.csdnimg.cn/5bfecca2c5464eb6978ffffeaffc2c66.png
[a65bb6ffa11045c1acfb365ee70d47ca.png]: https://img-blog.csdnimg.cn/a65bb6ffa11045c1acfb365ee70d47ca.png
[ceb8eab9e838468084803bbf85779306.png]: https://img-blog.csdnimg.cn/ceb8eab9e838468084803bbf85779306.png
[1de02bb7a8204c8ea27f9f3a0e569bdb.png]: https://img-blog.csdnimg.cn/1de02bb7a8204c8ea27f9f3a0e569bdb.png
[6b608e9e7d9f4bacb7bfbf5ef9750822.png]: https://img-blog.csdnimg.cn/6b608e9e7d9f4bacb7bfbf5ef9750822.png
[d26630dc18824d5d8f586ab6fd832569.png]: https://img-blog.csdnimg.cn/d26630dc18824d5d8f586ab6fd832569.png
[4502ae2c70924ca6a808bb5bdd691af5.png]: https://img-blog.csdnimg.cn/4502ae2c70924ca6a808bb5bdd691af5.png
[c8a7da6330e6425481c69777fb9caee4.png]: https://img-blog.csdnimg.cn/c8a7da6330e6425481c69777fb9caee4.png
[67991978532b41db988ccab478ec4bde.png]: https://img-blog.csdnimg.cn/67991978532b41db988ccab478ec4bde.png
[f52b133b053f48679d9ac6b3cde199ac.png]: https://img-blog.csdnimg.cn/f52b133b053f48679d9ac6b3cde199ac.png
[74372587b99841cebcaa154e4df1c5d6.png]: https://img-blog.csdnimg.cn/74372587b99841cebcaa154e4df1c5d6.png
[3b0776366a6b472cac2e5e85d8e0ad25.png]: https://img-blog.csdnimg.cn/3b0776366a6b472cac2e5e85d8e0ad25.png
[5be60ade086443d5a1e0cd4dde7770a7.png]: https://img-blog.csdnimg.cn/5be60ade086443d5a1e0cd4dde7770a7.png
[3497957ed3984c3fbe2a9b92d704ddde.png]: https://img-blog.csdnimg.cn/3497957ed3984c3fbe2a9b92d704ddde.png
[81ed6fca07b742f39d0756bacb5fbff3.png]: https://img-blog.csdnimg.cn/81ed6fca07b742f39d0756bacb5fbff3.png
[8c0192421bfd427f9381fd2a9ed4d5c8.png]: https://img-blog.csdnimg.cn/8c0192421bfd427f9381fd2a9ed4d5c8.png
[28d75ef0df7e4e9484cbfc458e9675f5.png]: https://img-blog.csdnimg.cn/28d75ef0df7e4e9484cbfc458e9675f5.png
[1c4de3e9e0d844ed8d69b375402132ee.png]: https://img-blog.csdnimg.cn/1c4de3e9e0d844ed8d69b375402132ee.png
[9d2bcc116062417fb6e59294d78cc77a.png]: https://img-blog.csdnimg.cn/9d2bcc116062417fb6e59294d78cc77a.png
[a7662bf893654d90b6543fc8b00f659d.png]: https://img-blog.csdnimg.cn/a7662bf893654d90b6543fc8b00f659d.png
[b617cea44418438c8c66f27255d0c1fe.png]: https://img-blog.csdnimg.cn/b617cea44418438c8c66f27255d0c1fe.png
[7d8568b079564837b9858c0cafce4a49.png]: https://img-blog.csdnimg.cn/7d8568b079564837b9858c0cafce4a49.png
[53b25add2fe840c6b610f60efef3d6d4.png]: https://img-blog.csdnimg.cn/53b25add2fe840c6b610f60efef3d6d4.png
[605d021d20ec4040bfd0e6cc6bc513d8.png]: https://img-blog.csdnimg.cn/605d021d20ec4040bfd0e6cc6bc513d8.png
[bd80030badee4bc3921c54386f40c444.png]: https://img-blog.csdnimg.cn/bd80030badee4bc3921c54386f40c444.png
[abe629c0e6cc461aa5ab7554ef5fb1a3.png]: https://img-blog.csdnimg.cn/abe629c0e6cc461aa5ab7554ef5fb1a3.png
[39bf3d156eba49758d30b735d538301d.png]: https://img-blog.csdnimg.cn/39bf3d156eba49758d30b735d538301d.png
[dcf43e6f459a4680b0b48c54d5aef550.png]: https://img-blog.csdnimg.cn/dcf43e6f459a4680b0b48c54d5aef550.png
[1686434a9b23447f885e6c1bdaf50937.png]: https://img-blog.csdnimg.cn/1686434a9b23447f885e6c1bdaf50937.png
[99b1339b84f04ee7a8d0ea1a20b5ab64.png]: https://img-blog.csdnimg.cn/99b1339b84f04ee7a8d0ea1a20b5ab64.png
[5215e87723a74c2c93be7ac680d8e535.png]: https://img-blog.csdnimg.cn/5215e87723a74c2c93be7ac680d8e535.png
[c94dbd4c034f4b4b9c2477facd8e39a1.png]: https://img-blog.csdnimg.cn/c94dbd4c034f4b4b9c2477facd8e39a1.png
[bc7a3372025442bea13cfdd0dfb9d619.png]: https://img-blog.csdnimg.cn/bc7a3372025442bea13cfdd0dfb9d619.png
[4260dab903d4497c9d4975cb49ddcd3e.png]: https://img-blog.csdnimg.cn/4260dab903d4497c9d4975cb49ddcd3e.png
[59d9692b54d64e5e97b7d78eb1536b25.png]: https://img-blog.csdnimg.cn/59d9692b54d64e5e97b7d78eb1536b25.png
[709eabb9c8994bb998edda3617ab9668.png]: https://img-blog.csdnimg.cn/709eabb9c8994bb998edda3617ab9668.png
[5eea308dbbc74ff692320c56dad13bc4.png]: https://img-blog.csdnimg.cn/5eea308dbbc74ff692320c56dad13bc4.png
[a2edb2fd22774dbbb64887a33cd27aca.png]: https://img-blog.csdnimg.cn/a2edb2fd22774dbbb64887a33cd27aca.png
[0b50e254d03b40f79ba163af56a6607f.png]: https://img-blog.csdnimg.cn/0b50e254d03b40f79ba163af56a6607f.png
[97917c45072f42a8b89576df7e8ca4fa.png]: https://img-blog.csdnimg.cn/97917c45072f42a8b89576df7e8ca4fa.png
[20d1a1f20f3048eb82d870424f711e5e.png]: https://img-blog.csdnimg.cn/20d1a1f20f3048eb82d870424f711e5e.png
[18c8f7fed13d4218a5a4cea02c8c2bca.png]: https://img-blog.csdnimg.cn/18c8f7fed13d4218a5a4cea02c8c2bca.png
[087c0aaab37342579479655317503b0c.png]: https://img-blog.csdnimg.cn/087c0aaab37342579479655317503b0c.png
[17f718b356334f6e9f2fb44348a59dd2.png]: https://img-blog.csdnimg.cn/17f718b356334f6e9f2fb44348a59dd2.png
[048ab318a0b24940a9b19bb9b35e68d0.png]: https://img-blog.csdnimg.cn/048ab318a0b24940a9b19bb9b35e68d0.png
[4180c3e4918741fe938cef2acd7a1ad1.png]: https://img-blog.csdnimg.cn/4180c3e4918741fe938cef2acd7a1ad1.png
[247b6253429340bca5054b60e0c58c7c.png]: https://img-blog.csdnimg.cn/247b6253429340bca5054b60e0c58c7c.png
[b25585cef5a943e39dcb47c919516a77.png]: https://img-blog.csdnimg.cn/b25585cef5a943e39dcb47c919516a77.png
[9fd288137f864a0983803a761d235f09.png]: https://img-blog.csdnimg.cn/9fd288137f864a0983803a761d235f09.png
[27cd629a17c34bf6a3ef262713a52a0a.png]: https://img-blog.csdnimg.cn/27cd629a17c34bf6a3ef262713a52a0a.png
[06ca6a5121be4a3eb0641497198a7195.png]: https://img-blog.csdnimg.cn/06ca6a5121be4a3eb0641497198a7195.png
[f460e5fa905141a7b9a443560929831f.png]: https://img-blog.csdnimg.cn/f460e5fa905141a7b9a443560929831f.png
[151364a4890041b384e52d0c10821675.png]: https://img-blog.csdnimg.cn/151364a4890041b384e52d0c10821675.png
[10f19f6898704490a00ec1ca87ee4fb9.png]: https://img-blog.csdnimg.cn/10f19f6898704490a00ec1ca87ee4fb9.png
[c07a6e503cb947069f301bab8a67aa53.png]: https://img-blog.csdnimg.cn/c07a6e503cb947069f301bab8a67aa53.png
[f684885096e743038efa743d6b378f0a.png]: https://img-blog.csdnimg.cn/f684885096e743038efa743d6b378f0a.png
[bc4016be35ea415c8a4810ba56e257d2.png]: https://img-blog.csdnimg.cn/bc4016be35ea415c8a4810ba56e257d2.png
[7a47a4c5d8a94b19a5313b0a0c614428.png]: https://img-blog.csdnimg.cn/7a47a4c5d8a94b19a5313b0a0c614428.png
[8a00ec3dbbbd4036bc9411a21867d855.png]: https://img-blog.csdnimg.cn/8a00ec3dbbbd4036bc9411a21867d855.png
[121a14436d7b40bbaaa5c08ec2e89361.png]: https://img-blog.csdnimg.cn/121a14436d7b40bbaaa5c08ec2e89361.png
[205adce2a99643e094202fb06a3484b8.png]: https://img-blog.csdnimg.cn/205adce2a99643e094202fb06a3484b8.png
[ac5de477c6864b2eb89fedb791aa1ddf.png]: https://img-blog.csdnimg.cn/ac5de477c6864b2eb89fedb791aa1ddf.png
[c9ec7a63b662459d83ae7ea795bdb5e0.png]: https://img-blog.csdnimg.cn/c9ec7a63b662459d83ae7ea795bdb5e0.png
[9910ea8fdb0146959a6c45db1d385195.png]: https://img-blog.csdnimg.cn/9910ea8fdb0146959a6c45db1d385195.png
[b0aa941fdb3044ebacbbd34424381cc2.png]: https://img-blog.csdnimg.cn/b0aa941fdb3044ebacbbd34424381cc2.png
[210c5a9cb573406d8c741ec4c033a4ab.png]: https://img-blog.csdnimg.cn/210c5a9cb573406d8c741ec4c033a4ab.png
[5ef65eac6acc4c78a697fa31a1e043a1.png]: https://img-blog.csdnimg.cn/5ef65eac6acc4c78a697fa31a1e043a1.png
[8260d41d9f004cad8beb84dd52e37635.png]: https://img-blog.csdnimg.cn/8260d41d9f004cad8beb84dd52e37635.png
[fbc0ac386fba4e718e6c23c555b7ef81.png]: https://img-blog.csdnimg.cn/fbc0ac386fba4e718e6c23c555b7ef81.png
[23fc05060502465988c8b86577623729.png]: https://img-blog.csdnimg.cn/23fc05060502465988c8b86577623729.png
[8677ffba355e463fa853f3d90ab8d59a.png]: https://img-blog.csdnimg.cn/8677ffba355e463fa853f3d90ab8d59a.png
[af4383b738984d60949145ac1ef107a6.png]: https://img-blog.csdnimg.cn/af4383b738984d60949145ac1ef107a6.png
[3f7a59891b794e37a762e7a9b906233d.png]: https://img-blog.csdnimg.cn/3f7a59891b794e37a762e7a9b906233d.png
[6ce2db1196b7404a8122b21cd130f57e.png]: https://img-blog.csdnimg.cn/6ce2db1196b7404a8122b21cd130f57e.png
[efa4b62a52684ce7b5b856048cc2adbd.png]: https://img-blog.csdnimg.cn/efa4b62a52684ce7b5b856048cc2adbd.png