微服务开发与实战Day09 - Elasticsearch - 酸梨子-专注技术分享

一、DSL查询

Elasticsearch提供了DSL（Domain Specific Language）查询，就是以JSON格式来定义查询条件。类似这样：

DSL查询可以分为两大类：

叶子查询（Leaf query clauses）：一般是在特定的字段里查询特定值，属于简单查询，很少单独使用。
复合查询（Compound query clauses）：以逻辑方式组合多个叶子查询或者更改叶子查询的行为方式。

在查询以后，还可以对查询的结果做处理，包括：

排序：按照1个或多个字段值做排序
分页：根据from和size做分页，类似MySQL
高亮：对搜索结果中的关键字添加特殊样式，使其更加醒目
复合：对搜索结果做数据统计以形成报表

1. 快速入门

基于DSL的查询语法如下：

GET /{索引库名}/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}

例如，以最简单的无条件查询为例，无条件查询到类型是：match_all，因此其查询语句如下：

# 查询所有
GET /items/_search
{
  "query": {
    "match_all": {
      
    }
  }
}

查询结果：

你会发现虽然是match_all，但是响应结果中并不会包含索引库中的所有文档，而是仅有10条。这是因为处于安全考虑，elasticsearch设置了默认的查询页数。

2. 叶子查询

Query DSL | Elasticsearch Guide [7.12] | Elastic

叶子查询还可以进一步细分，常见的有：

全文检索（full text）查询：利用分词器对用户输入内容分词，然后去词表列表中匹配。例如：

match_query
multi_match_query

精确查询：不对用户输入内容分词，直接精确匹配，一般是查找keyword、数值、日期、布尔等类型。例如：

ids
range
term

地理（geo）查询：用于搜索地理位置，搜索方式很多。例如：

geo_distance
geo_bounding_box

2.1 全文检索查询：

match查询：全文检索查询的一种，会对用户输入内容分词，然后去倒排索引库检索，语法：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "字段名": "搜索条件"
    }
  }
}

例如，

# match查询
GET /items/_search
{
  "query": {
    "match": {
      "name": "女式牛仔裤"
    }
  }
}

multi_macth查询：与match查询类似，只不过允许同时查询多个字段，参与查询字段越多，查询性能越差，语法：

GET /{索引库名}/_search
{
  "query": {
    "multi_match": {
      "query": "搜索条件",
      "fields": ["字段1", "字段2"]
    }
  }
}

例如，

# multi_match查询
GET /items/_search
{
  "query": {
    "multi_match": {
      "query": "女式牛仔裤",
      "fields": ["name", "category"]
    }
  }
}

2.2 精确查询

term查询：根据词条精确匹配，一般搜索keyword类型、数值类型、布尔类型、日期类型字段，语法：

GET /{索引库名}/_search
{
  "query": {
    "term": {
      "字段名": {
        "value": "搜索条件"
      }
    }
  }
}

例如，

# term查询
GET /items/_search
{
  "query": {
    "term": {
      "brand": {
        "value": "德亚"
      }
    }
  }
}

range查询：根据数值范围查询，可以是数值、日期的范围，语法：

GET /{索引库名}/_search
{
  "query": {
    "range": {
      "字段名": {
        "gte": {最小值},
        "lte": {最大值}
      }
    }
  }
}

例如，

# range查询
GET /items/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 50000,
        "lte": 100000
      }
    }
  }
}

ids查询：根据id集合进行查询，语法：

GET /{索引库名}/_search
{
  "query": {
    "ids": {
      "value": ["id值1", "id值2"]
      }
    }
  }
}

例如，

# ids查询
GET /items/_search
{
  "query": {
    "ids": {
      "values": ["613359", "627719"]
    }
  }
}

3. 复合查询

Compound queries | Elasticsearch Guide [7.12] | Elastic

复合查询大致可以分为两类：

第一类：基于逻辑运算组合叶子查询，实现组合条件，例如：

bool

第二类：基于某种算法修改查询时的文档相关性算分，从而改变文档排名。例如：

function_score
dis_max

3.1 bool查询

布尔查询是一个或多个查询子句的组合。子查询的组合方式有：

must：必须匹配每个子查询，类似”与“
should：选择性匹配子查询，类似”或“
must_not：必须不匹配，不参与算分，类似”非“
filter：必须匹配，不参与算分

bool查询的语法如下：

GET /items/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}}
      ],
      "should": [
        {"term": {"brand": { "value": "vivo" }}},
        {"term": {"brand": { "value": "小米" }}}
      ],
      "must_not": [
        {"range": {"price": {"gte": 2500}}}
      ],
      "filter": [
        {"range": {"price": {"lte": 1000}}}
      ]
    }
  }
}

出于性能考虑，与搜索关键字无关的查询尽量采用must_not或filter逻辑运算，避免参与相关性算分。

