从零开始的ElasticSearch安装方法到使用方法到SpringBoot整合ElasticSearch全程无废话

末蓝、 2023-10-03 04:27 4阅读 0赞

# **不想看简介可以直接左下角选择目录** #

目录  
一、简介  
二、进阶检索  
三、Mapping字段映射  
四、elasticsearch-Rest-Client  
五、SpringBoot整合ElasticSearch  
六、product-es准备

**话不多说咱们直接上干货**

## 0、简介 ##

es–> solr

mysql用作持久化存储，ES用作检索

基本概念：index库>type表>document文档

### index索引（index在es中添加） ###

相当于mysql的insert

### Type类型 ###

put /index/user

“name”:“zhansan”

在index中，可以定义一个或多个类型

类似于mysql的table，每一种类型的数据放在一起

### Document文档(必须是json格式) ###

保存在某个index下，某种type的一个数据document，文档是json格式的，document就像是mysql中的某个table里面的内容。每一行对应的列叫属性  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center]

## 为什么ES搜索快？倒排索引 ##

### 保存的记录 ###

*  红海行动
 *  探索红海行动
 *  红海特别行动
 *  红海记录片
 *  特工红海特别探索

将内容分词就记录到索引中

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 1]

### 检索： ###

1）、红海特工行动？查出后计算相关性得分：3号记录命中了2次，且3号本身才有3个单词，2/3，所以3号最匹配  
2）、红海行动？

关系型数据库中两个数据表示是独立的，即使他们里面有相同名称的列也不影响使用，但ES中不是这样的。elasticsearch是基于Lucene开发的搜索引擎，而ES中不同type下名称相同的filed最终在Lucene中的处理方式是一样的。

两个不同type下的两个user\_name，在ES同一个索引下其实被认为是同一个filed，你必须在两个不同的type中定义相同的filed映射。否则，不同type中的相同字段名称就会在处理中出现冲突的情况，导致Lucene处理效率下降。  
去掉type就是为了提高ES处理数据的效率。  
Elasticsearch 7.xURL中的type参数为可选。比如，索引一个文档不再要求提供文档类型。  
Elasticsearch 8.x不再支持URL中的type参数。  
解决：将索引从多类型迁移到单类型，每种类型文档一个独立索引

## 1、安装elastic search ##

### dokcer中安装elastic search ###

#### （1）下载ealastic search（存储和检索）和kibana（可视化检索） ####

docker pull elasticsearch:7.4.2

docker pull kibana:7.4.2 版本要统一

#### （2）配置 ####

将docker里的目录挂载到linux的/mydata目录中

修改/mydata就可以改掉docker里的

mkdir -p /mydata/elasticsearch/config  
mkdir -p /mydata/elasticsearch/data

es可以被远程任何机器访问

echo “http.host: 0.0.0.0” >/mydata/elasticsearch/config/elasticsearch.yml

递归更改权限，es需要访问

chmod -R 777 /mydata/elasticsearch/

#### （3）启动Elastic search ####

**9200是用户交互端口 9300是集群心跳端口**

\-e指定是单阶段运行

\-e指定占用的内存大小，生产时可以设置32G

docker run --name elasticsearch -p 9200:9200 -p 9300:9300  
\-e “discovery.type=single-node”  
\-e ES\_JAVA\_OPTS="-Xms64m -Xmx512m"  
\-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml  
\-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data  
\-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins  
\-d elasticsearch:7.4.2

设置开机启动elasticsearch

docker update elasticsearch --restart=always

因为容器里的文件映射到了外面，所以删除容器和新建容器数据还在  
第一次查docker ps启动了，第二次查的时候发现关闭了，docker logs elasticsearch  
http://192.168.56.10:9200-----(*192.168.56.10是我的虚拟机ip,后续为了更直观我直接用我自己的ip了*)  
数据挂载到外面，但是访问权限不足  
把/mydata/elasticsearch下文件夹的权限设置好，上面已经设置过了  
遇到了更新阿里源也下载不下来kibana镜像的情况，先在别的网络下载下来后传到vagrant中

docker save -o kibana.tar kibana:7.4.2

docker load -i kibana.tar

如何通过其他工具链接ssh

修改/etc/ssh/sshd\_config  
修改 PasswordAuthentication yes

systemctl restart sshd.service 或 service sshd restart

连接192.168.56.10:22端口成功，用户名root，密码vagrant

也可以通过vagrant ssh-config查看ip和端口，此时是127.0.0.1:2222  
在安装离线docker镜像的时候还提示内存不足，看了下是因为外部挂载的内存也算在了vagrant中，即使外部删了很多文件，vagrant中df -h硬盘占用率也不下降。我在外部删完文件后在内部又rm -rf XXX 强行接触占用

#### （4）启动kibana： ####

kibana指定了了ES交互端口9200 \# 5600位kibana主页端口

docker run --name kibana -e ELASTICSEARCH\_HOSTS=http://192.168.56.10:9200 -p 5601:5601 -d kibana:7.4.2

设置开机启动kibana

docker update kibana --restart=always

#### （5）测试 ####

查看elasticsearch版本信息： http://192.168.56.10:9200

\{  
“name”: “66718a266132”,  
“cluster\_name”: “elasticsearch”,  
“cluster\_uuid”: “xhDnsLynQ3WyRdYmQk5xhQ”,  
“version”: \{  
“number”: “7.4.2”,  
“build\_flavor”: “default”,  
“build\_type”: “docker”,  
“build\_hash”: “2f90bbf7b93631e52bafb59b3b049cb44ec25e96”,  
“build\_date”: “2019-10-28T20:40:44.881551Z”,  
“build\_snapshot”: false,  
“lucene\_version”: “8.2.0”,  
“minimum\_wire\_compatibility\_version”: “6.8.0”,  
“minimum\_index\_compatibility\_version”: “6.0.0-beta1”  
\},  
“tagline”: “You Know, for Search”  
\}

##### 显示elasticsearch 节点信息http://192.168.56.10:9200/\_cat/nodes #####

127.0.0.1 14 99 25 0.29 0.40 0.22 dilm \* 66718a266132

66718a266132代表上面的结点（2）`GET /_cat/health`：查看es健康状况

如： http://192.168.56.10:9200/\_cat/health

