ElasticSearch、ES、es使用教程

Elasticsearch

简介

官网学习文档：https://www.elastic.co/guide/en/elasticsearch/reference/7.x/index.html

Elasticsearch 是一个分布式可扩展的实时搜索和分析引擎,一个建立在全文搜索引擎 Apache Lucene™ 基础上的搜索引擎.当然 Elasticsearch 并不仅仅是 Lucene 那么简单：

• 分布式实时文件存储，并将每一个字段都编入索引，使其可以被搜索。

• 实时分析的分布式搜索引擎。

• 可以扩展到上百台服务器，处理PB级别的结构化或非结构化数据。

一、基本概念

1、index（索引）

动词，相当于mysql中的insert

名字，相当于mysql中的database

2、Type（类型）

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

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

3、Document（文档）

保存在某个索引（index）下，某种类型（Type）的一个数据，文档是JSON格式的，Document就像是mysql中的某个table里面的内容

简单总结下：Index—>数据库；Type—>表；Document—>数据

4、倒排索引机制

分词器

二、安装

1、下载镜像文件

# 使用docker安装
[root@pihao ~] docker pull elasticsearch:7.4.2
# 可视化检索数据
[root@pihao ~] docker pull kibana:7.4.2

2、创建实例

1、ElasticSearch

# 宿主机用于存放配置文件以及数据文件
[root@pihao ~] mkdir -p /mydata/elasticsearch/config
[root@pihao ~] mkdir -p /mydata/elasticsearch/data
[root@pihao ~] chmod -R 777 /mydata/elasticsearch/ # 给data文件授权，不然后面挂载会失败
# 设置任何ip都能访问
[root@pihao ~] echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml

# 启动容器 9200:http请求通信端口;9300:分布式集群之间用于通信的端口
[root@pihao ~] docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx128m" \
-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

# 查看容器的启动日志 （测试启动成功！）
[root@pihao ~] docker logs xxxx

# 或者使用地址访问  http:主机ip:9200,返回结果如下，说明启动成功
{
  "name" : "a1b49510002c",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "i-8c_jowQjWmurRdQ_E94Q",
  "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" # You Know, for Search
}

2、Kibana

[root@pihao ~] docker run --name kibana -e ELASTICSEARCH_HOSTS=http://112.74.167.52:9200 \
-p 5601:5601 -d kibana:7.4.2

启动成功后通过 http://你主机ip:5601 直接访问kibana的web页面，如出现下图则表示启动成功！

三、初步检索

1、_cat

用于查询es的一些信息

• GET /_cat/nodes：查看所有节点
• GET /_cat/health：查看es健康状态
• GET /_cat/master：查看主节点
• GET /_cat/indices：查看所有索引 show databases

2、索引一个文档（保存）

保存一个数据，保存在哪个索引的哪个类型下，指定用哪个唯一标识

• PUT customer/external/1

# 表示在customer这个索引下的external类型下的1号数据
{
	"name":"pihao"
}

