欢迎来到雄杰鑫电商资讯网
技术教程

Elasticsearch复杂嵌套布尔查询的Java API实现指南

碧海醫心 次阅读

本文旨在指导读者如何使用elasticsearch java high-level rest client构建复杂的嵌套布尔查询。我们将详细解析如何将包含多字段匹配、模糊匹配以及多层`must`和`should`逻辑的elasticsearch dsl查询转换为java api，涵盖查询构建、组合逻辑及执行方法，以实现精确且灵活的数据检索。

在Elasticsearch中，构建复杂的搜索逻辑通常需要使用嵌套的布尔（bool）查询，其中包含must、should、filter和must_not等子句。当需要通过Java应用程序与Elasticsearch交互时，将这些复杂的DSL查询转换为Java High-Level REST Client API是核心任务。本教程将通过一个具体示例，详细阐述如何实现这一转换。

核心查询组件概述

在Elasticsearch Java High-Level REST Client中，我们主要依赖以下类来构建查询：

  • SearchRequest: 定义搜索请求，包括索引名称。
  • SearchSourceBuilder: 构建搜索源，包含查询、分页、排序等。
  • QueryBuilders: 静态工厂类，用于创建各种类型的查询，如matchQuery、multiMatchQuery、boolQuery等。
  • BoolQueryBuilder: 用于构建布尔查询，支持must（必须匹配）、should（应该匹配，至少一个）、filter（过滤，不参与评分）和mustNot（必须不匹配）子句。
  • MultiMatchQueryBuilder: 用于构建多字段匹配查询。
  • MatchQueryBuilder: 用于构建单字段精确匹配查询。

逐步构建复杂嵌套查询

我们将以下面的Elasticsearch DSL查询为例，将其转换为Java API：

GET /list/_search
{
  "size": 12,
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "should": [
              {
                "multi_match": {
                  "query": "city hed",
                  "type": "bool_prefix",
                  "fields": [
                    "cityName",
                    "countryCodeName",
                    "iso"
                  ]
                }
              },
              {
                "multi_match": {
                  "query": "city hed",
                  "fuzziness": "AUTO",
                  "fields": [
                    "cityName*"
                    ]
                }
              }
            ]
          }
        },
        {
          "bool": {
            "should": [
              {
                "match": {
                  "iso": ""
                }
              },
              {
                "match": {
                  "iso": ""
                }
              }
            ]
          }
        }
      ]
    }
  }
}

这个查询的核心是一个外部的bool查询，它包含两个must子句。每个must子句内部又是一个bool查询，其中包含should子句。

1. 初始化搜索请求

首先，我们需要创建一个SearchRequest实例来指定要搜索的索引，并创建一个SearchSourceBuilder来构建查询体。

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.MultiMatchQueryBuilder.Type;
import org.elasticsearch.search.builder.SearchSourceBuilder;

// 假设 getClient() 方法返回一个 RestHighLevelClient 实例
public class ElasticsearchQueryBuilder {

    private RestHighLevelClient client; // 假设已注入或初始化

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