1613741055 13:24:15 elasticsearch green 1 1 0 0 0 0 0 0 - 100.0%

### 2、初步检索 ###

#### 1）检索es信息 ####

（1）`GET /_cat/nodes`：查看所有节点

如：http://192.168.56.10:9200/\_cat/nodes

可以直接浏览器输入上面的url，也可以在kibana中输入`GET /_cat/nodes`

127.0.0.1 12 97 3 0.00 0.01 0.05 dilm * 66718a266132
    
    66718a266132代表结点
    *代表是主节点

（2）`GET /_cat/health`：查看es健康状况

如： http://192.168.56.10:9200/\_cat/health

1613741055 13:24:15 elasticsearch green 1 1 0 0 0 0 0 0 - 100.0%

注：green表示健康值正常

（3）`GET /_cat/master`：查看主节点

如： http://192.168.56.10:9200/\_cat/master

089F76WwSaiJcO6Crk7MpA 127.0.0.1 127.0.0.1 66718a266132
    
    主节点唯一编号
    虚拟机地址

（4）`GET/_cat/indicies`：查看所有索引 ，等价于mysql数据库的show databases;

如：http://192.168.56.10:9200/\_cat/indices

green  open .kibana_task_manager_1   DhtDmKrsRDOUHPJm1EFVqQ 1 0 2 3 40.8kb 40.8kb
    green  open .apm-agent-configuration vxzRbo9sQ1SvMtGkx6aAHQ 1 0 0 0   230b   230b
    green  open .kibana_1                rdJ5pejQSKWjKxRtx-EIkQ 1 0 5 1 18.2kb 18.2kb
    
    这3个索引是kibana创建的

#### 2）新增文档 post put ####

保存一个数据，保存在哪个索引的哪个类型下（哪张数据库哪张表下），保存时用唯一标识指定

# # 在customer索引下的external类型下保存1号数据
    PUT customer/external/1
    
    # POSTMAN输入
    http://192.168.56.10:9200/customer/external/1
    
    {
        
     "name":"John Doe"
    }

##### PUT和POST区别 #####

POST新增。如果不指定id，会自动生成id。指定id就会修改这个数据，并新增版本号；  
可以不指定id，不指定id时永远为创建  
指定不存在的id为创建  
指定存在的id为更新，而版本号会根据内容变没变而觉得版本号递增与否  
PUT可以新增也可以修改。PUT必须指定id；由于PUT需要指定id，我们一般用来做修改操作，不指定id会报错。  
必须指定id  
版本号总会增加  
怎么记：put和java里map.put一样必须指定key-value。而post相当于mysql insert

seq_no和version的区别：
    每个文档的版本号"_version" 起始值都为1 每次对当前文档成功操作后都加1
    而序列号"_seq_no"则可以看做是索引的信息 在第一次为索引插入数据时为0，每对索引内数据操作成功一次sqlNO加1， 并且文档会记录是第几次操作使它成为现在的情况的
    可以参考https://www.cnblogs.com/Taeso/p/13363136.html

下面是在postman中的测试数据：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 2]  
创建数据成功后，显示201 created表示插入记录成功

