微服务开发与实战Day09 - Elasticsearch

标签：实战 Day09 request search 查询 Elasticsearch import query response

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

结果：

四、作业

参考代码：

package com.hmall.item.controller;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hmall.common.domain.PageDTO;
import com.hmall.item.domain.po.Item;
import com.hmall.item.domain.po.ItemDoc;
import com.hmall.item.domain.query.ItemPageQuery;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.http.HttpHost;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.MultiBucketsAggregation;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Api(tags = "搜索相关接口")
@RestController
@RequestMapping("/search")
public class SearchController {

    private RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
            HttpHost.create("http://192.168.126.151:9200")
        ));

    @ApiOperation("搜索商品")
    @GetMapping("/list")
    public PageDTO<ItemDoc> search(ItemPageQuery query) throws IOException {
        // 1. 准备Request
        SearchRequest request = new SearchRequest("items");
        // 2. 构造查询条件
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        // 2.1 查询关键字
        if(StrUtil.isNotBlank(query.getKey())) {
            queryBuilder.must(QueryBuilders.matchQuery("name", query.getKey()));
        }
        // 2.2 查询的品牌
        if(StrUtil.isNotBlank(query.getBrand())) {
            queryBuilder.filter(QueryBuilders.termQuery("brand", query.getBrand()));
        }
        // 2.3 查询的分类
        if(StrUtil.isNotBlank(query.getCategory())) {
            queryBuilder.filter(QueryBuilders.matchQuery("category", query.getCategory()));
        }
        // 2.4 查询的价格区间
        if(query.getMaxPrice() != null) {
            queryBuilder.filter(QueryBuilders.rangeQuery("price").gte(query.getMinPrice()).lte(query.getMaxPrice()));
        }
        // 3. 组织DSL参数
        request.source()
                .query(queryBuilder)
                .size(query.getPageSize())
                .from(query.from());

        // 4. 排序
        List<OrderItem> orders = query.toMpPage("updateTime", false).getOrders();
        for (OrderItem orderItem : orders) {
            request.source().sort(orderItem.getColumn(), orderItem.isAsc() ? SortOrder.ASC : SortOrder.DESC);
        }

        // 5. 发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        // 6. 解析响应结果
        SearchHits hits = response.getHits();
        // 6.1 查询的总条数
        long total = hits.getTotalHits().value;
        // 6.2 查询的页码
        long pages = query.getPageNo();
        // 6.3 查询的结果数组
        SearchHit[] searchHits = hits.getHits();
        ArrayList<ItemDoc> itemDocs = new ArrayList<>();
        if(searchHits != null) {
            for (SearchHit searchHit : searchHits) {
                itemDocs.add(JSONUtil.toBean(searchHit.getSourceAsString(), ItemDoc.class));
            }
        }

        // 7. 封装并返回
        Page<Item> page = new Page<>();
        page.setTotal(total);
        page.setPages(pages);
        return PageDTO.of(page, itemDocs);
    }

    @ApiOperation("搜索商品分类")
    @PostMapping("/filters")
    public Map filters(ItemPageQuery query) throws IOException {
        // 1. 准备Request
        SearchRequest request = new SearchRequest("items");
        // 2. 组织请求参数
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        // 2.1 查询关键字
        if (StrUtil.isNotBlank(query.getKey())) {
            queryBuilder.must(QueryBuilders.matchQuery("name", query.getKey()));
        }
        // 2.2 查询的品牌
        if (StrUtil.isNotBlank(query.getBrand())) {
            queryBuilder.filter(QueryBuilders.termQuery("brand", query.getBrand()));
        }
        // 2.3 查询的分类
        if (StrUtil.isNotBlank(query.getCategory())) {
            queryBuilder.filter(QueryBuilders.matchQuery("category", query.getCategory()));
        }
        // 2.4 查询的价格区间
        if(query.getMaxPrice() != null) {
            queryBuilder.filter(QueryBuilders.rangeQuery("price").gte(query.getMinPrice()).lte(query.getMaxPrice()));
        }
        // 2.5 聚合条件
        String categoryAgg = "category_agg";
        String brandAgg = "brand_agg";
        request.source().query(queryBuilder).aggregation(
                AggregationBuilders.terms(categoryAgg).field("category"))
                .aggregation(AggregationBuilders.terms(brandAgg).field("brand"));
        // 3. 发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        // 4. 解析响应
        HashMap<String, List<String>> resultMap = new HashMap<>();
        // 4.1 获取并解析聚合结果
        Terms terms = response.getAggregations().get(categoryAgg);
        // 4.2 获取分类信息
        if(terms != null) {
            resultMap.put("category", terms.getBuckets().
                            stream().
                            map(MultiBucketsAggregation.Bucket::getKeyAsString)
                            .collect(Collectors.toList()));
        }
        // 4.3 获取品牌信息
        terms = response.getAggregations().get(brandAgg);
        if(terms != null) {
            resultMap.put("brand", terms.getBuckets().
                    stream().
                    map(MultiBucketsAggregation.Bucket::getKeyAsString)
                    .collect(Collectors.toList()));
        }

        // 5. 封装并返回
        return resultMap;
    }
}

标签：实战,Day09,request,search,查询,Elasticsearch,import,query,response
From： https://blog.csdn.net/ltt159264/article/details/139703865

微服务开发与实战Day09 - Elasticsearch

一、DSL查询

1. 快速入门

2. 叶子查询

2.1 全文检索查询：

2.2 精确查询

3. 复合查询

3.1 bool查询

3.2 算分函数查询

4. 排序和分页

5. 高亮显示

二、JavaRestClient查询

1. 快速入门

1.1 构建并发起请求

1.2 解析查询结果

2. 构建查询条件

3. 排序和分页

4. 高亮显示

三、数据聚合

1. DSL聚合

1.1 桶（Bucket）聚合

1.2 度量（Metric）聚合

2. RestClient聚合

四、作业

相关文章

赞助商

阅读排行