Elasticsearch基础文档操作完全演示指南

干货分享，感谢您的阅读！在 Elasticsearch 中执行文档写入和更新操作的基本内容总结。

随着大数据时代的到来，企业和开发者面临着如何高效存储、检索和分析海量数据的挑战。Elasticsearch作为一个基于Lucene构建的分布式搜索引擎，因其强大的搜索能力和实时数据处理能力，成为了许多企业在构建搜索应用和分析平台时的首选工具。本文将深入探讨Elasticsearch中关于文档的基本操作，包括单条和批量写入、更新和删除文档，以及根据特定条件进行更新和删除的高级操作。通过实例和代码演示，读者将能够快速掌握如何在Elasticsearch中有效地管理文档，为构建高效的搜索和分析系统打下坚实的基础。

一、单条写入文档

在 Elasticsearch 中，要进行单条写入文档操作，可以使用

index

操作。要单条写入文档，可以使用以下DSL语句：

POST /your_index/_doc/1
{
  "field1": "value1",
  "field2": "value2",
  "field3": 123,
  "field4": true
}

POST 请求用于创建文档。
/your_index 是您的索引名称。
/_doc/1 中的 1 是文档的唯一标识符，您可以选择性地提供，如果未提供，Elasticsearch 会为您生成一个唯一标识符。
JSON数据包含文档的字段和值。

分析说明：

POST 请求用于创建文档。如果指定的标识符（在上述示例中为 1）已经存在于索引中，它将更新现有文档。否则，它将创建一个新的文档。
文档的字段和值在JSON数据中指定，您可以根据您的业务需求提供不同的字段和数据类型。

业务举例：

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

DSL语句示例：

POST /products/_doc/12345
{
  "product_name": "Laptop",
  "description": "High-performance laptop with SSD storage.",
  "price": 999.99,
  "in_stock": true
}

Java演示：

import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;

public class SingleDocumentIndexingExample {

    public static void main(String[] args) throws IOException {

        RestHighLevelClient client = createElasticsearchClient();

        // 构建索引请求
        IndexRequest request = new IndexRequest("products");
        request.id("12345"); // 文档标识符
        String jsonString = "{" +
                "\"product_name\":\"Laptop\"," +
                "\"description\":\"High-performance laptop with SSD storage.\"," +
                "\"price\":999.99," +
                "\"in_stock\":true" +
                "}";
        request.source(jsonString, XContentType.JSON);

        // 执行索引请求
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);

        // 分析响应
        if (response.status() == RestStatus.CREATED) {
            System.out.println("文档已创建");
        } else if (response.status() == RestStatus.OK) {
            System.out.println("文档已更新");
        } else {
            System.err.println("无法创建/更新文档");
        }

        // 关闭客户端
        client.close();
    }
}

二、批量写入文档

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

POST /your_index/_bulk
{"index":{"_id":"1"}}
{"field1":"value1","field2":"value2"}
{"index":{"_id":"2"}}
{"field1":"value3","field2":"value4"}
{"update":{"_id":"3"}}
{"doc":{"field1":"new_value"}}
{"delete":{"_id":"4"}}

POST 请求用于批量操作。
/your_index 是您的索引名称。
使用 {"index": {"_id": "1"}} 定义文档的元数据，包括文档标识符。
每个文档的数据在之后的行中提供，以JSON格式表示。

分析说明：

Bulk API 允许一次性处理多个索引请求，包括索引、更新和删除操作。
使用元数据（例如 {"index": {"_id": "1"}}）可以指定每个文档的唯一标识符。
除了索引操作，Bulk API 还支持更新和删除操作。

业务举例：

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

DSL语句示例：

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

Java演示：

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.unit.TimeValue;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class BulkIndexingExample {

    public static void main(String[] args) throws IOException {

        RestHighLevelClient client = createElasticsearchClient();

        // 创建批量请求对象
        BulkRequest request = new BulkRequest();

        // 添加索引请求
        request.add(new IndexRequest("products").id("1").source(/* JSON 数据 */));
        request.add(new IndexRequest("products").id("2").source(/* JSON 数据 */));
        request.add(new IndexRequest("products").id("3").source(/* JSON 数据 */));

        // 设置超时时间
        request.timeout(TimeValue.timeValueMinutes(2));
        request.timeout("2m");

        // 执行批量请求
        BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);

        // 分析响应
        if (bulkResponse.hasFailures()) {
            System.err.println("批量请求中存在失败的操作");
        } else {
            System.out.println("批量请求成功完成");
        }

        // 关闭客户端
        client.close();
    }
}