返回数据：
    带有下划线开头的，称为元数据，反映了当前的基本信息。  
    {
        
        "_index": "customer", 表明该数据在哪个数据库下；
        "_type": "external", 表明该数据在哪个类型下；
        "_id": "1",  表明被保存数据的id；
        "_version": 1,  被保存数据的版本
        "result": "created", 这里是创建了一条数据，如果重新put一条数据，则该状态会变为updated，并且版本号也会发生变化。
        "_shards": {
        
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "_seq_no": 0,
        "_primary_term": 1
    }

下面选用POST方式：

添加数据的时候，**不指定ID**，会自动的生成id，并且类型是新增：

{
        
        "_index": "customer",
        "_type": "external",
        "_id": "5MIjvncBKdY1wAQm-wNZ",
        "_version": 1,
        "result": "created",
        "_shards": {
        
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "_seq_no": 11,
        "_primary_term": 6
    }

再次使用POST插入数据，**不指定ID**，仍然是新增的：

{
        
        "_index": "customer",
        "_type": "external",
        "_id": "5cIkvncBKdY1wAQmcQNk",
        "_version": 1,
        "result": "created",
        "_shards": {
        
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "_seq_no": 12,
        "_primary_term": 6
    }

#### 3）查看文档 ####

GET /customer/external/1

http://192.168.56.10:9200/customer/external/1

\{  
“\_index”: “customer”,  
“\_type”: “external”,  
“\_id”: “1”,  
“\_version”: 10,  
“\_seq\_no”: 18,//并发控制字段，每次更新都会+1，用来做乐观锁  
“\_primary\_term”: 6,//同上，主分片重新分配，如重启，就会变化  
“found”: true,  
“\_source”: \{  
“name”: “John Doe”  
\}  
\}

乐观锁用法：通过“if_seq_no=1&if_primary_term=1”，当序列号匹配的时候，才进行修改，否则不修改。

实例：将id=1的数据更新为name=1，然后再次更新为name=2，起始1\_seq\_no=18，\_primary\_term=6

（1）将name更新为1

PUT http://192.168.56.10:9200/customer/external/1?if\_seq\_no=18&if\_primary\_term=6  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 4]  
（2）将name更新为2，更新过程中使用seq\_no=18

PUT http://192.168.56.10:9200/customer/external/1?if\_seq\_no=18&if\_primary\_term=6

结果为：

{
        
        "error": {
        
            "root_cause": [
                {
        
                    "type": "version_conflict_engine_exception",
                    "reason": "[1]: version conflict, required seqNo [18], primary term [6]. current document has seqNo [19] and primary term [6]",
                    "index_uuid": "mG9XiCQISPmfBAmL1BPqIw",
                    "shard": "0",
                    "index": "customer"
                }
            ],
            "type": "version_conflict_engine_exception",
            "reason": "[1]: version conflict, required seqNo [18], primary term [6]. current document has seqNo [19] and primary term [6]",
            "index_uuid": "mG9XiCQISPmfBAmL1BPqIw",
            "shard": "0",
            "index": "customer"
        },
        "status": 409
    }

出现更新错误。

（3）查询新的数据

GET http://192.168.56.10:9200/customer/external/1

{
        
        "_index": "customer",
        "_type": "external",
        "_id": "1",
        "_version": 11,
        "_seq_no": 19,
        "_primary_term": 6,
        "found": true,
        "_source": {
        
            "name": "1"
        }
    }

能够看到\_seq\_no变为19

（4）再次更新，更新成功

PUT http://192.168.56.10:9200/customer/external/1?if\_seq\_no=19&if\_primary\_term=1

#### 4）更新文档\_update ####

POST customer/externel/1/_update
    {
        
        "doc":{
        
            "name":"111"
        }
    }
    或者
    POST customer/externel/1
    {
        
        "doc":{
        
            "name":"222"
        }
    }
    或者
    PUT customer/externel/1
    {
        
        "doc":{
        
            "name":"222"
        }
    }

不同：带有update情况下

POST操作会对比源文档数据，如果相同不会有什么操作，文档version不增加。  
PUT操作总会重新保存并增加version版本  
POST时带\_update对比元数据如果一样就不进行任何操作。

看场景：

对于大并发更新，不带update  
对于大并发查询偶尔更新，带update；对比更新，重新计算分配规则  
（1）POST更新文档，带有\_update  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 6]

如果再次执行更新，则不执行任何操作，序列号也不发生变化

返回
    {
        
        "_index": "customer",
        "_type": "external",
        "_id": "1",
        "_version": 12,
        "result": "noop", // 无操作
        "_shards": {
        
            "total": 0,
            "successful": 0,
            "failed": 0
        },
        "_seq_no": 20,
        "_primary_term": 6
    }

POST更新方式，会对比原来的数据，和原来的相同，则不执行任何操作（version和\_seq\_no）都不变。

（2）POST更新文档，不带\_update

在更新过程中，重复执行更新操作，数据也能够更新成功，不会和原来的数据进行对比。

{
        
        "_index": "customer",
        "_type": "external",
        "_id": "1",
        "_version": 13,
        "result": "updated",
        "_shards": {
        
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "_seq_no": 21,
        "_primary_term": 6
    }

#### 5）删除文档或索引 ####

DELETE customer/external/1
    DELETE customer

注：elasticsearch并没有提供删除类型的操作，只提供了删除索引和文档的操作。

实例：删除id=1的数据，删除后继续查询

DELETE http://192.168.56.10:9200/customer/external/1

{
        
        "_index": "customer",
        "_type": "external",
        "_id": "1",
        "_version": 14,
        "result": "deleted",
        "_shards": {
        
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "_seq_no": 22,
        "_primary_term": 6
    }

再次执行DELETE http://192.168.56.10:9200/customer/external/1

{
        
        "_index": "customer",
        "_type": "external",
        "_id": "1",
        "_version": 15,
        "result": "not_found",
        "_shards": {
        
            "total": 2,
            "successful": 1,
            "failed": 0
        },
        "_seq_no": 23,
        "_primary_term": 6
    }

GET http://192.168.56.10:9200/customer/external/1

{
        
        "_index": "customer",
        "_type": "external",
        "_id": "1",
        "found": false
    }

##### 删除索引 #####

实例：删除整个costomer索引数据

删除前，所有的索引http://192.168.56.10:9200/\_cat/indices

green  open .kibana_task_manager_1   DhtDmKrsRDOUHPJm1EFVqQ 1 0 2 0 31.3kb 31.3kb
    green  open .apm-agent-configuration vxzRbo9sQ1SvMtGkx6aAHQ 1 0 0 0   283b   283b
    green  open .kibana_1                rdJ5pejQSKWjKxRtx-EIkQ 1 0 8 3 28.8kb 28.8kb
    yellow open customer                 mG9XiCQISPmfBAmL1BPqIw 1 1 9 1  8.6kb  8.6kb

删除“ customer ”索引

DELTE http://192.168.56.10:9200/customer

响应  
\{  
“acknowledged”: true  
\}  
删除后，所有的索引http://192.168.56.10:9200/\_cat/indices

green open .kibana\_task\_manager\_1 DhtDmKrsRDOUHPJm1EFVqQ 1 0 2 0 31.3kb 31.3kb  
green open .apm-agent-configuration vxzRbo9sQ1SvMtGkx6aAHQ 1 0 0 0 283b 283b  
green open .kibana\_1 rdJ5pejQSKWjKxRtx-EIkQ 1 0 8 3 28.8kb 28.8kb

#### 6）ES的批量操作——bulk ####

匹配导入数据

POST http://192.168.56.10:9200/customer/external/\_bulk

两行为一个整体
    {
        "index":{
        "_id":"1"}}
    {
        "name":"a"}
    {
        "index":{
        "_id":"2"}}
    {
        "name":"b"}
    注意格式json和text均不可，要去kibana里Dev Tools

语法格式：

{
        action:{
        metadata}}\n
    {
        request body  }\n
    
    {
        action:{
        metadata}}\n
    {
        request body  }\n

这里的批量操作，当发生某一条执行发生失败时，其他的数据仍然能够接着执行，也就是说彼此之间是独立的。

bulk api以此按顺序执行所有的action（动作）。如果一个单个的动作因任何原因失败，它将继续处理它后面剩余的动作。当bulk api返回时，它将提供每个动作的状态（与发送的顺序相同），所以您可以检查是否一个指定的动作是否失败了。

实例1: 执行多条数据

POST /customer/external/_bulk
    {
        "index":{
        "_id":"1"}}
    {
        "name":"John Doe"}
    {
        "index":{
        "_id":"2"}}
    {
        "name":"John Doe"}

执行结果

#! Deprecation: [types removal] Specifying types in bulk requests is deprecated.
    {
        
      "took" : 318,  花费了多少ms
      "errors" : false, 没有发生任何错误
      "items" : [ 每个数据的结果
        {
        
          "index" : {
         保存
            "_index" : "customer", 索引
            "_type" : "external", 类型
            "_id" : "1", 文档
            "_version" : 1, 版本
            "result" : "created", 创建
            "_shards" : {
        
              "total" : 2,
              "successful" : 1,
              "failed" : 0
            },
            "_seq_no" : 0,
            "_primary_term" : 1,
            "status" : 201 新建完成
          }
        },
        {
        
          "index" : {
         第二条记录
            "_index" : "customer",
            "_type" : "external",
            "_id" : "2",
            "_version" : 1,
            "result" : "created",
            "_shards" : {
        
              "total" : 2,
              "successful" : 1,
              "failed" : 0
            },
            "_seq_no" : 1,
            "_primary_term" : 1,
            "status" : 201
          }
        }
      ]
    }

实例2：对于整个索引执行批量操作

POST /_bulk
    {
        "delete":{
        "_index":"website","_type":"blog","_id":"123"}}
    {
        "create":{
        "_index":"website","_type":"blog","_id":"123"}}
    {
        "title":"my first blog post"}
    {
        "index":{
        "_index":"website","_type":"blog"}}
    {
        "title":"my second blog post"}
    {
        "update":{
        "_index":"website","_type":"blog","_id":"123"}}
    {
        "doc":{
        "title":"my updated blog post"}}

运行结果：

#! Deprecation: [types removal] Specifying types in bulk requests is deprecated.
    {
        
      "took" : 304,
      "errors" : false,
      "items" : [
        {
        
          "delete" : {
         删除
            "_index" : "website",
            "_type" : "blog",
            "_id" : "123",
            "_version" : 1,
            "result" : "not_found", 没有该记录
            "_shards" : {
        
              "total" : 2,
              "successful" : 1,
              "failed" : 0
            },
            "_seq_no" : 0,
            "_primary_term" : 1,
            "status" : 404 没有该
          }
        },
        {
        
          "create" : {
          创建
            "_index" : "website",
            "_type" : "blog",
            "_id" : "123",
            "_version" : 2,
            "result" : "created",
            "_shards" : {
        
              "total" : 2,
              "successful" : 1,
              "failed" : 0
            },
            "_seq_no" : 1,
            "_primary_term" : 1,
            "status" : 201
          }
        },
        {
        
          "index" : {
          保存
            "_index" : "website",
            "_type" : "blog",
            "_id" : "5sKNvncBKdY1wAQmeQNo",
            "_version" : 1,
            "result" : "created",
            "_shards" : {
        
              "total" : 2,
              "successful" : 1,
              "failed" : 0
            },
            "_seq_no" : 2,
            "_primary_term" : 1,
            "status" : 201
          }
        },
        {
        
          "update" : {
         更新
            "_index" : "website",
            "_type" : "blog",
            "_id" : "123",
            "_version" : 3,
            "result" : "updated",
            "_shards" : {
        
              "total" : 2,
              "successful" : 1,
              "failed" : 0
            },
            "_seq_no" : 3,
            "_primary_term" : 1,
            "status" : 200
          }
        }
      ]
    }

#### 7）样本测试数据 ####

准备了一份顾客银行账户信息的虚构的JSON文档样本。每个文档都有下列的schema（模式）。

{
        
    	"account_number": 1,
    	"balance": 39225,
    	"firstname": "Amber",
    	"lastname": "Duke",
    	"age": 32,
    	"gender": "M",
    	"address": "880 Holmes Lane",
    	"employer": "Pyrami",
    	"email": "amberduke@pyrami.com",
    	"city": "Brogan",
    	"state": "IL"
    }

## 二、进阶检索 ##

#### 3.1）search检索文档 ####

ES支持两种基本方式检索；

通过REST request uri 发送搜索参数 （uri +检索参数）；  
通过REST request body 来发送它们（uri+请求体）；  
信息检索

API： https://www.elastic.co/guide/en/elasticsearch/reference/7.x/getting-started-search.html

请求参数方式检索
    GET bank/_search?q=*&sort=account_number:asc
    说明：
    q=* # 查询所有
    sort # 排序字段
    asc #升序
    检索bank下所有信息，包括type和docs
    GET bank/_search

返回内容：

took – 花费多少ms搜索  
timed\_out – 是否超时  
\_shards – 多少分片被搜索了，以及多少成功/失败的搜索分片  
max\_score –文档相关性最高得分  
hits.total.value - 多少匹配文档被找到  
hits.sort - 结果的排序key（列），没有的话按照score排序  
hits.\_score - 相关得分 (not applicable when using match\_all)

GET bank/_search?q=*&sort=account_number:asc
    
    检索了1000条数据，但是根据相关性算法，只返回10条

uri+请求体进行检索

GET /bank/_search
    {
        
      "query": {
         "match_all": {
        } },
      "sort": [
        {
         "account_number": "asc" },
        {
         "balance":"desc"}
      ]
    }

POSTMAN中get不能携带请求体，我们变为post也是一样的，我们post一个jsob风格的查询请求体到\_search

需要了解，一旦搜索的结果被返回，es就完成了这次请求，不能切不会维护任何服务端的资源或者结果的cursor游标

#### 3.2）DSL领域特定语言 ####

Elasticsearch提供了一个可以执行查询的Json风格的DSL(domain-specific language领域特定语言)。这个被称为Query DSL，该查询语言非常全面。

##### （1）基本语法格式 #####

一个查询语句的典型结构

如果针对于某个字段，那么它的结构如下：
    {
        
      QUERY_NAME:{
           # 使用的功能
         FIELD_NAME:{
          #  功能参数
           ARGUMENT:VALUE,
           ARGUMENT:VALUE,...
          }   
       }
    }
    示例  使用时不要加#注释内容
    GET bank/_search
    {
        
      "query": {
          #  查询的字段
        "match_all": {
        }
      },
      "from": 0,  # 从第几条文档开始查
      "size": 5,
      "_source":["balance"],
      "sort": [
        {
        
          "account_number": {
          # 返回结果按哪个列排序
            "order": "desc"  # 降序
          }
        }
      ]
    }
    _source为要返回的字段

query定义如何查询；

match\_all查询类型【代表查询所有的索引】，es中可以在query中组合非常多的查询类型完成复杂查询；  
除了query参数之外，我们可也传递其他的参数以改变查询结果，如sort，size；  
from+size限定，完成分页功能；  
sort排序，多字段排序，会在前序字段相等时后续字段内部排序，否则以前序为准；

##### （2）from返回部分字段 #####

GET bank/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "from": 0,
      "size": 5,
      "sort": [
        {
        
          "account_number": {
        
            "order": "desc"
          }
        }
      ],
      "_source": ["balance","firstname"]
      
    }

##### （3）query/match匹配查询 #####

如果是非字符串，会进行精确匹配。如果是字符串，会进行全文检索

*  基本类型（非字符串），精确控制

GET bank/_search
    {
        
      "query": {
        
        "match": {
        
          "account_number": "20"
        }
      }
    }

*  字符串，全文检索
    
        GET bank/_search
        {
              
          "query": {
              
            "match": {
              
              "address": "kings"
            }
          }
        }
    
    ##### （4） `query/match_phrase` \[不拆分匹配\] #####

将需要匹配的值当成一整个单词（不分词）进行检索

*  `match_phrase`：不拆分字符串进行检索
 *  `字段.keyword`：必须全匹配上才检索成功

> 前面的是包含mill或road就查出来，我们现在要**都包含**才查出

GET bank/_search
    {
        
      "query": {
        
        "match_phrase": {
        
          "address": "mill road"   #  就是说不要匹配只有mill或只有road的，要匹配mill road一整个子串
        }
      }
    }

查处address中包含mill road的所有记录，并给出相关性得分

使用match的`keyword`

GET bank/_search
    {
        
      "query": {
        
        "match": {
        
          "address.keyword": "990 Mill"  # 字段后面加上 .keyword
        }
      }
    }

查询结果，一条也未匹配到

{
        
      "took" : 0,
      "timed_out" : false,
      "_shards" : {
        
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        
        "total" : {
        
          "value" : 0, # 因为要求完全equal，所以匹配不到
          "relation" : "eq"
        },
        "max_score" : null,
        "hits" : [ ]
      }
    }

修改匹配条件为“990 Mill Road”

GET bank/_search
    {
        
      "query": {
        
        "match": {
        
          "address.keyword": "990 Mill Road"  # 正好有这条文档，所以能匹配到
        }
      }
    }

文本字段的匹配，使用keyword，匹配的条件就是要显示字段的全部值，要进行精确匹配的。

match\_phrase是做短语匹配，只要文本中包含匹配条件，就能匹配到。

##### （5）query/multi\_math【多字段匹配】 #####

**state或者address中包含mill**，并且在查询过程中，会对于查询条件进行分词。

GET bank/_search
    {
        
      "query": {
        
        "multi_match": {
          # 前面的match仅指定了一个字段。
          "query": "mill",
          "fields": [ # state和address有mill子串  不要求都有
            "state",
            "address"
          ]
        }
      }
    }

##### （6）query/bool/must复合查询 #####

复合语句可以合并，任何其他查询语句，包括符合语句。这也就意味着，复合语句之间可以互相嵌套，可以表达非常复杂的逻辑。

must：必须达到must所列举的所有条件  
must\_not：必须不匹配must\_not所列举的所有条件。  
should：应该满足should所列举的条件。满足条件最好，不满足也可以，满足得分更高  
实例：查询gender=m，并且address=mill的数据

GET bank/_search
    {
        
       "query":{
        
            "bool":{
          # 
                 "must":[ # 必须有这些字段
                  {
        "match":{
        "address":"mill"}},
                  {
        "match":{
        "gender":"M"}}
                 ]
             }
        }
    }

**must\_not：必须不是指定的情况**

实例：查询gender=m，并且address=mill的数据，但是age不等于38的

GET bank/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
         "match": {
         "gender": "M" }},
            {
         "match": {
        "address": "mill"}}
          ],
          "must_not": [  # 不可以是指定值
            {
         "match": {
         "age": "38" }}
          ]
       }
    }