# 这是返回响应的内容：带"_"的表示元数据
{
    "_index": "customer", # 哪个index
    "_type": "external",  # 哪个类型
    "_id": "1", # 唯一编号
    "_version": 1, # 版本信息,会叠加类似git
    "result": "created", # created 新建;update 更新 
    "_shards": { # 分片
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 0,
    "_primary_term": 1
}

• POST /customer/external

post也可用于新增，如果不指定id,就会自动生成id,指定id就会修改这个数据，并新增版本号

post可以新增可以修改，put也可新增修改，但是put必须指定id,如果不指定就会报错

3、查询文档

• GET /customer/external/1

{
    "_index": "customer",
    "_type": "external",
    "_id": "1", # 记录id
    "_version": 2,
    "_seq_no": 5,  # 并发控制字段，每次更新就会+1,用来做乐观锁
    "_primary_term": 1, # 同上,主分片重新分配,如重启就会变化
    "found": true, # 表示找到了
    "_source": {  # 数据的内容
        "name": "pihao"
    }
}

# 乐观锁修改携带,表示只有在seq_no=0并且primary_term=1的情况下才会更改
PUT /customer/external/1?if_seq_no=0&if_primary_term=1 
### Body 略

4、更新文档

• POST /customer/external/1/_update

  与之前的差不多,但是这种方式的更新会与原来的值进行对比，_version不会叠加

# /_update这种方式必须要带上 "doc"
{
	"doc":{
		"name":"pihao"
	}
}

# 如果该次更改的值不发生变化，那么"result"的值就是noop,表示no opearation, _version以及_seq_no也不会改变
{
    "_index": "customer",
    "_type": "external",
    "_id": "1",
    "_version": 2,
    "result": "noop", # 没有修改
    "_shards": {
        "total": 0,
        "successful": 0,
        "failed": 0
    },
    "_seq_no": 5,
    "_primary_term": 1
}

5、删除文档和索引

• DELETE /customer/external/1 删除某条数据
• DELETE /customer 删除整个索引

注意：es中暂时没有提供删除类型的操作！

6、bulk批量API

往es中批量导入数据

• POST cusomter/external/_bulk

# 请求体的格式,这个并不是json的格式,不能在postman中测试
{"操作类型"：{"元数据"}}\n # 第一行
{"请求体"}\n # 第二行

#例如
{"index":{"_id":"1"}}
{"name":"pihao"}
{"index":{"_id":"2"}}
{"name":"haoge"}

• POST _bulk

每个执行的动作都是独立的，如果其中某个单一的动作失败了，不会影响到其他的动作

# _bulk与上面的请求不一致，没有指定index以及type
# 例 复杂示例
{"delete":{"_index":"website","_type":"blog","_id":"123"}} # 删除操作
{"create":{"_index":"website","_type":"blog","_id":"123"}} # 创建
{"title":"my first blog website"}
{"index":{"_index":"website","_type":"blog"}} # 创建
{"title":"my second blog website"}
{"update":{"_index":"website","_type":"blog","_id":"123"}} # 更新
{"doc":{"title":"my update bolg website"}}

在之前安装好的kibana中测试

7、样本测试数据

数据导入

测试数据下载地址：https://download.elastic.co/demos/kibana/gettingstarted/accounts.zip

拿到数据后在kibana测试导入（ctrl+home回到页面最顶处）

• POST /bank/acccount/_bulk

{"index":{"_id":"1"}}
{"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"}
## 后续数据省略...

四、进阶检索

1、SearchAPI

es支持两种基本方式检索：

• 一个是通过使用 REST request URL 发送搜索参数（url+检索参数）

• 另一个是通过使用 REST reqeust body 来发送检索参数

1）、检索信息

• 一切检索从 _search开始

GET /bank/_search 检索bank下的所有信息，包括docs和type

GET /bank/_search?q=*&sort=account_number:asc 请求参数方式检索

检索条件在url中

查询到1000条，默认只返回10条，类似分页查询

检索条件在请求体中

该种检索方式用的多

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

2、QueryDSL

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

1）、基本语法

# query_name有：query,form,sort,post_filter等等
query_name:{
	argument:value,
	argument:value...
}

• 如果针对某个具体字段，查询结构如下：

GET /bank/_search
{
	query_name:{
		field_name:{
			argument:value,
			argument:value...
		}
	}
}

# 分页查询 查询5条数据
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "account_number": "asc"
    }
  ],
  "from": 0,
  "size": 5
}

2）、返回部分字段 _source

类似mysql中的select 字段名 而不是select *

GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "account_number": "asc"
    }
  ],
  "from": 0,
  "size": 5,
  "_source":["balance","firstname"] # 指定需要返回的字段
}

3）、match匹配查询

• 基本类型（非字符串），精确匹配

GET /bank/_search
{
	"query":{
		"match":{
			"account_number":"20"  # 这里也可以是数字20
		}
	}
}
# match 返回account_number=20的

• 字符串，全文检索

