Elasticsearch底子文档操作完全演示指南

目录
一、单条写入文档
二、批量写入文档
三、更新单条文档
update 操作
upsert 操作
四、更新批量文档
五、根据条件更新文档
六、删除单条文档
七、批量删除文档
八、根据条件删除文档
九、示例 Elasticsearch 操作工具类
十、总结

---

干货分享，感谢您的阅读！在 Elasticsearch 中实行文档写入和更新操作的基本内容总结。
随着大数据期间的到来，企业和开辟者面对着如何高效存储、检索和分析海量数据的挑战。Elasticsearch作为一个基于Lucene构建的分布式搜刮引擎，因其强大的搜刮能力和及时数据处置惩罚能力，成为了许多企业在构建搜刮应用和分析平台时的首选工具。本文将深入探讨Elasticsearch中关于文档的基本操作，包括单条和批量写入、更新和删除文档，以及根据特定条件进行更新和删除的高级操作。通过实例和代码演示，读者将可以或许快速把握如何在Elasticsearch中有效地管理文档，为构建高效的搜刮和分析系统打下坚实的底子。
一、单条写入文档

在 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;
8. public class SingleDocumentIndexingExample {
10.     public static void main(String[] args) throws IOException {
12.         RestHighLevelClient client = createElasticsearchClient();
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);
25.         // 执行索引请求
26.         IndexResponse response = client.index(request, RequestOptions.DEFAULT);
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.         }
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;
7. import java.io.IOException;
8. import java.util.concurrent.TimeUnit;
10. public class BulkIndexingExample {
12.     public static void main(String[] args) throws IOException {
14.         RestHighLevelClient client = createElasticsearchClient();
16.         // 创建批量请求对象
17.         BulkRequest request = new BulkRequest();
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 数据 */));
24.         // 设置超时时间
25.         request.timeout(TimeValue.timeValueMinutes(2));
26.         request.timeout("2m");
28.         // 执行批量请求
29.         BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);
31.         // 分析响应
32.         if (bulkResponse.hasFailures()) {
33.             System.err.println("批量请求中存在失败的操作");
34.         } else {
35.             System.out.println("批量请求成功完成");
36.         }
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. }

复制代码

