SpringBoot整合Elasticsearch之索引，映射，文档，搜索的基本 *** 作案例分析_随笔

SpringBoot整合Elasticsearch之索引，映射，文档，搜索的基本 *** 作案例分析

索引，映射，文档，DSL增删改查

一）环境准备

1. ES版本：7.12.12. SpringBoot版本：2.5.8 二）ES的基本介绍

1. Elasticsearch 是什么2. Eelasticsearch的作用3. Elasticsearch，Solr和Lucene三者之间的关系4. Elasticsearch的索引结构--倒排索引5. ES中的一些基本概念三）ES索引的增删改查

1. mapping映射属性2. 索引库的创建3. 查询索引库4. 修改索引库5. 删除索引库6. 打开关闭索引库四）ES文档的增删改查

1. 创建文档2. 查询文档3. 删除文档4. 修改文档5. 批量增删改文档6. SpringData版增删改查五）ES的高级查询

1. DSL查询分类2. 查询所有文档3. 全文检索查询4. 关键字精确查询5. 指定查询字段6. 地理坐标查询7. 算分函数查询8. 模糊查询9. 复合查询10. 排序11. 分页12. 高亮查询13. 聚合查询六）聚合案例

需求1 统计哪种颜色的电视销量最高需求2 统计每种颜色电视平均价格需求3 继续下钻分析需求4：更多的metric 需求5：划分范围 histogram 需求6：按照日期分组聚合需求7 统计每季度每个品牌的销售额需求8 ：搜索与聚合结合，查询某个品牌按颜色销量需求9 global bucket：单个品牌与所有品牌销量对比需求10：过滤+聚合：统计价格大于1200的电视平均价格需求11 bucket filter：统计品牌最近一个月的平均价格需求12 排序：按每种颜色的平均销售额降序排序需求13 排序：按每种颜色的每种品牌平均销售额降序排序

一）环境准备 1. ES版本：7.12.1 2. SpringBoot版本：2.5.8

 
        spring-boot-parent
        org.springframework.boot
        2.5.8
    

    
        8
        8
    
    
        
            org.springframework.boot
            spring-boot-starter-test
        
        
            org.springframework.boot
            spring-boot-starter-data-elasticsearch
        
        
            org.projectlombok
            lombok

二）ES的基本介绍 1. Elasticsearch 是什么

Elaticsearch，简称为 ES，ES 是一个开源的高扩展的分布式全文搜索引擎，是整个 Elastic Stack 技术栈的核心。它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理 PB 级别的数据。

The Elastic Stack, 包括 Elasticsearch、Kibana、Beats 和 Logstash（也称为 ELK Stack）。能够安全可靠地获取任何来源、任何格式的数据，然后实时地对数据进行搜索、分析和可视化。

2. Eelasticsearch的作用

Elasticsearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容。

在GitHub搜索代码用于搜索引擎中搜索内容各大电商网站搜索商品打车软件搜索附近的车辆 3. Elasticsearch，Solr和Lucene三者之间的关系

目前市面上流行的搜索引擎软件，主流的就两款：Elasticsearch 和 Solr,这两款都是基于 Lucene 搭建的，可以独立部署启动的搜索引擎服务软件。

Lucene是一个Java语言的搜索引擎类库，是Apache公司的顶级项目，提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。

Elasticsearch和Solr对比

特征Solr/SolrCloudElasticsearch社区和开发者Apache软件基金和社区支持单一商业实体及其员工节点发现Apache Zookeeper.在大量项目中成熟且经过实战测试Zen内置于Elasticsearch本身，需要专用的主节点才能进行裂脑保护碎片放置本质上是静态，需要手动工作来迁移分片，从Solr 7开始- AutoscalingAPI允许一些动态 *** 作动态，可以根据群集状态按需移动分片高速缓存全局，每个段更改无效每段，更适合动态更改数据分析引擎性能非常适合精确计算的静态数据结果的准确性取决于数据放置全文搜索功能基于Lucene的语言分析，多建议，拼写检查，丰富的高亮显示支持基于Lucene的语言分析，单一建议API实现，高亮显示重新计算DevOps支持尚未完全，但即将到来非常好的API非平面数据处理嵌套文档和父子支持嵌套和对象类型的自然支持允许几乎无限的嵌套和父-子支持查询DSLJSON (有限)，XML (有限)或URL参数JSON机器学习内置-在流聚合之上，专注于逻辑回归和学习排名贡献模块商业功能，专注于异常和异常值以及时间序列数据 4. Elasticsearch的索引结构–倒排索引

倒排索引的概念是基于MySQL这样的正向索引而言的。

正向索引

那么什么是正向索引呢？例如给下表（tb_goods）中的id创建索引：

如果是根据id查询，那么直接走索引，查询速度非常快。

但如果是基于title做模糊查询，只能是逐行扫描数据，流程如下：

1）用户搜索数据，条件是title符合"%手机%"

2）逐行获取数据，比如id为1的数据

3）判断数据中的title是否符合用户搜索条件

4）如果符合则放入结果集，不符合则丢弃。回到步骤1

逐行扫描，也就是全表扫描，随着数据量增加，其查询效率也会越来越低。当数据量达到数百万时，就是一场灾难。

倒排索引

倒排索引中有两个非常重要的概念：

文档（document）：用来搜索的数据，其中的每一条数据就是一个文档。例如一个网页、一个商品信息。词条（Term）：对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条

创建倒排索引是对正向索引的一种特殊处理，流程如下：

将每一个文档的数据利用算法分词，得到一个个词条创建表，每行数据包括词条、词条所在文档id、位置等信息因为词条唯一性，可以给词条创建索引，例如hash表结构索引

如图：

倒排索引的搜索流程如下（以搜索"华为手机"为例）：

1）用户输入条件"华为手机"进行搜索。

2）对用户输入内容分词，得到词条：华为、手机。

3）拿着词条在倒排索引中查找，可以得到包含词条的文档id：1、2、3。

4）拿着文档id到正向索引中查找具体文档。

如图：

虽然要先查询倒排索引，再查询倒排索引，但是无论是词条、还是文档id都建立了索引，查询速度非常快！无需全表扫描。

正向索引和倒排索引比较

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

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

正向索引：

优点：

可以给多个字段创建索引根据索引字段搜索、排序速度非常快缺点：

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

倒排索引：

优点：

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

只能给词条创建索引，而不是字段无法根据字段做排序 5. ES中的一些基本概念

elasticsearch中有很多独有的概念，与mysql中略有差别，但也有相似之处。

结点和集群

结点（Node）：每个es实例称为一个节点。节点名自动分配，也可以手动配置。

集群（cluster）：包含一个或多个启动着es实例的机器群。通常一台机器起一个es实例。同一网络下，集名一样的多个es实例自动组成集群，自动均衡分片等行为。默认集群名为“elasticsearch”。

分片和副本

