【ElasticSearch】使用 Java 客户端 RestClient 实现对文档的查询操作，以及对搜索结果的排序、分页、高亮处理

最新推荐文章于 2024-05-18 18:43:48 发布
最新推荐文章于 2024-05-18 18:43:48 发布
阅读量960 收藏 1
点赞数 2
分类专栏： 微服务 ElasticSearch 文章标签： elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61635026/article/details/133688996
版权

文章目录

前言：RestClient 查询文档的 RestAPI

在 Elasticsearch 中，通过 RestAPI 进行 DSL 查询语句的构建通常是通过 HighLevelRestClient 中的 resource() 方法来实现的。该方法包含了查询、排序、分页、高亮等所有功能，为构建复杂的查询提供了便捷的接口。

RestAPI示意图

RestAPI 中构建查询条件的核心部分是由一个名为 QueryBuilders 的工具类提供的。该工具类包含了各种查询方法，如下图所示：

QueryBuilders工具类

查询的基本步骤如下：

  1. 创建 SearchRequest 对象。
  2. 准备 Request.source()，也就是 DSL。
  3. 使用 QueryBuilders 构建查询条件。
  4. 将查询条件传入 Request.source().query() 方法。
  5. 发送请求，得到结果。
  6. 解析结果，可以参考 JSON 结果，从外到内逐层解析。

这种方式使得构建复杂的查询变得简单而灵活。在接下来的实例中，我们将深入学习如何使用 HighLevelRestClient 中的 resource() 方法构建各种查询，并充分利用 QueryBuilders 工具类来满足不同的搜索需求。

一、全文检索查询

1.1 match_all 查询

match_all 查询的单元测试代码：

@Test
void testMatchAll() throws IOException {
    // 1. 准备Request
    SearchRequest request = new SearchRequest("hotel");

    // 2. 组织 DSL 请求
    request.source().query(QueryBuilders.matchAllQuery());

    // 3. 发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4. 解析结果
    List<HotelDoc> hotelDocs = handleResponse(response);
    System.out.println(hotelDocs);
}

这个测试代码演示了如何使用 match_all 查询来获取指定索引（这里是 “hotel”）下的所有文档。具体步骤如下：

  1. 创建 SearchRequest 对象，指定索引为 “hotel”。
  2. 使用 QueryBuilders.matchAllQuery() 构建查询条件。
  3. 将查询条件添加到请求的 DSL 中。
  4. 发送请求，得到查询结果。
  5. 解析查询结果，将文档转换为 HotelDoc 对象。

1.2 match 查询

@Test
void testMatch() throws IOException {
    // 1. 准备Request
    SearchRequest request = new SearchRequest("hotel");

    // 2. 组织 DSL 请求
    request.source().query(QueryBuilders.matchQuery("all", "如家"));

    // 3. 发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4. 解析结果
    List<HotelDoc> hotelDocs = handleResponse(response);
    System.out.println(hotelDocs);
}

这个测试代码演示了如何使用 match 查询来搜索包含特定关键词（这里是 “如家”）的文档。具体步骤如下：

  1. 创建 SearchRequest 对象，指定索引为 “hotel”。
  2. 使用 QueryBuilders.matchQuery("all", "如家") 构建查询条件，表示在 “all” 字段中搜索包含 “如家” 的文档。
  3. 将查询条件添加到请求的 DSL 中。
  4. 发送请求，得到查询结果。
  5. 解析查询结果，将文档转换为 HotelDoc 对象。

1.3 multi_match 查询

@Test
void testMultiMatch() throws IOException {
    // 1. 准备Request
    SearchRequest request = new SearchRequest("hotel");

    // 2. 组织 DSL 请求
    request.source().query(QueryBuilders.multiMatchQuery("如家", "name", "business"));

    // 3. 发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4. 解析结果
    List<HotelDoc> hotelDocs = handleResponse(response);
    System.out.println(hotelDocs);
}