• 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;
8. import java.io.IOException;
9. import java.util.Map;
11. public class UpdateSingleDocumentExample {
13.     public static void main(String[] args) throws IOException {
15.         RestHighLevelClient client = createElasticsearchClient();
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);
27.         // 执行更新请求
28.         UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
30.         // 分析响应
31.         if (response.status() == RestStatus.OK) {
32.             System.out.println("文档已成功更新");
33.         } else {
34.             System.err.println("无法更新文档");
35.         }
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;
8. import java.io.IOException;
10. public class UpsertExample {
12.     public static void main(String[] args) throws IOException {
14.         RestHighLevelClient client = createElasticsearchClient();
16.         // 创建更新请求，指定索引名称和文档标识符
17.         UpdateRequest request = new UpdateRequest("products", "123");
19.         // 设置要更新的字段和新值
20.         String jsonString = "{" +
21.                 ""product_name": "Updated Product"," +
22.                 ""price": 29.99" +
23.                 "}";
24.         request.doc(jsonString, XContentType.JSON);
26.         // 设置doc_as_upsert为true，以支持upsert
27.         request.docAsUpsert(true);
29.         // 执行更新请求
30.         UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
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.         }
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;
8. import java.io.IOException;
9. import java.util.List;
11. public class ElasticsearchBulkUpdater {
13.     private RestHighLevelClient client;
15.     public ElasticsearchBulkUpdater(RestHighLevelClient client) {
16.         this.client = client;
17.     }
19.     public void bulkUpdateByIdList(String indexName, List<String> docIdList, List<Map<String, Object>> updatedDataList) {
20.         try {
21.             BulkRequest request = new BulkRequest();
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.             }
33.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
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.     }
46.     private String getJsonString(Map<String, Object> updatedData) {
47.         // 创建更新文档的JSON字符串
48.         // 省略实现细节
49.         return jsonString;
50.     }
52.     // 其他方法和资源清理
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;
7. import java.io.IOException;
9. public class UpdateByQueryExample {
11.     public static void main(String[] args) throws IOException {
13.         RestHighLevelClient client = createElasticsearchClient();
15.         // 创建 Update By Query 请求
16.         UpdateByQueryRequest request = new UpdateByQueryRequest("products");
18.         // 在脚本中指定更新逻辑
19.         request.setScript("ctx._source.price = ctx._source.price * 1.1");
21.         // 设置查询条件，只更新电子产品且价格低于100的产品
22.         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
23.                 .must(QueryBuilders.termQuery("category", "electronics"))
24.                 .must(QueryBuilders.rangeQuery("price").lt(100));
25.         request.setQuery(boolQuery);
27.         // 执行 Update By Query 请求
28.         UpdateByQueryResponse response = client.updateByQuery(request, RequestOptions.DEFAULT);
30.         // 分析响应
31.         if (response.status() == RestStatus.OK) {
32.             System.out.println("文档更新成功");
33.         } else {
34.             System.err.println("文档更新失败");
35.         }
37.         // 关闭客户端
38.         client.close();
39.     }
40. }

复制代码

六、删除单条文档

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

1. DELETE /your_index/_doc/your_document_id

复制代码

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

分析阐明：

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

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

1. 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;
7. import java.io.IOException;
9. public class DeleteSingleDocumentExample {
11.     public static void main(String[] args) throws IOException {
13.         RestHighLevelClient client = createElasticsearchClient();
15.         // 创建删除请求
16.         DeleteRequest request = new DeleteRequest("blog_posts", "12345"); // 指定索引名称和文档ID
18.         // 执行删除请求
19.         DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
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.         }
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;
7. import java.io.IOException;
8. import java.util.List;
10. public class ElasticsearchBulkDeleter {
12.     private RestHighLevelClient client;
14.     public ElasticsearchBulkDeleter(RestHighLevelClient client) {
15.         this.client = client;
16.     }
18.     public void bulkDeleteByIdList(String indexName, List<String> docIdList) {
19.         try {
20.             BulkRequest request = new BulkRequest();
22.             for (String docId : docIdList) {
23.                 request.add(client.deleteRequest(indexName, docId));
24.             }
26.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
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.     }
39.     // 其他方法和资源清理
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;
7. import java.io.IOException;
9. public class DeleteByQueryExample {
11.     public static void main(String[] args) throws IOException {
13.         RestHighLevelClient client = createElasticsearchClient();
15.         // 创建 Delete By Query 请求
16.         DeleteByQueryRequest request = new DeleteByQueryRequest("documents");
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);
24.         // 执行 Delete By Query 请求
25.         DeleteByQueryResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
27.         // 分析响应
28.         if (response.status() == RestStatus.OK) {
29.             System.out.println("文档删除成功");
30.         } else {
31.             System.err.println("文档删除失败");
32.         }
34.         // 关闭客户端
35.         client.close();
36.     }
37. }

复制代码

九、示例 Elasticsearch 操作工具类

1. package org.zyf.javabasic.es;
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;
15. import java.io.IOException;
16. import java.util.List;
17. import java.util.Map;
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;
28.     public ElasticsearchOperations(RestHighLevelClient client) {
29.         this.client = client;
30.     }
32.     public void singleIndexDoc(String indexName, String indexId, Map<String, Object> dataMap) {
33.         // 实现单条写入文档的逻辑，类似于之前示例中的单条写入代码
34.         try {
35.             IndexRequest request = new IndexRequest(indexName)
36.                     .id(indexId)
37.                     .source(dataMap, XContentType.JSON);
39.             IndexResponse response = client.index(request, RequestOptions.DEFAULT);
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.     }
52.     public void bulkIndexDoc(String indexName, String docIdKey, List<Map<String, Object>> recordMapList) {
53.         // 实现批量写入文档的逻辑，类似于之前示例中的批量写入代码
54.         try {
55.             BulkRequest request = new BulkRequest();
57.             for (Map<String, Object> recordMap : recordMapList) {
58.                 String docId = recordMap.get(docIdKey).toString();
59.                 request.add(new IndexRequest(indexName)
60.                         .id(docId)
61.                         .source(recordMap, XContentType.JSON));
62.             }
64.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
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.     }
77.     public void singleUpdate(String indexName, String docIdKey, Map<String, Object> recordMap) {
78.         // 实现单条更新文档的逻辑，类似于之前示例中的单条更新代码
79.         try {
80.             String docId = recordMap.get(docIdKey).toString();
81.             UpdateRequest request = new UpdateRequest(indexName, docId)
82.                     .doc(recordMap, XContentType.JSON);
84.             UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
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.     }
97.     public void bulkUpdate(String indexName, String docIdKey, List<Map<String, Object>> recordMapList) {
98.         // 实现批量更新文档的逻辑，类似于之前示例中的批量更新代码
99.         try {
100.             BulkRequest request = new BulkRequest();
102.             for (Map<String, Object> recordMap : recordMapList) {
103.                 String docId = recordMap.get(docIdKey).toString();
104.                 request.add(new UpdateRequest(indexName, docId)
105.                         .doc(recordMap, XContentType.JSON));
106.             }
108.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
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.     }
121.     public void singleDelete(String indexName, String docId) {
122.         // 实现单条删除文档的逻辑，类似于之前示例中的单条删除代码
123.         try {
124.             DeleteRequest request = new DeleteRequest(indexName, docId);
126.             DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
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.     }
139.     public void bulkDelete(String indexName, List<String> docIdList) {
140.         // 实现批量删除文档的逻辑，类似于之前示例中的批量删除代码
141.         try {
142.             BulkRequest request = new BulkRequest();
144.             for (String docId : docIdList) {
145.                 request.add(new DeleteRequest(indexName, docId));
146.             }
148.             BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
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.     }
161.     public void deleteByQuery(String indexName, Map<String, Object> query) {
162.         // 实现根据条件删除文档的逻辑，类似于之前示例中的 Delete By Query 代码
163.         try {
164.             // 创建 Delete By Query 请求
165.             DeleteByQueryRequest request = new DeleteByQueryRequest(indexName);
167.             // 设置查询条件
168.             BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
169.             for (Map.Entry<String, Object> entry : query.entrySet()) {
170.                 boolQuery.must(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()));
171.             }
172.             request.setQuery(boolQuery);
174.             // 执行 Delete By Query 请求
175.             DeleteByQueryResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
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.     }
188.     // 可以添加其他操作方法，根据实际需求扩展
190.     public void closeClient() {
191.         try {
192.             client.close();
193.         } catch (IOException e) {
194.             System.err.println("关闭 Elasticsearch 客户端时出现异常: " + e.getMessage());
195.         }
196.     }
197. }

复制代码

十、总结

在本文中，我们探讨了Elasticsearch文档操作的基本和高级功能，包括单条文档的插入、更新和删除，以及批量操作的应用。这些操作不仅使数据管理变得更加高效，还可以或许通过特定条件对文档进行精确控制，从而满足复杂业务需求。
我们通过现实的代码示例展示了如何使用Elasticsearch的REST API进行文档操作，夸大了在进行批量写入时注意的事项，以及在更新和删除过程中如何制止数据丢失和辩论。这些知识对开辟人员在处置惩罚大规模数据时尤其重要，可以资助他们计划更为高效和可靠的系统。
随着数据量的不断增长，把握Elasticsearch文档操作的技巧将使您在搜刮和分析范畴拥有更大的竞争上风。盼望通过本文的介绍，您可以或许更深入地理解Elasticsearch的文档管理机制，为未来的项目奠定坚实的底子。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。