Elasticsearch数据聚合（查询筛选聚合酒店信息案例）

Elasticsearch数据聚合

1、聚合的种类

**聚合（aggregations）**可以让我们极其方便的实现对数据的统计、分析、运算。例如：

• 什么品牌的手机最受欢迎？
• 这些手机的平均价格、最高价格、最低价格？
• 这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

1.1、聚合常见的有三类：

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

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

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

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

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

**注意：**参加聚合的字段必须是keyword、日期、数值、布尔类型

2、DSL实现聚合

现在，我们要统计所有数据中的酒店品牌有几种，其实就是按照品牌对数据分组。此时可以根据酒店品牌的名称做聚合，也就是Bucket聚合。

2.1、DSL聚合的核心语句

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

2.2、程序运行结果

2.3、聚合结果排序

默认情况下，Bucket聚合会统计Bucket内的文档数量，记为_count，并且按照_count降序排序。

我们可以指定order属性，自定义聚合的排序方式：

# 聚合分类，自定义排序规则
GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "_count": "asc"
        }
      }
    }
  }
}

2.4、限定聚合范围

默认情况下，Bucket聚合是对索引库的所有文档做聚合，但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。

我们可以限定要聚合的文档范围，只要添加query条件即可：

# 聚合分类，限定聚合的范围
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200
      }
    }
  }, 
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "_count": "asc"
        }
      }
    }
  }
}

2.4、Metric聚合语法

我们对酒店按照品牌分组，形成了一个个桶。现在我们需要对桶内的酒店做运算，获取每个品牌的用户评分的min、max、avg等值。

这就要用到Metric聚合了，例如stat聚合：就可以获取min、max、avg等结果。

使用语法如下：

GET /hotel/_search
{
  "size": 0, 
  "aggs": {
    "brandAgg": { 
      "terms": { 
        "field": "brand", 
        "size": 20
      },
      "aggs": { // 是brands聚合的子聚合，也就是分组后对每组分别计算
        "score_stats": { // 聚合名称
          "stats": { // 聚合类型，这里stats可以计算min、max、avg等
            "field": "score" // 聚合字段，这里是score
          }
        }
      }
    }
  }
}

这次的score_stats聚合是在brandAgg的聚合内部嵌套的子聚合。因为我们需要在每个桶分别计算。

另外，我们还可以给聚合结果做个排序，例如按照每个桶的酒店平均分做排序：

# 嵌套聚合metric度量聚合
GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "scoreAge.avg": "asc"
        }
      },
      "aggs": {
        "scoreAge": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}

执行结果

"buckets" : [
        {
    
    
          "key" : "7天酒店",
          "doc_count" : 30,
          "scoreAge" : {
    
    
            "count" : 30,
            "min" : 35.0,
            "max" : 43.0,
            "avg" : 37.86666666666667,
            "sum" : 1136.0
          }
        }}

小结

aggs代表聚合，与query同级，此时query的作用是？

• 限定聚合的的文档范围

聚合必须的三要素：

• 聚合名称
• 聚合类型
• 聚合字段

聚合可配置属性有：

• size：指定聚合结果数量
• order：指定聚合结果排序方式
• field：指定聚合字段

3、RestAPI实现聚合

聚合条件与query条件同级别，因此需要使用request.source()来指定聚合条件。

聚合条件的语法：

聚合的结果也与查询结果不同，API也比较特殊。不过同样是JSON逐层解析：

实现代码

/**
 * 实现聚合分类
 */
@Test
void testAggregation() throws IOException {
    
    
    // 1、准备
    SearchRequest request = new SearchRequest("hotel");
    // 2、准备DSL
    request.source().size(0);
    request.source().aggregation(
            AggregationBuilders
                    // 名称
                    .terms("brandAgg")
                    // 字段
                    .field("brand")
                    // 数量
                    .size(10)
    );
    // 3、发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4、解析响应结果
    Aggregations aggregations = response.getAggregations();
    // 4.1、根据聚合名称获取聚合结果
    Terms brandTerms = aggregations.get("brandAgg");
    // 4.2、获取buckets
    List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
    // 4.4、遍历结果集
    for (Terms.Bucket bucket : buckets) {
    
    
        // 获取key
        String key = bucket.getKeyAsString();
        System.out.println(key);
    }
}

4、实现聚合查询并返回数据

需求：搜索页面的品牌、城市等信息不应该是在页面写死，而是通过聚合索引库中的酒店数据得来的：

分析：

目前，页面的城市列表、星级列表、品牌列表都是写死的，并不会随着搜索结果的变化而变化。但是用户搜索条件改变时，搜索结果会跟着变化。

例如：用户搜索“东方明珠”，那搜索的酒店肯定是在上海东方明珠附近，因此，城市只能是上海，此时城市列表中就不应该显示北京、深圳、杭州这些信息了。

也就是说，搜索结果中包含哪些城市，页面就应该列出哪些城市；搜索结果中包含哪些品牌，页面就应该列出哪些品牌。

如何得知搜索结果中包含哪些品牌？如何得知搜索结果中包含哪些城市？