例如黑马商城的搜索页面：

其中输入框的搜索条件肯定要参与相关性算分，可以采用match。但是价格范围过滤、品牌过滤、分类过滤等尽量采用filter，不要参与相关性算分。

比如，我们要搜索手机，但品牌必须是华为，价格必须是900~1599，那么可以这样写：

GET /items/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}}
      ],
      "filter": [
        {"term": {"brand": { "value": "华为" }}},
        {"range": {"price": {"gte": 90000, "lt": 159900}}}
      ]
    }
  }
}

3.2 算分函数查询

当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排序。

例如，我们搜索”手机“”，结果如下：

从Elasticsearch5.1开始，采用的相关性打分算法是BM25算法，公式如下：

基于这套公式，就可以判断出某个文档与用户搜索的关键字之间的关联度。但是在实际业务需求中，常常会有竞价排名的功能。不是相关度越高排名越靠前，而是掏的钱越多排名越靠前。

要想人为控制相关性算分，就需要利用elasticsearch中的function score查询了。

基本语法：

function score查询中包含四部分内容：

原始查询条件：query部分，基于这个条件搜索文档，并且基于BM25算法给文档打分，原始算分（query score）

过滤条件：filter部分，符合该条件的文档才会重新算分

算分函数：符合filter条件的文档要根据这个函数做运算，得到的函数算分（function score），有四种函数

weight：函数结果是常量
field_value_factor：以文档中的某个字段值作为函数结果
random_score：以随机数作为函数结果
script_score：自定义算分函数算法

运算模式：算分函数的结果、原始查询的相关性算分，两者之间的运算方式，包括：

multiply：相乘
replace：用function score替换query score
其它，例如：sum、avg、max、min

function score的运行流程如下：

①根据原始条件查询搜索文档，并且计算相关性算分，称为原始算分（query score）
②根据过滤条件，过滤文档
③符合过滤条件的文档，基于算分函数运算，得到函数算分（function score）
④将原始算分（query score）和函数算分（function score）基于运算模式做运算，得到最终结果，作为相关性算分。

因此，其中的关键点是：

过滤条件：决定哪些文档的算分被修改
算分函数：决定函数算分的算法
运算模式：决定最终算分结果

示例：给IPhone这个品牌的手机算分提高十倍，分析如下：

过滤条件：品牌必须为IPhone
算分函数：常量weight，值为10
算分模式：相乘multiply

对应的代码如下：

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {  .... }, // 原始查询，可以是任意条件
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是Iphone
            "term": {
              "brand": "Iphone"
            }
          },
          "weight": 10 // 算分权重为2
        }
      ],
      "boost_mode": "multipy" // 加权模式，求乘积
    }
  }
}

4. 排序和分页

排序

elasticsearch支持对搜索结果排序，默认是根据相关度算分（_score）来排序，也可以指定字段排序。可以排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

语法：

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "排序字段": {
        "order": "排序方式asc和desc"
      }
    }
  ]
}

示例，按照商品销量排序，销量一样则按照价格升序排序：

GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "sold": {
        "order": "desc"
      }
    },
    {
      "price": {
        "order": "asc"
      }
    }
  ]
}

分页

基础分页

elasticsearch默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。elasticsearch中通过修改from、size参数来控制要返回的分页结果：

from：从第几个文档开始
size：总共查询几个文档

语法：

GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10,  // 每页文档数量，默认10
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

深度分页

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。查询数据时需要汇总各个分片的数据。

假如我们需要查询第100页数据，每页查10条：

GET /items/_search
{
  "from": 990, // 从第990条开始查询
  "size": 10, // 每页查询10条
  "sort": [
    {
      "price": "asc"
    }
  ]
}

实现思路：

①对数据排序
②找出第990~1000名

要知道每一片的数据都不一样，第1片上的第900~1000，在另1个节点上并不一定依然是900~1000名。所以我们只能在每一个分片上都找出排名前1000的数据，然后汇总到一起，重新排序，才能找出整个索引库中真正的前1000名，此时截取990~1000的数据即可。

试想一下，假如我们现在要查询的是第999页数据呢，是不是要找第9990~10000的数据，那岂不是需要把每个分片中的前10000名数据都查询出来，汇总在一起，在内存中排序？如果查询的分页深度更深呢，需要一次检索的数据岂不是更多？

由此可知，当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。因此elasticsearch会禁止from+ size 超过10000的请求。

针对深度分页，ES提供了两种解决方案：Paginate search results | Elasticsearch Guide [7.12] | Elastic

rsearch after：分页式需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式

优点：没有查询上限，支持深度分页
缺点：只能向后逐页查询，不能随机翻页
场景：数据迁移、手机滚动查询

scroll：原理将排序数据形成快照，保存在内存。官方已经不推荐使用。

5. 高亮显示

