ElasticSearch学习笔记(五)Bucket聚合、Metric聚合

文章目录

前言
9 项目实战
- 9.3 我周边的酒店
- 9.4 酒店竞价排名
10 数据聚合
- 10.1 聚合的分类
- 10.2 DSL实现聚合
- - 10.2.1 Bucket聚合
  - 10.2.2 聚合结果排序
  - 10.2.3 限定聚合范围
  - 10.2.4 Metric聚合
- 10.3 RestAPI实现聚合
- - 10.3.1 API语法
  - 10.3.2 业务需求
  - 10.3.3 业务实现
  - 10.3.4 功能测试

前言

ElasticSearch学习笔记(一)倒排索引、ES和Kibana安装、索引操作
ElasticSearch学习笔记(二)文档操作、RestHighLevelClient的使用
ElasticSearch学习笔记(三)RestClient操作文档、DSL查询文档、搜索结果排序
ElasticSearch学习笔记(四)分页、高亮、RestClient查询文档

9 项目实战

9.3 我周边的酒店

1）需求分析

点击页面右侧的地图组件的定位按钮，将位置信息发送给后台，后台基于位置坐标，按照距离远近对附近的酒店进行排序。

2）修改RequestParams参数，接收location字段

// cn.hsgx.hotel.pojo.RequestParams

@Data
public class RequestParams {
    private String key;
    private Integer page;
    private Integer size;
    private String sortBy;
    private String brand;
    private String city;
    private String starName;
    private Integer minPrice;
    private Integer maxPrice;
    // 位置信息
    private String location;
}

3）在HotelServiceImpl实现类的handleQueryParams()方法中，添加根据地理位置排序功能

// cn.hsgx.hotel.service.impl.HotelServiceImpl

private void handleQueryParams(RequestParams params, SearchRequest request) {
    
    // ......
    
    // 1.6 根据地理位置排序
    String location = params.getLocation();
    if(StringUtils.isNotBlank(location)) {
        request.source().sort(SortBuilders
                .geoDistanceSort("location", new GeoPoint(location))
                .order(SortOrder.ASC)
                .unit(DistanceUnit.KILOMETERS)
        );
    }
    // 2.设置查询条件
    request.source().query(functionScoreQuery);
}

4）功能测试

查阅日志中打印的DSL语句及其返回信息：

5）获取附近每个酒店距离当前位置的具体距离值

根据距离进行排序时，具体的距离值也会一起返回，只是不在source部分：

因此在结果解析时，除了解析source部分，还要得到sort部分，也就是排序的距离，然后放到响应结果中。

修改HotelServiceImpl类中的handleResponse方法，添加对sort值的获取：

// cn.hsgx.hotel.service.impl.HotelServiceImpl

private PageResult handleResponse(SearchResponse response) {
    SearchHits searchHits = response.getHits();
    // 4.1.总条数
    long total = searchHits.getTotalHits().value;
    // 4.2.获取文档数组
    SearchHit[] hits = searchHits.getHits();
    // 4.3.遍历
    List<HotelDoc> hotels = new ArrayList<>(hits.length);
    for (SearchHit hit : hits) {
        // 4.4.获取source
        String json = hit.getSourceAsString();
        // 4.5.反序列化，非高亮的
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        // 4.6.排序信息
        Object[] sortValues = hit.getSortValues();
        if (sortValues.length > 0) {
            hotelDoc.setDistance(sortValues[0]);
        }
        // 4.7.放入集合
        hotels.add(hotelDoc);
    }
    return new PageResult(total, hotels);
}

9.4 酒店竞价排名

1）需求分析

让指定的酒店在搜索结果中排名置顶。 要实现这个功能，其实就是使用function_score查询改变查询结果的算分，算分高了，排名就会靠前。

function_score查询包含3个要素：

过滤条件：哪些文档要加分
算分函数：如何计算function score
加权方式：function score与query score如何运算

为此，则需要给这些酒店添加一个标记，这样在过滤条件中就可以根据这个标记来判断是否要提高算分。比如，给酒店添加一个字段：isAD，Boolean类型，为true时表示是广告，为false时表示不是广告。

这样function_score查询的3个要素也就确定了：

过滤条件：判断isAD是否为true
算分函数：可以用最简单的weight，固定加权值
加权方式：可以用默认的相乘，大大提高算分
2）随意挑选几个酒店，添加isAD字段，设置为true

3）添加算分函数查询

之前是用的boolean查询，现在要改成function_socre查询。查询结构如下：

修改HotelServiceImpl类的handleQueryParams()方法：

// cn.hsgx.hotel.service.impl.HotelServiceImpl

private void handleQueryParams(RequestParams params, SearchRequest request) {
    // 1.准备boolean查询
    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    
    // ......
    
    // 2.算分函数查询
    FunctionScoreQueryBuilder functionScoreQuery = QueryBuilders.functionScoreQuery(
            boolQuery, // 原始查询，boolQuery
            new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{ // function数组
                    new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                            QueryBuilders.termQuery("isAD", true), // 过滤条件
                            ScoreFunctionBuilders.weightFactorFunction(10) // 算分函数
                    )
            }
    );
    // 3.设置查询条件
    request.source().query(functionScoreQuery);
}