三、更新单条文档

update

操作

在 Elasticsearch 中，更新单条文档通常使用

update

操作。要更新单条文档，您可以使用

update

操作，示例如下：

POST /your_index/_update/1
{
  "doc": {
    "field1": "new_value1",
    "field2": "new_value2"
  }
}

POST 请求用于执行更新操作。
/your_index 是您的索引名称。
/_update/1 中的 1 是要更新的文档的唯一标识符。
在 doc 字段中指定要更新的字段和新值。

分析说明：

update 操作允许您仅更新文档的特定字段，而不必重写整个文档。这是一种高效的方式来更新文档。
更新操作是部分更新，只会修改指定字段的值，而不会影响其他字段。

业务举例：

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

DSL语句示例：

POST /blog_posts/_update/123
{
  "doc": {
    "title": "Updated Title",
    "content": "This is the updated content of the blog post."
  }
}

Java演示：

import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;
import java.util.Map;

public class UpdateSingleDocumentExample {

    public static void main(String[] args) throws IOException {

        RestHighLevelClient client = createElasticsearchClient();

        // 创建更新请求
        UpdateRequest request = new UpdateRequest("blog_posts", "123");
        String jsonString = "{" +
                "\"doc\": {" +
                "\"title\": \"Updated Title\"," +
                "\"content\": \"This is the updated content of the blog post.\"" +
                "}" +
                "}";
        request.doc(jsonString, XContentType.JSON);

        // 执行更新请求
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);

        // 分析响应
        if (response.status() == RestStatus.OK) {
            System.out.println("文档已成功更新");
        } else {
            System.err.println("无法更新文档");
        }

        // 关闭客户端
        client.close();
    }
}

upsert

操作

upsert

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

upsert

操作，可以在

update

操作中使用

doc_as_upsert

参数，示例如下：

POST /your_index/_update/1
{
  "doc": {
    "field1": "new_value1",
    "field2": "new_value2"
  },
  "doc_as_upsert": true
}

doc 中指定要更新的字段和新值。
doc_as_upsert 设置为 true，表示如果文档不存在，则将 doc 中的内容插入（新增）为新文档。

分析说明：

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

业务举例：

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

DSL语句示例：

POST /products/_update/123
{
  "doc": {
    "product_name": "Updated Product",
    "price": 29.99
  },
  "doc_as_upsert": true
}

Java演示：

import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;

public class UpsertExample {

    public static void main(String[] args) throws IOException {

        RestHighLevelClient client = createElasticsearchClient();

        // 创建更新请求，指定索引名称和文档标识符
        UpdateRequest request = new UpdateRequest("products", "123");

        // 设置要更新的字段和新值
        String jsonString = "{" +
                "\"product_name\": \"Updated Product\"," +
                "\"price\": 29.99" +
                "}";
        request.doc(jsonString, XContentType.JSON);

        // 设置doc_as_upsert为true，以支持upsert
        request.docAsUpsert(true);

        // 执行更新请求
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);

        // 分析响应
        if (response.status() == RestStatus.CREATED) {
            System.out.println("文档已创建（upsert）");
        } else if (response.status() == RestStatus.OK) {
            System.out.println("文档已成功更新");
        } else {
            System.err.println("无法更新文档");
        }

        // 关闭客户端
        client.close();
    }
}

四、更新批量文档

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

update

）、索引名称、文档ID和更新数据。

POST /_bulk
{"update":{"_index":"your_index","_id":"doc1"}}
{"doc":{"field1":"new_value1"}}
{"update":{"_index":"your_index","_id":"doc2"}}
{"doc":{"field2":"new_value2"}}

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

分析说明：

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

Java演示：

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;
import java.util.List;

public class ElasticsearchBulkUpdater {

    private RestHighLevelClient client;

    public ElasticsearchBulkUpdater(RestHighLevelClient client) {
        this.client = client;
    }