GET /bank/_search
{
	"query":{
		"match":{
			"address":"mill"
		}
	}
}
# 返回address字段中包含"mill"的所有记录,全文检索+模糊匹配
# 全文检索按照评分经行排序，会对检索条件进行分词匹配

4）、match_phrase短语匹配

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

GET /bank/_search
{
	"query":{
		"match_phrase":{
			"address":"mill road"
		}
	}
}
# 返回address字段中包含"mill road"的所有记录，并给出相关性得分

5）、multi_match多字段匹配

GET /bank/_search
{
	"query":{
		"multi_match":{
			"query":"mill",
			"fields":["state","address"]
		}
	}
}
## 返回"state"或者"address"字段中包含有"mill"的所有记录

6）、bool复合查询

在复合查询中，用的比较多的有： must，must_not，should，filter

GET /bank/_search
{
	"query":{
		"bool":{ # 复合查询
			"must":[
				{
					"match":{
						"age":"40"
					}
				}
			],
			"must_not":[
				  {
				  "match":{
					  "gender":"F"
				  }
				}
			],
			"should": [ # 表示应该,有最好,没有也没关系,加分项
			  {
			    "match": {
			      "firstname": "Cameron"
			    }
			  }
			]
		}
	}
}
# 返回age=20并且gender!=F的所有数据

7）、filter 结果过滤

filter的作用和must的作用差不多，但是使用filter不会维护score得分

GET /bank/_search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "age": {
            "gte": 18,
            "lte": 30
          }
        }
      }
    }
  }
}
# 返回age在18-30范围的数据

GET /bank/_search
{
  "query": {
    "bool": {
      "must": [ # 使用must与上面的效果一样，不同的是会维护score
        {
          "range": {
            "age": {
              "gte": 18,
              "lte": 30
            }
          }
        }
      ]
    }
  }
}

8）、term

和match一样，匹配某个属性的值。全文检索字段用match，其他非text字段匹配用tern

GET /bank/_search
{
	"query":{
		"term":{
			"age":28
		}
	}
}
# 记住：查询非文本字段使用term语句,文本的就是用match

来看一个现象 match_phrase和 .keyword的区别

9）、aggregations 执行聚合

聚合提供了从数据中分组和提取数据的能力，最简单的聚合方法大致等于 sql group by 和sql的聚合函数，在ElasticSearch中，你可以执行查询和多个聚合，并且在一次使用中得到各自的返回结果，使用一次简洁和简化的API来避免网络往返

## 搜索address中包含有mill的所有人的年龄分布以及平均年龄
GET /bank/_search
{
	"query":{
		"match":{
			"address":"mill"
		}
	},
	"aggs":{ # 表示聚合
		"ageAgg":{ # 第一个聚合,取个名字
			"terms":{ # 聚合类型 
				"field":"age",
                 "order": { "_count": "asc" } # 按数量排序
				"size":10 # 只看10个
			}
		},
		"ageAvg":{ # 第二个聚合,取个名字
			"avg":{ # 聚合类型
				"field":"age"
			}
		}
	},
	"size":0 # 如果不想看具体的击中数据可以加size限定
}

按照年龄聚合,并且请求这些年龄段的这些人的平均薪资

# 第一步,先查出年龄分布
GET /bank/_search
{
	"query":{
		"match_all":{}
	},
	"aggs":{
		"ageAgg":{
			"terms":{
				"field":"age",
				"size":100
			}
		}
	}
}

# 然后还要查询出里面每个年龄的平均工资,那么就需要进行子聚合

# 第二部 继续进行子聚合
GET /bank/_search
{
	"query":{
		"match_all":{}
	},
	"aggs":{
		"ageAgg":{
			"terms":{
				"field":"age",
				"size":100
			},
			"aggs":{ # 在ageAgg聚合中继续聚合
				"ageAvg":{
					"avg":{
						"field":"balance" # 求薪资的平均值
					}
				}
			}
		}
	}
}