    public SearchResponse executeComplexQuery() throws Exception {
        SearchRequest searchRequest = new SearchRequest("idx_name"); // 替换为你的索引名称
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.size(12); // 设置返回结果数量

2. 构建内部的should查询

DSL查询中包含两个独立的should逻辑块。我们将分别构建它们。

第一个should块：包含两个multi_match查询

  • 第一个multi_match：query: "city hed", type: "bool_prefix", 匹配cityName, countryCodeName, iso字段。
  • 第二个multi_match：query: "city hed", fuzziness: "AUTO", 匹配cityName*字段。
        // 第一个 multi_match 查询 (bool_prefix 类型)
        MultiMatchQueryBuilder multiMatchQueryBuilder1 = QueryBuilders
            .multiMatchQuery("city hed")
            .type(Type.PHRASE_PREFIX) // 对应 DSL 中的 "bool_prefix"
            .field("cityName")
            .field("countryCodeName")
            .field("iso");

        // 第二个 multi_match 查询 (fuzziness 模糊匹配)
        MultiMatchQueryBuilder multiMatchQueryBuilder2 = QueryBuilders
            .multiMatchQuery("city hed")
            .fuzziness("2") // 对应 DSL 中的 "AUTO"，这里使用具体值
            .field("cityName*");

        // 将这两个 multi_match 查询组合成一个 should 逻辑块
        BoolQueryBuilder boolShouldQuery1 = QueryBuilders.boolQuery()
            .should(multiMatchQueryBuilder1)
            .should(multiMatchQueryBuilder2);

第二个should块：包含两个match查询

  • 两个match查询都针对iso字段，但查询值为空字符串。在实际应用中，这些值通常是动态传入的。
        // 第一个 match 查询
        MatchQueryBuilder matchQuery1 = QueryBuilders.matchQuery("iso", ""); // 替换为实际的 iso 值

        // 第二个 match 查询
        MatchQueryBuilder matchQuery2 = QueryBuilders.matchQuery("iso", ""); // 替换为实际的 iso 值

        // 将这两个 match 查询组合成一个 should 逻辑块
        BoolQueryBuilder boolShouldQuery2 = QueryBuilders.boolQuery()
            .should(matchQuery1)
            .should(matchQuery2);

3. 组合外部的must查询

现在，我们有了两个BoolQueryBuilder实例（boolShouldQuery1和boolShouldQuery2），它们分别代表了DSL中的两个should逻辑块。根据DSL，这两个should块是外部bool查询的must子句。

        // 创建主布尔查询，将两个 should 逻辑块作为 must 子句
        BoolQueryBuilder mainBoolQuery = QueryBuilders.boolQuery()
            .must(boolShouldQuery1)
            .must(boolShouldQuery2);

4. 整合查询并执行

最后，将构建好的主布尔查询设置到SearchSourceBuilder中，并将SearchSourceBuilder设置到SearchRequest中，然后执行搜索。

        searchSourceBuilder.query(mainBoolQuery); // 设置主查询

        searchRequest.source(searchSourceBuilder); // 将查询源设置到搜索请求

        // 执行搜索请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        return searchResponse;
    }
}

完整示例代码

以下是整合所有部分的完整Java代码：

import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.MultiMatchQueryBuilder.Type;
import org.elasticsearch.search.builder.SearchSourceBuilder;

import java.io.IOException;

public class ElasticsearchComplexNestedQueryExample {

    private final RestHighLevelClient client; // 假设 RestHighLevelClient 实例已经初始化

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

    public SearchResponse executeComplexNestedQuery(String indexName, String queryText, String isoValue) throws IOException {
        SearchRequest searchRequest = new SearchRequest(indexName);
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.size(12); // 设置返回结果数量

        // --- 构建第一个 should 逻辑块 ---
        // 1. 第一个 multi_match 查询 (bool_prefix 语义)
        MultiMatchQueryBuilder multiMatchQueryBuilder1 = QueryBuilders
            .multiMatchQuery(queryText) // "city hed"
            .type(Type.PHRASE_PREFIX) // 对应 DSL 中的 "bool_prefix"
            .field("cityName")
            .field("countryCodeName")
            .field("iso");

        // 2. 第二个 multi_match 查询 (fuzziness 模糊匹配)
        MultiMatchQueryBuilder multiMatchQueryBuilder2 = QueryBuilders
            .multiMatchQuery(queryText) // "city hed"
            .fuzziness("2") // 对应 DSL 中的 "AUTO"，这里使用具体值
            .field("cityName*");

        // 组合这两个 multi_match 查询为第一个 should 逻辑块
        BoolQueryBuilder boolShouldQuery1 = QueryBuilders.boolQuery()
            .should(multiMatchQueryBuilder1)
            .should(multiMatchQueryBuilder2);

        // --- 构建第二个 should 逻辑块 ---
        // 1. 第一个 match 查询
        MatchQueryBuilder matchQuery1 = QueryBuilders.matchQu
ery("iso", isoValue); // 替换为实际的 iso 值

        // 2. 第二个 match 查询
        MatchQueryBuilder matchQuery2 = QueryBuilders.matchQuery("iso", isoValue); // 替换为实际的 iso 值

        // 组合这两个 match 查询为第二个 should 逻辑块
        BoolQueryBuilder boolShouldQuery2 = QueryBuilders.boolQuery()
            .should(matchQuery1)
            .should(matchQuery2);

        // --- 组合主布尔查询 ---
        // 将两个 should 逻辑块作为主布尔查询的 must 子句
        BoolQueryBuilder mainBoolQuery = QueryBuilders.boolQuery()
            .must(boolShouldQuery1)
            .must(boolShouldQuery2);

        // --- 设置查询并执行 ---
        searchSourceBuilder.query(mainBoolQuery);
        searchRequest.source(searchSourceBuilder);

        // 执行搜索请求
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        return searchResponse;
    }

