代码收藏家 【微服务教程】第29节：使用 RestClient 查询 ElasticSearch 数据
目录
1.RestClient查询
1.1.快速入门
1.1.1.发送请求
1.1.2.解析响应结果
1.1.3.总结
1.2.叶子查询
1.3.复合查询
1.4.排序和分页
1.5.高亮
2.数据聚合
2.1.DSL实现聚合
2.1.1.Bucket聚合
2.1.2.带条件聚合
2.1.3.Metric聚合
2.1.4.总结
2.2.RestClient实现聚合
1.RestClient查询
文档的查询依然使用学习的 RestHighLevelClient对象，查询的基本步骤如下⁉️ ：
1）创建request对象，这次是搜索，所以是SearchRequest
2）准备请求参数，也就是查询DSL对应的JSON参数
3）发起请求
4）解析响应，响应结果相对复杂，需要逐层解析
1.1.快速入门
之前说过，由于Elasticsearch对外暴露的接口都是Restful风格的接口，因此JavaAPI调用就是在发送Http请求。而我们核心要做的就是利用利用Java代码组织请求参数，解析响应结果。
这个参数的格式完全参考DSL查询语句的JSON结构，因此我们在学习的过程中，会不断的把JavaAPI与DSL语句对比。大家在学习记忆的过程中，也应该这样对比学习。
1.1.1.发送请求
首先以match_all查询为例，其DSL和JavaAPI的对比如图：
代码解读：
☑️第一步，创建SearchRequest对象，指定索引库名
☑️第二步，利用request.source()构建DSL，DSL中可以包含查询、分页、排序、高亮等
query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL
☑️第三步，利用client.search()发送请求，得到响应
这里关键的API有两个，一个是request.source()，它构建的就是DSL中的完整JSON参数。其中包含了query、sort、from、size、highlight等所有功能：
另一个是QueryBuilders，其中包含了我们学习过的各种叶子查询、复合查询等：
1.1.2.解析响应结果
在发送请求以后，得到了响应结果SearchResponse，这个类的结构与我们在kibana中看到的响应结果JSON结构完全一致：
{
"took" : 0,
"timed_out" : false,
"hits" : {
"total" : {
"value" : 2,
"relation" : "eq"
},
"max_score" : 1.0,
"hits" : [
{
"_index" : "heima",
"_type" : "_doc",
"_id" : "1",
"_score" : 1.0,
"_source" : {
"info" : "Java讲师",
"name" : "赵云"
}
}
]
}
}因此，我们解析SearchResponse的代码就是在解析这个JSON结果，对比如下：
代码解读：
elasticsearch返回的结果是一个JSON字符串，结构包含：
hits：命中的结果
total：总条数，其中的value是具体的总条数值
max_score：所有结果中得分最高的文档的相关性算分
hits：搜索结果的文档数组，其中的每个文档都是一个json对象
_source：文档中的原始数据，也是json对象
因此，我们解析响应结果，就是逐层解析JSON字符串，流程如下：
SearchHits：通过response.getHits()获取，就是JSON中的最外层的hits，代表命中的结果
SearchHits#getTotalHits().value：获取总条数信息
SearchHits#getHits()：获取SearchHit数组，也就是文档数组
SearchHit#getSourceAsString()：获取文档结果中的_source，也就是原始的json文档数据
1.1.3.总结
🔍文档搜索的基本步骤是：
创建
SearchRequest对象准备
request.source()，也就是DSL。
QueryBuilders来构建查询条件传入
request.source()的query()方法发送请求，得到结果
解析结果（参考JSON结果，从外到内，逐层解析）
完整代码如下
1.2.叶子查询
所有的查询条件都是由QueryBuilders来构建的，叶子查询也不例外。因此整套代码中变化的部分仅仅是query条件构造的方式，其它不动。
例如match查询：
@Test
void testMatch() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}再比如multi_match查询：
@Test
void testMultiMatch() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
request.source().query(QueryBuilders.multiMatchQuery("脱脂牛奶", "name", "category"));
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}还有range查询：
@Test
void testRange() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
request.source().query(QueryBuilders.rangeQuery("price").gte(10000).lte(30000));
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}还有term查询：
@Test
void testTerm() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
request.source().query(QueryBuilders.termQuery("brand", "华为"));
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}1.3.复合查询
复合查询也是由QueryBuilders来构建，我们以bool查询为例，DSL和JavaAPI的对比如图：
完整代码如下：
@Test
void testBool() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
// 2.1.准备bool查询
BoolQueryBuilder bool = QueryBuilders.boolQuery();
// 2.2.关键字搜索
bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 2.3.品牌过滤
bool.filter(QueryBuilders.termQuery("brand", "德亚"));
// 2.4.价格过滤
bool.filter(QueryBuilders.rangeQuery("price").lte(30000));
request.source().query(bool);
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}1.4.排序和分页
之前说过，requeset.source()就是整个请求JSON参数，所以排序、分页都是基于这个来设置，其DSL和JavaAPI的对比如下：
完整示例代码：
@Test
void testPageAndSort() throws IOException {
int pageNo = 1, pageSize = 5;
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
// 2.1.搜索条件参数
request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 2.2.排序参数
request.source().sort("price", SortOrder.ASC);
// 2.3.分页参数
request.source().from((pageNo - 1) * pageSize).size(pageSize);
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}1.5.高亮
高亮查询与前面的查询有两点不同：
条件同样是在request.source()中指定，只不过高亮条件要基于HighlightBuilder来构造
高亮响应结果与搜索的文档结果不在一起，需要单独解析
首先来看高亮条件构造，其DSL和JavaAPI的对比如图：
示例代码如下：
@Test
void testHighlight() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
// 2.1.query条件
request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 2.2.高亮条件
request.source().highlighter(
SearchSourceBuilder.highlight()
.field("name")
.preTags("<em>")
.postTags("</em>")
);
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}再来看结果解析，文档解析的部分不变，主要是高亮内容需要单独解析出来，其DSL和JavaAPI的对比如图：
代码解读：
第3、4步：从结果中获取_source。hit.getSourceAsString()，这部分是非高亮结果，json字符串。还需要反序列为ItemDoc对象
第5步：获取高亮结果。hit.getHighlightFields()，返回值是一个Map，key是高亮字段名称，值是HighlightField对象，代表高亮值
第5.1步：从Map中根据高亮字段名称，获取高亮字段值对象HighlightField
第5.2步：从HighlightField中获取Fragments，并且转为字符串。这部分就是真正的高亮字符串了
最后：用高亮的结果替换ItemDoc中的非高亮结果
完整代码如下：
private void handleResponse(SearchResponse response) {
SearchHits searchHits = response.getHits();
// 1.获取总条数
long total = searchHits.getTotalHits().value;
System.out.println("共搜索到" + total + "条数据");
// 2.遍历结果数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
// 3.得到_source，也就是原始json文档
String source = hit.getSourceAsString();
// 4.反序列化
ItemDoc item = JSONUtil.toBean(source, ItemDoc.class);
// 5.获取高亮结果
Map<String, HighlightField> hfs = hit.getHighlightFields();
if (CollUtils.isNotEmpty(hfs)) {
// 5.1.有高亮结果，获取name的高亮结果
HighlightField hf = hfs.get("name");
if (hf != null) {
// 5.2.获取第一个高亮结果片段，就是商品名称的高亮值
String hfName = hf.getFragments()[0].string();
item.setName(hfName);
}
}
System.out.println(item);
}
}2.数据聚合
聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析、运算。例如：
什么品牌的手机最受欢迎？
这些手机的平均价格、最高价格、最低价格？
这些手机每月的销售情况如何？
实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。
官方文档：
https://www.elastic.co/guide/en/elasticsearch/reference/7.12/search-aggregations.html
聚合常见的有三类：
桶（Bucket）聚合：用来对文档做分组
TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
Avg：求平均值
Max：求最大值
Min：求最小值
Stats：同时求max、min、avg、sum等
管道（pipeline）聚合：其它聚合的结果为基础做进一步运算
注意：参加聚合的字段必须是keyword、日期、数值、布尔类型
2.1.DSL实现聚合
与之前的搜索功能类似，我们依然先学习DSL的语法，再学习JavaAPI.
2.1.1.Bucket聚合
例如我们要统计所有商品中共有哪些商品分类，其实就是以分类（category）字段对数据分组。category值一样的放在同一组，属于Bucket聚合中的Term聚合。
基本语法如下：
GET /items/_search
{
"size": 0,
"aggs": {
"category_agg": {
"terms": {
"field": "category",
"size": 20
}
}
}
}语法说明：
size：设置size为0，就是每页查0条，则结果中就不包含文档，只包含聚合
aggs：定义聚合
category_agg：聚合名称，自定义，但不能重复
terms：聚合的类型，按分类聚合，所以用term
field：参与聚合的字段名称
size：希望返回的聚合结果的最大数量
来看下查询的结果：
2.1.2.带条件聚合
默认情况下，Bucket聚合是对索引库的所有文档做聚合，例如我们统计商品中所有的品牌，结果如下：
可以看到统计出的品牌非常多。
但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。
例如，我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？
我们需要从需求中分析出搜索查询的条件和聚合的目标：
搜索查询条件：
价格高于3000
必须是手机
聚合目标：统计的是品牌，肯定是对brand字段做term聚合
语法如下：
GET /items/_search
{
"query": {
"bool": {
"filter": [
{
"term": {
"category": "手机"
}
},
{
"range": {
"price": {
"gte": 300000
}
}
}
]
}
},
"size": 0,
"aggs": {
"brand_agg": {
"terms": {
"field": "brand",
"size": 20
}
}
}
}聚合结果如下：
{
"took" : 2,
"timed_out" : false,
"hits" : {
"total" : {
"value" : 13,
"relation" : "eq"
},
"max_score" : null,
"hits" : [ ]
},
"aggregations" : {
"brand_agg" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [
{
"key" : "华为",
"doc_count" : 7
},
{
"key" : "Apple",
"doc_count" : 5
},
{
"key" : "小米",
"doc_count" : 1
}
]
}
}
}
可以看到，结果中只剩下3个品牌了。
2.1.3.Metric聚合
上节课，我们统计了价格高于3000的手机品牌，形成了一个个桶。现在我们需要对桶内的商品做运算，获取每个品牌价格的最小值、最大值、平均值。
这就要用到Metric聚合了，例如stat聚合，就可以同时获取min、max、avg等结果。
语法如下：
GET /items/_search
{
"query": {
"bool": {
"filter": [
{
"term": {
"category": "手机"
}
},
{
"range": {
"price": {
"gte": 300000
}
}
}
]
}
},
"size": 0,
"aggs": {
"brand_agg": {
"terms": {
"field": "brand",
"size": 20
},
"aggs": {
"stats_meric": {
"stats": {
"field": "price"
}
}
}
}
}
}query部分就不说了，我们重点解读聚合部分语法。
可以看到我们在brand_agg聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。
stats_meric：聚合名称
stats：聚合类型，stats是metric聚合的一种
field：聚合字段，这里选择price，统计价格
由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值。
结果如下：
另外，我们还可以让聚合按照每个品牌的价格平均值排序：
2.1.4.总结
aggs代表聚合，与query同级，此时query的作用是？
限定聚合的的文档范围
聚合必须的三要素：
聚合名称
聚合类型
聚合字段
聚合可配置属性有：
size：指定聚合结果数量
order：指定聚合结果排序方式
field：指定聚合字段
2.2.RestClient实现聚合
可以看到在DSL中，aggs聚合条件与query条件是同一级别，都属于查询JSON参数。因此依然是利用request.source()方法来设置。
不过聚合条件的要利用AggregationBuilders这个工具类来构造。DSL与JavaAPI的语法对比如下：
聚合结果与搜索文档同一级别，因此需要单独获取和解析。具体解析语法如下：
完整代码如下：
@Test
void testAgg() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.准备请求参数
BoolQueryBuilder bool = QueryBuilders.boolQuery()
.filter(QueryBuilders.termQuery("category", "手机"))
.filter(QueryBuilders.rangeQuery("price").gte(300000));
request.source().query(bool).size(0);
// 3.聚合参数
request.source().aggregation(
AggregationBuilders.terms("brand_agg").field("brand").size(5)
);
// 4.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 5.解析聚合结果
Aggregations aggregations = response.getAggregations();
// 5.1.获取品牌聚合
Terms brandTerms = aggregations.get("brand_agg");
// 5.2.获取聚合中的桶
List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
// 5.3.遍历桶内数据
for (Terms.Bucket bucket : buckets) {
// 5.4.获取桶内key
String brand = bucket.getKeyAsString();
System.out.print("brand = " + brand);
long count = bucket.getDocCount();
System.out.println("; count = " + count);
}
}作者：枫蜜柚子茶
