Elasticsearch讲解

悲伤的创可贴2024-09-30 15:32

1.Elasticsearch基本知识

1.基本认识和安装

Elasticsearch是由elastic公司开发的一套搜索引擎技术，它是elastic技术栈中的一部分。完整的技术栈包括：

  • Elasticsearch：用于数据存储、计算和搜索

  • Logstash/Beats：用于数据收集

  • Kibana：用于数据可视化

整套技术栈被称为ELK，经常用来做日志收集、系统监控和状态分析等等;

Kibana是elastic公司提供的用于操作Elasticsearch的可视化控制台。它的功能非常强大，包括：

  • 对Elasticsearch数据的搜索、展示

  • 对Elasticsearch数据的统计、聚合，并形成图形化报表、图形

  • 对Elasticsearch的集群状态监控

  • 它还提供了一个开发控制台（DevTools），在其中对Elasticsearch的Restful的API接口提供了语法提示

安装elasticsearch

执行如下代码，并访问9200端口

docker run -d \
  --name es \
  -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
  -e "discovery.type=single-node" \
  -v es-data:/usr/share/elasticsearch/data \
  -v es-plugins:/usr/share/elasticsearch/plugins \
  --privileged \
  --network hm-net \
  -p 9200:9200 \
  -p 9300:9300 \
  elasticsearch:7.12.1

安装Kibana

执行如下代码，并访问5601端口

docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=hm-net \
-p 5601:5601  \
kibana:7.12.1

2.倒排索引

正向索引 是最传统的，根据id索引的方式。但根据词条查询时，必须先逐条获取每个文档，然后判断文档中是否包含所需要的词条，是根据文档找词条的过程。

而倒排索引 则相反，是先找到用户要搜索的词条，根据词条得到保护词条的文档的id，然后根据id获取文档。是根据词条找文档的过程。

正向索引

优点：

  • 可以给多个字段创建索引

  • 根据索引字段搜索、排序速度非常快

缺点：

根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。

倒排索引

优点：

  • 根据词条搜索、模糊搜索时，速度非常快

缺点：

  • 只能给词条创建索引，而不是字段

  • 无法根据字段做排序

3.IK分词器

Elasticsearch的关键就是倒排索引，而倒排索引依赖于对文档内容的分词，而分词则需要高效、精准的分词算法，IK分词器就是这样一个中文分词算法。

需要将中文分词器挂载到es的数据卷上

官方默认方式

POST /_analyze
{
  "analyzer": "standard",
  "text": "世界人民大团结万岁"
}

IK分词器包含两种模式：

  • ik_smart：智能语义切分

  • ik_max_word：最细粒度切分

    POST /_analyze
    {
    "analyzer": "ik_smart",
    "text": "世界人民大团结万岁"
    }

    POST /_analyze
    {
    "analyzer": "ik_max_word",
    "text": "世界人民大团结万岁"
    }

有些词语字典里面没有，需要自己手动添加，还可以对某些字或词语不进行分词

在config目录下如图三个文件

添加自己的词语和不希望分词的词语即可

4.mysql和es的对比

MySQL Elasticsearch 说明
Table Index 索引(index)，就是文档的集合，类似数据库的表(table)
Row Document 文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式
Column Field 字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）
Schema Mapping Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）
SQL DSL DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD

2.索引库的操作

1.Mapping映射属性

Mapping是对索引库中文档的约束，常见的Mapping属性包括：

  • type：字段数据类型，常见的简单类型有：

    • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）

    • 数值：long、integer、short、byte、double、float、

    • 布尔：boolean

    • 日期：date

    • 对象：object

  • index：是否创建索引，默认为true

  • analyzer：使用哪种分词器

  • properties：该字段的子字段

2.索引库的CRUD

创建索引库

基本语法：

  • 请求方式：PUT

  • 请求路径：/索引库名，可以自定义

  • 请求参数：mapping映射

代码如下：

