Elasticsearch底子文档操作完全演示指南
目录一、单条写入文档
二、批量写入文档
三、更新单条文档
update 操作
upsert 操作
四、更新批量文档
五、根据条件更新文档
六、删除单条文档
七、批量删除文档
八、根据条件删除文档
九、示例 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的文档管理机制，为未来的项目奠定坚实的底子。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]