    public void bulkUpdateByIdList(String indexName, List<String> docIdList, List<Map<String, Object>> updatedDataList) {
        try {
            BulkRequest request = new BulkRequest();

            for (int i = 0; i < docIdList.size(); i++) {
                String docId = docIdList.get(i);
                String jsonString = "{" +
                        "\"doc\":" + getJsonString(updatedDataList.get(i)) +
                        "}";
                request.add(client.updateRequest(indexName, docId)
                        .doc(jsonString, XContentType.JSON)
                        .docAsUpsert(true));
            }

            BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("批量更新成功");
            } else {
                System.err.println("批量更新失败");
            }
        } catch (IOException e) {
            System.err.println("执行批量更新时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    private String getJsonString(Map<String, Object> updatedData) {
        // 创建更新文档的JSON字符串
        // 省略实现细节
        return jsonString;
    }

    // 其他方法和资源清理

}

五、根据条件更新文档

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

POST /your_index/_update_by_query
{
  "script": {
    "source": "ctx._source.field1 = 'new_value1'; ctx._source.field2 = 'new_value2';"
  },
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "field3": "value_to_match"
          }
        },
        {
          "range": {
            "field4": {
              "gte": 10,
              "lt": 20
            }
          }
        }
      ]
    }
  }
}

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语句示例：

POST /products/_update_by_query
{
  "script": {
    "source": "ctx._source.price = ctx._source.price * 1.1;"
  },
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "category": "electronics"
          }
        },
        {
          "range": {
            "price": {
              "lt": 100
            }
          }
        }
      ]
    }
  }
}

Java演示：

import org.elasticsearch.action.updatebyquery.UpdateByQueryRequest;
import org.elasticsearch.action.updatebyquery.UpdateByQueryResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;

public class UpdateByQueryExample {

    public static void main(String[] args) throws IOException {

        RestHighLevelClient client = createElasticsearchClient();

        // 创建 Update By Query 请求
        UpdateByQueryRequest request = new UpdateByQueryRequest("products");

        // 在脚本中指定更新逻辑
        request.setScript("ctx._source.price = ctx._source.price * 1.1");

        // 设置查询条件，只更新电子产品且价格低于100的产品
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.termQuery("category", "electronics"))
                .must(QueryBuilders.rangeQuery("price").lt(100));
        request.setQuery(boolQuery);

        // 执行 Update By Query 请求
        UpdateByQueryResponse response = client.updateByQuery(request, RequestOptions.DEFAULT);

        // 分析响应
        if (response.status() == RestStatus.OK) {
            System.out.println("文档更新成功");
        } else {
            System.err.println("文档更新失败");
        }

        // 关闭客户端
        client.close();
    }
}

六、删除单条文档

要删除单条文档，可以使用 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演示：

import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;

public class DeleteSingleDocumentExample {

    public static void main(String[] args) throws IOException {

        RestHighLevelClient client = createElasticsearchClient();

        // 创建删除请求
        DeleteRequest request = new DeleteRequest("blog_posts", "12345"); // 指定索引名称和文档ID

        // 执行删除请求
        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

        // 分析响应
        if (response.status() == RestStatus.OK) {
            System.out.println("文档已成功删除");
        } else if (response.status() == RestStatus.NOT_FOUND) {
            System.err.println("文档未找到，无法删除");
        } else {
            System.err.println("无法删除文档");
        }

        // 关闭客户端
        client.close();
    }
}

七、批量删除文档

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

POST /your_index/_bulk
{"delete":{"_index":"your_index","_id":"doc1"}}
{"delete":{"_index":"your_index","_id":"doc2"}}

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

分析说明：

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

业务举例：

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

DSL语句示例：

POST /order_history/_bulk
{"delete":{"_index":"order_history","_id":"order1"}}
{"delete":{"_index":"order_history","_id":"order2"}}

Java演示：

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;
import java.util.List;

public class ElasticsearchBulkDeleter {

    private RestHighLevelClient client;

    public ElasticsearchBulkDeleter(RestHighLevelClient client) {
        this.client = client;
    }