#新增
PUT /pxy
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "age":{
        "type": "byte"
      },
      "email":{
        "type": "keyword",
        "index": false
      },
      "name":{
        "type": "object",
        "properties": {
          "firstname":{
            "type": "keyword"
          },
          "lastname":{
            "type": "keyword",
            "index":false
          }
        }
      }
    }
  }
}

查询索引库

基本语法：

  • 请求方式：GET

  • 请求路径：/索引库名

  • 请求参数：无

代码如下：

#查询
GET /pxy

修改索引库

无法修改索引库，但是可以添加新的字段

#es不支持修改，但可以添加
PUT /pxy/_mapping
{
  "properties":{
    "age":{
      "type":"byte"
    }
  }
}

删除索引库

语法：

  • 请求方式：DELETE

  • 请求路径：/索引库名

  • 请求参数：无

    #删除
    DELETE /pxy

3.文档的操作

1.文档的CRUD

增加数据

#新增数据
POST /pxy/_doc/1
{
  "info":"我是大帅哥",
  "age":18,
  "email":"123456@qq.com",
  "name":{
    "firstname":"潘",
    "lastname":"xy"
  }
}

查询数据

#查询数据
GET /pxy/_doc/1

删除数据

#删除数据
DELETE /pxy/_doc/1

修改数据

分为全量修改和局部修改。全量修改是删除原来的数据在新增数据，局部修改只是把原来的数据修改掉。

#修改数据

#全量修改
Put /pxy/_doc/1
{
  "info":"我是大帅哥",
  "age":17,
  "email":"123456@qq.com",
  "name":{
    "firstname":"p",
    "lastname":"xy"
  }
}

#局部修改
POST /pxy/_update/1
{
  "doc": {
    "info":"无敌是多么寂寞",
    "name":{
      "firstname":"wd",
      "lastname":"jm"
    }
  }
}

2.批量处理

一次处理多个请求

批处理采用POST请求，基本语法如下：

POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "create" : { "_index" : "test", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

其中：

  • index代表新增操作

    • _index：指定索引库名

    • _id指定要操作的文档id

    • { "field1" : "value1" }：则是要新增的文档内容

  • delete代表删除操作

    • _index：指定索引库名

    • _id指定要操作的文档id

  • update代表更新操作

    • _index：指定索引库名

    • _id指定要操作的文档id

    • { "doc" : {"field2" : "value2"} }：要更新的文档字段

批量新增操作

POST /_bulk
  {"index":{"_index":"pxy","_id":"2"}}
  {"info":"我是大帅哥","age":17,"email":"123456@qq.com", "name":{"firstname":"p","lastname":"xy"}}
  {"index":{"_index":"pxy","_id":"3"}}
  {"info":"我是大帅哥","age":17,"email":"123456@qq.com", "name":{"firstnam:"p","lastname":"xy"}}

批量删除操作

POST /_bulk
  {"delete":{"_index":"pxy","_id":"2"}}
  {"delete":{"_index":"pxy","_id":"3"}}

4.用java程序操作es

1.注册RestHighLevelClient

在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。

导入依赖：

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.12.1<version>
</dependency>

初始化代码如下：

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

2.对索引进行操作

创建索引

    @Test
    public void createindex() throws IOException {
        //准备request对象
        CreateIndexRequest request = new CreateIndexRequest("pxy");
        //准备请求参数
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        //发送请求体
        client.indices().create(request, RequestOptions.DEFAULT);
    }
    private final static String MAPPING_TEMPLATE="{\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"id\": {\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"name\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\"\n" +
            "      },\n" +
            "      \"price\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"stock\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"image\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"category\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"brand\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"sold\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"commentCount\":{\n" +
            "        \"type\": \"integer\",\n" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"isAD\":{\n" +
            "        \"type\": \"boolean\"\n" +
            "      },\n" +
            "      \"updateTime\":{\n" +
            "        \"type\": \"date\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";
}

查询索引

    @Test
    public void getindex() throws IOException {
        //准备request对象
        GetIndexRequest request = new GetIndexRequest("pxy");
        //发送请求体
//        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
//        System.out.println("返回参数"+response);
        //判断请求参数是否存在
        Boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println("exists="+exists);
    }

删除索引

@Test
    public void deleteindex() throws IOException {
        //准备request对象
        DeleteIndexRequest request = new DeleteIndexRequest("pxy");
        //发送请求体
        client.indices().delete(request, RequestOptions.DEFAULT);
    }

3.对文档进行操作

新增文档

@Test
void testAddDocument() throws IOException {
    // 1.准备Request对象
    IndexRequest request = new IndexRequest("pxy").id("1");
    // 2.准备Json文档
    request.source({}, XContentType.JSON);
    // 3.发送请求
    client.index(request, RequestOptions.DEFAULT);
}

查询文档

@Test
void testGetDocumentById() throws IOException {
    // 1.准备Request对象
    GetRequest request = new GetRequest("pxy").id("1");
    // 2.发送请求
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    // 3.获取响应结果中的source
    String json = response.getSourceAsString();
    System.out.println("json= " + json);
}

删除文档

@Test
void testDeleteDocument() throws IOException {
    // 1.准备Request，两个参数，第一个是索引库名，第二个是文档id
    DeleteRequest request = new DeleteRequest("pxy", "1");
    // 2.发送请求
    client.delete(request, RequestOptions.DEFAULT);
}

修改文档

修改一共两种方式：

  • 全量修改：本质是先根据id删除，再新增

  • 局部修改：修改文档中的指定字段值

在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：

  • 如果新增时，ID已经存在，则修改

  • 如果新增时，ID不存在，则新增

这里不再赘述，我们主要关注局部修改的API即可。

@Test
void testUpdateDocument() throws IOException {
    // 1.准备Request
    UpdateRequest request = new UpdateRequest("pxy", "1");
    // 2.准备请求参数
    request.doc(
            "price", 58800,
            "commentCount", 1
    );
    // 3.发送请求
    client.update(request, RequestOptions.DEFAULT);
}

批量处理文档

@Test
void testBulk() throws IOException {
    // 1.创建Request
    BulkRequest request = new BulkRequest();
    // 2.准备请求参数
    //新增文档
    request.add(new IndexRequest("items").id("1").source("json doc1", XContentType.JSON));
    request.add(new IndexRequest("items").id("2").source("json doc2", XContentType.JSON));
    //删除文档
    request.add(new DeleteRequest("items").id("2"));
    // 3.发送请求
    client.bulk(request, RequestOptions.DEFAULT);
}

5.DSL查询

1.叶子查询

全文检索查询

全文检索中的match，语法如下：

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

与match类似的还有multi_match，区别在于可以同时对多个字段搜索，而且多个字段都要满足，语法示例：

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

精确查询

精确查询，英文是Term-level query，顾名思义，词条级别的查询。也就是说不会对用户输入的搜索条件再分词，而是作为一个词条，与搜索的字段内容精确值匹配。因此推荐查找keyword、数值、日期、boolean类型的字段。

term查询其语法如下：

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

range查询语法如下：

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

range是范围查询，对于范围筛选的关键字有：

  • gte：大于等于

  • gt：大于

  • lte：小于等于

  • lt：小于

2.复合查询

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

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

    • bool

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

    • function_score

    • dis_max

bool查询讲解

bool查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。bool查询支持的逻辑运算有：

  • must：必须匹配每个子查询，类似"与"

  • should：选择性匹配子查询，类似"或"

  • must_not：必须不匹配，不参与算分，类似"非"

  • filter：必须匹配，不参与算分

    GET /items/_search
    {
    "query": {
    "bool": {
    "must": [
    {"match": {"name": "手机"}} #必须是手机
    ],
    "should": [ #或者小米或者vivo
    {"term": {"brand": { "value": "vivo" }}},
    {"term": {"brand": { "value": "小米" }}}
    ],
    "must_not": [ #不是大于等于2500块的
    {"range": {"price": {"gte": 2500}}}
    ],
    "filter": [ #必须是小于等于1000块的
    {"range": {"price": {"lte": 1000}}}
    ]
    }
    }
    }

3.排序

elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。不过分词字段无法排序，能参与排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

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

示例，我们按照商品价格排序：

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

4.分页

elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。

基础分页

elasticsearch中通过修改from、size参数来控制要返回的分页结果：

  • from：从第几个文档开始

  • size：总共查询几个文档

类似于mysql中的limit ?, ?

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

深度分页

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。这种存储方式比较有利于数据扩展，但给分页带来了一些麻烦。

针对深度分页，elasticsearch提供了两种解决方案：

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

  • scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。

5.高亮

实现高亮的思路就是：

  • 用户输入搜索关键字搜索数据

  • 服务端根据搜索关键字到elasticsearch搜索，并给搜索结果中的关键字词条添加html标签

  • 前端提前给约定好的html标签添加CSS样式

    GET /{索引库名}/_search
    {
    "query": {
    "match": {
    "搜索字段": "搜索关键字"
    }
    },
    "highlight": {
    "fields": {
    "高亮字段名称": {
    "pre_tags": "",
    "post_tags": "    "
    }
    }
    }
    }

注意：

  • 搜索必须有查询条件，而且是全文检索类型的查询条件，例如match

  • 参与高亮的字段必须是text类型的字段

  • 默认情况下参与高亮的字段要与搜索字段一致，除非添加：required_field_match=false

6.用java代码实现DSL查询

文档的查询依然使用昨天学习的 RestHighLevelClient对象，查询的基本步骤如下：

  • 1）创建request对象，这次是搜索，所以是SearchRequest

  • 2）准备请求参数，也就是查询DSL对应的JSON参数

  • 3）发起请求

  • 4）解析响应，响应结果相对复杂，需要逐层解析

handleResponse函数实现解析返回结果

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

1.叶子查询

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

2.复合查询

复合查询也是由QueryBuilders来构建，以下是bool查询实例

@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.排序和分页

代码如下：

@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来构造

  • 高亮响应结果与搜索的文档结果不在一起，需要单独解析

    @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("")
    .postTags("    ")
    );
    // 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);
    // 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);
    }
    }