查出所有年龄分布，并且这些年龄段中M的平均新增和F的平均薪资以及这个年龄段的总体平均薪资

GET /bank/_search
{
	"query":{
		"match_all":{}
	},
	"aggs":{
		"ageAgg":{
			"terms":{ # 先找出所有年龄的分布:数量就是每个年龄的数量 ageCount
				"field":"age",
				"size":100
			},
			"aggs":{
				"ageBalanceAvg":{ # 所有年龄分布的总平均薪资
					"avg":{
						"field":"balance"
					}
				},
				"genderAgg":{
                    "terms":{ # 对每个年龄按性别再次分布:数量就是：ageCount x 2
                        "field":"gender.keyword"
                    },
                    "aggs":{
                    	"balanceAvg":{
                    		"avg":{
                    			"field":"balance"
                    		}
                    	}
                    }
				}
			}
		}
	}
}

3、Mapping

1）、字段类型

2）、映射

Maping是用来定义一个文档document,以及它所包含的属性field是如何存储和索引的，比如

• 哪些字符串属性应该看作全文本属性
• 哪些属性包含数字，日期或者地理位置
• 文档中的所有属性是否都能被索引
• 日期的格式
• 自定义映射规则来执行动态添加属性

查看mapping信息

GET /bank/_mapping

3）、新版本改动

1、创建映射

PUT /my_index # 发送put请求
{
	"mappings":{
		"properties":{
			"age":{"type":"integer"},
			"email":{"type":"keyword"},
			"name":{"type":"text"}
		}
	}
}

### 返回结果
{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "my_index"
}

2、添加新的字段映射

PUT /my_index/_mapping
{
	"properties":{
		"employee-id":{ # 新增加一个employee-id的字段,类型为keyword精确匹配
			"type":"keyword",
			"index":false # 不需要被索引,默认的是所有的index都为true
		}
	}
}

## 返回结果
{
  "acknowledged" : true
}

3、更新映射

对于已经存在的映射字段，我们不能更新。这就好比你mysql数据库中已经有数据了，你突然给我说有个字段定义的类型错了。尼玛的揍不死你！所以这样的操作不允许的，必须要创建新的索引进行数据迁移

4、数据迁移

先创建出 newbank 的正确映射。然后使用如下方式经行数据迁移

# 创建新索引并重新指定映射类型
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": "keyword"},
			"state":{"type": "keyword"}
		}
	}
}

### 结果返回
{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "newbank"
}

## 导入数据
POST /_reindex
{
	"source":{
		"index":"bank",
		"type":"account" # 老版本导入数据时指定这个type,版本7之后舍弃了type这个概念(测试：可以不用加type)
	},
	"dest":{
		"index":"newbank"
	}
}
## ok

4、分词

一个tokenizer（分词器）接收一个字符流，将之分割为独立的tokens（词元，通常是独立的单词），然后输出tokens流

参考官方文档Analyzers章节 https://www.elastic.co/guide/en/elasticsearch/reference/7.5/analysis-standard-analyzer.html

# 测试
POST _analyze
{
  "analyzer": "standard",
  "text": "张坤你要挺住"
}

## 发现返回一个一个的汉字,这就是默认分词器的效果,所以我们需要下载我们自己的分词器,这样就能识别中文的短语
{
  "tokens" : [
    {
      "token" : "张",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "坤",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    }]
 }

1）、安装ik分词器

注意：不能使用默认的 elasticsearch-plugin install xxx.zip 进行安装

下载地址： https://github.com/medcl/elasticsearch-analysis-ik/releases 下载对应版本

# 将下载好的ik分词器安装包放置在docker的外部挂载文件中
[root@pihao plugins]# pwd
/mydata/elasticsearch/plugins
[root@pihao plugins]# ls
elasticsearch-analysis-ik-7.4.2.zip  # 使用unzip解压出来
[root@pihao plugins]# unzip elasticsearch-analysis-ik-7.4.2.zip -d 指定的目录

