【ElasticSearch】（四）—— RestClient操作ES

已于 2022-05-24 22:38:19 修改
阅读量5.4k 收藏 39
点赞数 20
分类专栏： elasticsearch 文章标签： elasticsearch java 搜索引擎 大数据
于 2022-05-17 22:51:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a6470831/article/details/124790059
版权

目录

​编辑

一、RestClient操作索引

环境搭建

1、导入数据

2、导入项目

3、mapping映射分析

4、初始化RestClient

1）创建索引库

1、代码解读

2、完整示例

2）删除索引库

3）判断索引库是否存在

4）总结

二、RestClient操作文档

1）新增文档

1、索引库实体类

2、语法说明

3、完整代码

2）查询文档

1、语法说明

2、完整代码

3）删除文档

4）修改文档

1、语法说明

2、完整代码

5）批量导入文档

1、语法说明

2、完整代码

6）小结

 三、RestClient查询进阶

1）快速入门

1、发起查询请求

2、解析响应

3、小结

2）match查询

3）精确查询

4）布尔查询

5）排序&分页

6）高亮 

1、高亮请求构建

2、高亮结果解析

一、RestClient操作索引

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。官方文档地址：Elasticsearch Clients | Elastic

其中的Java Rest Client又包括两种：

  • Java Low Level Rest Client

  • Java High Level Rest Client

    我们学习的是Java HighLevel Rest Client客户端API 

环境搭建

1、导入数据

首先数据库数据：