    // 示例用法 (需要一个 RestHighLevelClient 实例)
    public static void main(String[] args) {
        // 实际应用中，这里需要初始化 RestHighLevelClient
        // 例如:
        // RestHighLevelClient client = new RestHighLevelClient(
        //     RestClient.builder(new HttpHost("localhost", 9200, "http")));

        // 假设 client 已初始化
        RestHighLevelClient client = null; // 请替换为实际的客户端实例

        if (client != null) {
            ElasticsearchComplexNestedQueryExample example = new ElasticsearchComplexNestedQueryExample(client);
            try {
                String index = "list"; // 索引名称
                String queryText = "city hed"; // 查询文本
                String iso = "USA"; // ISO 编码，这里假设一个值

                SearchResponse response = example.executeComplexNestedQuery(index, queryText, iso);
                System.out.println("Search Hits: " + response.getHits().getTotalHits().value);
                // 进一步处理搜索结果
            } catch (IOException e) {
                System.err.println("Error during Elasticsearch search: " + e.getMessage());
            } finally {
                try {
                    client.close(); // 关闭客户端
                } catch (IOException e) {
                    System.err.println("Error closing Elasticsearch client: " + e.getMessage());
                }
            }
        } else {
            System.err.println("Elasticsearch client not initialized. Please set up your RestHighLevelClient.");
        }
    }
}

注意事项

  1. 客户端初始化: RestHighLevelClient的初始化和管理是关键。在生产环境中，通常会使用连接池或单例模式来管理客户端实例。
  2. 异常处理: 执行client.search()方法会抛出IOException，因此需要进行适当的异常捕获和处理。
  3. 查询类型映射: DSL中的"type": "bool_prefix"在Java API中通常通过MultiMatchQueryBuilder.type(Type.PHRASE_PREFIX)来实现，它提供了类似的前缀匹配功能。虽然命名略有不同，但通常能满足需求。
  4. 模糊度（Fuzziness）: DSL中的"fuzziness": "AUTO"在Java API中可以通过fuzziness("AUTO")或指定具体数字（如fuzziness("2")）来实现。AUTO会根据词语长度自动调整编辑距离。
  5. 字段通配符: 在multi_match中，"cityName*"这样的通配符字段名是有效的，它会匹配所有以cityName开头的字段。
  6. 索引名称和查询参数: 示例中的"idx_name"、"city hed"和""（空字符串）是占位符，在实际应用中应替换为具体的索引名称和动态传入的查询参数。
  7. 分页设置: searchSourceBuilder.size(12)用于设置返回结果的数量，对应DSL中的"size": 12。

总结

通过本教程，我们详细展示了如何将一个复杂的Elasticsearch嵌套布尔查询转换为Java High-Level REST Client API。核心在于理解QueryBuilders和BoolQueryBuilder的用法，以及如何将DSL中的must和should逻辑层层嵌套地构建出来。掌握这些技巧，将使您能够利用Java API构建出强大而灵活的Elasticsearch搜索功能。在实际开发中，建议将查询参数化，并做好客户端连接管理和异常处理，以确保应用程序的健壮性。

ai java 编码 java api java应用程序

相关文章

按ESC键退出。