使用聚合功能，利用Bucket聚合，对搜索结果中的文档基于品牌分组、基于城市分组，就能得知包含哪些品牌、哪些城市了。

因为是对搜索结果聚合，因此聚合是限定范围的聚合，也就是说聚合的限定条件跟搜索文档的条件一致。

返回结果是一个Map结构：

• key是字符串，城市、星级、品牌、价格
• value是集合，例如多个城市的名称

4.1、业务实现

在cn.itcast.hotel.web包的HotelController中添加一个方法，遵循下面的要求：

• 请求方式：POST
• 请求路径：/hotel/filters
• 请求参数：RequestParams，与搜索文档的参数一致
• 返回值类型：Map<String, List<String>>

代码：

@PostMapping("filters")
public Map<String, List<String>> getFilters(@RequestBody RequestParams params){
    
    
    return hotelService.getFilters(params);
}

在cn.itcast.hotel.service.IHotelService中定义新方法：

Map<String, List<String>> filters(RequestParams params);

4.2、业务层的实现方法

如下代码都将可重复使用的代码封装为了一个函数，方便后面的代码进行重复的调用，而查询条件是上一篇中所封装的

/**
 * 聚合结果返回
 * @param params
 * @return
 */
@Override
public Map<String, List<String>> filters(RequestParams params) {
    
    
    try {
    
    
        // 1、准备
        SearchRequest request = new SearchRequest("hotel");
        // 2、准备DSL
        // 2.1、调用聚合结果
        buildBaicQuery(params, request);
        // 2.2、设置查询的文档数
        request.source().size(0);
        // 2.3、调用封装的聚合查询条件
        buildAggregation(request);
        // 3、发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        // 4、解析响应结果
        Map<String, List<String>> result = new HashMap<>();
        Aggregations aggregations = response.getAggregations();
        // 4.1 根据匹配的名称获取匹配结果
        List<String> brandList = getAggByName(aggregations,"brandAgg");
        result.put("品牌",brandList);
        // 4.1 根据匹配的名称获取匹配结果
        List<String> cityList = getAggByName(aggregations,"cityAgg");
        result.put("城市",cityList);
        // 4.1 根据匹配的名称获取匹配结果
        List<String> starList = getAggByName(aggregations,"starAgg");
        result.put("星际",starList);
        return result;
    } catch (IOException e) {
    
    
        throw new RuntimeException();
    }
}

/**
 * 封装的聚合结果解析
 * @param aggregations 获取到聚合数据
 * @param aggName 指定的key值
 * @return
 */
private List<String> getAggByName(Aggregations aggregations,String aggName) {
    
    
    // 4.1、根据聚合名称获取聚合结果
    Terms brandTerms = aggregations.get(aggName);
    // 4.2、获取buckets
    List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
    // 4.4、遍历结果集
    List<String> brandList = new ArrayList<>();
    for (Terms.Bucket bucket : buckets) {
    
    
        // 获取key
        String key = bucket.getKeyAsString();
        brandList.add(key);
    }
    return brandList;
}

/**
 * 重构筛选条件
 *
 * @param params
 * @param request
 */
private void buildBaicQuery(RequestParams params, SearchRequest request) {
    
    
    // 将查询的条件较多，所以封装在一起
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    // 2.1、关键字搜索
    String key = params.getKey();
    if (key == null || "".equals(key)) {
    
    
        boolQuery.must(QueryBuilders.matchAllQuery());
    } else {
    
    
        boolQuery.must(QueryBuilders.matchQuery("all", key));
    }
    // 城市条件查询，不要参与算分
    if (params.getCity() != null && !params.getCity().equals("")) {
    
    
        boolQuery.filter(QueryBuilders.matchQuery("city", params.getCity()));
    }
    // 匹配条件
    if (params.getBrand() != null && !params.getBrand().equals("")) {
    
    
        boolQuery.filter(QueryBuilders.matchQuery("brand", params.getBrand()));
    }
    // 星级条件
    if (params.getStarName() != null && !params.getStarName().equals("")) {
    
    
        boolQuery.filter(QueryBuilders.matchQuery("starName", params.getStarName()));
    }
    // 价格判断
    if (params.getMinPrice() != null && !params.getMaxPrice().equals("")) {
    
    
        // 大于等于和小于等于
        boolQuery.filter(QueryBuilders.rangeQuery("price").gte(params.getMinPrice()).lte(params.getMaxPrice()));
    }

    // 2、算分控制
    FunctionScoreQueryBuilder functionScoreQueryBuilder =
            QueryBuilders.functionScoreQuery(
                    // 原始算分方法
                    boolQuery,
                    // function score的数组
                    new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
    
    
                            // 其中一个function score原始
                       new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                               // 过滤条件
                               QueryBuilders.termQuery("isAD",true),
                               // 算分函数
                               ScoreFunctionBuilders.weightFactorFunction(10)
                       )
                    }
            );

    request.source().query(boolQuery);
}

查询结果如下

会根据一个关键字key实现条件聚合查询