• Elasticsearch基础操作演示总结

    一、索引操作

    （一）创建索引

    创建Elasticsearch（ES）索引是在ES中存储和管理数据的重要操作之一。索引是用于组织和检索文档的结构化数据存储。

    当创建Elasticsearch索引时，通常需要同时指定索引的设置（Settings）和映射（Mappings）。以下是一个包括索引的设置和映射的示例：

    1. PUT /my_index
    2. {
    3.   "settings": {
    4.     "number_of_shards": 5,
    5.     "number_of_replicas": 1
    6.   },
    7.   "mappings": {
    8.     "properties": {
    9.       "field1": {
    10.         "type": "text",
    11.         "analyzer": "standard"
    12.       },
    13.       "field2": {
    14.         "type": "keyword"
    15.       },
    16.       "field3": {
    17.         "type": "integer"
    18.       },
    19.       "field4": {
    20.         "type": "date",
    21.         "format": "yyyy-MM-dd"
    22.       }
    23.     }
    24.   }
    25. }

    在这个示例中：

    • settings 部分包括索引的配置设置。例如，它指定了索引将被分成5个主分片（number_of_shards），并包含1个副本（number_of_replicas）。您可以根据需求自定义这些设置。

    • mappings 部分用于定义索引中的字段映射。每个字段都包括字段名、数据类型（例如，text、keyword、integer、date等）以及可选的属性（例如，分析器、日期格式等）。

    这个示例通过DSL告诉Elasticsearch如何创建索引、如何配置索引的主分片和副本，以及如何映射字段以便正确存储和检索文档数据。在创建索引后，可以将文档添加到索引中，并使用查询DSL执行各种查询操作。

    假设您正在构建一个电子商务网站，需要存储和检索产品信息。可以定义产品索引的映射，包括产品名称、描述、价格等字段的数据类型和属性。

    DSL示例：

    1. PUT /products
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "product_name": {
    6.         "type": "text",
    7.         "analyzer": "standard"
    8.       },
    9.       "description": {
    10.         "type": "text",
    11.         "analyzer": "english"
    12.       },
    13.       "price": {
    14.         "type": "float"
    15.       },
    16.       "category": {
    17.         "type": "keyword"
    18.       }
    19.     }
    20.   }
    21. }

    Java示例：

    1. CreateIndexRequest request = new CreateIndexRequest("products");
    2. request.mapping("_doc", 
    3.     "product_name", "type=text,analyzer=standard",
    4.     "description", "type=text,analyzer=english",
    5.     "price", "type=float",
    6.     "category", "type=keyword"
    7. );
    8.  
    9. CreateIndexResponse createIndexResponse = client.indices()
    10. .create(request, RequestOptions.DEFAULT);

    （二）删除索引

    删除 Elasticsearch（ES）索引是一项重要的操作，可以用来清理不再需要的数据索引。要删除 Elasticsearch 索引，可以使用以下常规DSL语句：

    DELETE /my_index

    在上述示例中，DELETE 是 HTTP 请求方法，/my_index 是要删除的索引名称。这个简单的DSL语句会告诉 Elasticsearch 删除名为 my_index 的索引及其所有数据。

    • DELETE：这是 HTTP 请求方法，指示 Elasticsearch 执行删除操作。

    • /my_index：这是要删除的索引的名称。确保您提供的索引名称是正确的，因为删除后无法恢复。

    假设您运营一个博客平台，以索引和存储博客文章。有时，您可能需要删除某些旧的博客索引以释放存储空间。要删除名为 blog_posts 的博客索引，可以使用以下DSL语句：

    DELETE /blog_posts

    对应java代码可以为：

    1. DeleteIndexRequest deleteRequest = new DeleteIndexRequest("blog_posts");
    2. AcknowledgedResponse deleteResponse = client.indices()
    3. .delete(deleteRequest, RequestOptions.DEFAULT);
    4.  
    5. if (deleteResponse.isAcknowledged()) {
    6.     System.out.println("博客索引删除成功");
    7. } else {
    8.     System.out.println("博客索引删除失败");
    9. }

    （三）关闭索引

    关闭 Elasticsearch（ES）索引是一种操作，可以将索引设置为不可用状态，以减少资源消耗，但仍然保留索引定义和数据。要关闭 Elasticsearch 索引，可以使用以下常规DSL语句：

    POST /my_index/_close

    在上述示例中，POST 是 HTTP 请求方法，/my_index/_close 是要关闭的索引的路径。这个DSL语句会告诉 Elasticsearch 关闭名为 my_index 的索引。

    • POST：这是 HTTP 请求方法，用于执行关闭操作。

    • /my_index/_close：这是要关闭的索引的路径。请注意，关闭操作是通过向索引的特殊路径发送 POST 请求来执行的。

    假设您运营一个文档管理系统，使用 Elasticsearch 来存储文档索引。有时，您可能需要关闭某个索引以释放资源，但仍然保留索引定义，以便以后再次启用。要关闭名为 document_index 的文档索引，可以使用以下DSL语句：

    POST /document_index/_close

    对应java代码可写为：

    1. CloseIndexRequest closeIndexRequest = new CloseIndexRequest("document_index");
    2. AcknowledgeResponse closeResponse = client.indices()
    3. .close(closeIndexRequest, RequestOptions.DEFAULT);
    4.  
    5. if (closeResponse.isAcknowledged()) {
    6.     System.out.println("索引关闭成功");
    7. } else {
    8.     System.out.println("索引关闭失败");
    9. }

    （四）打开索引

    打开 Elasticsearch（ES）索引是一种操作，可以将先前关闭的索引重新设置为可用状态，以便进行搜索和写入操作。要打开 Elasticsearch 索引，可以使用以下常规DSL语句：

    POST /my_index/_open

    在上述示例中，POST 是 HTTP 请求方法，/my_index/_open 是要打开的索引的路径。这个DSL语句会告诉 Elasticsearch 打开名为 my_index 的索引。

    • POST：这是 HTTP 请求方法，用于执行打开操作。

    • /my_index/_open：这是要打开的索引的路径。请注意，打开操作是通过向索引的特殊路径发送 POST 请求来执行的。

    假设您运营一个文档管理系统，使用 Elasticsearch 存储文档索引。有时，可能需要重新打开以前关闭的索引，以便用户可以再次访问和搜索文档。要重新打开名为 document_index 的文档索引，可以使用以下DSL语句：

    POST /document_index/_open

    对应java代码可写为：

    1. OpenIndexRequest openIndexRequest = new OpenIndexRequest("document_index");
    2. OpenIndexResponse openResponse = client.indices()
    3. .open(openIndexRequest, RequestOptions.DEFAULT);
    4.  
    5. if (openResponse.isAcknowledged()) {
    6.     System.out.println("索引打开成功");
    7. } else {
    8.     System.out.println("索引打开失败");
    9. }

    这个示例适用于文档管理系统，如果先前关闭的文档索引需要再次被用户访问和搜索，那么重新打开索引是一个有效的操作。这可以用于重新激活不再频繁使用但仍然有价值的索引。

    总之，重新打开 Elasticsearch 索引是一种管理索引可用性的操作，可用于恢复先前关闭的索引以进行搜索和写入操作。根据具体需求，可以使用DSL或 Elasticsearch 客户端库来执行此操作。请注意，重新打开索引后，用户可以再次对其执行搜索和写入操作。

    （五）索引别名

    Elasticsearch索引别名是一项强大的功能，用于管理索引的命名别称，以提供更灵活的索引管理和查询。

    用法分析

    1. 索引版本控制：索引别名可以用于实现索引版本控制。当您需要更新索引时，可以创建一个新的索引，并将别名指向新索引，而不需要更改应用程序中的查询。这使得您可以平滑地进行索引维护和升级。

    2. 切换索引：别名允许您在不中断查询的情况下切换索引。这对于在索引上执行滚动更新、备份、恢复和数据迁移等操作时非常有用。

    3. 多索引查询：您可以将一个别名关联到多个索引上，从而实现多索引查询。这对于执行跨多个索引的复杂查询非常有用，而无需明确指定每个索引的名称。

    4. 索引分割与归档：索引别名可以用于将数据分割到不同的索引中，以便更好地管理大量数据。例如，您可以创建每天一个新索引，然后使用别名汇总它们，之后可以轻松地归档或删除旧的索引。

    5. 索引安全性：通过使用别名，您可以在后端更改实际索引名称，从而增强索引的安全性。外部用户不需要知道真正的索引名称。

    注意事项

    1. 别名不是索引：索引别名本身不存储数据，它只是一个指向一个或多个索引的符号引用。因此，创建和删除别名是低成本的操作。

    2. 别名更改是原子操作：将别名切换到新索引或删除别名是原子操作，这意味着它们不会中断正在执行的查询。但请注意，将别名从一个索引切换到另一个索引后，新的索引可能需要时间来完全加载数据。

    3. 谨慎使用别名：虽然索引别名非常强大，但也需要谨慎使用。不恰当的别名管理可能会导致混淆和错误。

    4. 版本控制的注意事项：当使用别名进行索引版本控制时，需要确保新索引的映射与旧索引的映射兼容。否则，应用程序可能会出现问题。

    5. 查询性能：尽管别名可以提高查询的灵活性，但跨多个索引执行查询可能会增加性能开销。请谨慎设计查询以优化性能。

    总之，索引别名是 Elasticsearch 灵活索引管理的有力工具，但需要仔细规划和使用。它们可以用于索引版本控制、查询优化和索引维护，但需要谨慎管理以确保正确性和性能。

    应用案例举例和具体案例展示

    案例举例-版本控制：

    • 案例：假设您的应用程序存储用户生成的文档，并且您需要定期更新文档结构，例如添加新字段或更改映射。同时，您希望用户可以持续访问其旧文档，并逐渐迁移到新文档结构。
    • 解决方案：您可以为每个文档类型创建一个别名，例如"v1"和"v2"，每个别名指向不同版本的索引。当您需要更新索引时，创建一个新的索引版本，并将别名指向新索引。这样，新文档将被写入新索引，而用户仍然可以查询旧索引以访问旧文档。逐渐迁移用户到新索引后，您可以删除旧索引。

    案例举例-多索引查询：

    • 案例：您的应用程序需要执行复杂的查询，涉及多个索引。例如，在电子商务平台上，您可能有一个索引用于存储产品信息，另一个用于存储订单信息，而查询需要同时涵盖这两个索引。
    • 解决方案：创建一个别名，例如"ecommerce_data"，将其指向产品和订单索引。然后，您的查询可以针对"ecommerce_data"别名执行，而无需明确指定每个索引的名称。这使得查询更简单且更具可维护性。

    案例举例​​​​​​​-索引分割与归档：

    • 案例：您的应用程序需要存储大量数据，例如日志数据，但不希望将所有数据存储在一个巨大的索引中。您还希望能够轻松地归档旧数据，同时保持查询的可用性。
    • 解决方案：创建一个别名，例如"logs"，将其指向每天一个新索引。每天结束时，创建新索引并更新别名，这样新数据将被写入新索引。旧索引可以被归档或删除，而查询可以继续使用"logs"别名，无需更改。

    案例举例​​​​​​​索引切换：

    • 案例：您的应用程序需要进行滚动更新，例如，将新版本的数据引入到生产环境中，同时确保零停机时间。
    • 解决方案：创建一个别名，例如"live_data"，将其指向当前的生产索引。然后，将新索引准备好，并在准备就绪后，将别名从旧索引切换到新索引。这样，新数据将在不中断查询的情况下引入到生产环境中。

    这些案例说明了索引别名在处理数据版本控制、查询优化、数据分割与归档以及索引切换方面的实际应用。通过巧妙使用别名，可以更灵活地管理和操作您的 Elasticsearch 索引，同时确保数据的可用性和性能。

    选择上面提到的 "版本控制" 案例，并进行具体的展示和分析步骤。这个案例涉及使用索引别名进行索引版本控制，允许平滑地更新索引结构而不中断用户查询。

    背景：假设我们运营一个博客平台，使用 Elasticsearch 来存储博客文章。需要定期更新博客文章的结构，例如，添加新字段或更改映射。同时希望用户可以持续访问其旧的博客文章，并逐渐迁移到新的文章结构。

    第一步：创建初始索引和别名

    创建初始的博客索引，例如 blog_posts_v1。

    1. PUT /blog_posts_v1
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "title": {
    6.         "type": "text"
    7.       },
    8.       "content": {
    9.         "type": "text"
    10.       },
    11.       "date_published": {
    12.         "type": "date"
    13.       }
    14.     }
    15.   }
    16. }

    创建一个别名 blog_posts，将其指向初始的博客索引。

    1. POST /_aliases
    2. {
    3.   "actions": [
    4.     {
    5.       "add": {
    6.         "index": "blog_posts_v1",
    7.         "alias": "blog_posts"
    8.       }
    9.     }
    10.   ]
    11. }

    第二步：定期更新索引结构。当需要更新索引结构时，创建一个新的博客索引，例如 blog_posts_v2，并更新映射。

    1. PUT /blog_posts_v2
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "title": {
    6.         "type": "text"
    7.       },
    8.       "content": {
    9.         "type": "text"
    10.       },
    11.       "date_published": {
    12.         "type": "date"
    13.       },
    14.       "author": {
    15.         "type": "keyword"
    16.       }
    17.     }
    18.   }
    19. }

    第三步：切换别名。一旦新的博客索引 blog_posts_v2 准备就绪，使用别名切换将别名 blog_posts 从旧索引 blog_posts_v1 切换到新索引 blog_posts_v2。

    1. POST /_aliases
    2. {
    3.   "actions": [
    4.     {
    5.       "remove": {
    6.         "index": "blog_posts_v1",
    7.         "alias": "blog_posts"
    8.       }
    9.     },
    10.     {
    11.       "add": {
    12.         "index": "blog_posts_v2",
    13.         "alias": "blog_posts"
    14.       }
    15.     }
    16.   ]
    17. }

    第四步：用户迁移。用户可以继续访问和查询博客文章，而无需更改他们的查询代码。新的博客文章将写入新的索引 blog_posts_v2，而旧的博客文章仍然可查询。

    第五步：清理旧索引。定期清理旧的博客索引（例如，blog_posts_v1），或者在不再需要它们时进行归档或删除。

    这个案例说明了如何使用索引别名在更新索引结构时，平滑地迁移用户到新的索引版本，同时保持查询的连续性。索引别名是实现版本控制和索引维护的有力工具。

    二、映射操作

    在 Elasticsearch 中，映射（Mapping）是用来定义如何存储和索引文档中字段的方式的重要概念。映射操作用于指定字段的数据类型、分析器以及其他属性，以便 Elasticsearch 能够正确地处理和查询文档中的数据。

    映射是 Elasticsearch 中的元数据，它描述了索引中每个字段的数据类型、如何被索引以及如何存储。它允许 Elasticsearch 理解和处理文档中的数据。

    映射的主要元素：

    • 数据类型：定义字段的数据类型，如文本、数字、日期、地理位置等。
    • 分析器（Analyzer）：指定用于分词和处理文本字段的分析器。分析器将文本字段拆分成单词，以便进行全文搜索。
    • 属性（Properties）：定义字段的其他属性，如是否可搜索、是否存储原始值、是否支持排序等。
    • 嵌套映射（Nested Mapping）：用于处理复杂数据结构，如嵌套文档或数组。

    映射对于正确索引和查询文档非常重要。如果映射不正确，将导致搜索和分析错误。正确的映射可以优化查询性能，使 Elasticsearch 能够更好地理解和处理文档数据。一旦索引创建后，通常不能直接更改映射。但可以通过重新索引数据或创建新索引来应用新的映射。

    映射的注意事项：

    • 映射的设计需要仔细考虑，因为不正确的映射可能会导致数据不一致或搜索性能下降。
    • 映射更改可能需要谨慎处理，特别是在生产环境中，因为不正确的映射更改可能会导致数据丢失或不可用。

    总之，映射是 Elasticsearch 中用于定义和管理索引字段的关键操作。正确的映射设计可以提高查询性能和数据质量，而不正确的映射可能会导致问题。在设计和管理索引时，请谨慎考虑映射的使用和更改。

    （一）查看映射

    在 Elasticsearch 中，可以使用映射操作查看索引的映射信息。要查看索引的映射，可以使用以下常规DSL语句：

    GET /my_index/_mapping

    在上述示例中，GET 是 HTTP 请求方法，/my_index/_mapping 是要查看映射的索引名称。

    • GET：这是 HTTP 请求方法，用于执行查看映射操作。

    • /my_index/_mapping：这是要查看映射的索引的路径。

    假设运营一个电子商务网站，使用 Elasticsearch 来存储产品信息。电子商务网站存储产品信息的 Elasticsearch 索引名为 products，该索引包含产品的名称、价格、描述等信息。使用以下DSL语句来查看产品索引 products 的映射：

    GET /products/_mapping

    使用以下DSL请求 GET /products/_mapping 会返回关于索引 products 的映射信息。返回结果将是一个JSON格式的响应，其中包含有关索引中字段的详细信息。以下是对返回结果的分析说明：

    1. {
    2.   "products": {
    3.     "mappings": {
    4.       "properties": {
    5.         "name": {
    6.           "type": "text",
    7.           "fields": {
    8.             "keyword": {
    9.               "type": "keyword",
    10.               "ignore_above": 256
    11.             }
    12.           }
    13.         },
    14.         "price": {
    15.           "type": "float"
    16.         },
    17.         "description": {
    18.           "type": "text"
    19.         },
    20.         // 其他字段...
    21.       }
    22.     }
    23.   }
    24. }

    （二）扩展映射

    在 Elasticsearch 中，扩展映射（Mapping Expansion）是一项操作，用于在已有的索引映射基础上添加新的字段或修改已有字段的属性。这可以用于动态地适应数据模型的变化或为索引中的字段添加新功能。以下是有关扩展映射的分析：

    扩展映射的使用场景

    • 适应数据模型的变化：当应用程序需要存储新类型的数据或更改现有数据的结构时，扩展映射是一种灵活的方式。例如，可以将新的文本字段添加到索引，以存储新类型的信息。

    • 引入新的数据属性：可能需要在索引中添加新的字段来存储与现有数据相关的新属性。例如，如果索引包含产品信息，可能希望在以后添加字段来存储产品的新特性。

    • 索引迭代和升级：当需要对索引进行迭代和升级时，扩展映射是必要的。例如，如果在旧版本的索引中不包括某些字段，但在新版本中需要这些字段，可以扩展映射以包括这些字段。

    扩展映射的操作步骤

    1. 创建新映射：首先，需要定义新字段的映射。这包括指定字段的数据类型、分析器和其他属性。可以通过创建一个新的索引映射来完成。

    2. 将新映射添加到索引：一旦新映射定义好了，可以使用索引别名或新的索引名称，将新映射添加到索引中。

    3. 重新索引数据：如果新映射需要应用于已有的数据，需要重新索引现有数据以适应新的映射。这可以通过重新索引工具或 Elasticsearch 的 Reindex API 来实现。

    4. 测试和验证：在应用新映射之前，建议对其进行测试和验证，以确保数据存储和查询操作按预期工作。

    注意事项和考虑因素

    • 扩展映射可能需要一些索引维护工作，特别是对于大型索引。重新索引数据可能会导致一些性能开销。

    • 在扩展映射时，确保新映射的定义与应用程序的需求和数据模型一致。

    • 考虑数据迁移策略，特别是在高可用性和生产环境中。数据迁移应谨慎进行，以确保不会导致数据丢失或中断查询。

    总之，扩展映射是 Elasticsearch 中用于适应数据模型变化和引入新属性的重要操作。它提供了灵活性，允许根据应用程序需求不断发展和扩展索引映射。在执行扩展映射操作时，请谨慎规划和测试，以确保数据的完整性和性能。

    业务举例：扩展映射以添加作者和标签字段

    假设运营一个在线新闻门户网站，使用 Elasticsearch 来存储新闻文章的索引。最初的索引只包含文章的标题、内容和发布日期。现在，我们决定扩展映射，以添加新的字段以存储文章的作者和标签。新闻门户网站使用 Elasticsearch 索引 news_articles 来存储新闻文章。最初的映射定义如下：

    1. {
    2.   "news_articles": {
    3.     "mappings": {
    4.       "properties": {
    5.         "title": {
    6.           "type": "text"
    7.         },
    8.         "content": {
    9.           "type": "text"
    10.         },
    11.         "publish_date": {
    12.           "type": "date"
    13.         }
    14.       }
    15.     }
    16.   }
    17. }

    现在，决定扩展映射，以包括文章的作者和标签信息。

    第一步：创建新映射。需要创建新的映射，以包括作者和标签字段。新映射如下所示：

    1. {
    2.   "news_articles": {
    3.     "mappings": {
    4.       "properties": {
    5.         "title": {
    6.           "type": "text"
    7.         },
    8.         "content": {
    9.           "type": "text"
    10.         },
    11.         "publish_date": {
    12.           "type": "date"
    13.         },
    14.         "author": {
    15.           "type": "text"
    16.         },
    17.         "tags": {
    18.           "type": "keyword"
    19.         }
    20.       }
    21.     }
    22.   }
    23. }

    在新映射中，我们添加了两个新字段：author 和 tags，分别用于存储文章的作者名字和标签（以关键字类型存储）。

    第二步：将新映射添加到索引。为了将新映射添加到现有索引中，可以执行以下步骤：

    • 创建一个新的索引，例如 news_articles_v2，并应用新的映射。
    • 使用 Elasticsearch 的 Reindex API 将现有索引中的数据重新索引到新索引中。在此过程中，新映射将被应用于已有的数据。
    • 更新索引别名，以使别名指向新的索引，使其成为主要的查询目标。

    第三步：测试和验证。在应用新映射之前，进行测试和验证以确保查询和索引操作按预期工作。确保新字段的数据存储和检索都正确无误。

    （三）基本的数据类型

    keyword类型

    在 Elasticsearch 映射操作中，keyword 类型是一种常用的基本数据类型，用于存储关键字数据。与 text 类型不同，keyword 类型不进行分词，它将整个文本视为单个词条。这使得 keyword 类型非常适合用于排序、聚合和精确匹配等操作。

    • 关键字数据：keyword 类型用于存储不需要分词的关键字数据。这包括标签、标识符、名称、状态等文本信息，通常需要进行精确匹配或按照字母顺序排序。

    • 不分词：与 text 类型不同，keyword 类型不会对文本进行分词。它将整个文本视为单个词条，保留原始文本的完整性。

    • 精确匹配和排序：由于不进行分词，keyword 类型非常适合进行精确匹配（例如，过滤和筛选操作）和排序操作。您可以确保查询的精确匹配，而不受分词的影响，同时还可以按照字母顺序对数据进行排序。

    • 不适用于全文搜索：由于不进行分词，keyword 类型不适用于全文搜索。如果需要全文搜索，通常应使用 text 类型。

    假设您正在使用 Elasticsearch 存储产品信息，并且每个产品都有一个标签列表，希望能够按照标签进行精确匹配和排序。

    创建一个索引映射，包括一个 keyword 类型的字段来存储产品标签。

    1. PUT /products
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "name": {
    6.         "type": "text"
    7.       },
    8.       "tags": {
    9.         "type": "keyword"
    10.       }
    11.     }
    12.   }
    13. }

    向索引中添加一些产品文档，包括标签信息。

    1. POST /products/_doc/1
    2. {
    3.   "name": "Product A",
    4.   "tags": ["electronics", "smartphone"]
    5. }
    6.  
    7. POST /products/_doc/2
    8. {
    9.   "name": "Product B",
    10.   "tags": ["clothing", "shoes"]
    11. }

    执行一个精确匹配的查询，查找包含特定标签的产品。

    1. GET /products/_search
    2. {
    3.   "query": {
    4.     "match": {
    5.       "tags": "electronics"
    6.     }
    7.   }
    8. }

    此查询将返回包含 "electronics" 标签的产品，而不会返回包含 "smartphone" 标签的产品。

    执行一个排序查询，按标签字段的字母顺序对产品进行排序。

    1. GET /products/_search
    2. {
    3.   "sort": [
    4.     {
    5.       "tags": "asc"
    6.     }
    7.   ]
    8. }

    此查询将返回产品按标签字段的字母顺序升序排列。

    通过使用 keyword 类型来存储标签信息，可以轻松地进行精确匹配和排序，同时保留了标签的原始完整性。这在许多应用中非常有用，特别是在需要处理结构化数据的情况下。

    text类型

    在 Elasticsearch 映射操作中，text 类型是一种常用的基本数据类型，用于存储文本数据，通常用于全文搜索和分析。

    • 文本数据：text 类型主要用于存储文本数据，例如文章内容、产品描述、评论等。这些字段通常需要进行全文搜索和分析。

    • 分词：text 类型会对文本进行分词，将文本拆分成单词或词条，以便更好地支持全文搜索和分析。分词可以根据配置的分析器进行，以便处理不同语言和文本特性。

    • 全文搜索：由于分词的支持，text 类型非常适合进行全文搜索操作。它允许用户查询包含特定单词或短语的文档，而不需要精确匹配整个字段内容。

    • 分析功能：text 类型还支持分析功能，包括在搜索时执行文本预处理（如小写化、去停用词、词干提取等）以及相关性评分。

    假设正在使用 Elasticsearch 存储产品评论，希望能够搜索和分析评论内容。创建一个索引映射，包括一个 text 类型的字段来存储评论内容。

    1. PUT /product_reviews
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "product_name": {
    6.         "type": "keyword"
    7.       },
    8.       "comment": {
    9.         "type": "text"
    10.       }
    11.     }
    12.   }
    13. }

    向索引中添加一些产品评论文档。

    1. POST /product_reviews/_doc/1
    2. {
    3.   "product_name": "Product A",
    4.   "comment": "This product is amazing! I love it."
    5. }
    6.  
    7. POST /product_reviews/_doc/2
    8. {
    9.   "product_name": "Product B",
    10.   "comment": "Not satisfied with this product. It doesn't meet my expectations."
    11. }

    执行一个全文搜索的查询，查找包含特定关键字的评论。

    1. GET /product_reviews/_search
    2. {
    3.   "query": {
    4.     "match": {
    5.       "comment": "amazing"
    6.     }
    7.   }
    8. }

    此查询将返回包含 "amazing" 关键字的评论。

    执行一个分析查询，使用分析功能评分。

    1. GET /product_reviews/_search
    2. {
    3.   "query": {
    4.     "match_phrase": {
    5.       "comment": "product satisfaction"
    6.     }
    7.   },
    8.   "sort": [
    9.     "_score" // 根据相关性评分排序
    10.   ]
    11. }
    12.

    此查询将返回包含 "product satisfaction" 短语的评论，并且可以根据相关性进行排序。

    1. {
    2.   "took": 15,
    3.   "timed_out": false,
    4.   "_shards": {
    5.     "total": 1,
    6.     "successful": 1,
    7.     "skipped": 0,
    8.     "failed": 0
    9.   },
    10.   "hits": {
    11.     "total": {
    12.       "value": 2,
    13.       "relation": "eq"
    14.     },
    15.     "max_score": 1.2345678, // 最高评分
    16.     "hits": [
    17.       {
    18.         "_index": "product_reviews",
    19.         "_type": "_doc",
    20.         "_id": "3",
    21.         "_score": 1.2345678, // 文档的评分
    22.         "_source": {
    23.           "product_name": "Product C",
    24.           "comment": "I have found great product satisfaction with this item."
    25.         }
    26.       },
    27.       {
    28.         "_index": "product_reviews",
    29.         "_type": "_doc",
    30.         "_id": "4",
    31.         "_score": 0.9876543, // 文档的评分
    32.         "_source": {
    33.           "product_name": "Product D",
    34.           "comment": "Product satisfaction is important for me."
    35.         }
    36.       }
    37.     ]
    38.   }
    39. }

    通过使用 text 类型来存储评论内容，可以进行全文搜索和分析，以更好地理解用户的反馈和需求。这对于处理文本数据的应用场景非常有用，例如产品评论、新闻文章、博客内容等。

    数值类型

    在 Elasticsearch 映射操作中，数值类型用于存储数值数据，这些数据通常包括整数和浮点数。数值类型非常适用于执行范围查询、聚合操作和数值计算。主要数值类型如下：

    1. integer：用于存储整数值。适用于存储没有小数部分的整数。

    2. long：用于存储长整数值。通常用于存储较大范围的整数。

    3. float：用于存储单精度浮点数值。

    4. double：用于存储双精度浮点数值。通常用于存储高精度的浮点数。

    这些数值类型用于存储不同范围和精度的数值数据，以支持各种数值计算和分析需求。

    假设正在使用 Elasticsearch 存储销售数据，其中包括产品的价格（浮点数）和销售数量（整数）。创建一个名为 "sales" 的索引，其中包括了价格（price）和销售数量（quantity）字段：

    1. PUT /sales
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "price": {
    6.         "type": "float"
    7.       },
    8.       "quantity": {
    9.         "type": "integer"
    10.       }
    11.     }
    12.   }
    13. }

    插入了两个产品的销售数据：

    1. POST /sales/_doc/1
    2. {
    3.   "price": 75.99,
    4.   "quantity": 15
    5. }
    6.  
    7. POST /sales/_doc/2
    8. {
    9.   "price": 95.50,
    10.   "quantity": 20
    11. }

    假设希望查找价格在 50 到 100 之间且销售数量大于等于 10 的产品。

    1. GET /sales/_search
    2. {
    3.   "query": {
    4.     "bool": {
    5.       "must": [
    6.         {
    7.           "range": {
    8.             "price": {
    9.               "gte": 50,
    10.               "lte": 100
    11.             }
    12.           }
    13.         },
    14.         {
    15.           "range": {
    16.             "quantity": {
    17.               "gte": 10
    18.             }
    19.           }
    20.         }
    21.       ]
    22.     }
    23.   }
    24. }

    返回结果将包含与查询条件匹配的文档。

    1. {
    2.   "took": 10,
    3.   "timed_out": false,
    4.   "_shards": {
    5.     "total": 1,
    6.     "successful": 1,
    7.     "skipped": 0,
    8.     "failed": 0
    9.   },
    10.   "hits": {
    11.     "total": {
    12.       "value": 2,
    13.       "relation": "eq"
    14.     },
    15.     "max_score": 1.0,
    16.     "hits": [
    17.       {
    18.         "_index": "sales",
    19.         "_type": "_doc",
    20.         "_id": "1",
    21.         "_score": 1.0,
    22.         "_source": {
    23.           "product_name": "Product A",
    24.           "price": 75.99,
    25.           "quantity": 15
    26.         }
    27.       },
    28.       {
    29.         "_index": "sales",
    30.         "_type": "_doc",
    31.         "_id": "2",
    32.         "_score": 1.0,
    33.         "_source": {
    34.           "product_name": "Product B",
    35.           "price": 95.50,
    36.           "quantity": 20
    37.         }
    38.       }
    39.     ]
    40.   }
    41. }

    分析说明：

    • 查询使用了 range 查询来查找价格在 50 到 100 之间的产品，以及销售数量大于等于 10 的产品。

    • 返回结果包含了匹配的文档，每个文档都包括了相关信息和相关性评分。

    • 查询结果中包括两个产品，它们的价格和销售数量满足查询条件。

    这个示例演示了如何使用数值类型进行范围查询，以查找满足特定条件的文档。数值类型非常适用于存储和查询数值数据，对于分析、统计和报告等用途非常有用。

    布尔类型

    在 Elasticsearch 映射操作中，布尔类型（Boolean）是一种基本的数据类型，用于存储布尔值，即 true 或 false。布尔类型通常用于存储表示真假条件的信息，例如是否已完成、是否可用等。

    • 布尔数据：布尔类型用于存储布尔值，它们表示真假条件。在 Elasticsearch 中，布尔字段可以用于标识文档是否满足某些条件。

    • 存储效率：布尔字段非常节省存储空间，因为它们只需要一个位来表示 true 或 false。这对于存储大量布尔信息的索引非常有用。

    • 查询和过滤：布尔字段可用于执行查询和过滤操作。可以根据布尔字段的值来筛选文档，例如查找所有已完成的任务或所有可用的产品。

    假设正在使用 Elasticsearch 存储任务列表，并希望标识哪些任务已完成（true）和哪些任务未完成（false）。使用 PUT 请求创建一个索引（index），并指定索引映射（mapping）。在此示例中，我们创建一个名为 "tasks" 的索引，并定义了两个字段：任务名称（task_name）和是否已完成（is_completed）。

    1. PUT /tasks
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "task_name": {
    6.         "type": "text"
    7.       },
    8.       "is_completed": {
    9.         "type": "boolean"
    10.       }
    11.     }
    12.   }
    13. }

    插入一些示例任务数据的请求：

    1. POST /tasks/_doc/1
    2. {
    3.   "task_name": "Task A",
    4.   "is_completed": true
    5. }
    6.  
    7. POST /tasks/_doc/2
    8. {
    9.   "task_name": "Task B",
    10.   "is_completed": false
    11. }
    12.  
    13. POST /tasks/_doc/3
    14. {
    15.   "task_name": "Task C",
    16.   "is_completed": true
    17. }

    假设要查询所有已完成的任务：

    1. GET /tasks/_search
    2. {
    3.   "query": {
    4.     "term": {
    5.       "is_completed": true
    6.     }
    7.   }
    8. }

    返回结果将包含已完成的任务文档：

    1. {
    2.   "took": 5,
    3.   "timed_out": false,
    4.   "_shards": {
    5.     "total": 1,
    6.     "successful": 1,
    7.     "skipped": 0,
    8.     "failed": 0
    9.   },
    10.   "hits": {
    11.     "total": {
    12.       "value": 3,
    13.       "relation": "eq"
    14.     },
    15.     "max_score": 1.0,
    16.     "hits": [
    17.       {
    18.         "_index": "tasks",
    19.         "_type": "_doc",
    20.         "_id": "1",
    21.         "_score": 1.0,
    22.         "_source": {
    23.           "task_name": "Task A",
    24.           "is_completed": true
    25.         }
    26.       },
    27.       {
    28.         "_index": "tasks",
    29.         "_type": "_doc",
    30.         "_id": "3",
    31.         "_score": 1.0,
    32.         "_source": {
    33.           "task_name": "Task C",
    34.           "is_completed": true
    35.         }
    36.       }
    37.     ]
    38.   }
    39. }

    • 查询使用了 term 查询来查找 is_completed 字段为 true 的任务。

    • 返回结果包含了已完成的任务文档，每个文档都包括了相关信息和相关性评分（如果使用相关性评分）。

    这个示例演示了如何使用布尔类型字段来标识和查询已完成的任务。布尔类型在存储和查询表示真假条件的信息时非常有用，例如任务状态、商品可用性等。通过这种方式，可以有效地管理和查询布尔值数据。

    日期类型

    在 Elasticsearch 映射操作中，日期类型（Date）是一种基本的数据类型，用于存储日期和时间信息。日期类型通常用于记录事件发生的时间戳或日期值。

    • 日期时间数据：日期类型用于存储日期和时间信息，通常表示为 ISO 8601 格式的日期字符串（例如："2023-10-06T15:30:00Z"）。

    • 存储格式：Elasticsearch 内部将日期类型存储为 UNIX 时间戳（以毫秒为单位），但可以在查询和返回结果中使用更人类可读的日期字符串。

    • 支持的日期格式：Elasticsearch 支持多种日期格式的解析，允许索引不同格式的日期，并在查询时执行日期范围过滤和聚合。

    • 时区处理：日期类型支持时区信息，以确保正确处理不同时区的日期和时间。

    假设您正在使用 Elasticsearch 存储新闻文章，并希望记录每篇文章的发布日期。使用 PUT 请求创建一个索引（index），并指定索引映射（mapping）。在此示例中，我们创建一个名为 "news_articles" 的索引，并定义了两个字段：新闻标题（headline）和发布日期（publish_date）。

    1. PUT /news_articles
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "headline": {
    6.         "type": "text"
    7.       },
    8.       "publish_date": {
    9.         "type": "date"
    10.       }
    11.     }
    12.   }
    13. }

    插入一些示例新闻文章数据的请求：

    1. POST /news_articles/_doc/1
    2. {
    3.   "headline": "Elasticsearch 8.0 Released",
    4.   "publish_date": "2023-04-15T10:30:00Z"
    5. }
    6.  
    7. POST /news_articles/_doc/2
    8. {
    9.   "headline": "Big Data Summit 2023 Recap",
    10.   "publish_date": "2023-07-20T14:45:00Z"
    11. }
    12.  
    13. POST /news_articles/_doc/3
    14. {
    15.   "headline": "AI Advances in Healthcare",
    16.   "publish_date": "2023-11-10T08:15:00Z"
    17. }

    假设您要查询所有发布日期在特定时间段内的文章：

    1. GET /news_articles/_search
    2. {
    3.   "query": {
    4.     "range": {
    5.       "publish_date": {
    6.         "gte": "2023-01-01T00:00:00Z",
    7.         "lte": "2023-12-31T23:59:59Z"
    8.       }
    9.     }
    10.   }
    11. }

    返回结果将包含发布日期在指定时间段内的文章：

    1. {
    2.   "took": 5,
    3.   "timed_out": false,
    4.   "_shards": {
    5.     "total": 1,
    6.     "successful": 1,
    7.     "skipped": 0,
    8.     "failed": 0
    9.   },
    10.   "hits": {
    11.     "total": {
    12.       "value": 3,
    13.       "relation": "eq"
    14.     },
    15.     "max_score": 1.0,
    16.     "hits": [
    17.       {
    18.         "_index": "news_articles",
    19.         "_type": "_doc",
    20.         "_id": "1",
    21.         "_score": 1.0,
    22.         "_source": {
    23.           "headline": "Article A",
    24.           "publish_date": "2023-04-15T10:30:00Z"
    25.         }
    26.       },
    27.       {
    28.         "_index": "news_articles",
    29.         "_type": "_doc",
    30.         "_id": "2",
    31.         "_score": 1.0,
    32.         "_source": {
    33.           "headline": "Article B",
    34.           "publish_date": "2023-07-20T14:45:00Z"
    35.         }
    36.       },
    37.       {
    38.         "_index": "news_articles",
    39.         "_type": "_doc",
    40.         "_id": "3",
    41.         "_score": 1.0,
    42.         "_source": {
    43.           "headline": "Article C",
    44.           "publish_date": "2023-11-10T08:15:00Z"
    45.         }
    46.       }
    47.     ]
    48.   }
    49. }

    • 查询使用了 range 查询来查找发布日期在 2023 年内的文章。

    • 返回结果包含了发布日期在指定时间段内的文章，每个文档都包括了相关信息和相关性评分（如果使用相关性评分）。

    这个示例演示了如何使用日期类型字段来存储和查询日期信息。日期类型在存储和分析与时间相关的数据时非常有用，例如新闻发布日期、事件发生时间等。通过这种方式，可以轻松地执行日期范围过滤和聚合操作，以满足各种时间相关的查询需求。

    （四）复杂数据类型

    数组类型

    在 Elasticsearch 映射操作中，数组类型用于存储多个值的集合，这些值可以是相同类型的，也可以是不同类型的。数组类型通常用于表示复杂的多值字段，例如标签、评论、作者列表等。

    • 数组数据：数组类型允许在单个字段中存储多个值，这些值可以是文本、数字、日期或其他数据类型。

    • 多值字段：与传统数据库不同，Elasticsearch 允许字段具有多个值，而不需要创建多个字段。这使得数组类型非常适用于存储多值属性。

    • 支持的数据类型：数组可以包含不同类型的数据，例如文本、数字、日期等。这使得它非常灵活。

    • 查询和过滤：可以使用数组字段执行查询和过滤操作，例如查找包含特定值的文档或在数组中查找范围内的值。

    假设您正在使用 Elasticsearch 存储图书信息，每本书可以有多个作者。使用 PUT 请求创建一个索引（index），并指定索引映射（mapping）。在此示例中，我们创建一个名为 "books" 的索引，并定义了两个字段：书名（title）和作者列表（authors）。

    1. PUT /books
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "title": {
    6.         "type": "text"
    7.       },
    8.       "authors": {
    9.         "type": "keyword"
    10.       }
    11.     }
    12.   }
    13. }

    插入一些示例图书数据的请求：

    1. POST /books/_doc/1
    2. {
    3.   "title": "Book A",
    4.   "authors": ["John Smith", "Alice Johnson"]
    5. }
    6.  
    7. POST /books/_doc/2
    8. {
    9.   "title": "Book B",
    10.   "authors": ["John Smith", "David Williams"]
    11. }
    12.  
    13. POST /books/_doc/3
    14. {
    15.   "title": "Book C",
    16.   "authors": ["Alice Johnson", "Emily Davis"]
    17. }

    假设要查询包含作者 "John Smith" 的书籍：

    1. GET /books/_search
    2. {
    3.   "query": {
    4.     "match": {
    5.       "authors": "John Smith"
    6.     }
    7.   }
    8. }

    返回结果将包含包含 "John Smith" 作为作者的书籍：

    1. {
    2.   "took": 7,
    3.   "timed_out": false,
    4.   "_shards": {
    5.     "total": 1,
    6.     "successful": 1,
    7.     "skipped": 0,
    8.     "failed": 0
    9.   },
    10.   "hits": {
    11.     "total": {
    12.       "value": 2,
    13.       "relation": "eq"
    14.     },
    15.     "max_score": 1.0,
    16.     "hits": [
    17.       {
    18.         "_index": "books",
    19.         "_type": "_doc",
    20.         "_id": "1",
    21.         "_score": 1.0,
    22.         "_source": {
    23.           "title": "Book A",
    24.           "authors": ["John Smith", "Alice Johnson"]
    25.         }
    26.       },
    27.       {
    28.         "_index": "books",
    29.         "_type": "_doc",
    30.         "_id": "2",
    31.         "_score": 1.0,
    32.         "_source": {
    33.           "title": "Book B",
    34.           "authors": ["John Smith", "David Williams"]
    35.         }
    36.       }
    37.     ]
    38.   }
    39. }

    • 查询使用了 match 查询来查找包含作者 "John Smith" 的书籍。

    • 返回结果包含了满足查询条件的书籍文档，每个文档都包括了相关信息和相关性评分（如果使用相关性评分）。

    这个示例演示了如何使用数组类型字段来存储和查询多个值的集合。数组类型非常适用于表示多值属性，例如多个作者、标签或评论。通过这种方式，可以轻松地查询包含特定值的文档，以满足各种多值属性的查询需求。

    对象类型

    在 Elasticsearch 映射操作中，对象类型（Object）是一种复杂的数据类型，用于存储嵌套的结构化数据。对象类型允许将多个字段组合到一个单独的对象中，这些字段可以是不同类型的，形成了文档内的嵌套结构。

    • 对象数据：对象类型用于存储嵌套的结构化数据。它允许将多个字段组织为一个单独的对象，以便更好地表示数据的层次性和复杂性。

    • 嵌套字段：对象字段中的每个子字段都可以有自己的数据类型。这允许在一个文档中存储多个嵌套字段，每个字段可以有不同的数据类型，例如文本、数字、日期等。

    • 结构化数据：对象类型特别适用于存储具有层次结构的数据，例如产品包含属性、订单包含多个项目等。

    • 查询和过滤：可以使用对象类型执行查询和过滤操作，以访问和操作嵌套的数据。

    假设您正在使用 Elasticsearch 存储个人信息，其中每个文档表示一个人，包括姓名（name）、地址（address）、联系信息（contact）等。

    1. PUT /people
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "name": {
    6.         "type": "text"
    7.       },
    8.       "address": {
    9.         "type": "object",
    10.         "properties": {
    11.           "city": {
    12.             "type": "text"
    13.           },
    14.           "state": {
    15.             "type": "keyword"
    16.           }
    17.         }
    18.       },
    19.       "contact": {
    20.         "type": "object",
    21.         "properties": {
    22.           "email": {
    23.             "type": "text"
    24.           },
    25.           "phone": {
    26.             "type": "text"
    27.           }
    28.         }
    29.       }
    30.     }
    31.   }
    32. }

    插入一些示例数据的请求：

    1. POST /people/_doc/1
    2. {
    3.   "name": "Alice Johnson",
    4.   "address": {
    5.     "city": "New York",
    6.     "state": "NY"
    7.   },
    8.   "contact": {
    9.     "email": "alice@example.com",
    10.     "phone": "555-1234"
    11.   }
    12. }
    13.  
    14. POST /people/_doc/2
    15. {
    16.   "name": "Bob Smith",
    17.   "address": {
    18.     "city": "Los Angeles",
    19.     "state": "CA"
    20.   },
    21.   "contact": {
    22.     "email": "bob@example.com",
    23.     "phone": "555-5678"
    24.   }
    25. }

    假设您要查询所有居住在特定城市的人：

    1. GET /people/_search
    2. {
    3.   "query": {
    4.     "match": {
    5.       "address.city": "New York"
    6.     }
    7.   }
    8. }

    返回结果将包含居住在纽约的人的文档：

    1. {
    2.   "took": 5,
    3.   "timed_out": false,
    4.   "_shards": {
    5.     "total": 1,
    6.     "successful": 1,
    7.     "skipped": 0,
    8.     "failed": 0
    9.   },
    10.   "hits": {
    11.     "total": {
    12.       "value": 2,
    13.       "relation": "eq"
    14.     },
    15.     "max_score": 1.0,
    16.     "hits": [
    17.       {
    18.         "_index": "people",
    19.         "_type": "_doc",
    20.         "_id": "1",
    21.         "_score": 1.0,
    22.         "_source": {
    23.           "name": "Alice Johnson",
    24.           "address": {
    25.             "city": "New York",
    26.             "state": "NY"
    27.           },
    28.           "contact": {
    29.             "email": "alice@example.com",
    30.             "phone": "555-1234"
    31.           }
    32.         }
    33.       },
    34.       {
    35.         "_index": "people",
    36.         "_type": "_doc",
    37.         "_id": "2",
    38.         "_score": 1.0,
    39.         "_source": {
    40.           "name": "Bob Smith",
    41.           "address": {
    42.             "city": "New York",
    43.             "state": "NY"
    44.           },
    45.           "contact": {
    46.             "email": "bob@example.com",
    47.             "phone": "555-5678"
    48.           }
    49.         }
    50.       }
    51.     ]
    52.   }
    53. }

    • 查询使用了 match 查询来查找居住在纽约的人。

    • 返回结果包含了满足查询条件的人的文档，每个文档都包括了姓名、地址、联系信息等嵌套字段的信息。

    这个示例演示了如何使用对象类型字段来存储和查询嵌套的结构化数据。对象类型非常适用于表示层次结构的数据，例如个人信息、产品属性、订单项目等。通过这种方式，可以轻松地访问和操作嵌套的数据，以满足各种复杂数据结构的存储和查询需求。

    地理类型

    在 Elasticsearch 映射操作中，地理类型（Geo）用于存储地理位置信息，如经度和纬度坐标。这种类型允许索引和查询地理位置数据，以便执行空间分析和地理搜索。

    • 地理数据：地理类型用于存储地理位置信息，通常表示为经度和纬度坐标。这种类型非常适用于存储地理空间数据，如地点、地理区域和地理坐标。

    • 地理索引：Elasticsearch 使用地理类型来构建地理索引，以便更容易地执行地理位置相关的查询和分析。这包括范围查询、距离查询、聚合等。

    • 支持的地理形状：Elasticsearch 支持多种地理形状，例如点、线、多边形等，使您能够索引和查询各种地理空间数据。

    • 地理距离计算：地理类型允许您计算地理坐标之间的距离，以便查找在一定距离内的地理位置。

    假设您正在使用 Elasticsearch 存储餐厅信息，每个餐厅都有一个地理坐标，希望能够查询距离特定位置一定距离范围内的餐厅。创建一个名为 "restaurants" 的索引，其中包含了餐厅名称（name）和地理坐标（location）。

    1. PUT /restaurants
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "name": {
    6.         "type": "text"
    7.       },
    8.       "location": {
    9.         "type": "geo_point"
    10.       }
    11.     }
    12.   }
    13. }

    插入一些示例餐厅数据的请求：

    1. POST /restaurants/_doc/1
    2. {
    3.   "name": "Restaurant A",
    4.   "location": {
    5.     "lat": 40.7120,
    6.     "lon": -74.0050
    7.   }
    8. }
    9.  
    10. POST /restaurants/_doc/2
    11. {
    12.   "name": "Restaurant B",
    13.   "location": {
    14.     "lat": 40.7130,
    15.     "lon": -74.0070
    16.   }
    17. }
    18.  
    19. POST /restaurants/_doc/3
    20. {
    21.   "name": "Restaurant C",
    22.   "location": {
    23.     "lat": 40.7110,
    24.     "lon": -74.0080
    25.   }
    26. }

    假设要查找距离纽约市中心（40.7128, -74.0060）10公里以内的餐厅。

    1. GET /restaurants/_search
    2. {
    3.   "query": {
    4.     "bool": {
    5.       "filter": {
    6.         "geo_distance": {
    7.           "distance": "10km",
    8.           "location": {
    9.             "lat": 40.7128,
    10.             "lon": -74.0060
    11.           }
    12.         }
    13.       }
    14.     }
    15.   }
    16. }

    返回结果将包含距离纽约市中心10公里以内的餐厅。

    1. {
    2.   "took": 12,
    3.   "timed_out": false,
    4.   "_shards": {
    5.     "total": 1,
    6.     "successful": 1,
    7.     "skipped": 0,
    8.     "failed": 0
    9.   },
    10.   "hits": {
    11.     "total": {
    12.       "value": 3,
    13.       "relation": "eq"
    14.     },
    15.     "max_score": 1.0,
    16.     "hits": [
    17.       {
    18.         "_index": "restaurants",
    19.         "_type": "_doc",
    20.         "_id": "1",
    21.         "_score": 1.0,
    22.         "_source": {
    23.           "name": "Restaurant A",
    24.           "location": {
    25.             "lat": 40.7120,
    26.             "lon": -74.0050
    27.           }
    28.         }
    29.       },
    30.       {
    31.         "_index": "restaurants",
    32.         "_type": "_doc",
    33.         "_id": "2",
    34.         "_score": 1.0,
    35.         "_source": {
    36.           "name": "Restaurant B",
    37.           "location": {
    38.             "lat": 40.7130,
    39.             "lon": -74.0070
    40.           }
    41.         }
    42.       },
    43.       {
    44.         "_index": "restaurants",
    45.         "_type": "_doc",
    46.         "_id": "3",
    47.         "_score": 1.0,
    48.         "_source": {
    49.           "name": "Restaurant C",
    50.           "location": {
    51.             "lat": 40.7110,
    52.             "lon": -74.0080
    53.           }
    54.         }
    55.       }
    56.     ]
    57.   }
    58. }

    • 查询使用了 geo_distance 查询来查找距离指定地理坐标一定距离范围内的餐厅。

    • 返回结果包含了满足查询条件的餐厅文档，每个文档都包括了餐厅名称和地理坐标的信息。

    这个示例演示了如何使用地理类型字段来存储和查询地理位置信息。地理类型非常适用于处理地理空间数据，如地点搜索、附近搜索和地理分析等需求。通过这种方式，可以轻松地执行地理空间查询和分析，以满足各种地理位置相关的查询需求。

    （五）动态映射

    动态映射（Dynamic Mapping）是 Elasticsearch 中的一项功能，允许自动检测和创建索引映射，无需手动定义字段的数据类型和属性。当索引文档时，Elasticsearch 根据文档内容自动创建映射，包括字段的数据类型、分析器、索引选项等。这使得索引的管理更加灵活，特别适用于处理不断变化的数据和不确定的数据结构。

    以下是常见的 JSON 数据类型和 Elasticsearch 索引类型的对应表：

    JSON 数据类型：字符串（String）

    • Elasticsearch 索引类型：text 或 keyword
    • 说明：字符串类型可以映射为 text 类型用于全文搜索和分析，或映射为 keyword 类型用于精确匹配和聚合。

    JSON 数据类型：整数（Integer）

    • Elasticsearch 索引类型：integer 或 long
    • 说明：整数类型可以映射为 integer 类型（32 位有符号整数）或 long 类型（64 位有符号整数），取决于数据范围。

    JSON 数据类型：浮点数（Float/Double）

    • Elasticsearch 索引类型：float 或 double
    • 说明：浮点数类型可以映射为 float 类型（32 位浮点数）或 double 类型（64 位浮点数）。

    JSON 数据类型：布尔值（Boolean）

    • Elasticsearch 索引类型：boolean
    • 说明：布尔值类型映射为 boolean 类型，用于存储 true 或 false。

    JSON 数据类型：日期和时间（Date/Time）

    • Elasticsearch 索引类型：date
    • 说明：日期和时间类型映射为 date 类型，用于存储日期和时间信息。

    JSON 数据类型：数组（Array）

    • Elasticsearch 索引类型：array
    • 说明：JSON 数组通常映射为 Elasticsearch 中的数组，可以包含多个值。Elasticsearch 中的数组字段通常需要指定 nested 类型，以支持多值字段的查询和聚合。

    JSON 数据类型：对象（Object）

    • Elasticsearch 索引类型：object
    • 说明：JSON 对象可以映射为 Elasticsearch 的对象类型，用于存储嵌套的结构化数据。

    JSON 数据类型：地理坐标（Geospatial Coordinates）

    • Elasticsearch 索引类型：geo_point
    • 说明：地理坐标类型用于存储经度和纬度坐标，以支持地理位置相关的查询和分析。

    这个对应表展示了常见的 JSON 数据类型与 Elasticsearch 索引类型之间的映射关系。当索引文档时，Elasticsearch 会根据文档的字段内容自动选择合适的数据类型。如果需要更精细的控制，可以通过显式映射来定义字段的数据类型和属性。动态映射为 Elasticsearch 提供了灵活性，使其适应各种数据结构和用例。

    （六）多字段

    在 Elasticsearch 中，多字段（Multi-Field）是一种索引映射策略，用于将一个字段存储在多个不同的子字段中，每个子字段可以具有不同的数据类型或分析器。多字段的引入允许在一个字段上执行多种操作，例如全文搜索、精确匹配、聚合等，同时保留原始数据的不同表示形式。

    多字段的特点和用途

    • 数据多样性：多字段允许您在一个字段上存储多个不同的数据表示，以适应各种查询需求。例如，一个字段可以同时存储原始文本和分析后的词汇。

    • 支持不同数据类型：每个子字段可以具有不同的数据类型。例如，一个字段可以同时映射为 text 类型用于全文搜索和 keyword 类型用于精确匹配。

    • 支持不同分析器：每个子字段可以使用不同的文本分析器。这使得您可以在一个字段上执行不同类型的文本分析。

    • 灵活性：多字段使您能够针对不同的查询场景选择最合适的子字段，同时保持原始数据的完整性。

    • 支持复杂查询：多字段允许您执行复杂的查询操作，例如同时执行全文搜索和精确匹配，或者在多个子字段上执行聚合操作。

    多字段示例

    假设有一个名为 "product" 的索引，其中包含了产品名称（product_name）字段。希望能够在同一字段上执行全文搜索和精确匹配。以下是使用多字段的示例映射：

    1. PUT /product
    2. {
    3.   "mappings": {
    4.     "properties": {
    5.       "product_name": {
    6.         "type": "text",
    7.         "fields": {
    8.           "keyword": {
    9.             "type": "keyword"
    10.           }
    11.         }
    12.       }
    13.     }
    14.   }
    15. }

    在上述映射中，我们定义了一个 product_name 字段，并在该字段下创建了一个子字段 keyword，它具有 keyword 数据类型。这个子字段将用于精确匹配。

    多字段的用法示例-全文搜索：要执行全文搜索，可以使用原始字段 product_name。例如：

    1. GET /product/_search
    2. {
    3.   "query": {
    4.     "match": {
    5.       "product_name": "Elasticsearch"
    6.     }
    7.   }
    8. }

    多字段的用法示例-精确匹配：要执行精确匹配，可以使用子字段 product_name.keyword。例如：

    1. GET /product/_search
    2. {
    3.   "query": {
    4.     "term": {
    5.       "product_name.keyword": "Elasticsearch"
    6.     }
    7.   }
    8. }

    在此示例中，我们分别使用原始字段和子字段执行不同类型的查询。

    多字段的引入使得索引中的字段可以灵活地适应各种查询需求，同时保持原始数据的完整性。这在处理多样性的数据和不同的查询场景时非常有用。

    三、文档操作

    （一）单条写入文档

    在 Elasticsearch 中，要进行单条写入文档操作，可以使用 index 操作。要单条写入文档，可以使用以下DSL语句：

    1. POST /your_index/_doc/1
    2. {
    3.   "field1": "value1",
    4.   "field2": "value2",
    5.   "field3": 123,
    6.   "field4": true
    7. }
    • POST 请求用于创建文档。
    • /your_index 是您的索引名称。
    • /_doc/1 中的 1 是文档的唯一标识符，您可以选择性地提供，如果未提供，Elasticsearch 会为您生成一个唯一标识符。
    • JSON数据包含文档的字段和值。

    分析说明：

    • POST 请求用于创建文档。如果指定的标识符（在上述示例中为 1）已经存在于索引中，它将更新现有文档。否则，它将创建一个新的文档。

    • 文档的字段和值在JSON数据中指定，您可以根据您的业务需求提供不同的字段和数据类型。

    业务举例：

    假设您正在构建一个电子商务平台，并希望将一件商品的信息写入 Elasticsearch 中，以便进行搜索和分析。以下是一个示例，包括DSL和Java演示：

    DSL语句示例：

    1. POST /products/_doc/12345
    2. {
    3.   "product_name": "Laptop",
    4.   "description": "High-performance laptop with SSD storage.",
    5.   "price": 999.99,
    6.   "in_stock": true
    7. }

    Java演示：

    1. import org.elasticsearch.action.index.IndexRequest;
    2. import org.elasticsearch.action.index.IndexResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.common.xcontent.XContentType;
    6. import org.elasticsearch.rest.RestStatus;
    7.  
    8. public class SingleDocumentIndexingExample {
    9.  
    10.     public static void main(String[] args) throws IOException {
    11.  
    12.         RestHighLevelClient client = createElasticsearchClient();
    13.  
    14.         // 构建索引请求
    15.         IndexRequest request = new IndexRequest("products");
    16.         request.id("12345"); // 文档标识符
    17.         String jsonString = "{" +
    18.                 "\"product_name\":\"Laptop\"," +
    19.                 "\"description\":\"High-performance laptop with SSD storage.\"," +
    20.                 "\"price\":999.99," +
    21.                 "\"in_stock\":true" +
    22.                 "}";
    23.         request.source(jsonString, XContentType.JSON);
    24.  
    25.         // 执行索引请求
    26.         IndexResponse response = client.index(request, RequestOptions.DEFAULT);
    27.  
    28.         // 分析响应
    29.         if (response.status() == RestStatus.CREATED) {
    30.             System.out.println("文档已创建");
    31.         } else if (response.status() == RestStatus.OK) {
    32.             System.out.println("文档已更新");
    33.         } else {
    34.             System.err.println("无法创建/更新文档");
    35.         }
    36.  
    37.         // 关闭客户端
    38.         client.close();
    39.     }
    40. }

    （二）批量写入文档

    在 Elasticsearch 中，批量写入文档通常使用批量索引（Bulk Indexing）API 来实现。允许一次性将多个文档索引到索引中，提高了性能和效率。要批量写入文档，可以使用 Bulk API 发送一批索引请求。

    1. POST /your_index/_bulk
    2. {"index":{"_id":"1"}}
    3. {"field1":"value1","field2":"value2"}
    4. {"index":{"_id":"2"}}
    5. {"field1":"value3","field2":"value4"}
    6. {"update":{"_id":"3"}}
    7. {"doc":{"field1":"new_value"}}
    8. {"delete":{"_id":"4"}}
    • POST 请求用于批量操作。
    • /your_index 是您的索引名称。
    • 使用 {"index": {"_id": "1"}} 定义文档的元数据，包括文档标识符。
    • 每个文档的数据在之后的行中提供，以JSON格式表示。

    分析说明：

    • Bulk API 允许一次性处理多个索引请求，包括索引、更新和删除操作。

    • 使用元数据（例如 {"index": {"_id": "1"}}）可以指定每个文档的唯一标识符。

    • 除了索引操作，Bulk API 还支持更新和删除操作。

    业务举例：

    假设您正在构建一个电子商务平台，需要批量索引多个产品的信息。以下是一个示例，包括DSL和Java演示：

    DSL语句示例：

    1. POST /products/_bulk
    2. {"index":{"_id":"1"}}
    3. {"product_name":"Laptop1","description":"High-performance laptop with SSD storage.","price":999.99,"in_stock":true}
    4. {"index":{"_id":"2"}}
    5. {"product_name":"Laptop2","description":"Affordable laptop for everyday use.","price":599.99,"in_stock":true}
    6. {"index":{"_id":"3"}}
    7. {"product_name":"Smartphone1","description":"Flagship smartphone with advanced features.","price":799.99,"in_stock":false}

    Java演示：

    1. import org.elasticsearch.action.bulk.BulkRequest;
    2. import org.elasticsearch.action.bulk.BulkResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.common.unit.TimeValue;
    6.  
    7. import java.io.IOException;
    8. import java.util.concurrent.TimeUnit;
    9.  
    10. public class BulkIndexingExample {
    11.  
    12.     public static void main(String[] args) throws IOException {
    13.  
    14.         RestHighLevelClient client = createElasticsearchClient();
    15.  
    16.         // 创建批量请求对象
    17.         BulkRequest request = new BulkRequest();
    18.  
    19.         // 添加索引请求
    20.         request.add(new IndexRequest("products").id("1").source(/* JSON 数据 */));
    21.         request.add(new IndexRequest("products").id("2").source(/* JSON 数据 */));
    22.         request.add(new IndexRequest("products").id("3").source(/* JSON 数据 */));
    23.  
    24.         // 设置超时时间
    25.         request.timeout(TimeValue.timeValueMinutes(2));
    26.         request.timeout("2m");
    27.  
    28.         // 执行批量请求
    29.         BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);
    30.  
    31.         // 分析响应
    32.         if (bulkResponse.hasFailures()) {
    33.             System.err.println("批量请求中存在失败的操作");
    34.         } else {
    35.             System.out.println("批量请求成功完成");
    36.         }
    37.  
    38.         // 关闭客户端
    39.         client.close();
    40.     }
    41. }

    （三）更新单条文档

    update 操作

    在 Elasticsearch 中，更新单条文档通常使用 update 操作。要更新单条文档，您可以使用 update 操作，示例如下：

    1. POST /your_index/_update/1
    2. {
    3.   "doc": {
    4.     "field1": "new_value1",
    5.     "field2": "new_value2"
    6.   }
    7. }
    8.
    • POST 请求用于执行更新操作。
    • /your_index 是您的索引名称。
    • /_update/1 中的 1 是要更新的文档的唯一标识符。
    • 在 doc 字段中指定要更新的字段和新值。

    分析说明：

    • update 操作允许您仅更新文档的特定字段，而不必重写整个文档。这是一种高效的方式来更新文档。

    • 更新操作是部分更新，只会修改指定字段的值，而不会影响其他字段。

    业务举例：

    假设您正在构建一个博客平台，并希望更新特定博客文章的内容。以下是一个示例，包括DSL和Java演示：

    DSL语句示例：

    1. POST /blog_posts/_update/123
    2. {
    3.   "doc": {
    4.     "title": "Updated Title",
    5.     "content": "This is the updated content of the blog post."
    6.   }
    7. }

    Java演示：

    1. import org.elasticsearch.action.update.UpdateRequest;
    2. import org.elasticsearch.action.update.UpdateResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.common.xcontent.XContentType;
    6. import org.elasticsearch.rest.RestStatus;
    7.  
    8. import java.io.IOException;
    9. import java.util.Map;
    10.  
    11. public class UpdateSingleDocumentExample {
    12.  
    13.     public static void main(String[] args) throws IOException {
    14.  
    15.         RestHighLevelClient client = createElasticsearchClient();
    16.  
    17.         // 创建更新请求
    18.         UpdateRequest request = new UpdateRequest("blog_posts", "123");
    19.         String jsonString = "{" +
    20.                 "\"doc\": {" +
    21.                 "\"title\": \"Updated Title\"," +
    22.                 "\"content\": \"This is the updated content of the blog post.\"" +
    23.                 "}" +
    24.                 "}";
    25.         request.doc(jsonString, XContentType.JSON);
    26.  
    27.         // 执行更新请求
    28.         UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
    29.  
    30.         // 分析响应
    31.         if (response.status() == RestStatus.OK) {
    32.             System.out.println("文档已成功更新");
    33.         } else {
    34.             System.err.println("无法更新文档");
    35.         }
    36.  
    37.         // 关闭客户端
    38.         client.close();
    39.     }
    40. }
    upsert 操作

    upsert 是 Elasticsearch 更新操作中的一个重要概念，它允许在更新文档时，如果文档不存在，则将其插入（新增）。这在希望更新文档的同时，如果文档尚不存在，就创建一个新文档的情况下非常有用。要执行 upsert 操作，可以在 update 操作中使用 doc_as_upsert 参数，示例如下：

    1. POST /your_index/_update/1
    2. {
    3.   "doc": {
    4.     "field1": "new_value1",
    5.     "field2": "new_value2"
    6.   },
    7.   "doc_as_upsert": true
    8. }
    • doc 中指定要更新的字段和新值。
    • doc_as_upsert 设置为 true，表示如果文档不存在，则将 doc 中的内容插入（新增）为新文档。

    分析说明：

    • 当文档存在时，upsert 操作与普通更新操作相同，更新指定的字段。
    • 当文档不存在时，upsert 操作会将 doc 中的内容插入为新文档。

    业务举例：

    假设您正在构建一个在线商店，想要更新产品的信息，同时如果产品不存在，则添加新产品。以下是一个示例，包括DSL和Java演示：

    DSL语句示例：

    1. POST /products/_update/123
    2. {
    3.   "doc": {
    4.     "product_name": "Updated Product",
    5.     "price": 29.99
    6.   },
    7.   "doc_as_upsert": true
    8. }

    Java演示：

    1. import org.elasticsearch.action.update.UpdateRequest;
    2. import org.elasticsearch.action.update.UpdateResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.common.xcontent.XContentType;
    6. import org.elasticsearch.rest.RestStatus;
    7.  
    8. import java.io.IOException;
    9.  
    10. public class UpsertExample {
    11.  
    12.     public static void main(String[] args) throws IOException {
    13.  
    14.         RestHighLevelClient client = createElasticsearchClient();
    15.  
    16.         // 创建更新请求，指定索引名称和文档标识符
    17.         UpdateRequest request = new UpdateRequest("products", "123");
    18.  
    19.         // 设置要更新的字段和新值
    20.         String jsonString = "{" +
    21.                 "\"product_name\": \"Updated Product\"," +
    22.                 "\"price\": 29.99" +
    23.                 "}";
    24.         request.doc(jsonString, XContentType.JSON);
    25.  
    26.         // 设置doc_as_upsert为true，以支持upsert
    27.         request.docAsUpsert(true);
    28.  
    29.         // 执行更新请求
    30.         UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
    31.  
    32.         // 分析响应
    33.         if (response.status() == RestStatus.CREATED) {
    34.             System.out.println("文档已创建（upsert）");
    35.         } else if (response.status() == RestStatus.OK) {
    36.             System.out.println("文档已成功更新");
    37.         } else {
    38.             System.err.println("无法更新文档");
    39.         }
    40.  
    41.         // 关闭客户端
    42.         client.close();
    43.     }
    44. }

    （四）更新批量文档

    如果只有文档的ID列表而没有其他条件来更新文档，可以使用 Elasticsearch 的 Bulk API 来批量更新这些文档。Bulk API 不需要DSL语句，而是需要一个包含每个文档更新操作的请求列表。每个更新操作通常包括三个部分：操作类型（update）、索引名称、文档ID和更新数据。

    1. POST /_bulk
    2. {"update":{"_index":"your_index","_id":"doc1"}}
    3. {"doc":{"field1":"new_value1"}}
    4. {"update":{"_index":"your_index","_id":"doc2"}}
    5. {"doc":{"field2":"new_value2"}}

    • POST 请求用于执行批量更新操作。
    • _bulk 是Bulk API的端点。
    • 对于每个文档，首先定义了一个update操作，然后指定了索引名称（_index）和文档ID（_id），最后提供了要更新的数据。

    分析说明：

    • 使用Bulk API，可以在一个请求中批量执行多个文档更新操作。
    • 更新操作包括了要更新的文档的索引名称、文档ID以及要更新的数据。

    Java演示：

    1. import org.elasticsearch.action.bulk.BulkRequest;
    2. import org.elasticsearch.action.bulk.BulkResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.common.xcontent.XContentType;
    6. import org.elasticsearch.rest.RestStatus;
    7.  
    8. import java.io.IOException;
    9. import java.util.List;
    10.  
    11. public class ElasticsearchBulkUpdater {
    12.  
    13.     private RestHighLevelClient client;
    14.  
    15.     public ElasticsearchBulkUpdater(RestHighLevelClient client) {
    16.         this.client = client;
    17.     }
    18.  
    19.     public void bulkUpdateByIdList(String indexName, List docIdList, List> updatedDataList) {
    20.         try {
    21.             BulkRequest request = new BulkRequest();
    22.  
    23.             for (int i = 0; i < docIdList.size(); i++) {
    24.                 String docId = docIdList.get(i);
    25.                 String jsonString = "{" +
    26.                         "\"doc\":" + getJsonString(updatedDataList.get(i)) +
    27.                         "}";
    28.                 request.add(client.updateRequest(indexName, docId)
    29.                         .doc(jsonString, XContentType.JSON)
    30.                         .docAsUpsert(true));
    31.             }
    32.  
    33.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
    34.  
    35.             if (response.status() == RestStatus.OK) {
    36.                 System.out.println("批量更新成功");
    37.             } else {
    38.                 System.err.println("批量更新失败");
    39.             }
    40.         } catch (IOException e) {
    41.             System.err.println("执行批量更新时出现IO异常: " + e.getMessage());
    42.             // 在此处处理异常情况
    43.         }
    44.     }
    45.  
    46.     private String getJsonString(Map updatedData) {
    47.         // 创建更新文档的JSON字符串
    48.         // 省略实现细节
    49.         return jsonString;
    50.     }
    51.  
    52.     // 其他方法和资源清理
    53.  
    54. }

    （五）根据条件更新文档

    要根据条件更新文档，可以使用 Elasticsearch 的 Update By Query API。使用 Update By Query API 来根据条件更新文档。示例如下：

    1. POST /your_index/_update_by_query
    2. {
    3.   "script": {
    4.     "source": "ctx._source.field1 = 'new_value1'; ctx._source.field2 = 'new_value2';"
    5.   },
    6.   "query": {
    7.     "bool": {
    8.       "must": [
    9.         {
    10.           "term": {
    11.             "field3": "value_to_match"
    12.           }
    13.         },
    14.         {
    15.           "range": {
    16.             "field4": {
    17.               "gte": 10,
    18.               "lt": 20
    19.             }
    20.           }
    21.         }
    22.       ]
    23.     }
    24.   }
    25. }
    • POST 请求用于执行更新操作。
    • /your_index 是您的索引名称。
    • _update_by_query 表示根据查询条件更新文档。
    • 在 script 中指定要更新的字段和新值的逻辑。
    • 在 query 中定义筛选条件，以确定要更新哪些文档。在此示例中，我们使用了布尔查询（bool），并设置了两个条件：一个是 field3 必须匹配特定值，另一个是 field4 的值必须在10到20之间。

    分析说明：

    • 使用 Update By Query API，您可以根据自定义查询条件更新文档。
    • 在 script 部分，您可以编写更新逻辑，将需要更新的字段设置为新值。在这个示例中，我们使用 ctx._source.field1 和 ctx._source.field2 来更新字段。

    业务举例：

    假设您正在管理一个电子商务网站的产品目录，并需要根据条件更新产品信息。以下是一个示例，包括DSL和Java演示：

    DSL语句示例：

    1. POST /products/_update_by_query
    2. {
    3.   "script": {
    4.     "source": "ctx._source.price = ctx._source.price * 1.1;"
    5.   },
    6.   "query": {
    7.     "bool": {
    8.       "must": [
    9.         {
    10.           "term": {
    11.             "category": "electronics"
    12.           }
    13.         },
    14.         {
    15.           "range": {
    16.             "price": {
    17.               "lt": 100
    18.             }
    19.           }
    20.         }
    21.       ]
    22.     }
    23.   }
    24. }

    Java演示：

    1. import org.elasticsearch.action.updatebyquery.UpdateByQueryRequest;
    2. import org.elasticsearch.action.updatebyquery.UpdateByQueryResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.rest.RestStatus;
    6.  
    7. import java.io.IOException;
    8.  
    9. public class UpdateByQueryExample {
    10.  
    11.     public static void main(String[] args) throws IOException {
    12.  
    13.         RestHighLevelClient client = createElasticsearchClient();
    14.  
    15.         // 创建 Update By Query 请求
    16.         UpdateByQueryRequest request = new UpdateByQueryRequest("products");
    17.  
    18.         // 在脚本中指定更新逻辑
    19.         request.setScript("ctx._source.price = ctx._source.price * 1.1");
    20.  
    21.         // 设置查询条件，只更新电子产品且价格低于100的产品
    22.         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
    23.                 .must(QueryBuilders.termQuery("category", "electronics"))
    24.                 .must(QueryBuilders.rangeQuery("price").lt(100));
    25.         request.setQuery(boolQuery);
    26.  
    27.         // 执行 Update By Query 请求
    28.         UpdateByQueryResponse response = client.updateByQuery(request, RequestOptions.DEFAULT);
    29.  
    30.         // 分析响应
    31.         if (response.status() == RestStatus.OK) {
    32.             System.out.println("文档更新成功");
    33.         } else {
    34.             System.err.println("文档更新失败");
    35.         }
    36.  
    37.         // 关闭客户端
    38.         client.close();
    39.     }
    40. }

    （六）删除单条文档

    要删除单条文档，可以使用 Elasticsearch 的 Delete API。使用 Delete API 来删除单条文档。示例如下：

    DELETE /your_index/_doc/your_document_id
    • DELETE 请求用于执行删除操作。
    • /your_index 是您的索引名称。
    • /_doc 表示文档类型，根据Elasticsearch的最新版本，文档类型通常为_doc。
    • your_document_id 是要删除的文档的唯一标识符。

    分析说明：

    • 使用 Delete API，您可以根据文档的唯一标识符删除单条文档。
    • 您需要指定索引名称和文档的唯一标识符来执行删除操作。

    业务举例：

    假设正在管理一个博客平台的文章索引，以下是一个示例，包括DSL和Java演示，用于删除单篇文章：

    DSL语句示例：

    DELETE /blog_posts/_doc/12345

    Java演示：

    1. import org.elasticsearch.action.delete.DeleteRequest;
    2. import org.elasticsearch.action.delete.DeleteResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.rest.RestStatus;
    6.  
    7. import java.io.IOException;
    8.  
    9. public class DeleteSingleDocumentExample {
    10.  
    11.     public static void main(String[] args) throws IOException {
    12.  
    13.         RestHighLevelClient client = createElasticsearchClient();
    14.  
    15.         // 创建删除请求
    16.         DeleteRequest request = new DeleteRequest("blog_posts", "12345"); // 指定索引名称和文档ID
    17.  
    18.         // 执行删除请求
    19.         DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
    20.  
    21.         // 分析响应
    22.         if (response.status() == RestStatus.OK) {
    23.             System.out.println("文档已成功删除");
    24.         } else if (response.status() == RestStatus.NOT_FOUND) {
    25.             System.err.println("文档未找到，无法删除");
    26.         } else {
    27.             System.err.println("无法删除文档");
    28.         }
    29.  
    30.         // 关闭客户端
    31.         client.close();
    32.     }
    33. }

    （七）批量删除文档

    要批量删除文档，可以使用 Elasticsearch 的 Bulk API。使用 Bulk API 来批量删除文档。示例如下：

    1. POST /your_index/_bulk
    2. {"delete":{"_index":"your_index","_id":"doc1"}}
    3. {"delete":{"_index":"your_index","_id":"doc2"}}
    • POST 请求用于执行批量操作。
    • /your_index 是您的索引名称。
    • _bulk 是Bulk API的端点。
    • 对于每个文档，首先定义了一个delete操作，然后指定了索引名称（_index）和文档ID（_id）。

    分析说明：

    • 使用 Bulk API，可以在一个请求中批量执行多个文档的删除操作。
    • 每个删除操作包括要删除的文档的索引名称和文档ID。

    业务举例：

    假设正在管理一个电子商务网站的订单历史记录，并需要批量删除特定日期之前的订单记录。以下是一个示例，包括DSL和Java演示：

    DSL语句示例：

    1. POST /order_history/_bulk
    2. {"delete":{"_index":"order_history","_id":"order1"}}
    3. {"delete":{"_index":"order_history","_id":"order2"}}

    Java演示：

    1. import org.elasticsearch.action.bulk.BulkRequest;
    2. import org.elasticsearch.action.bulk.BulkResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.rest.RestStatus;
    6.  
    7. import java.io.IOException;
    8. import java.util.List;
    9.  
    10. public class ElasticsearchBulkDeleter {
    11.  
    12.     private RestHighLevelClient client;
    13.  
    14.     public ElasticsearchBulkDeleter(RestHighLevelClient client) {
    15.         this.client = client;
    16.     }
    17.  
    18.     public void bulkDeleteByIdList(String indexName, List docIdList) {
    19.         try {
    20.             BulkRequest request = new BulkRequest();
    21.  
    22.             for (String docId : docIdList) {
    23.                 request.add(client.deleteRequest(indexName, docId));
    24.             }
    25.  
    26.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
    27.  
    28.             if (response.status() == RestStatus.OK) {
    29.                 System.out.println("批量删除成功");
    30.             } else {
    31.                 System.err.println("批量删除失败");
    32.             }
    33.         } catch (IOException e) {
    34.             System.err.println("执行批量删除时出现IO异常: " + e.getMessage());
    35.             // 在此处处理异常情况
    36.         }
    37.     }
    38.  
    39.     // 其他方法和资源清理
    40.  
    41. }

    （八）根据条件删除文档

    要根据条件删除文档，可以使用 Elasticsearch 的 Delete By Query API。使用 Delete By Query API 来根据条件删除文档。示例如下：

    1. POST /your_index/_delete_by_query
    2. {
    3.   "query": {
    4.     "bool": {
    5.       "must": [
    6.         {
    7.           "term": {
    8.             "field1": "value_to_match"
    9.           }
    10.         },
    11.         {
    12.           "range": {
    13.             "field2": {
    14.               "lte": 10
    15.             }
    16.           }
    17.         }
    18.       ]
    19.     }
    20.   }
    21. }
    • POST 请求用于执行删除操作。
    • /your_index 是您的索引名称。
    • /_delete_by_query 表示根据查询条件删除文档。
    • 在 query 中定义筛选条件，以确定要删除哪些文档。在此示例中，我们使用了布尔查询（bool），并设置了两个条件：一个是 field1 必须匹配特定值，另一个是 field2 的值必须小于或等于10。

    分析说明：

    • 使用 Delete By Query API，可以根据自定义查询条件删除文档。
    • 在 query 部分，您可以定义要删除的文档的筛选条件。

    业务举例：

    假设正在管理一个文档存储系统，需要根据条件删除文档。以下是一个示例，包括DSL和Java演示：

    DSL语句示例：

    1. POST /documents/_delete_by_query
    2. {
    3.   "query": {
    4.     "bool": {
    5.       "must": [
    6.         {
    7.           "term": {
    8.             "category": "archived"
    9.           }
    10.         },
    11.         {
    12.           "range": {
    13.             "last_modified_date": {
    14.               "lte": "2022-01-01"
    15.             }
    16.           }
    17.         }
    18.       ]
    19.     }
    20.   }
    21. }

    Java演示：

    1. import org.elasticsearch.action.deletebyquery.DeleteByQueryRequest;
    2. import org.elasticsearch.action.deletebyquery.DeleteByQueryResponse;
    3. import org.elasticsearch.client.RequestOptions;
    4. import org.elasticsearch.client.RestHighLevelClient;
    5. import org.elasticsearch.rest.RestStatus;
    6.  
    7. import java.io.IOException;
    8.  
    9. public class DeleteByQueryExample {
    10.  
    11.     public static void main(String[] args) throws IOException {
    12.  
    13.         RestHighLevelClient client = createElasticsearchClient();
    14.  
    15.         // 创建 Delete By Query 请求
    16.         DeleteByQueryRequest request = new DeleteByQueryRequest("documents");
    17.  
    18.         // 设置查询条件，只删除属于 "archived" 类别且最后修改日期早于等于 "2022-01-01" 的文档
    19.         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
    20.                 .must(QueryBuilders.termQuery("category", "archived"))
    21.                 .must(QueryBuilders.rangeQuery("last_modified_date").lte("2022-01-01"));
    22.         request.setQuery(boolQuery);
    23.  
    24.         // 执行 Delete By Query 请求
    25.         DeleteByQueryResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
    26.  
    27.         // 分析响应
    28.         if (response.status() == RestStatus.OK) {
    29.             System.out.println("文档删除成功");
    30.         } else {
    31.             System.err.println("文档删除失败");
    32.         }
    33.  
    34.         // 关闭客户端
    35.         client.close();
    36.     }
    37. }

    （九）示例 Elasticsearch 操作工具类

    1. package org.zyf.javabasic.es;
    2.  
    3. import org.elasticsearch.action.bulk.BulkRequest;
    4. import org.elasticsearch.action.bulk.BulkResponse;
    5. import org.elasticsearch.action.delete.DeleteRequest;
    6. import org.elasticsearch.action.delete.DeleteResponse;
    7. import org.elasticsearch.action.update.UpdateRequest;
    8. import org.elasticsearch.action.update.UpdateResponse;
    9. import org.elasticsearch.client.RequestOptions;
    10. import org.elasticsearch.client.RestHighLevelClient;
    11. import org.elasticsearch.common.xcontent.XContentType;
    12. import org.elasticsearch.index.query.QueryBuilders;
    13. import org.elasticsearch.rest.RestStatus;
    14.  
    15. import java.io.IOException;
    16. import java.util.List;
    17. import java.util.Map;
    18.  
    19. /**
    20.  * @program: zyfboot-javabasic
    21.  * @description: Elasticsearch 操作工具类的简化示例
    22.  * @author: zhangyanfeng
    23.  * @create: 2023-10-06 22:29
    24.  **/
    25. public class ElasticsearchOperations {
    26.     private RestHighLevelClient client;
    27.  
    28.     public ElasticsearchOperations(RestHighLevelClient client) {
    29.         this.client = client;
    30.     }
    31.  
    32.     public void singleIndexDoc(String indexName, String indexId, Map dataMap) {
    33.         // 实现单条写入文档的逻辑，类似于之前示例中的单条写入代码
    34.         try {
    35.             IndexRequest request = new IndexRequest(indexName)
    36.                     .id(indexId)
    37.                     .source(dataMap, XContentType.JSON);
    38.  
    39.             IndexResponse response = client.index(request, RequestOptions.DEFAULT);
    40.  
    41.             if (response.status() == RestStatus.CREATED) {
    42.                 System.out.println("文档已创建");
    43.             } else {
    44.                 System.err.println("无法创建文档");
    45.             }
    46.         } catch (IOException e) {
    47.             System.err.println("执行单条写入文档时出现IO异常: " + e.getMessage());
    48.             // 在此处处理异常情况
    49.         }
    50.     }
    51.  
    52.     public void bulkIndexDoc(String indexName, String docIdKey, List> recordMapList) {
    53.         // 实现批量写入文档的逻辑，类似于之前示例中的批量写入代码
    54.         try {
    55.             BulkRequest request = new BulkRequest();
    56.  
    57.             for (Map recordMap : recordMapList) {
    58.                 String docId = recordMap.get(docIdKey).toString();
    59.                 request.add(new IndexRequest(indexName)
    60.                         .id(docId)
    61.                         .source(recordMap, XContentType.JSON));
    62.             }
    63.  
    64.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
    65.  
    66.             if (response.status() == RestStatus.OK) {
    67.                 System.out.println("批量写入成功");
    68.             } else {
    69.                 System.err.println("批量写入失败");
    70.             }
    71.         } catch (IOException e) {
    72.             System.err.println("执行批量写入文档时出现IO异常: " + e.getMessage());
    73.             // 在此处处理异常情况
    74.         }
    75.     }
    76.  
    77.     public void singleUpdate(String indexName, String docIdKey, Map recordMap) {
    78.         // 实现单条更新文档的逻辑，类似于之前示例中的单条更新代码
    79.         try {
    80.             String docId = recordMap.get(docIdKey).toString();
    81.             UpdateRequest request = new UpdateRequest(indexName, docId)
    82.                     .doc(recordMap, XContentType.JSON);
    83.  
    84.             UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
    85.  
    86.             if (response.status() == RestStatus.OK) {
    87.                 System.out.println("文档已成功更新");
    88.             } else {
    89.                 System.err.println("无法更新文档");
    90.             }
    91.         } catch (IOException e) {
    92.             System.err.println("执行单条更新文档时出现IO异常: " + e.getMessage());
    93.             // 在此处处理异常情况
    94.         }
    95.     }
    96.  
    97.     public void bulkUpdate(String indexName, String docIdKey, List> recordMapList) {
    98.         // 实现批量更新文档的逻辑，类似于之前示例中的批量更新代码
    99.         try {
    100.             BulkRequest request = new BulkRequest();
    101.  
    102.             for (Map recordMap : recordMapList) {
    103.                 String docId = recordMap.get(docIdKey).toString();
    104.                 request.add(new UpdateRequest(indexName, docId)
    105.                         .doc(recordMap, XContentType.JSON));
    106.             }
    107.  
    108.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
    109.  
    110.             if (response.status() == RestStatus.OK) {
    111.                 System.out.println("批量更新成功");
    112.             } else {
    113.                 System.err.println("批量更新失败");
    114.             }
    115.         } catch (IOException e) {
    116.             System.err.println("执行批量更新文档时出现IO异常: " + e.getMessage());
    117.             // 在此处处理异常情况
    118.         }
    119.     }
    120.  
    121.     public void singleDelete(String indexName, String docId) {
    122.         // 实现单条删除文档的逻辑，类似于之前示例中的单条删除代码
    123.         try {
    124.             DeleteRequest request = new DeleteRequest(indexName, docId);
    125.  
    126.             DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
    127.  
    128.             if (response.status() == RestStatus.OK) {
    129.                 System.out.println("文档已成功删除");
    130.             } else {
    131.                 System.err.println("无法删除文档");
    132.             }
    133.         } catch (IOException e) {
    134.             System.err.println("执行单条删除文档时出现IO异常: " + e.getMessage());
    135.             // 在此处处理异常情况
    136.         }
    137.     }
    138.  
    139.     public void bulkDelete(String indexName, List docIdList) {
    140.         // 实现批量删除文档的逻辑，类似于之前示例中的批量删除代码
    141.         try {
    142.             BulkRequest request = new BulkRequest();
    143.  
    144.             for (String docId : docIdList) {
    145.                 request.add(new DeleteRequest(indexName, docId));
    146.             }
    147.  
    148.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
    149.  
    150.             if (response.status() == RestStatus.OK) {
    151.                 System.out.println("批量删除成功");
    152.             } else {
    153.                 System.err.println("批量删除失败");
    154.             }
    155.         } catch (IOException e) {
    156.             System.err.println("执行批量删除文档时出现IO异常: " + e.getMessage());
    157.             // 在此处处理异常情况
    158.         }
    159.     }
    160.  
    161.     public void deleteByQuery(String indexName, Map query) {
    162.         // 实现根据条件删除文档的逻辑，类似于之前示例中的 Delete By Query 代码
    163.         try {
    164.             // 创建 Delete By Query 请求
    165.             DeleteByQueryRequest request = new DeleteByQueryRequest(indexName);
    166.  
    167.             // 设置查询条件
    168.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    169.             for (Map.Entry entry : query.entrySet()) {
    170.                 boolQuery.must(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()));
    171.             }
    172.             request.setQuery(boolQuery);
    173.  
    174.             // 执行 Delete By Query 请求
    175.             DeleteByQueryResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
    176.  
    177.             if (response.status() == RestStatus.OK) {
    178.                 System.out.println("文档删除成功");
    179.             } else {
    180.                 System.err.println("文档删除失败");
    181.             }
    182.         } catch (IOException e) {
    183.             System.err.println("执行根据条件删除文档时出现IO异常: " + e.getMessage());
    184.             // 在此处处理异常情况
    185.         }
    186.     }
    187.  
    188.     // 可以添加其他操作方法，根据实际需求扩展
    189.  
    190.     public void closeClient() {
    191.         try {
    192.             client.close();
    193.         } catch (IOException e) {
    194.             System.err.println("关闭 Elasticsearch 客户端时出现异常: " + e.getMessage());
    195.         }
    196.     }
    197. }

    四、搜索操作

    搜索操作是 Elasticsearch 的核心功能之一，它使您能够以高效的方式从大量数据中检索所需的信息。

    （一）搜索辅助功能

    辅助功能一：指定返回的字段

    （二）搜索匹配功能

    （三）按字段值排序

  • 相关阅读:
    Java的基础语法(三)
    pytorch collate_fn测试用例
    嵌入式mqtt总线架构方案mosquitto+paho
    SpringBoot+VUE3前后端分离-【支付宝支付】
    Multisim14.0仿真应用设计（四）基于LM324的电压跟随器仿真
    大数据之LibrA数据库常见术语（七）
    Centos7单机部署zookeeper与kafka整体步骤，附上安装测试
    智安网络|面临日益增长的安全威胁：云安全和零信任架构的重要性
    2022-08-25 AndroidR 默认赋予app权限，不弹出权限申请窗口
    Mysql视图
  • 原文地址：https://blog.csdn.net/xiaofeng10330111/article/details/133615069