分片 ( shard ）: index数据过大时，将index里面的数据，分为多个shard，分布式的存储在各个服务器上面。可以支持海量数据和高并发，提升性能和吞吐量，充分利用多台机器的cpu。

副本( replica ) : 在分布式环境下，任何一台机器都会随时宕机，如果宕机，index的一个分片没有，导致此index不能搜索。所以，为了保证数据的安全，我们会将每个index的分片经行备份，存储在另外的机器上。保证少数机器宕机es集群仍可以搜索。

能正常提供查询和插入的分片我们叫做主分片（primary shard），其余的我们就管他们叫做备份的分片（replica shard）。

文档和字段

elasticsearch是面向文档(document) 存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中：

而Json文档中往往包含很多的字段（Field），类似于数据库中的列。

索引和映射

索引（Index），就是相同类型的文档的集合。

例如：

所有用户文档，就可以组织在一起，称为用户的索引；所有商品的文档，可以组织在一起，称为商品的索引；所有订单的文档，可以组织在一起，称为订单的索引；

因此，我们可以把索引当做是数据库中的表。

数据库的表会有约束信息，用来定义表的结构、字段的名称、类型等信息。因此，索引库中就有映射（mapping），是索引中文档的字段约束信息，类似表的结构约束。

mysql与elasticsearch比较

我们统一的把mysql与elasticsearch的概念做一下对比：

MySQLElasticsearch说明TableIndex索引(index)，就是文档的集合，类似数据库的表(table)Rowdocument文档（document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式ColumnField字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）SchemaMappingMapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）SQLDSLDSL是elasticsearch提供的JSON风格的请求语句，用来 *** 作elasticsearch，实现CRUD

是不是说，我们学习了elasticsearch就不再需要mysql了呢？

并不是如此，两者各自有自己的擅长支出：

Mysql：擅长事务类型 *** 作，可以确保数据的安全和一致性

Elasticsearch：擅长海量数据的搜索、分析、计算

因此在企业中，往往是两者结合使用：

对安全性要求较高的写 *** 作，使用mysql实现对查询性能要求较高的搜索需求，使用elasticsearch实现两者再基于某种方式，实现数据的同步，保证一致性

数据同步思路分析

常见的数据同步方案有三种：

同步调用异步通知监听binlog

1.同步调用

方案一：同步调用

基本步骤如下：

hotel-demo对外提供接口，用来修改elasticsearch中的数据酒店管理服务在完成数据库 *** 作后，直接调用hotel-demo提供的接口，

2.异步通知

方案二：异步通知

流程如下：

hotel-admin对mysql数据库数据完成增、删、改后，发送MQ消息hotel-demo监听MQ，接收到消息后完成elasticsearch数据修改

3.监听binlog

方案三：监听binlog

流程如下：

给mysql开启binlog功能mysql完成增、删、改 *** 作都会记录在binlog中hotel-demo基于canal监听binlog变化，实时更新elasticsearch中的内容

4.选择

方式一：同步调用

优点：实现简单，粗暴缺点：业务耦合度高

方式二：异步通知

优点：低耦合，实现难度一般缺点：依赖mq的可靠性

方式三：监听binlog

优点：完全解除服务间耦合缺点：开启binlog增加数据库负担、实现复杂度高三）ES索引的增删改查

索引库就类似数据库表，mapping映射就类似表的结构。我们要向es中存储数据，必须先创建“库”和“表”。

1. mapping映射属性

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

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

字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）数值：long、integer、short、byte、double、float、布尔：boolean日期：date对象：object index：是否创建索引，默认为trueanalyzer：使用哪种分词器store：是否将数据进行独立存储，默认为 false
原始的文本会存储在_source 里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source 里面提取出来的。当然你也可以独立的存储某个字段，只要设置"store": true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。properties：该字段的子字段 2. 索引库的创建

基本语法：

请求方式：PUT请求路径：/索引库名，可以自定义请求参数：mapping映射

格式：

PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2":{
        "type": "keyword",
        "index": "false"
      },
      "字段名3":{
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // ...略
    }
  }
}

示例：

PUT /xianyu
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "falsae"
      },
      "name":{
        "properties": {
          "firstName": {
            "type": "keyword"
          }
        }
      },
      // ... 略
    }
  }
}

RestAPI基本步骤：

//1.创建请求
CreateIndexRequest request=new CreateIndexRequest("hotel");
//2.准备请求参数
request.source(HotelConstants.MAPPING_TEMPLATE, XContentType.JSON);
//3.发送请求
client.indices().create(request, RequestOptions.DEFAULT);

1.同步创建：

    //创建索引对象
    CreateIndexRequest createIndexRequest = new CreateIndexRequest("itheima_book");
    //设置参数
    createIndexRequest.settings(Settings.builder().put("number_of_shards", "1").put("number_of_replicas", "0"));
    //指定映射1
    createIndexRequest.mapping(" {n" +
            " t"properties": {n" +
            "            "name":{n" +
            "             "type":"keyword"n" +
            "           },n" +
            "           "description": {n" +
            "              "type": "text"n" +
            "           },n" +
            "            "price":{n" +
            "             "type":"long"n" +
            "           },n" +
            "           "pic":{n" +
            "             "type":"text",n" +
            "             "index":falsen" +
            "           }n" +
            " t}n" +
            "}", XContentType.JSON);

    //指定映射2
```

//        Map message = new HashMap<>();
//        message.put("type", "text");
//        Map properties = new HashMap<>();
//        properties.put("message", message);
//        Map mapping = new HashMap<>();
//        mapping.put("properties", properties);
//        createIndexRequest.mapping(mapping);

```
    //指定映射3
```

//        XContentBuilder builder = XContentFactory.jsonBuilder();
//        builder.startObject();
//        {
//            builder.startObject("properties");
//            {
//                builder.startObject("message");
//                {
//                    builder.field("type", "text");
//                }
//                builder.endObject();
//            }
//            builder.endObject();
//        }
//        builder.endObject();
//        createIndexRequest.mapping(builder);

```
    //设置别名
    createIndexRequest.alias(new Alias("itheima_index_new"));

    // 额外参数
    //设置超时时间
    createIndexRequest.setTimeout(Timevalue.timevalueMinutes(2));
    //设置主节点超时时间
    createIndexRequest.setMasterTimeout(Timevalue.timevalueMinutes(1));
    //在创建索引API返回响应之前等待的活动分片副本的数量，以int形式表示
    createIndexRequest.waitForActiveShards(ActiveShardCount.from(2));
    createIndexRequest.waitForActiveShards(ActiveShardCount.DEFAULT);

    // *** 作索引的客户端
    IndicesClient indices = client.indices();
    //执行创建索引库
    CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);

    //得到响应（全部）
    boolean acknowledged = createIndexResponse.isAcknowledged();
    //得到响应 指示是否在超时前为索引中的每个分片启动了所需数量的碎片副本
    boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();

    System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!" + acknowledged);
    System.out.println(shardsAcknowledged);

}

2.异步创建：

 //创建索引对象
    CreateIndexRequest createIndexRequest = new CreateIndexRequest("itheima_book2");
    //设置参数
    createIndexRequest.settings(Settings.builder().put("number_of_shards", "1").put("number_of_replicas", "0"));
    //指定映射1
    createIndexRequest.mapping(" {n" +
            " t"properties": {n" +
            "            "name":{n" +
            "             "type":"keyword"n" +
            "           },n" +
            "           "description": {n" +
            "              "type": "text"n" +
            "           },n" +
            "            "price":{n" +
            "             "type":"long"n" +
            "           },n" +
            "           "pic":{n" +
            "             "type":"text",n" +
            "             "index":falsen" +
            "           }n" +
            " t}n" +
            "}", XContentType.JSON);

    //监听方法
    ActionListener listener =
            new ActionListener() {

                @Override
                public void onResponse(CreateIndexResponse createIndexResponse) {
                    System.out.println("!!!!!!!!创建索引成功");
                    System.out.println(createIndexResponse.toString());
                }

                @Override
                public void onFailure(Exception e) {
                    System.out.println("!!!!!!!!创建索引失败");
                    e.printStackTrace();
                }
            };

    // *** 作索引的客户端
    IndicesClient indices = client.indices();
    //执行创建索引库
    indices.createAsync(createIndexRequest, RequestOptions.DEFAULT, listener);

    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

3.SpringData自动创建

// 可以通过注解@document @Filed @Setting 来自定义配置
@document(indexName = "book")
@Data
public class Book {
    // 必须有 id,这里的 id 是全局唯一的标识，等同于 es 中的"_id"
    @Id
    private String id;
    @Field(type = FieldType.Keyword, analyzer = "ik_max_word",searchAnalyzer= "ik_smart")
    private String bookName;
    @Field(type = FieldType.Text, analyzer = "ik_max_word",searchAnalyzer= "ik_smart")
    private String bookDesc;
    @Field(type = FieldType.Double, index = false)
    private Double bookPrice;
    @Field(type = FieldType.Long, index = false)
    private Integer bookNumber;
}

3. 查询索引库

基本语法：