# 紧接着查看docker容器中的elasticsearch,看看ik分词器有没有安装好
[root@pihao plugins]# docker ps
CONTAINER ID   IMAGE                 COMMAND                  CREATED        STATUS             
feb7cdd7b777   kibana:7.4.2          "/usr/local/bin/dumb…"   45 hours ago   Up 45 hours   
a1b49510002c   elasticsearch:7.4.2   "/usr/local/bin/dock…"   46 hours ago   Up 46 hours   

[root@pihao plugins]# docker exec -it a1b49510002c /bin/bash
[root@a1b49510002c elasticsearch]# cd plugins/
[root@a1b49510002c plugins]# ls
ik7.4.2 # 解压安装的ik分词器
[root@a1b49510002c plugins]# cd ..
[root@a1b49510002c elasticsearch]# cd bin/
[root@a1b49510002c bin]# elasticsearch-plugin list 查看已安装的插件
ik7.4.2 # 显示已安装了ik
[root@a1b49510002c bin]# 安装成功

2、测试分词器

测试之前记得重启docker elasticsearch 容器

# analyzer 指定为 ik_smart \ ik_max_word

3、自定义词库

由于安装解压的词库还不能满足我们日常网络用于所需，所以我们需要导入新的词库

1、启动一个nginx应用

为了演示，我们需要启动一个能访问的应用tomcat或者nginx都行，在这里我就快速启动一个nginx吧，然后添加自己的词库

## 安装nginx 
[root@pihao mydata]#  docker run -p 80:80 --name nginx -d nginx:1.10
# 复制nginx容器中的配置文件
[root@pihao mydata]# ls
elasticsearch  mysql  nginx  redis
[root@pihao mydata]# docker container cp nginx:/etc/nginx .    将容器中nginx的/etc/nginx下的文件复制
[root@pihao mydata]# ls
elasticsearch  mysql  nginx  redis
[root@pihao mydata]# cd nginx/
[root@pihao nginx]# ls
conf.d  fastcgi_params  koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params  uwsgi_params 
[root@pihao nginx]# 然后停掉nginx,把上述的nginx文件名字改为conf,然后再创建一个nginx的文件夹,把conf移入nginx上面启动一个nginx的容器主要是为了获得里面的配置文件。不然启动的时候没法挂载配置文件

# 正式启动nginx
[root@pihao nginx]# docker run -p 80:80 --name nginx \
-v /mydata/nginx/html:/usr/share/nginx/html \
-v /mydata/nginx/logs:/var/log/nginx \
-v /mydata/nginx/conf:/etc/nginx \
-d nginx:1.10

[root@pihao nginx]# 启动成功,在nginx/html里面写一个index.html文件  <h1>hello nginx</h1> 启动测试成功！

添加自定义的分词

## 在nginx的html配置下新建es文件夹,创建fenci.txt文件再添加如下测试内容

[root@pihao es]# pwd
/mydata/nginx/html/es
[root@pihao es]# ls
fenci.txt
[root@pihao es]# cat fenci.txt
张坤
菜嵩松
刘彦春
朱少醒
谢志宇
葛兰
[root@pihao es]# 测试访问 http://112.74.167.52/es/fenci.txt    测试无误 可以从elasticsearch中引入了！

2、引入nginx的词库

修改/usr/share/elasticsearch/plugins/ik/config中的IKAnalyzer.cfg.xml

[root@pihao config]# pwd
/mydata/elasticsearch/plugins/ik7.4.2/config
[root@pihao config]# ls
extra_main.dic         extra_single_word_full.dic      extra_stopword.dic  main.dic         quantifier.dic  suffix.dic
extra_single_word.dic  extra_single_word_low_freq.dic  IKAnalyzer.cfg.xml  preposition.dic  stopword.dic    surname.dic
[root@pihao config]# vim IKAnalyzer.cfg.xml

保存退出后重启docker elasticsearch

测试成功

五、SpingBoot整合ElasticSearch

Elasticsearch-Rest-Client 官方提供的RestClient,封装了ES的操作，API层次分明，上手简单