**should：应该达到should列举的条件，如果到达会增加相关文档的评分，并不会改变查询的结果。如果query中只有should且只有一种匹配规则，那么should的条件就会被作为默认匹配条件二区改变查询结果。**

实例：匹配lastName应该等于Wallace的数据

GET bank/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
        
              "match": {
        
                "gender": "M"
              }
            },
            {
        
              "match": {
        
                "address": "mill"
              }
            }
          ],
          "must_not": [
            {
        
              "match": {
        
                "age": "18"
              }
            }
          ],
          "should": [
            {
        
              "match": {
        
                "lastname": "Wallace"
              }
            }
          ]
        }
      }
    }

##### （7）query/filter【结果过滤】 #####

must 贡献得分  
should 贡献得分  
must\_not 不贡献得分  
filter 不贡献得分  
上面的must和should影响相关性得分，而must\_not仅仅是一个filter ，不贡献得分  
must改为filter就使must不贡献得分  
如果只有filter条件的话，我们会发现得分都是0  
一个key多个值可以用terms  
并不是所有的查询都需要产生分数，特别是哪些仅用于filtering过滤的文档。为了不计算分数，elasticsearch会自动检查场景并且优化查询的执行。

不参与评分更快

GET bank/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
         "match": {
        "address": "mill" } }
          ],
          "filter": {
          # query.bool.filter
            "range": {
        
              "balance": {
          # 哪个字段
                "gte": "10000",
                "lte": "20000"
              }
            }
          }
        }
      }
    }