7.数据聚合

聚合常见的有三类：

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

    • TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组

    • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组

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

    • Avg：求平均值

    • Max：求最大值

    • Min：求最小值

    • Stats：同时求max、min、avg、sum等

  • 管道（ pipeline **）**聚合：其它聚合的结果为基础做进一步运算

1.DSL实现聚合

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：希望返回的聚合结果的最大数量

Metric聚合

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

可以看到我们在brand_agg聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。

  • stats_meric：聚合名称

    • stats：聚合类型，stats是metric聚合的一种

      • field：聚合字段，这里选择price，统计价格

由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值。

2.用java实现聚合

@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);
    }
}
相关推荐
Data跳动1 小时前
Spark内存都消耗在哪里了？
大数据·分布式·spark
woshiabc1112 小时前
windows安装Elasticsearch及增删改查操作
大数据·elasticsearch·搜索引擎
lucky_syq3 小时前
Saprk和Flink的区别
大数据·flink
lucky_syq3 小时前
流式处理，为什么Flink比Spark Streaming好？
大数据·flink·spark
袋鼠云数栈3 小时前
深入浅出Flink CEP丨如何通过Flink SQL作业动态更新Flink CEP作业
大数据
小白学大数据4 小时前
如何使用Selenium处理JavaScript动态加载的内容？
大数据·javascript·爬虫·selenium·测试工具
15年网络推广青哥4 小时前
国际抖音TikTok矩阵运营的关键要素有哪些？
大数据·人工智能·矩阵
节点。csn5 小时前
Hadoop yarn安装
大数据·hadoop·分布式
arnold665 小时前
探索 ElasticSearch：性能优化之道
大数据·elasticsearch·性能优化
NiNg_1_2346 小时前
基于Hadoop的数据清洗
大数据·hadoop·分布式
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程