官方地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high.html

引入Maven依赖

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

注入RestHighLevelClient

@Configuration
public class ElasticSearchConfig {

    @Bean
    public RestHighLevelClient esRestClient(){
        RestHighLevelClient esRestClient = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("主机ip", 9200, "http")));
        return esRestClient;
    }
    
    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
//        builder.addHeader("Authorization", "Bearer " + TOKEN); 需要的话就配置
//        builder.setHttpAsyncResponseConsumerFactory(
//                new HttpAsyncResponseConsumerFactory
//                        .HeapBufferedResponseConsumerFactory(30 * 1024 * 1024 * 1024));
        COMMON_OPTIONS = builder.build();
    }

}

测试保存数据

 /**
     * 测试存储数据
     */
    @Test
    public void indexData() throws IOException {
        IndexRequest indexRequest = new IndexRequest("users");
        indexRequest.id("1");
        User user = new User();
        user.setUserName("pihao");
        user.setAge(20);
        user.setGender("male");
        String jsonString = JSON.toJSONString(user);
        indexRequest.source(jsonString, XContentType.JSON); //直接传入json字符串,指定 application/json

        //同步执行操作
        IndexResponse index = client.index(indexRequest,ElasticSearchConfig.COMMON_OPTIONS);
        //提取有用的响应数据
        System.out.println(index.toString());

    }

测试检索

@Test
    public void searchData() throws IOException {
        //创建检索请求
        SearchRequest searchRequest = new SearchRequest();
        //指定索引
        searchRequest.indices("bank");
        //指定DSL,检索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
            //构造检索条件
            sourceBuilder.query(QueryBuilders.matchQuery("address","mill"));
            //按照年龄的值分布来聚合
            TermsAggregationBuilder ageAgg = AggregationBuilders.terms("ageAgg").field("age").size(10);
            sourceBuilder.aggregation(ageAgg);
            //按照薪资聚合
            AvgAggregationBuilder balanceAgg = AggregationBuilders.avg("balanceAgg").field("balance");
            sourceBuilder.aggregation(balanceAgg);
//            sourceBuilder.from();
//            sourceBuilder.size();
        System.out.println("检索条件："+sourceBuilder.toString());
        searchRequest.source(sourceBuilder);

        //执行检索
        SearchResponse searchResponse = client.search(searchRequest,ElasticSearchConfig.COMMON_OPTIONS);
        //分析结果
        SearchHits hits = searchResponse.getHits(); //外层最大的hits
        SearchHit[] searchHits = hits.getHits(); //真正的记录
        for (SearchHit hit :searchHits) {
            /**
             * "_index" : "bank","_type" : "acccount","_id" : "1","_score" : 1.0,"_source"  都有相应的get方法
             */
            String jsonStr = hit.getSourceAsString(); //将返回的source转为json,最后肯定需要映射成java实体类
            Account account = JSON.parseObject(jsonStr, Account.class);
            System.out.println(account);
        }

        // 获取检索到的聚合信息
        Aggregations aggregations = searchResponse.getAggregations();
        Terms ageAgg1 = aggregations.get("ageAgg"); //这里的ageAgg是term类型的,所以可以转成Terms
        List<? extends Terms.Bucket> buckets = ageAgg1.getBuckets();
        for (Terms.Bucket bucket:buckets) {
            String keyAsString = bucket.getKeyAsString(); //打印年龄种类
            long docCount = bucket.getDocCount(); //打印每种年龄出现的频率
            System.out.println("年龄: "+keyAsString+"=====> 频率: "+docCount);
        }
        Avg balanceAvg = aggregations.get("balanceAgg"); //balanceAgg是avg的类型
        double value = balanceAvg.getValue();
        System.out.println("平均薪资是: "+value);


//        for (Aggregation aggregation:aggregations.asList()) {   //可以直接如上面获取到具体的聚合
//            System.out.println("当前聚合的名字："+aggregation.getName());
//        }
    }

加油！！！