这个测试代码演示了如何使用 multi_match 查询来在多个字段（这里是 “name” 和 “business”）中搜索包含特定关键词（这里是 “如家”）的文档。具体步骤如下：

  1. 创建 SearchRequest 对象，指定索引为 “hotel”。
  2. 使用 QueryBuilders.multiMatchQuery("如家", "name", "business") 构建查询条件，表示在 “name” 和 “business” 字段中搜索包含 “如家” 的文档。
  3. 将查询条件添加到请求的 DSL 中。
  4. 发送请求，得到查询结果。
  5. 解析查询结果，将文档转换为 HotelDoc 对象。

可以看到，这些测试代码的结构类似，只是在构建查询条件时使用了不同的 QueryBuilders 方法，用于满足不同的查询需求。

二、精确查询

精确查询常见的有 term 查询和 range 查询，同样使用 QueryBuilders 指定具体的查询方式。

2.1 term 查询

@Test
void testTerm() throws IOException {
    // 1. 准备Request
    SearchRequest request = new SearchRequest("hotel");

    // 2. 组织 DSL 请求
  	request.source().query(QueryBuilders.termQuery("city", "上海"));

    // 3. 发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4. 解析结果
    List<HotelDoc> hotelDocs = handleResponse(response);
    System.out.println(hotelDocs);
}

这个测试代码演示了如何使用 term 查询来搜索指定字段（这里是 “city”）中包含特定关键词（这里是 “上海”）的文档。具体步骤如下：

  1. 创建 SearchRequest 对象，指定索引为 “hotel”。
  2. 使用 QueryBuilders.termQuery("city", "上海") 构建查询条件，表示在 “city” 字段中搜索包含 “上海” 的文档。
  3. 将查询条件添加到请求的 DSL 中。
  4. 发送请求，得到查询结果。
  5. 解析查询结果，将文档转换为 HotelDoc 对象。

2.2 range 查询

@Test
void testRange() throws IOException {
    // 1. 准备Request
    SearchRequest request = new SearchRequest("hotel");

    // 2. 组织 DSL 请求
    request.source().query(QueryBuilders.rangeQuery("price").gte(150).lte(200));

    // 3. 发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4. 解析结果
    List<HotelDoc> hotelDocs = handleResponse(response);
    System.out.println(hotelDocs);
}

这个测试代码演示了如何使用 range 查询来搜索指定字段（这里是 “price”）中在给定范围内的文档。具体步骤如下：

  1. 创建 SearchRequest 对象，指定索引为 “hotel”。
  2. 使用 QueryBuilders.rangeQuery("price").gte(150).lte(200) 构建查询条件，表示在 “price” 字段中搜索价格在 150 到 200 之间的文档。
  3. 将查询条件添加到请求的 DSL 中。
  4. 发送请求，得到查询结果。
  5. 解析查询结果，将文档转换为 HotelDoc 对象。

这些测试代码演示了如何使用精确查询来满足特定的搜索需求。在实际应用中，可以根据具体的业务场景和数据结构选择不同的查询方式。

三、复合查询：Boolean 查询与 function score 查询的综合案例

例如，现在通过一个酒店预订网址的查询功能不但可以在搜索框输入关键字进行查询，还可以勾选指定的筛选条件，比如城市、星级、品牌和价格范围：


另外，再所有的酒店数据中还存在一部分属于广告（ES 文档中新增一个布尔类型的 isAD 字段表示），要求查询结果中的广告需要顶置显示，因此整个查询分为两部分：即 boolean 查询和 function score 查询。

  • boolean 查询：实现对搜索关键字的查询，以及过滤：城市、星级、品牌和价格等条件；
  • function score 查询：实现对广告文档的相关性增加操作。

具体的查询代码如下：