这里先是查询所有匹配address=mill的文档，然后再根据10000<=balance<=20000进行过滤查询结果

Each must, should, and must\_not element in a Boolean query is referred to as a query clause. How well a document meets the criteria in each must or should clause contributes to the document’s relevance score. The higher the score, the better the document matches your search criteria. By default, Elasticsearch returns documents ranked by these relevance scores.

在boolean查询中，must, should 和must\_not 元素都被称为查询子句 。 文档是否符合每个“must”或“should”子句中的标准，决定了文档的“相关性得分”。 得分越高，文档越符合您的搜索条件。 默认情况下，Elasticsearch返回根据这些相关性得分排序的文档。

The criteria in a must\_not clause is treated as a filter. It affects whether or not the document is included in the results, but does not contribute to how documents are scored. You can also explicitly specify arbitrary filters to include or exclude documents based on structured data.

“must\_not”子句中的条件被视为“过滤器”。 它影响文档是否包含在结果中， 但不影响文档的评分方式。 还可以显式地指定任意过滤器来包含或排除基于结构化数据的文档。

filter在使用过程中，并不会计算相关性得分：

GET bank/_search
    {
        
      "query": {
        
        "bool": {
        
          "must": [
            {
        
              "match": {
        
                "address": "mill"
              }
            }
          ],
          "filter": {
        
            "range": {
        
              "balance": {
        
                "gte": "10000",
                "lte": "20000"
              }
            }
          }
        }
      }
    }