4）功能测试

添加前：

添加后：

10 数据聚合

ES的数据聚合（aggregations）功能可以极其方便地实现对数据的统计、分析、运算。 例如可以统计出什么品牌的酒店最受欢迎？这些酒店的平均价格、最高价格、最低价格是多少？这些酒店每月的订单情况如何？

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

10.1 聚合的分类

常见的聚合有三类：

桶（Bucket）聚合：用来对文档做分组
- TermAggregation：按照文档字段值分组，例如按照品牌分组、按照城市分组
- DateHistogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
- 参加聚合的字段必须是keyword、日期、数值、布尔类型
度量（Metric）聚合：用以计算一些值，例如最大值、最小值、平均值等
- Avg：求平均值
- Max：求最大值
- Min：求最小值
- Stats：同时求Max、Min、Avg、Sum等
管道（pipeline）聚合：以其它聚合的结果为基础做聚合

10.2 DSL实现聚合

10.2.1 Bucket聚合

例如，现在要统计所有数据中的酒店品牌有几种，也就是按照品牌对数据进行分组。此时可以根据酒店品牌的名称做聚合，也就是Bucket聚合。其语法如下：

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

10.2.2 聚合结果排序

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

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

GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "_count": "asc" //按照_count升序排列
        }
      }
    }
  }
}

10.2.3 限定聚合范围

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

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

GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "_count": "asc" 
        }
      }
    }
  },
  "query": { //查询条件，只对价格在200元一下的文档进行聚合
    "range": {
      "price": {
        "lte": 200
      }
    }
  }
}

10.2.4 Metric聚合

前面是对酒店按照品牌进行分组，形成了一个个桶。现在需要对桶内的酒店做运算，获取每个品牌酒店的用户评分的Min、Max、Avg等值。

这就要用到Metric聚合了，例如stat聚合：就可以获取Min、Max、Avg等结果。其语法如下：

GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "scoreAgg.avg": "desc" //按照平均分进行降序排序 
        }
      },
      "aggs": { //Metric是品牌聚合的子聚合，也就是分组后对每组分别计算
        "scoreAgg": { //聚合名称
          "stats": { //聚合类型，这里stats可以计算Min、Max、Avg等
            "field": "score" //聚合字段，这里是score
          }
        }
      }
    }
  }
}

10.3 RestAPI实现聚合

10.3.1 API语法

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

聚合查询的结果也与query查询的结果不一样，其解析API如下：

10.3.2 业务需求

在搜索页面，可以根据城市、星级、品牌进行过滤，但这些信息不应该在页面写死，而是要通过聚合查询酒店数据得到，进行动态展示。

例如，用户搜索“广州塔”，那搜索得到的酒店肯定是在广州塔附近的，因此城市只能是广州，此时城市列表中就不应该显示北京、深圳、杭州这些了。

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

在原有查询的基础上，利用Bucket聚合，对搜索结果中的文档基于品牌分组、基于城市分组，就能得知包含哪些品牌、哪些城市了。

10.3.3 业务实现

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

请求方式：POST
请求路径：/hotel/filters
请求参数：RequestParams
返回值类型：Map<String, List<String>>

// cn.hsgx.hotel.web.HotelController

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

在IHotelService接口及其实现类HotelServiceImpl中实现该getFilters()方法：

// cn.hsgx.hotel.service.impl.HotelServiceImpl

@Override
public Map<String, List<String>> getFilters(RequestParams params) {
    try {
        // 1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        // 2.准备DSL
        // 2.1.基础query
        handleQueryParams(params, request);
        // 2.2.设置size
        request.source().size(0);
        // 2.3.设置聚合条件
        buildAggregation(request);
        // 3.发出请求
        SearchResponse response = restHighLevelClient.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.2.根据品牌名称，获取品牌结果
        List<String> cityList = getAggByName(aggregations, "cityAgg");
        result.put("城市", cityList);
        // 4.3.根据品牌名称，获取品牌结果
        List<String> starList = getAggByName(aggregations, "starAgg");
        result.put("星级", starList);
        return result;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

private void buildAggregation(SearchRequest request) {
    request.source().aggregation(AggregationBuilders
            .terms("brandAgg")
            .field("brand")
            .size(100)
    );
    request.source().aggregation(AggregationBuilders
            .terms("cityAgg")
            .field("city")
            .size(100)
    );
    request.source().aggregation(AggregationBuilders
            .terms("starAgg")
            .field("starName")
            .size(100)
    );
}

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.3.遍历
    List<String> brandList = new ArrayList<>();
    for (Terms.Bucket bucket : buckets) {
        // 4.4.获取key
        String key = bucket.getKeyAsString();
        brandList.add(key);
    }
    return brandList;
}