高亮显示：就是在搜索结果中把搜索关键字突出显示

实现高亮的思路就是：

用户输入搜索关键字搜索数据
服务端根据搜索关键字到elasticsearch搜索，并给搜索结果中的关键字词条添加html标签
前端提前给约定好的html标签添加CSS样式

基本语法如下：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "搜索字段": "搜索关键字"
    }
  },
  "highlight": {
    "fields": {  // 指定要高亮的字段
      "高亮字段名称": {
        "pre_tags": "<em>",  // 高亮的前置标签
        "post_tags": "</em>"  // 高亮的后置标签
      }
    }
  }
}

例如，

# 高亮
GET /items/_search
{
  "query": {
    "match": {
      "name": "脱脂牛奶"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

二、JavaRestClient查询

1. 快速入门

数据搜索的Java代码分为两部分：

构建并发起请求
解析查询结果

1.1 构建并发起请求

代码解读：

第一步，创建SearchRequest对象，指定索引库名
第二步，利用request.source()构建DSL，DSL中可以包含查询、分页、排序、高亮等
- query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL
第三步，利用client.search()发送请求，得到响应

这里关键的API有两个，一个是request.source()，它构建的就是DSL中的完整JSON参数。其中包含了query、sort、from、size、highlight等所有功能：

另一个是QueryBuilders，其中包含了我们学习过的各种叶子查询、复合查询等：

示例：

    @Test
    void testMatchAll() throws IOException {
        // 1. 创建request对象
        SearchRequest request = new SearchRequest("items");
        // 2. 配置request参数
        request.source()
                .query(QueryBuilders.matchAllQuery());
        // 3. 发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        System.out.println("response = " + response);
    }

1.2 解析查询结果

解析查询结果的API：

完整代码：

@Test
void testMatchAll() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    request.source().query(QueryBuilders.matchAllQuery());
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

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);
        System.out.println(item);
    }
}

2. 构建查询条件

在JavaRestAPI中，所有类型的query查询条件都是由QueryBuilders来构建的：

全文检索的查询条件构造API如下：

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);
}

精确查询的查询条件构造API如下：

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);
}

复合查询也是由QueryBuilders来构建，以bool查询为例：

案例：构建复杂条件的搜索

需求：利用JavaRestClient实现搜索功能，条件如下：

搜索关键字为脱脂牛奶
品牌必须为德亚
价格必须低于300元

@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);
}

3. 排序和分页

与query类似，排序和分页参数都是基于request.source()来设置：

@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);
}

4. 高亮显示

高亮查询与前面的查询有两点不同：

条件同样是在request.source()中指定，只不过高亮条件要基于HighlightBuilder来构造
高亮响应结果与搜索的文档结果不在一起，需要单独解析

高亮显示的条件构造API如下：

示例代码：

@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.解析响应
    parseResponseResult(response);
}

高亮显示的结果解析API如下：

完整代码：

    @Test
    void testHighlight() 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().highlighter(
                SearchSourceBuilder
                        .highlight()
                        .field("name")
                        .preTags("<em>")
                        .postTags("</em>")
        );
        // 3. 发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4. 解析响应
        parseResponseResult(response);
    }

    private static void parseResponseResult(SearchResponse response) {
        SearchHits searchHits = response.getHits();
        // 4.1 总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("total = " + total);
        // 4.2 命中的数据
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            // 4.2.1 获取source结果
            String json = hit.getSourceAsString();
            // 4.2.2 转为ItemDoc
            ItemDoc doc = JSONUtil.toBean(json, ItemDoc.class);
            // 4.3 处理高亮结果
            Map<String, HighlightField> hfs = hit.getHighlightFields();
            if(hfs != null && !hfs.isEmpty()) {
                // 4.3.1 根据高亮字段名获取高亮结果
                HighlightField hf = hfs.get("name");
                // 4.3.2 获取高亮结果，覆盖非高亮结果
                String hfName = hf.getFragments()[0].string();
                doc.setName(hfName);
            }
            System.out.println("doc = " + doc);
        }
    }
}

三、数据聚合

聚合（aggregations）：可以实现对文档数据的统计、分析、运算。聚合常见的三类：

桶（Bucket）聚合：用来对文档做分组

TermAggregation：按照文档字段值分组
Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组

度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等

Avg：求平均值
Max：求最大值
Min：求最小值
Stats：同时求max、min、avg、sum等

管道（pipeline）聚合：其他聚合的结果为基础做聚合

注意，参与聚合的字段必须是KeyWord、数值、日期、布尔等类型的字段。

1. DSL聚合

1.1 桶（Bucket）聚合

基本语法：