请求方式：GET

请求路径：/索引库名

请求参数：无

格式：

GET /索引库名

示例：

GET /xianyu
{
    "xianyu"【索引名】: {
        "aliases"【别名】: {},
        "mappings"【映射】: {},
         "settings"【设置】: {
            "index"【设置 - 索引】: {
                "creation_date"【设置 - 索引 - 创建时间】: "1614265373911",
                "number_of_shards"【设置 - 索引 - 主分片数量】: "1",
                "number_of_replicas"【设置 - 索引 - 副分片数量】: "1",
                "uuid"【设置 - 索引 - 唯一标识】: "eI5wemRERTumxGCc1bAk2A",
                "version"【设置 - 索引 - 版本】: {
                "created": "7080099"
                },
             "provided_name"【设置 - 索引 - 名称】: "xianyu"
                }
      }
         }
}

查询所有的索引库

#查询所有的索引库
GET /_cat/indices?v

表头含义health 当前服务器健康状态：green(集群完整) yellow(单点正常、集群不完整)red(单点不正常)status索引打开、关闭状态index索引名uuid索引统一编号pri主分片数量rep副本数量docs.count可用文档数量docs.deleted文档删除状态（逻辑删除）store.size主分片和副分片整体占空间大小pri.store.size主分片占空间大小

RestAPI

// 查询索引 - 请求对象
GetIndexRequest request = new GetIndexRequest("hotel");
// 发送请求，获取响应
GetIndexResponse response = client.indices().get(request, 
RequestOptions.DEFAULT);

4. 修改索引库

倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库一旦创建，无法修改mapping。

虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。

语法说明：

PUT /索引库名/_mapping
{
  "properties": {
    "新字段名":{
      "type": "integer"
    }
  }
}

5. 删除索引库

语法：

请求方式：DELETE

请求路径：/索引库名

请求参数：无

格式：

DELETE /索引库名

RestAPI：

//创建删除请求
DeleteIndexRequest request = new DeleteIndexRequest("hotel");     
//发送请求
client.indices().delete(request,RequestOptions.DEFAULT);

异步删除

 //删除索引对象
    DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("itheima_book2");
    // *** 作索引的客户端
    IndicesClient indices = client.indices();

    //监听方法
    ActionListener listener =
            new ActionListener() {
                @Override
                public void onResponse(AcknowledgedResponse deleteIndexResponse) {
                    System.out.println("!!!!!!!!删除索引成功");
                    System.out.println(deleteIndexResponse.toString());
                }

                @Override
                public void onFailure(Exception e) {
                    System.out.println("!!!!!!!!删除索引失败");
                    e.printStackTrace();
                }
            };
    //执行删除索引
    indices.deleteAsync(deleteIndexRequest, RequestOptions.DEFAULT, listener);

    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

6. 打开关闭索引库

 OpenIndexRequest request = new OpenIndexRequest("itheima_book");

    OpenIndexResponse openIndexResponse = client.indices().open(request, RequestOptions.DEFAULT);
    boolean acknowledged = openIndexResponse.isAcknowledged();
    System.out.println("!!!!!!!!!"+acknowledged);

 CloseIndexRequest request = new CloseIndexRequest("index");
    AcknowledgedResponse closeIndexResponse = client.indices().close(request, RequestOptions.DEFAULT);
    boolean acknowledged = closeIndexResponse.isAcknowledged();
    System.out.println("!!!!!!!!!"+acknowledged);

  GetIndexRequest request = new GetIndexRequest("itheima_book");
    request.local(false);//从主节点返回本地信息或检索状态
    request.humanReadable(true);//以适合人类的格式返回结果
    request.includeDefaults(false);//是否返回每个索引的所有默认设置

    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    System.out.println(exists);

四）ES文档的增删改查 1. 创建文档

语法：

POST /索引库名/_doc/文档id 
{
    "字段1": "值1",
    "字段2": "值2",
    "字段3": {
        "子属性1": "值3",
        "子属性2": "值4"
    },
    // ...
}

示例：

POST /xianyu/_doc/1 不加id会随机生成一个id
{
  "name":"咸鱼",
  "age":23
}

{
  "_index" : "xianyu", //索引名
  "_type" : "_doc", //类型
  "_id" : "1", //唯一标识 类似主键
  "_version" : 1, //版本
  "result" : "created", //结果 表示创建成功
  "_shards" : {  //分片
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}

RESTAPI

// 1.根据id查询酒店数据 
Hotel hotel = hotelService.getById(61083L);
// 2.转换为文档类型
HotelDoc hotelDoc = new HotelDoc(hotel);
// 3.将HotelDoc转json
String jsonString = JSON.toJSONString(hotelDoc);
// 1.准备Request对象
IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
// 2.准备Json文档
request.source(jsonString, XContentType.JSON);
// 3.发送请求
client.index(request, RequestOptions.DEFAULT);

同步

//        1构建请求
        IndexRequest request=new IndexRequest("test_posts");
        request.id("3");
//        =======================构建文档============================
//        构建方法1
        String jsonString="{n" +
                "  "user":"tomas J",n" +
                "  "postDate":"2019-07-18",n" +
                "  "message":"trying out es3"n" +
                "}";
        request.source(jsonString, XContentType.JSON);

//        构建方法2
//        Map jsonMap=new HashMap<>();
//        jsonMap.put("user", "tomas");
//        jsonMap.put("postDate", "2019-07-18");
//        jsonMap.put("message", "trying out es2");
//        request.source(jsonMap);

//        构建方法3
//        XContentBuilder builder= XContentFactory.jsonBuilder();
//        builder.startObject();
//        {
//            builder.field("user", "tomas");
//            builder.timeField("postDate", new Date());
//            builder.field("message", "trying out es2");
//        }
//        builder.endObject();
//        request.source(builder);
//        构建方法4
//        request.source("user","tomas",
//                    "postDate",new Date(),
//                "message","trying out es2");
//
//        ========================可选参数===================================
        //设置超时时间
        request.timeout(Timevalue.timevalueSeconds(1));
        request.timeout("1s");

        //自己维护版本号
//        request.version(2);
//        request.versionType(VersionType.EXTERNAL);



//        2执行
        //同步
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

异步

 //异步
//        ActionListener listener=new ActionListener() {
//            @Override
//            public void onResponse(IndexResponse indexResponse) {
//
//            }
//
//            @Override
//            public void onFailure(Exception e) {
//
//            }
//        };
//        client.indexAsync(request,RequestOptions.DEFAULT, listener );
//        try {
//            Thread.sleep(5000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }


//        3获取结果
        String index = indexResponse.getIndex();
        String id = indexResponse.getId();
        //获取插入的类型
        if(indexResponse.getResult()== DocWriteResponse.Result.CREATED){
            DocWriteResponse.Result result=indexResponse.getResult();
            System.out.println("CREATED:"+result);
        }else if(indexResponse.getResult()== DocWriteResponse.Result.UPDATED){
            DocWriteResponse.Result result=indexResponse.getResult();
            System.out.println("UPDATED:"+result);
        }

        ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
        if(shardInfo.getTotal()!=shardInfo.getSuccessful()){
            System.out.println("处理成功的分片数少于总分片！");
        }
        if(shardInfo.getFailed()>0){
           for (ReplicationResponse.ShardInfo.Failure failure:shardInfo.getFailures()) {
               String reason = failure.reason();//处理潜在的失败原因
               System.out.println(reason);
           }
        }
    }

2. 查询文档

语法：

GET /{索引库名称}/_doc/{id}

GET /xianyu/_doc/1

{
  "_index" : "xianyu",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "_seq_no" : 0,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "name" : "咸鱼",
    "age" : 23
  }
}

RESTAPI

 GetRequest request = new GetRequest("hotel","61083");
//得到响应
GetResponse response = client.get(request, RequestOptions.DEFAULT);
String json = response.getSourceAsString();
//解析文档
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);

  //构建请求
        GetRequest getRequest = new GetRequest("test_post", "1");

        //========================可选参数 start======================
        //为特定字段配置_source_include