CREATE TABLE 'tb_hotel' (
  'id' bigint(20) NOT NULL COMMENT '酒店id',
  'name' varchar(255) NOT NULL COMMENT '酒店名称；例：7天酒店',
  'address' varchar(255) NOT NULL COMMENT '酒店地址；例：航头路',
  'price' int(10) NOT NULL COMMENT '酒店价格；例：329',
  'score' int(2) NOT NULL COMMENT '酒店评分；例：45，就是4.5分',
  'brand' varchar(32) NOT NULL COMMENT '酒店品牌；例：如家',
  'city' varchar(32) NOT NULL COMMENT '所在城市；例：上海',
  'star_name' varchar(16) DEFAULT NULL COMMENT '酒店星级，从低到高分别是：1星到5星，1钻到5钻',
  'business' varchar(255) DEFAULT NULL COMMENT '商圈；例：虹桥',
  'latitude' varchar(32) NOT NULL COMMENT '纬度；例：31.2497',
  'longitude' varchar(32) NOT NULL COMMENT '经度；例：120.3925',
  'pic' varchar(255) DEFAULT NULL COMMENT '酒店图片；例:/img/1.jpg',
  PRIMARY KEY ('id')
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

2、导入项目

项目结构如图：

3、mapping映射分析

创建索引库，最关键的是mapping映射，而mapping映射要考虑的信息包括：

  • 字段名

  • 字段数据类型

  • 是否参与搜索

  • 是否需要分词

  • 如果分词，分词器是什么？

其中：

  • 字段名、字段数据类型，可以参考数据表结构的名称和类型

  • 是否参与搜索要分析业务来判断，例如图片地址，就无需参与搜索

  • 是否分词呢要看内容，内容如果是一个整体就无需分词，反之则要分词

  • 分词器，我们可以统一使用ik_max_word

来看下酒店数据的索引库结构:

PUT /hotel
{
  "mappings": {
    "properties": {
      "id": {
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "ik_max_word",
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },
      "city":{
        "type": "keyword",
        "copy_to": "all"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}

几个特殊字段说明：

  • location：地理坐标，里面包含精度、纬度

  • all：一个组合字段，其目的是将多字段的值 利用copy_to合并，提供给用户搜索

地理坐标说明： 

copy_to说明：

4、初始化RestClient

在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。

分为三步：

1）引入es的RestHighLevelClient依赖：

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

2）因为SpringBoot默认的ES版本是7.6.2，所以我们需要覆盖默认的ES版本：

<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.12.1</elasticsearch.version>
</properties>

3）初始化RestHighLevelClient：

初始化的代码如下：(ip&端口自定义)

RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
        HttpHost.create("http://localhost:9200")
));

这里为了单元测试方便，我们创建一个测试类HotelIndexTest，然后将初始化的代码编写在@BeforeEach方法中：

package com.elasticsearch.hotel;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;

/**
 * @author ：jizhibing
 * @date ：Created in 2022/5/17
 * @description：
 */
public class HostIndexTest {
   private RestHighLevelClient client;

   @BeforeEach
   void setUp(){
       this.client = new RestHighLevelClient(RestClient.builder(
               HttpHost.create("http://localhost:9200")
//               HttpHost.create("http://localhost:9200"),
//               HttpHost.create("http://localhost:9200")
       ));
   }

   @AfterEach
    void tearDown() throws IOException {
       this.client.close();
   }

    @Test
    void initTest(){
        System.out.println(client);
    }

}

1）创建索引库

1、代码解读

创建索引库的API如下：

代码分为三步：

  • 1）创建Request对象。因为是创建索引库的操作，因此Request是CreateIndexRequest。

  • 2）添加请求参数，其实就是DSL的JSON参数部分。因为json字符串很长，这里是定义了静态字符串常量MAPPING_TEMPLATE，让代码看起来更加优雅。

  • 3）发送请求，client.indices()方法的返回值是IndicesClient类型，封装了所有与索引库操作有关的方法。 

2、完整示例

创建一个类，定义mapping映射的JSON字符串常量：

package com.elasticsearch.hotel.constants;

/**
 * @author ：jizhibing
 * @date ：Created in 2022/5/17
 * @description：
 */
public class HotelConstants {

    public static final String MAPPING_TEMPLATE = "{\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"id\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"name\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_max_word\",\n" +
            "        \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"address\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"price\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"score\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"brand\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "         \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"city\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"copy_to\": \"all\"\n" +
            "      },\n" +
            "      \"starName\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      }    ,\n" +
            "      \"business\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"location\":{\n" +
            "        \"type\": \"geo_point\"\n" +
            "      },\n" +
            "      \"pic\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      , \"index\":false\n" +
            "      },\n" +
            "      \"all\":{\n" +
            "        \"type\":\"text\",\n" +
            "        \"analyzer\":\"ik_max_word\"\n" +
            "      }\n" +
            "        \n" +
            "      \n" +
            "    }\n" +
            "  }\n" +
            "}" ;

}

在hotel-demo中的HotelIndexTest测试类中，编写单元测试，实现创建索引：

@Test
void createHotelIndex() throws IOException {
    // 1.创建Request对象
    CreateIndexRequest request = new CreateIndexRequest("hotel");
    // 2.准备请求的参数：DSL语句
    request.source(MAPPING_TEMPLATE, XContentType.JSON);
    // 3.发送请求
    client.indices().create(request, RequestOptions.DEFAULT);
}

2）删除索引库

删除索引库的DSL语句非常简单：

DELETE /hotel

与创建索引库相比：

  • 请求方式从PUT变为DELTE

  • 请求路径不变

  • 无请求参数

所以代码的差异，注意体现在Request对象上。依然是三步走：

  • 1）创建Request对象。这次是DeleteIndexRequest对象

  • 2）准备参数。这里是无参

  • 3）发送请求。改用delete方法

在hotel-demo中的HotelIndexTest测试类中，编写单元测试，实现删除索引：

@Test
void testDeleteHotelIndex() throws IOException {
    // 1.创建Request对象
    DeleteIndexRequest request = new DeleteIndexRequest("hotel");
    // 2.发送请求
    client.indices().delete(request, RequestOptions.DEFAULT);
}

3）判断索引库是否存在

判断索引库是否存在，本质就是查询，对应的DSL是：

GET /hotel

因此与删除的Java代码流程是类似的。依然是三步走：

  • 1）创建Request对象。这次是GetIndexRequest对象

  • 2）准备参数。这里是无参

  • 3）发送请求。改用exists方法

@Test
void testExistsHotelIndex() throws IOException {
    // 1.创建Request对象
    GetIndexRequest request = new GetIndexRequest("hotel");
    // 2.发送请求
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    // 3.输出
    System.err.println(exists ? "索引库已经存在！" : "索引库不存在！");
}

4）总结

JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。

索引库操作的基本步骤：

  • 初始化RestHighLevelClient

  • 创建XxxIndexRequest。XXX是Create、Get、Delete

  • 准备DSL（ Create时需要，其它是无参）

  • 发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete

二、RestClient操作文档

为了与索引库操作分离，我们再次参加一个测试类，做两件事情：

  • 初始化RestHighLevelClient

  • 我们的酒店数据在数据库，需要利用IHotelService去查询，所以注入这个接口

package com.elasticsearch.hotel;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.elasticsearch.hotel.constants.HotelConstants;
import com.elasticsearch.hotel.pojo.Hotel;
import com.elasticsearch.hotel.pojo.HotelDoc;
import com.elasticsearch.hotel.service.IHotelService;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.Map;

/**
 * @author ：jizhibing
 * @date ：Created in 2022/5/17
 * @description：
 */
@SpringBootTest
public class HotelDocumentTest {

    @Autowired
    private IHotelService iHotelService ;

    private RestHighLevelClient client;


   @BeforeEach
   void setUp(){
       this.client = new RestHighLevelClient(RestClient.builder(
               HttpHost.create("http://localhost:9200")
       ));
   }

   @AfterEach
    void tearDown() throws IOException {
       this.client.close();
   }

}

1）新增文档

我们要将数据库的酒店数据查询出来，写入elasticsearch中。

1、索引库实体类

数据库查询后的结果是一个Hotel类型的对象。结构如下：

@Data
@TableName("tb_hotel")
public class Hotel {
    @TableId(type = IdType.INPUT)
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String longitude;
    private String latitude;
    private String pic;
}

与我们的索引库结构存在差异：

  • longitude和latitude需要合并为location

因此，我们需要定义一个新的类型，与索引库结构吻合：

package com.elasticsearch.hotel.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
public class HotelDoc {
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String location;
    private String pic;

    public HotelDoc(Hotel hotel) {
        this.id = hotel.getId();
        this.name = hotel.getName();
        this.address = hotel.getAddress();
        this.price = hotel.getPrice();
        this.score = hotel.getScore();
        this.brand = hotel.getBrand();
        this.city = hotel.getCity();
        this.starName = hotel.getStarName();
        this.business = hotel.getBusiness();
        this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
        this.pic = hotel.getPic();
    }
}

2、语法说明

新增文档的DSL语句如下：

POST /{索引库名}/_doc/1
{
    "name": "Jack",
    "age": 21
}

 对应的java代码如图：

可以看到与创建索引库类似，同样是三步走：

  • 1）创建Request对象

  • 2）准备请求参数，也就是DSL中的JSON文档

  • 3）发送请求

变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。

3、完整代码

我们导入酒店数据，基本流程一致，但是需要考虑几点变化：

  • 酒店数据来自于数据库，我们需要先查询出来，得到hotel对象

  • hotel对象需要转为HotelDoc对象

  • HotelDoc需要序列化为json格式

因此，代码整体步骤如下：

  • 1）根据id查询酒店数据Hotel

  • 2）将Hotel封装为HotelDoc

  • 3）将HotelDoc序列化为JSON

  • 4）创建IndexRequest，指定索引库名和id

  • 5）准备请求参数，也就是JSON文档

  • 6）发送请求

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@Test
void testAddDocument() throws IOException {
    // 1.根据id查询酒店数据
    Hotel hotel = hotelService.getById(61083L);
    // 2.转换为文档类型
    HotelDoc hotelDoc = new HotelDoc(hotel);
    // 3.将HotelDoc转json
    String json = JSON.toJSONString(hotelDoc);

    // 1.准备Request对象
    IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
    // 2.准备Json文档
    request.source(json, XContentType.JSON);
    // 3.发送请求
    client.index(request, RequestOptions.DEFAULT);
}

2）查询文档

1、语法说明

查询的DSL语句如下：

GET /hotel/_doc/{id}

非常简单，因此代码大概分两步：

  • 准备Request对象

  • 发送请求

不过查询的目的是得到结果，解析为HotelDoc，因此难点是结果的解析。完整代码如下：

可以看到，结果是一个JSON，其中文档放在一个_source属性中，因此解析就是拿到_source，反序列化为Java对象即可。

与之前类似，也是三步走：

  • 1）准备Request对象。这次是查询，所以是GetRequest

  • 2）发送请求，得到结果。因为是查询，这里调用client.get()方法

  • 3）解析结果，就是对JSON做反序列化

2、完整代码

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@Test
void testGetDocumentById() throws IOException {
    // 1.准备Request
    GetRequest request = new GetRequest("hotel", "61082");
    // 2.发送请求，得到响应
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    // 3.解析响应结果
    String json = response.getSourceAsString();

    HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
    System.out.println(hotelDoc);
}

3）删除文档

删除的DSL为是这样的：

DELETE /hotel/_doc/{id}

与查询相比，仅仅是请求方式从DELETE变成GET，可以想象Java代码应该依然是三步走：

  • 1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id

  • 2）准备参数，无参

  • 3）发送请求。因为是删除，所以是client.delete()方法

编写单元测试：

@Test
void testDeleteDocument() throws IOException {
    // 1.准备Request
    DeleteRequest request = new DeleteRequest("hotel", "61083");
    // 2.发送请求
    client.delete(request, RequestOptions.DEFAULT);
}

4）修改文档

1、语法说明

修改我们讲过两种方式：

  • 全量修改：本质是先根据id删除，再新增

  • 增量修改：修改文档中的指定字段值

在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：

  • 如果新增时，ID已经存在，则修改

  • 如果新增时，ID不存在，则新增

这里不再赘述，我们主要关注增量修改。

代码示例如图：

与之前类似，也是三步走：

  • 1）准备Request对象。这次是修改，所以是UpdateRequest

  • 2）准备参数。也就是JSON文档，里面包含要修改的字段

  • 3）更新文档。这里调用client.update()方法

2、完整代码

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@Test
void testUpdateDocument() throws IOException {
    // 1.准备Request
    UpdateRequest request = new UpdateRequest("hotel", "61083");
    // 2.准备请求参数
    request.doc(
        "price", "952",
        "starName", "四钻"
    );
    // 3.发送请求
    client.update(request, RequestOptions.DEFAULT);
}

5）批量导入文档

案例需求：利用BulkRequest批量将数据库数据导入到索引库中。

步骤如下：

  • 利用mybatis-plus查询酒店数据

  • 将查询到的酒店数据（Hotel）转换为文档类型数据（HotelDoc）

  • 利用JavaRestClient中的BulkRequest批处理，实现批量新增文档

1、语法说明

批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。

其中提供了一个add方法，用来添加其他请求：

可以看到，能添加的请求包括：

  • IndexRequest，也就是新增

  • UpdateRequest，也就是修改

  • DeleteRequest，也就是删除

因此Bulk中添加了多个IndexRequest，就是批量新增功能了。示例：

 

其实还是三步走：

  • 1）创建Request对象。这里是BulkRequest

  • 2）准备参数。批处理的参数，就是其它Request对象，这里就是多个IndexRequest

  • 3）发起请求。这里是批处理，调用的方法为client.bulk()方法

我们在导入酒店数据时，将上述代码改造成for循环处理即可。

2、完整代码

在hotel-demo的HotelDocumentTest测试类中，编写单元测试：

@Test
void testBulkRequest() throws IOException {
    // 批量查询酒店数据
    List<Hotel> hotels = hotelService.list();

    // 1.创建Request
    BulkRequest request = new BulkRequest();
    // 2.准备参数，添加多个新增的Request
    for (Hotel hotel : hotels) {
        // 2.1.转换为文档类型HotelDoc
        HotelDoc hotelDoc = new HotelDoc(hotel);
        // 2.2.创建新增文档的Request对象
        request.add(new IndexRequest("hotel")
                    .id(hotelDoc.getId().toString())
                    .source(JSON.toJSONString(hotelDoc), XContentType.JSON));
    }
    // 3.发送请求
    client.bulk(request, RequestOptions.DEFAULT);
}

6）小结

文档操作的基本步骤：

  • 初始化RestHighLevelClient

  • 创建XxxRequest。XXX是Index、Get、Update、Delete、Bulk

  • 准备参数（Index、Update、Bulk时需要）

  • 发送请求。调用RestHighLevelClient#.xxx()方法，xxx是index、get、update、delete、bulk

  • 解析结果（Get时需要）

 三、RestClient查询进阶

文档的查询基本步骤包括：

  • 1）准备Request对象

  • 2）准备请求参数

  • 3）发起请求

  • 4）解析响应

1）快速入门

我们以match_all查询为例

1、发起查询请求

   @Test
   void testMatchAll() throws IOException {
       //1、准备Request
       SearchRequest request = new SearchRequest("hotel");
       //2、准备DSL
       request.source().query(QueryBuilders.matchAllQuery());
       //3、发送请求
       SearchResponse search = client.search(request, RequestOptions.DEFAULT);
   }

代码解读：

  • 第一步，创建SearchRequest对象，指定索引库名

  • 第二步，利用request.source()构建DSL，DSL中可以包含查询、分页、排序、高亮等

    • query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL

  • 第三步，利用client.search()发送请求，得到响应

这里关键的API有两个，一个是request.source()，其中包含了查询、排序、分页、高亮等所有功能：

 另一个是QueryBuilders，其中包含match、term、function_score、bool等各种查询：

 2、解析响应

   @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、解析响应
       handleResponse(response);
   }

    private void handleResponse(SearchResponse response) {
        //4、解析响应
        SearchHits searchHits = response.getHits();
        //4.1查询总条数
        TotalHits totalHits = searchHits.getTotalHits();
        System.out.println("总共"+totalHits+"条记录");
        //4.2 查看结果数组
        SearchHit[] hits = searchHits.getHits();
        //4.3遍历
        for (SearchHit hit : hits){
            //获取文档source
            String source = hit.getSourceAsString();
            //反序列号
            HotelDoc hotelDoc = JSON.parseObject(source, HotelDoc.class);

            System.out.println("hotelDoc:"+hotelDoc.toString());
        }
    }

elasticsearch返回的结果是一个JSON字符串，结构包含：

  • hits：命中的结果

    • total：总条数，其中的value是具体的总条数值

    • max_score：所有结果中得分最高的文档的相关性算分

    • hits：搜索结果的文档数组，其中的每个文档都是一个json对象

      • _source：文档中的原始数据，也是json对象

因此，我们解析响应结果，就是逐层解析JSON字符串，流程如下：

  • SearchHits：通过response.getHits()获取，就是JSON中的最外层的hits，代表命中的结果

    • SearchHits#getTotalHits().value：获取总条数信息

    • SearchHits#getHits()：获取SearchHit数组，也就是文档数组

      • SearchHit#getSourceAsString()：获取文档结果中的_source，也就是原始的json文档数据

3、小结

查询的基本步骤是：

  1. 创建SearchRequest对象

  2. 准备Request.source()，也就是DSL。

    ① QueryBuilders来构建查询条件

    ② 传入Request.source() 的 query() 方法

  3. 发送请求，得到结果

  4. 解析结果（参考JSON结果，从外到内，逐层解析）

2）match查询

全文检索的match和multi_match查询与match_all的API基本一致。差别是查询条件，也就是query的部分

 因此，Java代码上的差异主要是request.source().query()中的参数了。同样是利用QueryBuilders提供的方法：

 完整代码如下：


    @Test
    void testMatch() throws IOException {
        //1、准备Request
        SearchRequest request = new SearchRequest("hotel");
        //2、准备DSL
        //单字段查询
        //        request.source().query(QueryBuilders.matchQuery("all","深圳"));
        //多字段查询
        request.source().query(QueryBuilders.multiMatchQuery("深圳","city","name"));

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

        //4、解析响应
        handleResponse(response);
    }

3）精确查询

精确查询主要是两者：

  • term：词条精确匹配

  • range：范围查询

与之前的查询相比，差异同样在查询条件，其它都一样。

查询条件构造的API如下：

    @Test
    void termQuery() throws IOException {
        //1、准备Request
        SearchRequest request = new SearchRequest("hotel");
        //2、准备DSL
        //精确查询
        request.source().query( QueryBuilders.rangeQuery("price").gte(100).lte(500));

        //词条查询
        //QueryBuilders.termQuery("city","深圳") ;
        //范围查询
        //QueryBuilders.rangeQuery("price").gte(100).lte(500);

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

        //4、解析响应
        handleResponse(response);
    }

4）布尔查询

布尔查询是用must、must_not、filter等方式组合其它查询，代码示例如下：

    @Test
    void boolQuery() throws IOException {
        //1、准备Request
        SearchRequest request = new SearchRequest("hotel");
        //2、准备DSL
        //创建布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //添加必须条件
        boolQueryBuilder.must(QueryBuilders.termQuery("city","深圳"));
        //添加过滤条件
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("score").lte(500));

        //精确查询
        request.source().query( boolQueryBuilder);


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

        //4、解析响应
        handleResponse(response);
    }