**能看到所有文档的 “\_score” : 0.0。**

##### （8）query/term #####

和match一样。匹配某个属性的值。

全文检索字段用match，  
其他非text字段匹配用term。  
不要使用term来进行文本字段查询

es默认存储text值时用分词分析，所以要搜索text值，使用match

https://www.elastic.co/guide/en/elasticsearch/reference/7.6/query-dsl-term-query.html

字段.keyword：要一一匹配到  
match\_phrase：子串包含即可  
使用term匹配查询

GET bank/_search
    {
        
      "query": {
        
        "term": {
        
          "address": "mill Road"
        }
      }
    }

一条也没有匹配到

而更换为match匹配时，能够匹配到32个文档

也就是说，**全文检索字段用match，其他非text字段匹配用term**。

##### （9）aggs/agg1（聚合） #####

前面介绍了存储、检索，但还没介绍分析

聚合提供了从数据中分组和提取数据的能力。最简单的聚合方法大致等于SQL Group by和SQL聚合函数。

在elasticsearch中，执行搜索返回this（命中结果），并且同时返回聚合结果，把以响应中的所有hits（命中结果）分隔开的能力。这是非常强大且有效的，你可以执行查询和多个聚合，并且在一次使用中得到各自的（任何一个的）返回结果，使用一次简洁和简化的API啦避免网络往返。

aggs：执行聚合。聚合语法如下：

"aggs":{
         # 聚合
        "aggs_name":{
         # 这次聚合的名字，方便展示在结果集中
            "AGG_TYPE":{
        } # 聚合的类型(avg,term,terms)
         }
    }

*  terms：看值的可能性分布，会合并锁查字段，给出计数即可
 *  avg：看值的分布平均

例：**搜索address中包含mill的所有人的年龄分布以及平均年龄，但不显示这些人的详情**

# 分别为包含mill、，平均年龄、
    GET bank/_search
    {
        
      "query": {
         # 查询出包含mill的
        "match": {
        
          "address": "Mill"
        }
      },
      "aggs": {
         #基于查询聚合
        "ageAgg": {
          # 聚合的名字，随便起
          "terms": {
         # 看值的可能性分布
            "field": "age",
            "size": 10
          }
        },
        "ageAvg": {
         
          "avg": {
         # 看age值的平均
            "field": "age"
          }
        },
        "balanceAvg": {
        
          "avg": {
         # 看balance的平均
            "field": "balance"
          }
        }
      },
      "size": 0  # 不看详情
    }

###### aggs/aggName/aggs/aggName子聚合 ######

复杂：  
按照年龄聚合，并且求这些年龄段的这些人的平均薪资

> 写到一个聚合里是基于上个聚合进行子聚合。
> 
> 下面求每个age分布的平均balance

GET bank/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "aggs": {
        
        "ageAgg": {
        
          "terms": {
         # 看分布
            "field": "age",
            "size": 100
          },
          "aggs": {
         # 与terms并列
            "ageAvg": {
         #平均
              "avg": {
        
                "field": "balance"
              }
            }
          }
        }
      },
      "size": 0
    }

复杂子聚合：查出所有年龄分布，并且这些**年龄段**中M的平均薪资和F的平均薪资以及这个年龄段的总体平均薪资

GET bank/_search
    {
        
      "query": {
        
        "match_all": {
        }
      },
      "aggs": {
        
        "ageAgg": {
        
          "terms": {
          #  看age分布
            "field": "age",
            "size": 100
          },
          "aggs": {
         # 子聚合
            "genderAgg": {
        
              "terms": {
         # 看gender分布
                "field": "gender.keyword" # 注意这里，文本字段应该用.keyword
              },
              "aggs": {
         # 子聚合
                "balanceAvg": {
        
                  "avg": {
         # 男性的平均
                    "field": "balance"
                  }
                }
              }
            },
            "ageBalanceAvg": {
        
              "avg": {
         #age分布的平均（男女）
                "field": "balance"
              }
            }
          }
        }
      },
      "size": 0

##### nested对象聚合 #####

属性是"type": “nested”,因为是内部的属性进行检索

数组类型的对象会被扁平化处理（对象的每个属性会分别存储到一起）

user.name=["aaa","bbb"]
    user.addr=["ccc","ddd"]
    
    这种存储方式，可能会发生如下错误：
    错误检索到{
        aaa,ddd}，这个组合是不存在的

数组的扁平化处理会使检索能检索到本身不存在的，为了解决这个问题，就采用了嵌入式属性，数组里是对象时用嵌入式属性（不是对象无需用嵌入式属性）

GET articles/_search
    {
        
      "size": 0, 
      "aggs": {
        
        "nested": {
         # 
          "nested": {
         #
            "path": "payment"
          },
          "aggs": {
        
            "amount_avg": {
        
              "avg": {
        
                "field": "payment.amount"
              }
            }
          }
        }
      }
    }

## 三、Mapping字段映射 ##

映射定义文档如何被存储和检索的

##### （1）字段类型 #####

https://www.elastic.co/guide/en/elasticsearch/reference/7.x/mapping-types.html

核心类型  
复合类型  
地理类型  
特定类型  
核心数据类型

（1）字符串

text ⽤于全⽂索引，搜索时会自动使用分词器进⾏分词再匹配  
keyword 不分词，搜索时需要匹配完整的值  
（2）数值型

整型： byte，short，integer，long  
浮点型： float, half\_float, scaled\_float，double  
（3）日期类型：date

（4）范围型

integer\_range， long\_range， float\_range，double\_range，date\_range

gt是大于，lt是小于，e是equals等于。

age\_limit的区间包含了此值的文档都算是匹配。

（5）布尔

boolean  
（6）二进制

binary 会把值当做经过 base64 编码的字符串，默认不存储，且不可搜索  
复杂数据类型

（1）对象

object一个对象中可以嵌套对象。  
（2）数组

Array  
嵌套类型

nested 用于json对象数组  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 7]

##### （2）映射 #####

Mapping(映射)是用来定义一个文档（document），以及它所包含的属性（field）是如何存储和索引的。比如：使用maping来定义：

哪些字符串属性应该被看做全文本属性（full text fields）；

哪些属性包含数字，日期或地理位置；

文档中的所有属性是否都嫩被索引（all 配置）；