    public void bulkDeleteByIdList(String indexName, List<String> docIdList) {
        try {
            BulkRequest request = new BulkRequest();

            for (String docId : docIdList) {
                request.add(client.deleteRequest(indexName, docId));
            }

            BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("批量删除成功");
            } else {
                System.err.println("批量删除失败");
            }
        } catch (IOException e) {
            System.err.println("执行批量删除时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    // 其他方法和资源清理

}

八、根据条件删除文档

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

POST /your_index/_delete_by_query
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "field1": "value_to_match"
          }
        },
        {
          "range": {
            "field2": {
              "lte": 10
            }
          }
        }
      ]
    }
  }
}

POST 请求用于执行删除操作。
/your_index 是您的索引名称。
/_delete_by_query 表示根据查询条件删除文档。
在 query 中定义筛选条件，以确定要删除哪些文档。在此示例中，我们使用了布尔查询（bool），并设置了两个条件：一个是 field1 必须匹配特定值，另一个是 field2 的值必须小于或等于10。

分析说明：

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

业务举例：

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

DSL语句示例：

POST /documents/_delete_by_query
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "category": "archived"
          }
        },
        {
          "range": {
            "last_modified_date": {
              "lte": "2022-01-01"
            }
          }
        }
      ]
    }
  }
}

Java演示：

import org.elasticsearch.action.deletebyquery.DeleteByQueryRequest;
import org.elasticsearch.action.deletebyquery.DeleteByQueryResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;

public class DeleteByQueryExample {

    public static void main(String[] args) throws IOException {

        RestHighLevelClient client = createElasticsearchClient();

        // 创建 Delete By Query 请求
        DeleteByQueryRequest request = new DeleteByQueryRequest("documents");

        // 设置查询条件，只删除属于 "archived" 类别且最后修改日期早于等于 "2022-01-01" 的文档
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.termQuery("category", "archived"))
                .must(QueryBuilders.rangeQuery("last_modified_date").lte("2022-01-01"));
        request.setQuery(boolQuery);

        // 执行 Delete By Query 请求
        DeleteByQueryResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);

        // 分析响应
        if (response.status() == RestStatus.OK) {
            System.out.println("文档删除成功");
        } else {
            System.err.println("文档删除失败");
        }

        // 关闭客户端
        client.close();
    }
}

九、示例 Elasticsearch 操作工具类

package org.zyf.javabasic.es;

import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @program: zyfboot-javabasic
 * @description: Elasticsearch 操作工具类的简化示例
 * @author: zhangyanfeng
 * @create: 2023-10-06 22:29
 **/
public class ElasticsearchOperations {
    private RestHighLevelClient client;

    public ElasticsearchOperations(RestHighLevelClient client) {
        this.client = client;
    }