private static void buildBasicQuery(RequestParams params, SearchRequest request) {
    // 1. 原始查询 Query

    BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
    // 关键字搜索 must
    String key = params.getKey();
    if (key == null || key.isEmpty()) {
        boolQuery.must(QueryBuilders.matchAllQuery());
    } else {
        boolQuery.must(QueryBuilders.matchQuery("all", key));
    }

    // 城市条件
    if (params.getCity() != null && !params.getCity().isEmpty()) {
        boolQuery.filter(QueryBuilders.termQuery("city", params.getCity()));
    }
    // 品牌条件
    if (params.getBrand() != null && !params.getBrand().isEmpty()) {
        boolQuery.filter(QueryBuilders.termQuery("brand", params.getBrand()));
    }
    // 星级条件
    if (params.getStarName() != null && !params.getStarName().isEmpty()) {
        boolQuery.filter(QueryBuilders.termQuery("starName", params.getStarName()));
    }
    // 价格范围
    if (params.getMaxPrice() != null && params.getMinPrice() != null) {
        boolQuery.filter(QueryBuilders
                .rangeQuery("price").lte(params.getMaxPrice()).gte(params.getMinPrice()));
    }

    // 2. 算分查询
    FunctionScoreQueryBuilder functionScoreQuery =
            QueryBuilders.functionScoreQuery(
                    // 原始查询，相关信算法的查询
                    boolQuery,
                    // function score 数组
                    new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                            // 其中一个具体的 function score
                            new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                    // 过滤条件
                                    QueryBuilders.termQuery("isAD", true),
                                    // 算分函数
                                    ScoreFunctionBuilders.weightFactorFunction(10)
                            )
                    });

    request.source().query(functionScoreQuery);
}

对上述代码的详细说明：

  • RequestParams 是一个封装了前端请求参数的对象，里面包含了 ES 文档中的各个字段；
  • 在这个方法中，首先构建了一个 boolQuery 作为原始查询条件，包含了关键字搜索、城市、品牌、星级和价格范围等多个条件；
  • 接着，构建了一个 functionScoreQuery，将原始查询作为参数传入，同时定义了一个 FilterFunctionBuilder，用于处理广告部分的查询，对广告文档的分数进行加权，使其在查询结果中更靠前显示；
  • 最后，将 functionScoreQuery 设置为请求的查询条件。

这个综合的查询案例涵盖了多个条件的组合查询以及对特定文档的加权分数处理。在实际应用中，可以根据业务需求扩展和修改这个查询方法。

四、对查询结果的处理

4.1 将查询结果按照自己的距离远近排序

在前端查询酒店数据的时候，一般都会定位获取到自己当前的位置，然后传递给后端。

  • RequestParams 作为前端参数的封装对象，包含了这个位置信息，可通过get 方法进行获取；
  • 然后可以通过 SortBuilders 中的 geoDistanceSort 方法计算距离并进行排序操作，即可获取酒店与自己的实际距离。
String location = params.getLocation();
if (location != null && !location.isEmpty()) {
    request.source().sort(SortBuilders
            .geoDistanceSort("location", new GeoPoint(location))
            .order(SortOrder.ASC)
            .unit(DistanceUnit.KILOMETERS)
    );
}

4.2 根据前端请求参数进行分页操作

分页需要的页码以及页面大小一般都由前端传递参数给后端，然后后端获取这两个参数进行分页操作。

  • RequestParams 作为前端参数的封装对象，包含了这两个参数，可通过get 方法进行获取；
  • 然后再根据分页偏移量的计算公式offset = (page - 1) * size 即可获取偏移量，然后通过 source 的 from 和 size 方法，即可实现分页查询。

例如：

int page = params.getPage();
            int size = params.getSize();
            request.source().from((page - 1) * size).size(size);

4.3 对搜索关键字进行高亮处理

要对搜索关键字进行高亮处理同样非常简单，只需要使用 resouce 中的 highlighter 方法指定要进行高亮的字段即可。

实现的示例代码如下：

@Test
void testHighlight() throws IOException {

    // 1. 准备Request
    SearchRequest request = new SearchRequest("hotel");

    // 2. 组织 DSL 请求
    // 2.1 query
    request.source().query(QueryBuilders.matchQuery("all", "如家"));

    // 2.2 设置高亮
    request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));

    // 3. 发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);

    // 4. 解析结果
    List<HotelDoc> hotelDocs = handleResponse(response);
    System.out.println(hotelDocs);
}

说明：