//        String[] includes = new String[]{"user", "message"};
//        String[] excludes = Strings.EMPTY_ARRAY;
//        FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
//        getRequest.fetchSourceContext(fetchSourceContext);

        //为特定字段配置_source_excludes
//        String[] includes1 = new String[]{"user", "message"};
//        String[] excludes1 = Strings.EMPTY_ARRAY;
//        FetchSourceContext fetchSourceContext1 = new FetchSourceContext(true, includes1, excludes1);
//        getRequest.fetchSourceContext(fetchSourceContext1);

        //设置路由
//        getRequest.routing("routing");

        // ========================可选参数 end=====================


        //查询 同步查询
      GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);

        //异步查询
//        ActionListener listener = new ActionListener() {
//            //查询成功时的立马执行的方法
//            @Override
//            public void onResponse(GetResponse getResponse) {
//                long version = getResponse.getVersion();
//                String sourceAsString = getResponse.getSourceAsString();//检索文档(String形式)
//                System.out.println(sourceAsString);
//            }
//
//            //查询失败时的立马执行的方法
//            @Override
//            public void onFailure(Exception e) {
//                e.printStackTrace();
//            }
//        };
//        //执行异步请求
//        client.getAsync(getRequest, RequestOptions.DEFAULT, listener);
//        try {
//            Thread.sleep(5000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        // 获取结果
        if (getResponse.isExists()) {
            long version = getResponse.getVersion();

            String sourceAsString = getResponse.getSourceAsString();//检索文档(String形式)
            System.out.println(sourceAsString);
            byte[] sourceAsBytes = getResponse.getSourceAsBytes();//以字节接受
            Map sourceAsMap = getResponse.getSourceAsMap();
            System.out.println(sourceAsMap);

        }else {

        }

    }

3. 删除文档

语法：

DELETE /{索引库名称}/_doc/{id}

DELETE /xianyu/_doc/1

{
  "_index" : "xianyu",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 2,
  "result" : "deleted",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 1,
  "_primary_term" : 1
}

条件删除文档

POST /xianyu/_delete_by_query
{
 "query":{
 "match":{
 "age":23
 }
 }
}

RESTAPI

 // 1.准备Request
DeleteRequest request = new DeleteRequest("hotel", "61083");
// 2.发送请求
client.delete(request, RequestOptions.DEFAULT);

4. 修改文档

修改有两种方式：

全量修改：直接覆盖原来的文档增量修改：修改文档中的部分字段

语法：

PUT /{索引库名}/_doc/文档id
{
    "字段1": "值1",
    "字段2": "值2",
    // ... 略
}

增量修改是只修改指定id匹配的文档中的部分字段。

语法：

POST /{索引库名}/_update/文档id
{
    "doc": {
         "字段名": "新的值",
    }
}

POST /xianyu/_update/1
{
  "doc": {
    "no":"20183033523"
  }
}

{
  "_index" : "xianyu",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 2,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 3,
  "_primary_term" : 1
}

RESTAPI

// 1.准备Request
UpdateRequest request = new UpdateRequest("hotel", "61083");
 // 2.准备请求参数
 request.doc(
               "price", "952",
                "starName", "四钻"
        );
 // 3.发送请求
client.update(request, RequestOptions.DEFAULT);

    1构建请求
        UpdateRequest request = new UpdateRequest("test_posts", "3");
        Map jsonMap = new HashMap<>();
        jsonMap.put("user", "tomas JJ");
        request.doc(jsonMap);
//===============================可选参数==========================================
        request.timeout("1s");//超时时间

        //重试次数
        request.retryOnConflict(3);

        //设置在继续更新之前，必须激活的分片数
//        request.waitForActiveShards(2);
        //所有分片都是active状态，才更新
//        request.waitForActiveShards(ActiveShardCount.ALL);

//        2执行
//        同步
        UpdateResponse updateResponse = client.update(request, RequestOptions.DEFAULT);
//        异步

//        3获取数据
        updateResponse.getId();
        updateResponse.getIndex();

        //判断结果
        if (updateResponse.getResult() == DocWriteResponse.Result.CREATED) {
            DocWriteResponse.Result result = updateResponse.getResult();
            System.out.println("CREATED:" + result);
        } else if (updateResponse.getResult() == DocWriteResponse.Result.UPDATED) {
            DocWriteResponse.Result result = updateResponse.getResult();
            System.out.println("UPDATED:" + result);
        }else if(updateResponse.getResult() == DocWriteResponse.Result.DELETED){
            DocWriteResponse.Result result = updateResponse.getResult();
            System.out.println("DELETED:" + result);
        }else if (updateResponse.getResult() == DocWriteResponse.Result.NOOP){
            //没有 *** 作
            DocWriteResponse.Result result = updateResponse.getResult();
            System.out.println("NOOP:" + result);
        }

5. 批量增删改文档

Bulk *** 作解释将文档的增删改查一些列 *** 作，通过一次请求全都做完。减少网络传输次数。

语法：

POST /_bulk
{"action": {"metadata"}}
{"data"}

如下 *** 作，删除5，新增14，修改2。

POST /_bulk
{ "delete": { "_index": "test_index",  "_id": "5" }} 
{ "create": { "_index": "test_index",  "_id": "14" }}
{ "test_field": "test14" }
{ "update": { "_index": "test_index",  "_id": "2"} }
{ "doc" : {"test_field" : "bulk test"} }

//        1创建请求
        BulkRequest request = new BulkRequest();
//        request.add(new IndexRequest("post").id("1").source(XContentType.JSON, "field", "1"));
//        request.add(new IndexRequest("post").id("2").source(XContentType.JSON, "field", "2"));

        request.add(new UpdateRequest("post","2").doc(XContentType.JSON, "field", "3"));
        request.add(new DeleteRequest("post").id("1"));

//        2执行
        BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);

        for (BulkItemResponse itemResponse : bulkResponse) {
            DocWriteResponse itemResponseResponse = itemResponse.getResponse();

            switch (itemResponse.getOpType()) {
                case INDEX:
                case CREATE:
                    IndexResponse indexResponse = (IndexResponse) itemResponseResponse;
                    indexResponse.getId();
                    System.out.println(indexResponse.getResult());
                    break;
                case UPDATE:
                    UpdateResponse updateResponse = (UpdateResponse) itemResponseResponse;
                    updateResponse.getIndex();
                    System.out.println(updateResponse.getResult());
                    break;
                case DELETE:
                    DeleteResponse deleteResponse = (DeleteResponse) itemResponseResponse;
                    System.out.println(deleteResponse.getResult());
                    break;
            }
        }

6. SpringData版增删改查