GET /items/_search
{
  "query": {"match_all": {}}, // 可以省略
  "size": 0, // 设置size为0，结果中不包含文档，只包含聚合结果
  "aggs": { // 定义聚合
    "category_agg": {  // 给聚合起个名字
      "terms": {  // 聚合的类型，按照品牌值聚合，所以选择term
        "field": "category",  // 参与聚合的字段
        "size": 20  // 希望获取的聚合结果数量
      }
    }
  }
}

案例1：我们要统计所有商品中共有哪些商品分类，其实就是以分类（category）字段做数据分组。category值一样的放在同一组，属于Bucket聚合中的Term聚合。

示例：

# Bucket聚合
GET /items/_search
{
  "size": 0,
  "aggs": {
    "cate_agg": {
      "terms": {
        "field": "category",
        "size": 5
      }
    },
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 5
      }
    }
  }
}

结果：

{
  "took" : 101,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 10000,
      "relation" : "gte"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "brand_agg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 73002,
      "buckets" : [
        {
          "key" : "华为",
          "doc_count" : 7145
        },
        {
          "key" : "南极人",
          "doc_count" : 2432
        },
        {
          "key" : "奥古狮登",
          "doc_count" : 2035
        },
        {
          "key" : "森马",
          "doc_count" : 2005
        },
        {
          "key" : "恒源祥",
          "doc_count" : 1856
        }
      ]
    },
    "cate_agg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 7583,
      "buckets" : [
        {
          "key" : "休闲鞋",
          "doc_count" : 20612
        },
        {
          "key" : "牛仔裤",
          "doc_count" : 19611
        },
        {
          "key" : "老花镜",
          "doc_count" : 16222
        },
        {
          "key" : "拉杆箱",
          "doc_count" : 14347
        },
        {
          "key" : "手机",
          "doc_count" : 10100
        }
      ]
    }
  }
}

案例2：默认情况下，Bucket聚合是对索引库的所有文档做聚合，我们可以限定要聚合的文档范围，只要添加query条件即可。

例如，我们想知道价格高于3000元的手机品牌有哪些：

GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {"term": {"category": "手机"}},
        {"range": {"price": {"gte": 300000}}}
      ]
    }
  },
  "size": 0,
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 10
      }
    }
  }
}

结果：

{
  "took" : 4,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 14,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "brand_agg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "Apple",
          "doc_count" : 7
        },
        {
          "key" : "华为",
          "doc_count" : 4
        },
        {
          "key" : "小米",
          "doc_count" : 2
        },
        {
          "key" : "三星",
          "doc_count" : 1
        }
      ]
    }
  }
}

1.2 度量（Metric）聚合

除了对数据分组（Bucket）之外，我们还可以对每个Bucket内的数据进一步做数据计算和统计。

例如，我们想知道手机有哪些品牌，每个品牌的价格最小值、最大值、平均值。

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"
          }
        }
      }
    }
  }
}

结果：

{
  "took" : 4,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 11,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "brand_agg" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "Apple",
          "doc_count" : 7,
          "stats_meric" : {
            "count" : 7,
            "min" : 628900.0,
            "max" : 688000.0,
            "avg" : 653871.4285714285,
            "sum" : 4577100.0
          }
        },
        {
          "key" : "华为",
          "doc_count" : 2,
          "stats_meric" : {
            "count" : 2,
            "min" : 429400.0,
            "max" : 544000.0,
            "avg" : 486700.0,
            "sum" : 973400.0
          }
        },
        {
          "key" : "三星",
          "doc_count" : 1,
          "stats_meric" : {
            "count" : 1,
            "min" : 474200.0,
            "max" : 474200.0,
            "avg" : 474200.0,
            "sum" : 474200.0
          }
        },
        {
          "key" : "小米",
          "doc_count" : 1,
          "stats_meric" : {
            "count" : 1,
            "min" : 889400.0,
            "max" : 889400.0,
            "avg" : 889400.0,
            "sum" : 889400.0
          }
        }
      ]
    }
  }
}

2. RestClient聚合

我们以品牌聚合为例：

结果解析：

完整代码：

    @Test
    void testAgg() throws IOException {
        // 1. 创建Request
        SearchRequest request = new SearchRequest("items");
        // 2. 组织请求参数
        // 2.1 分页
       request.source().size(0);
       // 2.2 聚合条件
        String brandAggName = "brandAgg";
        request.source().aggregation(
                AggregationBuilders.terms(brandAggName).field("brand").size(10)
        );
        // 3. 发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4. 解析响应
        // 4.1 解析聚合结果
        Aggregations aggregations = response.getAggregations();
        // 4.2 根据名称获取聚合结果
        Terms brandTerms = aggregations.get("brandAgg");
        // 4.3 获取桶
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        // 4.4 遍历
        for (Terms.Bucket bucket : buckets) {
            // 4.4.1 获取key，也就是品牌信息
            String brandName = bucket.getKeyAsString();
            System.out.println("brand = " + brandName);
        }
    }

结果：