注意requireFieldMatch方法的作用是高亮的字段是否需要和搜索的字段匹配。例如：使用字段 all 查询匹配 brand 字段，此时 brand 字段使用了 copy_to 到 all 字段，因此要高亮的字段并不匹配，如果不设置 requireFieldMatch 为 false 则会高亮失败。

对结果的解析：
实现高亮的原理是对搜索关键字加上了 <em> </em> 标签，通过在 Kibana 中使用高亮处理的 DSL 语句可以发现：


其实高亮的处理并没有作用到查询出的原始文档中，而是在每个 hits 里面新增了一个 highlight 字段，里面包含了高亮的关键字，因此还需要对 handleResponse 函数进行改造，使得能够处理高亮的查询结果：

例如，在handleResponse 函数的 result.add(hotelDoc) 这句代码之前，新增了以下代码用于处理高亮的情况，即使用高亮处理了的关键字替换查询结果中对应的关键字：

// 获取高亮结果
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if(highlightFields != null && !highlightFields.isEmpty()) {
    // 获取高亮名称
    HighlightField highlightField = highlightFields.get("name");
    // 获取高亮的值
    String name = highlightField.getFragments()[0].toString();
    hotelDoc.setName(name);
}

当运行这段测试代码，即可发现成功对 name 字段的 “如家” 添加了 <em> </em> 标签：

在这里插入图片描述