    public void singleIndexDoc(String indexName, String indexId, Map<String, Object> dataMap) {
        // 实现单条写入文档的逻辑，类似于之前示例中的单条写入代码
        try {
            IndexRequest request = new IndexRequest(indexName)
                    .id(indexId)
                    .source(dataMap, XContentType.JSON);

            IndexResponse response = client.index(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.CREATED) {
                System.out.println("文档已创建");
            } else {
                System.err.println("无法创建文档");
            }
        } catch (IOException e) {
            System.err.println("执行单条写入文档时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    public void bulkIndexDoc(String indexName, String docIdKey, List<Map<String, Object>> recordMapList) {
        // 实现批量写入文档的逻辑，类似于之前示例中的批量写入代码
        try {
            BulkRequest request = new BulkRequest();

            for (Map<String, Object> recordMap : recordMapList) {
                String docId = recordMap.get(docIdKey).toString();
                request.add(new IndexRequest(indexName)
                        .id(docId)
                        .source(recordMap, XContentType.JSON));
            }

            BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("批量写入成功");
            } else {
                System.err.println("批量写入失败");
            }
        } catch (IOException e) {
            System.err.println("执行批量写入文档时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    public void singleUpdate(String indexName, String docIdKey, Map<String, Object> recordMap) {
        // 实现单条更新文档的逻辑，类似于之前示例中的单条更新代码
        try {
            String docId = recordMap.get(docIdKey).toString();
            UpdateRequest request = new UpdateRequest(indexName, docId)
                    .doc(recordMap, XContentType.JSON);

            UpdateResponse response = client.update(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("文档已成功更新");
            } else {
                System.err.println("无法更新文档");
            }
        } catch (IOException e) {
            System.err.println("执行单条更新文档时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    public void bulkUpdate(String indexName, String docIdKey, List<Map<String, Object>> recordMapList) {
        // 实现批量更新文档的逻辑，类似于之前示例中的批量更新代码
        try {
            BulkRequest request = new BulkRequest();

            for (Map<String, Object> recordMap : recordMapList) {
                String docId = recordMap.get(docIdKey).toString();
                request.add(new UpdateRequest(indexName, docId)
                        .doc(recordMap, XContentType.JSON));
            }

            BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("批量更新成功");
            } else {
                System.err.println("批量更新失败");
            }
        } catch (IOException e) {
            System.err.println("执行批量更新文档时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    public void singleDelete(String indexName, String docId) {
        // 实现单条删除文档的逻辑，类似于之前示例中的单条删除代码
        try {
            DeleteRequest request = new DeleteRequest(indexName, docId);

            DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("文档已成功删除");
            } else {
                System.err.println("无法删除文档");
            }
        } catch (IOException e) {
            System.err.println("执行单条删除文档时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    public void bulkDelete(String indexName, List<String> docIdList) {
        // 实现批量删除文档的逻辑，类似于之前示例中的批量删除代码
        try {
            BulkRequest request = new BulkRequest();

            for (String docId : docIdList) {
                request.add(new DeleteRequest(indexName, docId));
            }

            BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("批量删除成功");
            } else {
                System.err.println("批量删除失败");
            }
        } catch (IOException e) {
            System.err.println("执行批量删除文档时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    public void deleteByQuery(String indexName, Map<String, Object> query) {
        // 实现根据条件删除文档的逻辑，类似于之前示例中的 Delete By Query 代码
        try {
            // 创建 Delete By Query 请求
            DeleteByQueryRequest request = new DeleteByQueryRequest(indexName);

            // 设置查询条件
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            for (Map.Entry<String, Object> entry : query.entrySet()) {
                boolQuery.must(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()));
            }
            request.setQuery(boolQuery);

            // 执行 Delete By Query 请求
            DeleteByQueryResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);

            if (response.status() == RestStatus.OK) {
                System.out.println("文档删除成功");
            } else {
                System.err.println("文档删除失败");
            }
        } catch (IOException e) {
            System.err.println("执行根据条件删除文档时出现IO异常: " + e.getMessage());
            // 在此处处理异常情况
        }
    }

    // 可以添加其他操作方法，根据实际需求扩展

    public void closeClient() {
        try {
            client.close();
        } catch (IOException e) {
            System.err.println("关闭 Elasticsearch 客户端时出现异常: " + e.getMessage());
        }
    }
}

十、总结

在本文中，我们探讨了Elasticsearch文档操作的基本和高级功能，包括单条文档的插入、更新和删除，以及批量操作的应用。这些操作不仅使数据管理变得更加高效，还能够通过特定条件对文档进行精确控制，从而满足复杂业务需求。

我们通过实际的代码示例展示了如何使用Elasticsearch的REST API进行文档操作，强调了在进行批量写入时注意的事项，以及在更新和删除过程中如何避免数据丢失和冲突。这些知识对开发人员在处理大规模数据时尤其重要，可以帮助他们设计更为高效和可靠的系统。

随着数据量的不断增加，掌握Elasticsearch文档操作的技巧将使您在搜索和分析领域拥有更大的竞争优势。希望通过本文的介绍，您能够更深入地理解Elasticsearch的文档管理机制，为未来的项目奠定坚实的基础。

标签：搜索引擎全文检索图搜索算法

本文转载自: https://blog.csdn.net/xiaofeng10330111/article/details/132866513
版权归原作者 张彦峰ZYF 所有，如有侵权，请联系我们删除。

Elasticsearch基础文档操作完全演示指南

一、单条写入文档

二、批量写入文档

三、更新单条文档

四、更新批量文档

五、根据条件更新文档

六、删除单条文档

七、批量删除文档

八、根据条件删除文档

九、示例 Elasticsearch 操作工具类

十、总结

发表评论

“Elasticsearch基础文档操作完全演示指南”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航