5）排序&分页

搜索结果的排序和分页是与query同级的参数，因此同样是使用request.source()来设置。

对应的API如下：

 完整代码：

    @Test
    void pageQuery() throws IOException {
        //1、准备Request
        SearchRequest request = new SearchRequest("hotel");
        //2、准备DSL


        //查询
        request.source().query( QueryBuilders.matchAllQuery());
        //分页
        request.source().from(0).size(5);
        //价格排序
        request.source().sort("price");
        //3、发送请求
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        //4、解析响应
        handleResponse(response);
    }

6）高亮 

高亮的代码与之前代码差异较大，有两点：

  • 查询的DSL：其中除了查询条件，还需要添加高亮条件，同样是与query同级。

  • 结果解析：结果除了要解析_source文档数据，还要解析高亮结果

1、高亮请求构建

高亮请求的构建API如下：

完整代码如下：

@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.解析响应
    handleResponse(response);

}

2、高亮结果解析

高亮的结果与查询的文档结果默认是分离的，并不在一起。

因此解析高亮的代码需要额外处理：

代码解读：

  • 第一步：从结果中获取source。hit.getSourceAsString()，这部分是非高亮结果，json字符串。还需要反序列为HotelDoc对象

  • 第二步：获取高亮结果。hit.getHighlightFields()，返回值是一个Map，key是高亮字段名称，值是HighlightField对象，代表高亮值

  • 第三步：从map中根据高亮字段名称，获取高亮字段值对象HighlightField

  • 第四步：从HighlightField中获取Fragments，并且转为字符串。这部分就是真正的高亮字符串了

  • 第五步：用高亮的结果替换HotelDoc中的非高亮结果

