Elasticsearch 与 Java 客户端集成 High Level REST Client 实战

原创于 2025-10-17 08:57:24 发布 · 1k 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#java #优快云

Elasticsearch 与 Java 客户端集成：High Level REST Client 实战指南

引言

Elasticsearch 作为当今最流行的分布式搜索引擎，在各种大数据和搜索场景中发挥着重要作用。对于 Java 开发者来说，如何高效地与 Elasticsearch 进行集成是一个关键问题。虽然 High Level REST Client 在 Elasticsearch 7.x 版本后已被官方标记为废弃，并在 8.x 中完全移除，但许多现有项目仍在使用这一客户端，了解其使用方式对维护老项目具有重要意义。

环境准备与依赖配置

Maven 依赖配置

我们需要在项目中添加 Elasticsearch High Level REST Client 的依赖：

xml <dependencies> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId> <version>7.17.0</version> </dependency> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version>7.17.0</version> </dependency> </dependencies>

客户端初始化配置

```java
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.apache.http.HttpHost;

public class ElasticsearchClientFactory {
private static RestHighLevelClient client;

public static RestHighLevelClient getClient() {

    if (client == null) {

        client = new RestHighLevelClient(

            RestClient.builder(

                new HttpHost("localhost", 9200, "http")

            )

        );

    }

    return client;

}



public static void closeClient() throws IOException {

    if (client != null) {

        client.close();

    }

}

}
```

核心操作实战

1. 索引管理操作

创建索引示例：

```java
public class IndexOperations {
public static void createIndex(String indexName) throws IOException {
RestHighLevelClient client = ElasticsearchClientFactory.getClient();

    CreateIndexRequest request = new CreateIndexRequest(indexName);

    request.settings(Settings.builder()

        .put("index.number_of_shards", 3)

        .put("index.number_of_replicas", 2)

    );



    CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);

    System.out.println("索引创建结果: " + response.isAcknowledged());

}

}
```

2. 文档 CRUD 操作

文档索引操作：

```java
public class DocumentOperations {
public static void indexDocument(String indexName, String id, Map document) throws IOException {
RestHighLevelClient client = ElasticsearchClientFactory.getClient();

    IndexRequest request = new IndexRequest(indexName)

        .id(id)

        .source(document)

        .opType(DocWriteRequest.OpType.INDEX);



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

    System.out.println("文档索引结果: " + response.getResult());

}



// 批量索引文档

public static void bulkIndexDocuments(String indexName, List<Map<String, Object>> documents) throws IOException {

    RestHighLevelClient client = ElasticsearchClientFactory.getClient();

    BulkRequest request = new BulkRequest();



    for (int i = 0; i < documents.size(); i++) {

        request.add(new IndexRequest(indexName)

            .id(String.valueOf(i))

            .source(documents.get(i))

        );

    }



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

    System.out.println("批量操作耗时: " + response.getTook());

}

}
```

3. 搜索查询实战

基本搜索实现：

```java
public class SearchOperations {
public static SearchHits basicSearch(String indexName, String field, String value) throws IOException {
RestHighLevelClient client = ElasticsearchClientFactory.getClient();

    SearchRequest request = new SearchRequest(indexName);

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();



    // 构建查询条件

    sourceBuilder.query(QueryBuilders.matchQuery(field, value));

    sourceBuilder.from(0);

    sourceBuilder.size(10);

    request.source(sourceBuilder);



    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    return response.getHits();

}



// 复杂布尔查询

public static SearchHits boolSearch(String indexName, String mustField, String mustValue, 

                                  String filterField, Object filterValue) throws IOException {

    SearchRequest request = new SearchRequest(indexName);

    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();



    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()

        .must(QueryBuilders.matchQuery(mustField, mustValue))

        .filter(QueryBuilders.termQuery(filterField, filterValue));



    sourceBuilder.query(boolQuery);

    request.source(sourceBuilder);



    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    return response.getHits();

}

}
```

4. 聚合查询示例

```java
public class AggregationOperations {
public static Aggregations termsAggregation(String indexName, String field) throws IOException {
SearchRequest request = new SearchRequest(indexName);
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

    // 添加 terms 聚合

    TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_" + field).field(field);

    sourceBuilder.aggregation(aggregation);

    sourceBuilder.size(0); // 不需要返回具体文档



    request.source(sourceBuilder);

    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    return response.getAggregations();

}

}
```

高级特性与最佳实践

1. 连接池配置优化

```java
public class OptimizedClientFactory {
public static RestHighLevelClient createOptimizedClient() {
RestClientBuilder builder = RestClient.builder(
new HttpHost("localhost", 9200, "http")
);

    // 配置连接超时

    builder.setRequestConfigCallback(requestConfigBuilder -> 

        requestConfigBuilder

            .setConnectTimeout(5000)

            .setSocketTimeout(60000)

    );



    // 配置连接池

    builder.setHttpClientConfigCallback(httpClientBuilder -> 

        httpClientBuilder

            .setMaxConnTotal(100)

            .setMaxConnPerRoute(100)

    );



    return new RestHighLevelClient(builder);

}

}
```

2. 异常处理机制

java public class SafeElasticsearchOperations { public static boolean safeIndexDocument(String indexName, String id, Map<String, Object> document) { try { indexDocument(indexName, id, document); return true; } catch (ElasticsearchException e) { if (e.status() == RestStatus.CONFLICT) { System.out.println("文档冲突: " + e.getDetailedMessage()); } else { System.out.println("Elasticsearch 异常: " + e.getMessage()); } } catch (IOException e) { System.out.println("IO 异常: " + e.getMessage()); } return false; } }

迁移到新客户端的建议

虽然 High Level REST Client 在历史项目中仍有广泛应用，但新项目建议使用官方推荐的 Elasticsearch Java API Client：

更好的类型安全：基于注解的映射配置
更现代的 API 设计：响应式编程支持
官方长期支持：持续更新和维护

java // 新客户端的简单示例 ElasticsearchClient client = new ElasticsearchClient( new ApacheHttpTransport.Builder().build() );

总结

High Level REST Client 作为 Elasticsearch 历史版本中的重要组件，为 Java 开发者提供了强大的数据操作能力。通过本文的实战示例，我们详细介绍了从客户端初始化到复杂查询的完整使用流程。虽然在新项目中建议使用最新的官方客户端，但对于维护现有系统来说，深入理解 High Level REST Client 仍然具有重要价值。

在实际项目中，建议结合具体业务场景选择合适的客户端版本，并遵循连接管理、异常处理等最佳实践，以确保系统的稳定性和性能。