求知.
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java es 入门高亮，分页，模糊，查询。
qq_34526237的博客
09-19 1976
es模糊查询前言一、es 索引建立以及kibana的相关操作1.1 kibana操作1.1.1 新建索引1.1.2 在kibana上新建索引，看到以下提示就是新建成功1.1.3 删除索引1.1.4 查询所有数据1.1.5 查看索引的映射情况二、使用步骤1.本文基于springboot，要先引入maven依赖2.建立连接3 es插入数据3.1注入client3.2 插入数据3.2.1 插入数据control层如下3.2.2 注意点3.查询3.1 查询代码如下总结 前言 es是一个优秀的搜索框架，最近项目上
Elasticsearch结合java实现组合查询（模糊，区间，精确，分页）
weixin_45531476的博客
05-21 3488
具体实现看下图： 导入es的jar <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </dependency> 创建Repository public interface U
三、Elasticsearch构造JAVA安全客户端
工作随记
09-03 220
记录Elasticsearch构造JAVA安全客户端
【ElasticSearch】JavaRestClient实现文档查询、排序、分页、高亮
llg___的博客
07-07 2914
发现结果并未高亮，因为上面抽取的handleResponse方法是对_source下处理的，这里的数据是原数据，本就不会被修改，因此要继续拿highlight下的数据，即解析高亮结果。构建DSL是通过HighLevelRestClient中的resource()方法来实现的，这里包含了查询、排序、分页、高亮等操作。精确查询常见的有term查询和range查询，同样利用QueryBuilders实现。构建查询条件的核心部分，即查询类型，是用一个名为。实现的，它包含了各种查询方法。对响应的处理代码相同，这里。
Elasticsearch Java客户端
sunlibincn
02-28 2084
文章目录Api Client 选择创建客户端索引操作添加索引 - 方式一添加索引二文档操作CRUD插入文档获取文档删除文档修改文档文档搜索分页搜索简单搜索高亮搜索 Api Client 选择 客户端 优点 缺点 说明 Java Low Level Rest Client 与ES版本之间没有关系，适用于作为所有版本ES的客户端 Java High Level Rest Client 使用最多 使用需与ES版本保持一致 基于Low Level Rest Client，注意：7.15版本之
优秀的Elasticsearch Java 客户端-Jest
白石的专栏
11-18 2130
在本教程中，我们简要介绍了 Jest 客户端，它是 Elasticsearch 的 RESTful Java 客户端。
Elasticsearch的几种Java客户端使用总结
csdncjh的博客
05-26 2146
JestClient jest是一批操作es的http api接口，你可以像使用普法方法一下操作es，在springboot2.3.0之前，JestClient是支持自动注入的，而在2.3.0之后，你必须为JestClient写一个组件类，通过注入组件类来使用jest，这一点有些麻烦了。 版本对应 Jest Version Elasticsearch Version >= 6.0.0 6 >= 5.0.0 5 >= 2.0.0 2 0.1.0
java连接elasticsearch将搜索结果高亮显示并分页。
04-29
java连接elasticsearch实现全文检索，并且高亮显示结果，实现分页。项目基于elasticsearch5.6.1可根据自己实际情况调整版本。最近项目需要所以学习了一下，项目很简单可以根据你的实际情况更改接口。我本地的搜索是...
Elasticsearch实现复合查询高亮结果功能
10-16
主要介绍了Elasticsearch实现复合查询,高亮结果功能，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
Elasticsearch5.5.1 JAVA客户端RestClient示例
09-05
Elasticsearch5.5.1 JAVA客户端RestClient示例代码,详细介绍:http://blog.csdn.net/u011781521/article/details/77853571
Java API整合ES实现深分页，高亮等操作.zip
03-22
Java API整合ES实现深分页，高亮等操作
springboot整合elasticsearch7实现es数据同步，查询、相关度排序、高亮显示、自动补全搜索等功能。
03-31
springboot整合elasticsearch7，进行数据同步。elasticsearch相关度查询、排序。高亮显示；自动补全等功能。代码仅供参考，代码中有具体的注释，可以根据代码及注释内容，对自己项目架构及业务进行修改、整合。
[elastic 8.x]java客户端连接elasticsearch与操作索引与文档
m0_67713667的博客
11-05 1484
/
Elasticsearch--客户端
CelineT的博客
07-14 3265
语言无关​java最常用的客户端是Java Client、Java Rest Client、Java Transport Client。
Elasticsearch Java客户端和Spring data elasticsearch-Elasticsearch文章三
北巷东东的专栏
07-31 1415
Elasticsearch Java客户端和Spring data elasticsearch elasticsearch7.17.9版本
Java操作ElasticSearch相关内容
weixin_45892531的博客
08-11 761
Java连接ES 创建Maven工程 导入依赖 <dependencies> <!-- 1. elasticsearch--> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version&gt...
Java中ElasticSearch的几个简单查询
qq_54048628的博客
08-11 2045
这可能是今后用的最频繁的查询方式了，它将多个子查询组合成一个布尔表达式（将多个查询查询条件，以一定逻辑组合在一起），子查询间的逻辑关系是“与”，只有子查询的结果都为“true”时，布尔查询的结果才为“true”范围查询，针对数值类型和日期类型，对某个field进行范围指定，的在查询中能使用gt：> gte：>= lt：< lte：<=。单值查询，代表完全匹配，类似于mysql中的 =。多值查询，和term的查询机制是一样的，不会分词，直接词库匹配。类似于sql里的in查询。
Java操作ES（四）：RestHighLevelClient操作ES的API
热门推荐
zhoushimiao1990的博客
04-16 1万+
Create Index API RestHighLevelClient client = new RestHighLevelClient( RestClient.builder( new HttpHost("localhost", 9200, "http"), ne...
es索引同步
最新发布
yusheng_xyb的博客
05-18 379
使用MQ的优势是代码解耦，但是需要处理消息可靠性的问题有一定的技术成本，做到消息可靠性需要做到生产者投递成功、消息持久化以及消费者消费成功三个方面，另外还要做好消息幂等性问题。通过向索引中添加文章信息最终实现了课 程的搜索，我们发现文章信息是先保存在关系数据库中，而后再写入索引，这个过程是将关系数据中的数据同步到elasticsearch索引中的过程，可以简单成为索引同步。为了避免重复索引已经存在且未更新的数据，可以使用增量同步策略，仅同步新增和更新的数据，同时删除已经被标记删除的数据。
java实现es分页查询_如何在elasticsearch里面使用深度分页功能
06-09
下面是一个 Java 实现 Elasticsearch 分页查询的示例代码： ``` import org.elasticsearch.action.search.SearchResponse; import org.elasticsearch.action.search.SearchType; import org.elasticsearch.client....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

求知.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值