完整代码如下： 

private void handleResponse(SearchResponse response) {
    // 4.解析响应
    SearchHits searchHits = response.getHits();
    // 4.1.获取总条数
    long total = searchHits.getTotalHits().value;
    System.out.println("共搜索到" + total + "条数据");
    // 4.2.文档数组
    SearchHit[] hits = searchHits.getHits();
    // 4.3.遍历
    for (SearchHit hit : hits) {
        // 获取文档source
        String json = hit.getSourceAsString();
        // 反序列化
        HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
        // 获取高亮结果
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        if (!CollectionUtils.isEmpty(highlightFields)) {
            // 根据字段名获取高亮结果
            HighlightField highlightField = highlightFields.get("name");
            if (highlightField != null) {
                // 获取高亮值
                String name = highlightField.getFragments()[0].string();
                // 覆盖非高亮结果
                hotelDoc.setName(name);
            }
        }
        System.out.println("hotelDoc = " + hotelDoc);
    }
}

机智兵
关注
  • 20
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
es入门操作-elasticsearch入门操作
12-27
es入门操作-elasticsearch入门操作
es-head Elasticsearch的可视化操作插件
12-19
es-head是一个针对Elasticsearch的可视化操作插件。它提供了一个便捷的操作工具，可以连接Elasticsearch搜索引擎，并提供可视化的操作页面，对Elasticsearch进行各种设置和数据检索功能的管理。 es-head 插件可以在谷歌浏览器中使用，以下是使用方法： 1.下载解压 es-head 插件。你可以从相关网站下载 es-head 插件的压缩包，然后解压。 2.将解压后的插件文件放入 Chrome 扩展程序目录。可以参考谷歌浏览器右上角设置，更多工具，扩展程序，选择加载已解压的扩展程序，选择解压 es-head 文件夹即可添加插件成功。 3.安装完成后，你可以打开开发者模式，查看 es-head 插件是否已经成功安装。 4.连接 Elasticsearch。在 es-head 插件页面输入连接地址 ip 和端口号后点链接即可。连接后显示绿色代表健康。
elasticsearch篇：RestClient操作
最新发布
viperd的博客
03-10 915
JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。索引库操作的基本步骤：初始化RestHighLevelClient创建XxxIndexRequest。XXX是Create、Get、Delete准备DSL（ Create时需要，其它是无参）发送请求。调用RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete。
Elasticsearch Rest-Client使用教程
wu_amber的博客
11-04 7730
Rest-Client使用教程DSL ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。介绍详解案例之Rest-Client REST客户端，通过http与集群交互，用户自定义编组请求JSON串，及解析响应JSON串，完成业务需求
Elasticsearch中RestClient使用
总结分享
09-03 591
这些客户端的本质就是组装DSL语句,通过Http请求发送给ES
ElasticSearch进阶篇之ElasticSearch-Rest-Client在SpringBoot项目中实战
波波烤鸭的博客
02-18 3527
1.ES 的Java API两种方式   Elasticsearch 的API 分为 REST Client API（http请求形式）以及 transportClient API两种。相比来说transportClient API效率更高，transportClient 是通过Elasticsearch内部RPC的形式进行请求的，连接可以是一个长连接，相当于是把客户端的请求当成   Elasticsearch 集群的一个节点，当然 REST Client API 也支持http keepAlive形式的.
restclient
12-08
WisdomTool REST Client，支持自动化测试RESTful API，输出精美的测试报告，并且自动生成RESTful API文档。 工具精悍哦！ https://github.com/wisdomtool/rest-client WisdomTool REST Client supports automated testing, output exquisite report, and automatically generating RESTful API document. Very powerful ! https://github.com/wisdomtool/r
RESTClient使用教程
weixin_34254823的博客
12-01 2608
Wisdom RESTClient 一款自动化测试REST API的工具，它可以自动化测试RESTful API并生成精美的测试报告，同时基于测试过的历史API，可以生成精美的RESTful API文档。 1. 使用RESTClient前的准备工作 1.1 下载RESTClient JAR包： restclient.jar； 1.2 使用...
Elasticsearch-基本操作
山丘i
11-19 656
1.初识elasticsearch 1.1.了解ES 1.1.1.elasticsearch的作用 elasticsearch是一款非常强大的开源搜索引擎，具备非常多强大功能，可以帮助我们从海量数据中快速找到需要的内容 例如： 在GitHub搜索代码 在电商网站搜索商品 在百度搜索答案 在打车软件搜索附近的车 1.1.2.ELK技术栈 elasticsearch结合kib...
RESTClient
weixin_30492601的博客
08-01 85
RESTClient is a Java application to test RESTful webservices. It can be used to test variety of HTTP communications. There are two executables: GUI version (restclient-ui-X.jar download) Cli ve...
ElasticSearch - RestClient操作ES基本操作
汤键的博客
01-27 1644
ElasticSearch - RestClient操作ES基本操作
Elasticsearch5.5.1 JAVA客户端RestClient示例
09-05
Elasticsearch5.5.1 JAVA客户端RestClient示例代码,详细介绍:http://blog.csdn.net/u011781521/article/details/77853571
restClient
01-05
restful http接口测试工具，解压后运行restclient-ui-3.7.1\restclient-ui-3.7.1\bin\restclient-ui.bat即可测试
restclient用法
12-01
介绍restclient测试API的详细用法，以及相关的注意事项。
restclient使用教程
12-01
restclient使用教程，介绍restclient使用的详细步骤和注意事项
restclient下载
03-13
Wisdom RESTClient https://github.com/Wisdom-Projects/rest-client
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用
11-12
本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、关键字查询、高亮显示、逻辑查询、过滤查询、分组查询等等。并且已经过生产环境验证，各位可放心使用。如有不对之处欢迎...
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用）
04-18
本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、关键字查询、高亮显示、逻辑查询、过滤查询、分组查询等等。并且已经过生产环境验证，各位可放心使用。
(狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战)
04-18
(狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战),包含了小狂神讲的东西，特别适合新手学习，笔记保存下来可以多看看。好记性不如烂笔头哦~，ElasticSearch，简称es，es是一个...
elasticsearch restclient
08-17
Elasticsearch RestClient是Elasticsearch官方提供的Java客户端库，用于与Elasticsearch集群进行通信。它提供了一种简单而灵活的方式来执行各种操作，如索引、搜索、更新和删除文档等。您可以使用RestClient发送HTTP请求到Elasticsearch集群，并处理响应结果。 RestClient支持两种不同的实现方式：低级别（Low-Level）和高级别（High-Level）客户端。 低级别客户端（Low-Level Client）允许您直接发送HTTP请求到Elasticsearch，处理响应结果。这种方式更接近原生的REST API，并且提供了更大的灵活性。您可以手动构建请求、处理响应和错误，以及处理各种参数和选项。 高级别客户端（High-Level Client）基于低级别客户端构建，并提供了更简化和更易使用的API。它封装了许多常见的操作，以便您更轻松地与Elasticsearch进行交互。高级别客户端提供了更高级别的抽象，使您能够以更简洁的方式执行索引、搜索、更新和删除等操作。 您可以根据自己的需求选择使用哪种客户端，但通常建议使用高级别客户端，因为它提供了更简化和更易用的API。您可以在Elasticsearch官方文档中找到更多关于RestClient的详细信息和用法示例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

机智兵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值