日期的格式；

自定义映射规则来执行动态添加属性；

查看mapping信息：GET bank/\_mapping

*  修改mapping信息

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 8]

##### （3）新版本改变 #####

ElasticSearch7-去掉type概念

两个不同type下的两个user\_name，在ES同一个索引下其实被认为是同一个filed，你必须在两个不同的type中定义相同的filed映射。否则，不同type中的相同字段名称就会在处理中出现冲突的情况，导致Lucene处理效率下降。  
去掉type就是为了提高ES处理数据的效率。  
Elasticsearch 7.x URL中的type参数为可选。比如，索引一个文档不再要求提供文档类型。

Elasticsearch 8.x 不再支持URL中的type参数。

解决：  
将索引从多类型迁移到单类型，每种类型文档一个独立索引

将已存在的索引下的类型数据，全部迁移到指定位置即可。详见数据迁移

Elasticsearch 7.x  
Specifying types in requests is deprecated. For instance, indexing a document no longer requires a document type. The new index APIs are PUT \{index\}/\_doc/\{id\} in case of explicit ids and POST \{index\}/\_doc for auto-generated ids. Note that in 7.0, \_doc is a permanent part of the path, and represents the endpoint name rather than the document type.  
The include\_type\_name parameter in the index creation, index template, and mapping APIs will default to false. Setting the parameter at all will result in a deprecation warning.  
The *default* mapping type is removed.  
Elasticsearch 8.x  
Specifying types in requests is no longer supported.  
The include\_type\_name parameter is removed.  
创建映射PUT /my\_index

第一次存储数据的时候es就猜出了映射  
第一次存储数据前可以指定映射  
创建索引并指定映射

PUT /my_index
    {
        
      "mappings": {
        
        "properties": {
        
          "age": {
        
            "type": "integer"
          },
          "email": {
        
            "type": "keyword" # 指定为keyword
          },
          "name": {
        
            "type": "text" # 全文检索。保存时候分词，检索时候进行分词匹配
          }
        }
      }
    }

**查看映射**`GET /my_index`

**添加新的字段映射**`PUT /my_index/_mapping`

PUT /my_index/_mapping
    {
        
      "properties": {
        
        "employee-id": {
        
          "type": "keyword",
          "index": false # 字段不能被检索。检索
        }
      }
    }

这里的 “index”: false，表明新增的字段不能被检索，只是一个冗余字段。

###### 不能更新映射 ######

对于已经存在的字段映射，我们不能更新。更新必须创建新的索引，进行数据迁移。

###### 数据迁移 ######

先创建new\_twitter的正确映射。

然后使用如下方式进行数据迁移。

6.0以后写法
    POST reindex
    {
        
      "source":{
        
          "index":"twitter"
       },
      "dest":{
        
          "index":"new_twitters"
       }
    }
    
    老版本写法
    POST reindex
    {
        
      "source":{
        
          "index":"twitter",
          "twitter":"twitter"
       },
      "dest":{
        
          "index":"new_twitters"
       }
    }

更多详情见： https://www.elastic.co/guide/en/elasticsearch/reference/7.6/docs-reindex.html

案例：原来类型为account，新版本没有类型了，所以我们把他去掉