```java
// Book : 实体类
// String : 主键类型
@Repository
public interface BookRepository extends ElasticsearchRepository {
    List findByBookNameLike(String bookName);
}

五）ES的高级查询 1. DSL查询分类

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询。常见的查询类型包括：

查询所有：查询出所有数据，一般测试用。例如：match_all

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

match_querymulti_match_query

精确查询：根据精确词条值查找数据，一般是查找keyword、数值、日期、boolean等类型字段。例如：

idsrangeterm

地理（geo）查询：根据经纬度查询。例如：

geo_distancegeo_bounding_box

复合（compound）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：

boolfunction_score

查询基本语法：

GET /indexName/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}

2. 查询所有文档

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

RestAPI

//1.创建请求
SearchRequest request = new SearchRequest("hotel");
//2.构建DSL
request.source().query(QueryBuilders.matchAllQuery());
//3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

结果解析：

	//将响应结果解析
    private void extractResponse(SearchResponse response) {
        SearchHits searchHits = response.getHits();
        //获取总条数
        long total = searchHits.getTotalHits().value;
        System.out.println("文档总条数为"+total);
        //获取文档数组
        SearchHit[] hits = searchHits.getHits();

       // Arrays.stream(hits).forEach(v-> JSON.parseObject(v.getSourceAsString(),HotelDoc.class));

        for (SearchHit hit : hits) {
            // 获取文档source
            String json = hit.getSourceAsString();
            // 反序列化
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            log.info("酒店数据：{}",hotelDoc);
        }
    }

3. 全文检索查询

使用场景

全文检索查询的基本流程如下：

对用户搜索的内容做分词，得到词条根据词条去倒排索引库中匹配，得到文档id根据文档id找到文档，返回给用户

比较常用的场景包括：

商城的输入框搜索百度输入框搜索

因为是拿着词条去匹配，因此参与搜索的字段也必须是可分词的text类型的字段。

基本语法

常见的全文检索查询包括：

match查询：单字段查询multi_match查询：多字段查询，任意一个字段符合条件就算符合查询条件，搜索字段越多，对查询性能影响越大，因此建议采用copy_to，然后单字段查询的方式。

match查询语法如下：

GET /indexName/_search
{
  "query": {
    "match": {
      "FIELD": "TEXT"
    }
  }
}

#匹配查询

GET /hotel/_search
{
  "query": {
    "match": {
      "city": "上海"
    }
  }
}

RestAPI

//创建请求
 SearchRequest request = new SearchRequest("hotel");
 //2.构建DSL
 request.source().query(QueryBuilders.matchQuery("city","上海"));
//3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

mulit_match语法如下：

GET /indexName/_search
{
  "query": {
    "multi_match": {
      "query": "TEXT",
      "fields": ["FIELD1", " FIELD12"]
    }
  }
}

#多字段匹配查询

注意：多字段匹配性能较低一般涉及到多字段搜索会使用copyto到一个字段进行查询

GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "汉庭",
      "fields": ["name","business"]
    }
  }
}

RestAPI

  //1.创建请求
SearchRequest request = new SearchRequest("hotel");
//2.构建DSL
request.source().query(QueryBuilders.multiMatchQuery("汉庭","name","business"));
 //3.发送请求
 SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

4. 关键字精确查询

精确查询一般是查找keyword、数值、日期、boolean等类型字段。所以不会对搜索条件分词。常见的有：

term：根据词条精确值查询range：根据值的范围查询terms：根据多个词条精确查询

term查询

因为精确查询的字段搜是不分词的字段，因此查询的条件也必须是不分词的词条。查询时，用户输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多，反而搜索不到数据。

语法说明：

// term查询
GET /indexName/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": "VALUE"
      }
    }
  }
}

#精确查询
GET /hotel/_search
{
  "query": {
    "term": {
      "brand": {
        "value": "汉庭"
      }
    }
  }
}

RestAPI

 //1.创建请求
SearchRequest request = new SearchRequest("hotel");
 //2.构建DSL    
 request.source().query(QueryBuilders.termQuery("city","上海"));
//3.发送请求
 SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

range查询

范围查询，一般应用在对数值类型做范围过滤的时候。比如做价格范围过滤。

基本语法：

// range查询
GET /indexName/_search
{
  "query": {
    "range": {
      "FIELD": {
        "gte": 10, // 这里的gte代表大于等于，gt则代表大于
        "lte": 20 // lte代表小于等于，lt则代表小于
      }
    }
  }
}

#范围查询
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 300,
        "lte": 400
      }
    }
  }
}

RestAPI

//1.创建请求
SearchRequest request = new SearchRequest("hotel");
//2.构建DSL
request.source().query(QueryBuilders.rangeQuery("price").gt(200).lt(400));
//3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

terms查询

terms 查询和 term 查询一样，但它允许你指定多值进行匹配。如果这个字段包含了指定值中的任何一个值，那么这个文档满足条件，类似于 mysql 的 in。

// term查询
GET /indexName/_search
{
  "query": {
    "term": {
      "FIELD": {
        "value": ["VALUE1","VALUE2"]
      }
    }
  }
}

GET /hotel/_search
{
  "query": {
    "terms": {
      "city": [
        "上海",
        "北京"
      ]
    }
  }
}

RestAPI

 //1.创建请求
 SearchRequest request = new SearchRequest("hotel");
  //2.构建DSL
 request.source().query(QueryBuilders.termsQuery("city","北京","上海"));
 //3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

exist query 查询有某些字段值的文档

GET /_search
{
    "query": {
        "exists": {
            "field": "join_date"
        }
    }
}

5. 指定查询字段

默认情况下，Elasticsearch 在搜索的结果中，会把文档中保存在_source 的所有字段都返回。如果我们只想获取其中的部分字段，我们可以添加_source 的过滤。

#指定筛选字段
GET /hotel/_search
{
  "_source": ["address","city"] ,
  "query": {
    "term": {
      "city": {
        "value": "上海"
      }
    }
  }
}

includes：来指定想要显示的字段excludes：来指定不想要显示的字段

GET /hotel/_search
{
  "_source": {
    //"excludes": , ["address","city"],
    "includes":  ["brand","price"]
  },
  "query": {
    "term": {
      "city": {
        "value": "上海"
      }
    }
  }
}

RestAPI

 //1.创建请求
 SearchRequest request = new SearchRequest("hotel");
//查询字段过滤
String[] includes={};
String[] excludes={"brand","location"};
//2.构建DSL
 request.source().query(QueryBuilders.termQuery("city","上海")).fetchSource(includes,excludes);
//3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

6. 地理坐标查询

所谓的地理坐标查询，其实就是根据经纬度查询。

常见的使用场景包括：

携程：搜索我附近的酒店滴滴：搜索我附近的出租车微信：搜索我附近的人

矩形范围查询

矩形范围查询，也就是geo_bounding_box查询，查询坐标落在某个矩形范围的所有文档：

查询时，需要指定矩形的左上、右下两个点的坐标，然后画出一个矩形，落在该矩形内的都是符合条件的点。

语法如下：

// geo_bounding_box查询
GET /indexName/_search
{
  "query": {
    "geo_bounding_box": {
      "FIELD": {
        "top_left": { // 左上点
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": { // 右下点
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}

附近查询

附近查询，也叫做距离查询（geo_distance）：查询到指定中心点小于某个距离值的所有文档。

换句话来说，在地图上找一个点作为圆心，以指定距离为半径，画一个圆，落在圆内的坐标都算符合条件：

语法说明：

// geo_distance 查询
GET /indexName/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "FIELD": "31.21,121.5" // 圆心
    }
  }
}

#地理坐标查询 半径5km范围内的
GET /hotel/_search
{
 "query": {
   "geo_distance": {
     "distance": "5km",
     "location": "31.21,121.5"
   }
 }  
}

RestAPI

		 //1.创建请求
        SearchRequest request = new SearchRequest("hotel");
        //2.构建DSL
        request.source().query(QueryBuilders
                .geoDistanceQuery("location")
                .distance("5", DistanceUnit.KILOMETERS)
                .point(31.21,121.5));
        //3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应
        extractResponse(response);

7. 算分函数查询

复合（compound）查询：复合查询可以将其它简单查询组合起来，实现更复杂的搜索逻辑。常见的有两种：

fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名bool query：布尔查询，利用逻辑关系组合多个其它的查询，实现复杂搜索

相关性算分

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

例如，我们搜索 “虹桥如家”，结果如下：

[
  {
    "_score" : 17.850193,
    "_source" : {
      "name" : "虹桥如家酒店真不错",
    }
  },
  {
    "_score" : 12.259849,
    "_source" : {
      "name" : "外滩如家酒店真不错",
    }
  },
  {
    "_score" : 11.91091,
    "_source" : {
      "name" : "迪士尼如家酒店真不错",
    }
  }
]

在elasticsearch中，早期使用的打分算法是TF-IDF算法，公式如下：

在后来的5.1版本升级中，elasticsearch将算法改进为BM25算法，公式如下：

TF-IDF算法有一各缺陷，就是词条频率越高，文档得分也会越高，单个词条对文档影响较大。而BM25则会让单个词条的算分有一个上限，曲线更加平滑：

算分函数查询

根据相关度打分是比较合理的需求，但合理的不一定是产品经理需要的。

以百度为例，你搜索的结果中，并不是相关度越高排名越靠前，而是谁掏的钱多排名就越靠前。

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

1）语法说明

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的运行流程如下：

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

因此，其中的关键点是：

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

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

RestAPI

8. 模糊查询

返回包含与搜索字词相似的字词的文档。

IDs

GET /book/_search
{
    "query": {
        "ids" : {
            "values" : ["1", "4", "100"]
        }
    }
}

RestAPI

 		// 1构建搜索请求
        SearchRequest searchRequest = new SearchRequest("book");

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.idsQuery().addIds("1","4","100"));




        searchRequest.source(searchSourceBuilder);

        //2执行搜索
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        //3获取结果
        SearchHits hits = searchResponse.getHits();

prefix 前缀查询

GET /book/_search
{
    "query": {
        "prefix": {
            "description": {
                "value": "spring"
            }
        }
    }
}

regexp query 正则查询

GET /book/_search
{
    "query": {
        "regexp": {
            "description": {
                "value": "j.*a",
                "flags" : "ALL",
                "max_determinized_states": 10000,
                "rewrite": "constant_score"
            }
        }
    }
}

Fuzzy query

GET /hotel/_search
{
  "query": {
    "fuzzy": {
      "name": {
        "value": "酒店",
        "fuzziness": 0.8
      }
    }
  }
}

RestAPI

 //1.创建请求
SearchRequest request = new SearchRequest("hotel");
//2.构建DSL
request.source().query(QueryBuilders.fuzzyQuery("name","酒店").fuzziness(Fuzziness.AUTO));
 //3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.解析响应
extractResponse(response);

9. 复合查询

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

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

比如在搜索酒店时，除了关键字搜索外，我们还可能根据品牌、价格、城市等字段做过滤：

每一个不同的字段，其查询的条件、方式都不一样，必须是多个不同的查询，而要组合这些查询，就必须用bool查询了。

需要注意的是，搜索时，参与打分的字段越多，查询的性能也越差。因此这种多条件查询时，建议这样做：

搜索框的关键字搜索，是全文检索查询，使用must查询，参与算分其它过滤条件，采用filter查询。不参与算分

语法所示：

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {"city": "上海" }}
      ],
      "should": [
        {"term": {"brand": "皇冠假日" }},
        {"term": {"brand": "华美达" }}
      ],
      "must_not": [
        { "range": { "price": { "lte": 500 } }}
      ],
      "filter": [
        { "range": {"score": { "gte": 45 } }}
      ]
    }
  }
}

RestAPI

 SearchRequest request = new SearchRequest("hotel");
// 2.1.准备BooleanQuery
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
boolQuery.filter(QueryBuilders.rangeQuery("score").gte(45));
boolQuery.must(QueryBuilders.termQuery("city","上海"));
boolQuery.should(QueryBuilders.termQuery("brand","华美达"));
boolQuery.should(QueryBuilders.termQuery("brand","皇冠假日"));
boolQuery.mustNot(QueryBuilders.rangeQuery("price").lte(500));
request.source().query(boolQuery);
 //发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//解析结果
extractResponse(response);

2）示例

需求：搜索名字包含“如家”，价格不高于400，在坐标31.21,121.5周围10km范围内的酒店。

分析：

名称搜索，属于全文检索查询，应该参与算分。放到must中价格不高于400，用range查询，属于过滤条件，不参与算分。放到must_not中周围10km范围内，用geo_distance查询，属于过滤条件，不参与算分。放到filter中

# 复合查询
GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "brand": {
              "value": "如家"
            }
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gt": 400
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "10km",
            "location": {
              "lat": 31.21,
              "lon": 121.5
            }
          }
        }
      ]
    }
  }
}

RestAPI

 SearchRequest request = new SearchRequest("hotel");
        // 2.1.准备BooleanQuery
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        boolQuery.filter(QueryBuilders
                .geoDistanceQuery("location")
                .distance(10,DistanceUnit.KILOMETERS)
                .point(31.21,121.5));
        
        boolQuery.must(QueryBuilders.termQuery("brand","如家"));
        boolQuery.mustNot(QueryBuilders.rangeQuery("price").gt(500));

        request.source().query(boolQuery);
        //发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //解析结果
        extractResponse(response);

filter与query对比

filter：仅仅只是按照搜索条件过滤出需要的数据而已，不计算任何相关度分数，对相关度没有任何影响。

query：会去计算每个document相对于搜索条件的相关度，并按照相关度进行排序。

应用场景：

一般来说，如果你是在进行搜索，需要将最匹配搜索条件的数据先返回，那么用query 如果你只是要根据一些条件筛选出一部分数据，不关注其排序，那么用filter

filter与query性能

filter，不需要计算相关度分数，不需要按照相关度分数进行排序，同时还有内置的自动cache最常使用filter的数据

query，相反，要计算相关度分数，按照分数进行排序，而且无法cache结果

10. 排序

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

1.普通单字段排序

keyword、数值、日期类型排序的语法基本一致。

{
 "query": {
   ...条件
 },
 "sort": [{
 "FIELD": {
 "order":"desc"
 }
 }]
}

2.普通多字段排序

GET /hotel/_search
{
  "query": {
    "match_all": {
      
    }
  },
  "sort": [
    {
      "price": {
        "order": "asc"
      },
      "score": {
        "order": "asc"
      }
    }
  ]
}

RestAPI

		 //1.创建请求
        SearchRequest request = new SearchRequest("hotel");
        //2.构建DSL
        request.source()
                .query(QueryBuilders.matchAllQuery())
                .sort("price",SortOrder.ASC)
                .sort("score",SortOrder.ASC);

        //3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应
        extractResponse(response);

3.地理坐标排序

语法说明：

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance" : {
          "FIELD" : "纬度，经度", // 文档中geo_point类型的字段名、目标坐标点
          "order" : "asc", // 排序方式
          "unit" : "km" // 排序的距离单位
      }
    }
  ]
}

这个查询的含义是：

指定一个坐标，作为目标点计算每一个文档中，指定字段（必须是geo_point类型）的坐标到目标点的距离是多少根据距离排序

示例：需求描述：实现对酒店数据按照到你的位置坐标的距离升序排序

RestAPI

		//1.创建请求
        SearchRequest request = new SearchRequest("hotel");
        //2.构建DSL
        request.source()
                .query(QueryBuilders.matchAllQuery())
                .sort(SortBuilders
                        .geoDistanceSort("location",31.5,121.5)
                        .order(SortOrder.ASC)
                        .unit(DistanceUnit.KILOMETERS));

        //3.发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //4.解析响应
        extractResponse(response);

11. 分页

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

from：从第几个文档开始，默认从 0 开始。 from = (pageNum - 1) * sizesize：总共查询几个文档

类似于mysql中的limit ?, ?

基本分页语法：

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
  ]
}

RestAPI

		 //创建请求
        SearchRequest request = new SearchRequest("hotel");
        //构建DSL
        request.source().query(QueryBuilders
                .matchAllQuery())
                .sort("price",SortOrder.ASC)
                .from(0)
                .size(10);
        //发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        //解析响应
        extractResponse(response);

深度分页问题

现在，我要查询990~1000的数据，查询逻辑要这么写：

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 990, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
  ]
}

这里是查询990开始的数据，也就是第990~第1000条数据。

不过，elasticsearch内部分页时，必须先查询 0~1000条，然后截取其中的990 ~ 1000的这10条：

查询TOP1000，如果es是单点模式，这并无太大影响。

但是elasticsearch将来一定是集群，例如我集群有5个节点，我要查询TOP1000的数据，并不是每个节点查询200条就可以了。

因为节点A的TOP200，在另一个节点可能排到10000名以外了。

因此要想获取整个集群的TOP1000，必须先查询出每个节点的TOP1000，汇总结果后，重新排名，重新截取TOP1000。

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

针对深度分页，ES提供了两种解决方案，官方文档：

search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。scroll：原理将排序后的文档id形成快照，保存在内存。官方已经不推荐使用。

分页查询的常见实现方案以及优缺点：

from + size：

优点：支持随机翻页缺点：深度分页问题，默认查询上限（from + size）是10000场景：百度、京东、谷歌、淘宝这样的随机翻页搜索

after search：

优点：没有查询上限（单次查询的size不超过10000）缺点：只能向后逐页查询，不支持随机翻页场景：没有随机翻页需求的搜索，例如手机向下滚动翻页

scroll：

优点：没有查询上限（单次查询的size不超过10000）缺点：会有额外内存消耗，并且搜索结果是非实时的场景：海量数据的获取和迁移。从ES7.1开始不推荐，建议用 after search方案。 12. 高亮查询

高亮原理

什么是高亮显示呢？

我们在百度，京东搜索时，关键字会变成红色，比较醒目，这叫高亮显示：

高亮显示的实现分为两步：

1）给文档中的所有关键字都添加一个标签，例如标签2）页面给标签编写CSS样式

实现高亮

高亮的语法：

GET /hotel/_search { "query": { "match": { "FIELD": "TEXT" // 查询条件，高亮一定要使用全文检索查询 } }, "highlight": { "fields": { // 指定要高亮的字段 "FIELD": { "pre_tags": "", // 用来标记高亮字段的前置标签 "post_tags": "" // 用来标记高亮字段的后置标签 } } } }

注意：

高亮是对关键字高亮，因此搜索条件必须带有关键字，而不能是范围这样的查询。默认情况下，高亮的字段，必须与搜索指定的字段一致，否则无法高亮如果要对非搜索字段高亮，则需要添加一个属性：required_field_match=false

ResAPI

// 1.准备Request SearchRequest request = new SearchRequest("hotel"); // 2.准备DSL // 2.1.query request.source().query(QueryBuilders.matchQuery("all", "如家")); // 2.2.高亮 request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false)); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 SearchHits searchHits = response.getHits(); // 4.1.获取总条数 long total = searchHits.getTotalHits().value; System.out.println("共搜索到" + total + "条数据"); // 4.2.文档数组 SearchHit[] hits = searchHits.getHits(); // 4.3.遍历 for (SearchHit hit : hits) { // 获取文档source String json = hit.getSourceAsString(); // 反序列化 HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class); // 获取高亮结果 Map highlightFields = hit.getHighlightFields(); if (!CollectionUtils.isEmpty(highlightFields)) { // 根据字段名获取高亮结果 HighlightField highlightField = highlightFields.get("name"); if (highlightField != null) { // 获取高亮值 String name = highlightField.getFragments()[0].string(); // 覆盖非高亮结果 hotelDoc.setName(name); } } System.out.println("hotelDoc = " + hotelDoc); }
13. 聚合查询
聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析、运算。例如：

什么品牌的手机最受欢迎？这些手机的平均价格、最高价格、最低价格？这些手机每月的销售情况如何？
实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

聚合的种类

聚合常见的有三类：

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

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

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

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

Avg：求平均值Max：求最大值Min：求最小值Stats：同时求max、min、avg、sum等
管道（pipeline）聚合：其它聚合的结果为基础做聚合

Bucket聚合语法如下：

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

结果：

RestAPI

//创建请求 SearchRequest request = new SearchRequest("hotel"); //创建DSL request.source().aggregation(AggregationBuilders .terms("brand_agg") .field("brand") .size(20)).size(0); //发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); //解析响应 Aggregations aggregations = response.getAggregations(); //根据名称获取结果 Terms brand_agg = aggregations.get("brand_agg"); //拿到桶 List buckets = brand_agg.getBuckets(); //遍历桶 for (Terms.Bucket bucket : buckets) { System.out.println(bucket.getKeyAsString()); }

聚合结果排序

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

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

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

SearchRequest request = new SearchRequest("hotel"); //创建DSL request.source().aggregation(AggregationBuilders .terms("brand_agg") .field("brand") .size(20)).size(0) .sort("_count",SortOrder.ASC); //发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT);

限定聚合范围

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

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

GET /hotel/_search { "query": { "range": { "price": { "lte": 200 // 只对200元以下的文档聚合 } } }, "size": 0, "aggs": { "brandAgg": { "terms": { "field": "brand", "size": 20 } } } }

RestAPI

//创建请求 SearchRequest request = new SearchRequest("hotel"); //创建DSL request.source().query(QueryBuilders.rangeQuery("price").lte(200)); request.source() .aggregation(AggregationBuilders .terms("brand_agg") .field("brand") .size(20)).size(0); //发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); //解析响应 Aggregations aggregations = response.getAggregations(); //根据名称获取结果 Terms brand_agg = aggregations.get("brand_agg"); //拿到桶 List buckets = brand_agg.getBuckets(); //遍历桶 for (Terms.Bucket bucket : buckets) { System.out.println(bucket.getKeyAsString()); }

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的聚合内部嵌套的子聚合。因为我们需要在每个桶分别计算。

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

RestAPI

//创建请求 SearchRequest request = new SearchRequest("hotel"); //创建DSL request.source().aggregation(AggregationBuilders .terms("brand_agg") .field("brand") .subAggregation(AggregationBuilders.stats("score_stats").field("score")) .size(20)) .size(0); //发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); //解析响应 Aggregations aggregations = response.getAggregations(); //根据名称获取结果 Terms brand_agg = aggregations.get("brand_agg"); //拿到桶 List buckets = brand_agg.getBuckets(); //遍历桶 for (Terms.Bucket bucket : buckets) { System.out.println(bucket.getKeyAsString()); }
六）聚合案例
电视案例

创建索引及映射

PUT /tvs PUT /tvs/_search { "properties": { "price": { "type": "long" }, "color": { "type": "keyword" }, "brand": { "type": "keyword" }, "sold_date": { "type": "date" } } }

插入数据

POST /tvs/_bulk { "index": {}} { "price" : 1000, "color" : "红色", "brand" : "长虹", "sold_date" : "2019-10-28" } { "index": {}} { "price" : 2000, "color" : "红色", "brand" : "长虹", "sold_date" : "2019-11-05" } { "index": {}} { "price" : 3000, "color" : "绿色", "brand" : "小米", "sold_date" : "2019-05-18" } { "index": {}} { "price" : 1500, "color" : "蓝色", "brand" : "TCL", "sold_date" : "2019-07-02" } { "index": {}} { "price" : 1200, "color" : "绿色", "brand" : "TCL", "sold_date" : "2019-08-19" } { "index": {}} { "price" : 2000, "color" : "红色", "brand" : "长虹", "sold_date" : "2019-11-05" } { "index": {}} { "price" : 8000, "color" : "红色", "brand" : "三星", "sold_date" : "2020-01-01" } { "index": {}} { "price" : 2500, "color" : "蓝色", "brand" : "小米", "sold_date" : "2020-02-12" }
需求1 统计哪种颜色的电视销量最高
GET /tvs/_search { "size" : 0, "aggs" : { "popular_colors" : { "terms" : { "field" : "color" } } } }

查询条件解析

size：只获取聚合结果，而不要执行聚合的原始数据
aggs：固定语法，要对一份数据执行分组聚合 *** 作
popular_colors：就是对每个aggs，都要起一个名字，
terms：根据字段的值进行分组
field：根据指定的字段的值进行分组

返回

{ "took" : 18, "timed_out" : false, "_shards" : { "total" : 1, "successful" : 1, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : { "value" : 8, "relation" : "eq" }, "max_score" : null, "hits" : [ ] }, "aggregations" : { "popular_colors" : { "doc_count_error_upper_bound" : 0, "sum_other_doc_count" : 0, "buckets" : [ { "key" : "红色", "doc_count" : 4 }, { "key" : "绿色", "doc_count" : 2 }, { "key" : "蓝色", "doc_count" : 2 } ] } } }

返回结果解析

hits.hits：我们指定了size是0，所以hits.hits就是空的
aggregations：聚合结果
popular_color：我们指定的某个聚合的名称
buckets：根据我们指定的field划分出的buckets
key：每个bucket对应的那个值
doc_count：这个bucket分组内，有多少个数据
数量，其实就是这种颜色的销量

每种颜色对应的bucket中的数据的默认的排序规则：按照doc_count降序排序
需求2 统计每种颜色电视平均价格
GET /tvs/_search { "size" : 0, "aggs": { "colors": { "terms": { "field": "color" }, "aggs": { "avg_price": { "avg": { "field": "price" } } } } } }

在一个aggs执行的bucket *** 作（terms），平级的json结构下，再加一个aggs，这个第二个aggs内部，同样取个名字，执行一个metric *** 作，avg，对之前的每个bucket中的数据的指定的field，price field，求一个平均值

返回：

{ "took" : 4, "timed_out" : false, "_shards" : { "total" : 1, "successful" : 1, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : { "value" : 8, "relation" : "eq" }, "max_score" : null, "hits" : [ ] }, "aggregations" : { "colors" : { "doc_count_error_upper_bound" : 0, "sum_other_doc_count" : 0, "buckets" : [ { "key" : "红色", "doc_count" : 4, "avg_price" : { "value" : 3250.0 } }, { "key" : "绿色", "doc_count" : 2, "avg_price" : { "value" : 2100.0 } }, { "key" : "蓝色", "doc_count" : 2, "avg_price" : { "value" : 2000.0 } } ] } } }

buckets，除了key和doc_count
avg_price：我们自己取的metric aggs的名字
value：我们的metric计算的结果，每个bucket中的数据的price字段求平均值后的结果

相当于sql: select avg(price) from tvs group by color
需求3 继续下钻分析
每个颜色下，平均价格及每个颜色下，每个品牌的平均价格

GET /tvs/_search { "size": 0, "aggs": { "group_by_color": { "terms": { "field": "color" }, "aggs": { "color_avg_price": { "avg": { "field": "price" } }, "group_by_brand": { "terms": { "field": "brand" }, "aggs": { "brand_avg_price": { "avg": { "field": "price" } } } } } } } }
需求4：更多的metric
count：bucket，terms，自动就会有一个doc_count，就相当于是count
avg：avg aggs，求平均值
max：求一个bucket内，指定field值最大的那个数据
min：求一个bucket内，指定field值最小的那个数据
sum：求一个bucket内，指定field值的总和

GET /tvs/_search { "size" : 0, "aggs": { "colors": { "terms": { "field": "color" }, "aggs": { "avg_price": { "avg": { "field": "price" } }, "min_price" : { "min": { "field": "price"} }, "max_price" : { "max": { "field": "price"} }, "sum_price" : { "sum": { "field": "price" } } } } } }
需求5：划分范围 histogram
GET /tvs/_search { "size" : 0, "aggs":{ "price":{ "histogram":{ "field": "price", "interval": 2000 }, "aggs":{ "income": { "sum": { "field" : "price" } } } } } }

histogram：类似于terms，也是进行bucket分组 *** 作，接收一个field，按照这个field的值的各个范围区间，进行bucket分组 *** 作

"histogram":{ "field": "price", "interval": 2000 }

interval：2000，划分范围，02000，20004000，40006000，60008000，8000~10000，buckets

bucket有了之后，一样的，去对每个bucket执行avg，count，sum，max，min，等各种metric *** 作，聚合分析
需求6：按照日期分组聚合
date_histogram，按照我们指定的某个date类型的日期field，以及日期interval，按照一定的日期间隔，去划分bucket

min_doc_count：即使某个日期interval，2017-01-01~2017-01-31中，一条数据都没有，那么这个区间也是要返回的，不然默认是会过滤掉这个区间的
extended_bounds，min，max：划分bucket的时候，会限定在这个起始日期，和截止日期内

GET /tvs/_search { "size" : 0, "aggs": { "sales": { "date_histogram": { "field": "sold_date", "interval": "month", "format": "yyyy-MM-dd", "min_doc_count" : 0, "extended_bounds" : { "min" : "2019-01-01", "max" : "2020-12-31" } } } } }
需求7 统计每季度每个品牌的销售额
GET /tvs/_search { "size": 0, "aggs": { "group_by_sold_date": { "date_histogram": { "field": "sold_date", "interval": "quarter", "format": "yyyy-MM-dd", "min_doc_count": 0, "extended_bounds": { "min": "2019-01-01", "max": "2020-12-31" } }, "aggs": { "group_by_brand": { "terms": { "field": "brand" }, "aggs": { "sum_price": { "sum": { "field": "price" } } } }, "total_sum_price": { "sum": { "field": "price" } } } } } }
需求8 ：搜索与聚合结合，查询某个品牌按颜色销量
搜索与聚合可以结合起来。

sql select count(*)

from tvs

where brand like “%小米%”

group by color

es aggregation，scope，任何的聚合，都必须在搜索出来的结果数据中之行，搜索结果，就是聚合分析 *** 作的scope

GET /tvs/_search { "size": 0, "query": { "term": { "brand": { "value": "小米" } } }, "aggs": { "group_by_color": { "terms": { "field": "color" } } } }
需求9 global bucket：单个品牌与所有品牌销量对比
aggregation，scope，一个聚合 *** 作，必须在query的搜索结果范围内执行

出来两个结果，一个结果，是基于query搜索结果来聚合的; 一个结果，是对所有数据执行聚合的

GET /tvs/_search { "size": 0, "query": { "term": { "brand": { "value": "小米" } } }, "aggs": { "single_brand_avg_price": { "avg": { "field": "price" } }, "all": { "global": {}, "aggs": { "all_brand_avg_price": { "avg": { "field": "price" } } } } } }
需求10：过滤+聚合：统计价格大于1200的电视平均价格
搜索+聚合

过滤+聚合

GET /tvs/_search { "size": 0, "query": { "constant_score": { "filter": { "range": { "price": { "gte": 1200 } } } } }, "aggs": { "avg_price": { "avg": { "field": "price" } } } }
需求11 bucket filter：统计品牌最近一个月的平均价格
GET /tvs/_search { "size": 0, "query": { "term": { "brand": { "value": "小米" } } }, "aggs": { "recent_150d": { "filter": { "range": { "sold_date": { "gte": "now-150d" } } }, "aggs": { "recent_150d_avg_price": { "avg": { "field": "price" } } } }, "recent_140d": { "filter": { "range": { "sold_date": { "gte": "now-140d" } } }, "aggs": { "recent_140d_avg_price": { "avg": { "field": "price" } } } }, "recent_130d": { "filter": { "range": { "sold_date": { "gte": "now-130d" } } }, "aggs": { "recent_130d_avg_price": { "avg": { "field": "price" } } } } } }

aggs.filter，针对的是聚合去做的

如果放query里面的filter，是全局的，会对所有的数据都有影响

但是，如果，比如说，你要统计，长虹电视，最近1个月的平均值; 最近3个月的平均值; 最近6个月的平均值

bucket filter：对不同的bucket下的aggs，进行filter
需求12 排序：按每种颜色的平均销售额降序排序
GET /tvs/_search { "size": 0, "aggs": { "group_by_color": { "terms": { "field": "color", "order": { "avg_price": "asc" } }, "aggs": { "avg_price": { "avg": { "field": "price" } } } } } }

相当于sql子表数据字段可以立刻使用。
需求13 排序：按每种颜色的每种品牌平均销售额降序排序
GET /tvs/_search { "size": 0, "aggs": { "group_by_color": { "terms": { "field": "color" }, "aggs": { "group_by_brand": { "terms": { "field": "brand", "order": { "avg_price": "desc" } }, "aggs": { "avg_price": { "avg": { "field": "price" } } } } } } } }

欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/5721456.html

SpringBoot整合Elasticsearch之索引，映射，文档，搜索的基本 *** 作案例分析

发表评论

评论列表（0条）