GET /bank/\_search\`

{
        
      "took" : 0,
      "timed_out" : false,
      "_shards" : {
        
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        
        "total" : {
        
          "value" : 1000,
          "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
          {
        
            "_index" : "bank",
            "_type" : "account",//原来类型为account，新版本没有类型了，所以我们把他去掉
            "_id" : "1",
            "_score" : 1.0,
            "_source" : {
        
              "account_number" : 1,
              "balance" : 39225,
              "firstname" : "Amber",
              "lastname" : "Duke",
              "age" : 32,
              "gender" : "M",
              "address" : "880 Holmes Lane",
              "employer" : "Pyrami",
              "email" : "amberduke@pyrami.com",
              "city" : "Brogan",
              "state" : "IL"
            }
          },
          ...

想要将年龄修改为integer

先创建新的索引

PUT /newbank
    {
        
      "mappings": {
        
        "properties": {
        
          "account_number": {
        
            "type": "long"
          },
          "address": {
        
            "type": "text"
          },
          "age": {
        
            "type": "integer"
          },
          "balance": {
        
            "type": "long"
          },
          "city": {
        
            "type": "keyword"
          },
          "email": {
        
            "type": "keyword"
          },
          "employer": {
        
            "type": "keyword"
          },
          "firstname": {
        
            "type": "text"
          },
          "gender": {
        
            "type": "keyword"
          },
          "lastname": {
        
            "type": "text",
            "fields": {
        
              "keyword": {
        
                "type": "keyword",
                "ignore_above": 256
              }
            }
          },
          "state": {
        
            "type": "keyword"
          }
        }
      }
    }

查看“newbank”的映射：

GET /newbank/\_mapping

将bank中的数据迁移到newbank中

POST _reindex
    {
        
      "source": {
        
        "index": "bank",
        "type": "account"
      },
      "dest": {
        
        "index": "newbank"
      }
    }

查看newbank中的数据

GET /newbank/_search
    
    输出
      "hits" : {
        
        "total" : {
        
          "value" : 1000,
          "relation" : "eq"
        },
        "max_score" : 1.0,
        "hits" : [
          {
        
            "_index" : "newbank",
            "_type" : "_doc", # 没有了类型

## 四、elasticsearch-Rest-Client ##

java操作es有两种方式

#### 1）9300: TCP ####

spring-data-elasticsearch:transport-api.jar;

*  springboot版本不同，ransport-api.jar不同，不能适配es版本
 *  7.x已经不建议使用，8以后就要废弃

#### 2）9200: HTTP ####

有诸多包

jestClient: 非官方，更新慢；  
RestTemplate：模拟HTTP请求，ES很多操作需要自己封装，麻烦；  
HttpClient：同上；  
Elasticsearch-Rest-Client：官方RestClient，封装了ES操作，API层次分明，上手简单；  
最终选择Elasticsearch-Rest-Client（elasticsearch-rest-high-level-client）

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high.html

## 五、SpringBoot整合ElasticSearch ##

创建项目gulimall-search

选择依赖web，但不要在里面选择es

### 1、导入依赖 ###

这里的版本要和所按照的ELK版本匹配。

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

在spring-boot-dependencies中所依赖的ES版本位6.8.5，要改掉

请求测试项，比如es添加了安全访问规则，访问es需要添加一个安全头，就可以通过requestOptions设置

官方建议把requestOptions创建成单实例

@Configuration
    public class GuliESConfig {
        
    
        public static final RequestOptions COMMON_OPTIONS;
    
        static {
        
            RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
    
            COMMON_OPTIONS = builder.build();
        }
    
        @Bean
        public RestHighLevelClient esRestClient() {
        
    
            RestClientBuilder builder = null;
            // 可以指定多个es
            builder = RestClient.builder(new HttpHost(host, 9200, "http"));//这里host写得是你ip地址
    
            RestHighLevelClient client = new RestHighLevelClient(builder);
            return client;
        }
    }

### 2、测试 ###

#### 1）保存数据 ####

参考官方的网址  
https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-document-index.html

保存方式分为同步和异步，异步方式多了个listener回调

@Autowired
        private RestHighLevelClient restHighLevelClient;
    
    @org.junit.Test
        public void test1() throws IOException {
        
        //这输出是看那个工具类取没取到
        System.out.println(restHighLevelClient);
       IndexRequest indexRequest = new IndexRequest("aaa");//aaa是索引 在mysql中这个叫数据库
       //这里index 在es中就是添加的意思
        User user = new User(3,"小彬","女");//随便定义一个实体类
       // 这个id是指定的id可有可无,默认是符号代替
    
    
      indexRequest.id(user.getId().toString());
      //转成json 因为es只能用于json
        String json = JSONObject.toJSONString(user);
        //设置要保存的内容，指定数据和类型
        indexRequest.source(json, XContentType.JSON);
        //执行创建索引和保存数据
        restHighLevelClient.index(indexRequest, GuliESConfig.COMMON_OPTIONS);
    
        System.out.println("成功");
    }

#### 2）获取数据 ####

强烈建议跟着官方文档做,下面是演示  
[https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-search.html][https_www.elastic.co_guide_en_elasticsearch_client_java-rest_current_java-rest-high-search.html]

@org.junit.Test
        public void Test2() throws IOException {
        
            // 1 创建检索请求  Search在es里面代表查询这个都知道吧
            SearchRequest searchRequest = new SearchRequest("aaa");
         //   创建条件构建器 SearchSourceBuilder
            SearchSourceBuilder builder = new SearchSourceBuilder();
            // 这里查的所有
            builder.query(QueryBuilders.matchAllQuery());
            //第二种写法
            /* 查询条件
            QueryBuilder query = QueryBuilders.matchAllQuery();
    
                指定查询条件
            searchSourceBuilder.query(query);*/
            //查询条件构建器
            searchRequest.source(builder);
            //查询，获取结果
            SearchResponse searchResponse = restHighLevelClient.search(searchRequest,GuliESConfig.COMMON_OPTIONS);
        //    System.out.println(searchResponse+"查所有");//我们可以看出很多我们不需要的值
           //获取命中对象 hits
            SearchHits hits = searchResponse.getHits();
            //获取hits数组
            SearchHit[] hits1 = hits.getHits();
            /*我们可以看出有我们想要的值,但是类型不一样
                可以创建一个集合存储es的每一条记录
            * */
           /* for (SearchHit documentFields : hits1) {
                System.out.println(documentFields);
            }*/
            ArrayList<User> users = new ArrayList<>();
            for (SearchHit documentFields : hits1) {
        
                //获取到hits中的每一个asString
                String asString = documentFields.getSourceAsString();
                //将asString中的数据封装为user对象
                User user = JSONObject.parseObject(asString, User.class);//当然你也可以一个一个赋值,我这里就省略了
                users.add(user);
            }
            //输出
            for (User user : users) {
        
                System.out.println(user);
            }
    
        }
    
    @Test
        public void find() throws IOException {
        
            // 1 创建检索请求
            SearchRequest searchRequest = new SearchRequest();
            searchRequest.indices("bank");
            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            // 构造检索条件
    //        sourceBuilder.query();
    //        sourceBuilder.from();
    //        sourceBuilder.size();
    //        sourceBuilder.aggregation();
            sourceBuilder.query(QueryBuilders.matchQuery("address","mill"));
            //AggregationBuilders工具类构建AggregationBuilder
            // 构建第一个聚合条件:按照年龄的值分布
            TermsAggregationBuilder agg1 = AggregationBuilders.terms("agg1").field("age").size(10);// 聚合名称
    // 参数为AggregationBuilder
            sourceBuilder.aggregation(agg1);
            // 构建第二个聚合条件:平均薪资
            AvgAggregationBuilder agg2 = AggregationBuilders.avg("agg2").field("balance");
            sourceBuilder.aggregation(agg2);
    
            System.out.println("检索条件"+sourceBuilder.toString());
    
            searchRequest.source(sourceBuilder);
    
            // 2 执行检索
            SearchResponse response = client.search(searchRequest, GuliESConfig.COMMON_OPTIONS);
            // 3 分析响应结果
            System.out.println(response.toString());
        }

#### 转换bean ####

// 3.1 获取java bean
    SearchHits hits = response.getHits();
    SearchHit[] hits1 = hits.getHits();
    for (SearchHit hit : hits1) {
        
        hit.getId();
        hit.getIndex();
        String sourceAsString = hit.getSourceAsString();
        Account account = JSON.parseObject(sourceAsString, Account.class);
        System.out.println(account);
    }

可能归纳的不太完整但还是希望能帮到你

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/c5516d211e444058bfdd662c37255f12.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/c448eb064e074b28916004995e15d9e9.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/b5c8f8e5d12c4eefbe440e322be768d0.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/3aea8d5f115c496fb275e27eefd57f84.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/87d486ec77174413947168614d905c34.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/fc64d6fb34b1471988f5f12e6e3f9860.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/c0fec45c2d2d4314bd7c86f4f5b9d08a.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/06c5983a738c4c8aa538dadfd29af565.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/f0c7305f7b2a4d63bd563b4a9f29c1fd.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2EyMDMyMDY4Njg=,size_16,color_FFFFFF,t_70#pic_center
[https_www.elastic.co_guide_en_elasticsearch_client_java-rest_current_java-rest-high-search.html]: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-search.html