新增文档

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

  • 初始化RestHighLevelClient

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

    索引库实体类

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

    1. @Data
    2. @TableName("tb_hotel")
    3. public class Hotel {
    4.   @TableId(type = IdType.INPUT)
    5.   private Long id;
    6.   private String name;
    7.   private String address;
    8.   private Integer price;
    9.   private Integer score;
    10.   private String brand;
    11.   private String city;
    12.   private String starName;
    13.   private String business;
    14.   private String longitude;
    15.   private String latitude;
    16.   private String pic;
    17. }

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

  • longitude和latitude需要合并为location

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

  1. package cn.itcast.hotel.pojo;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  6. @Data
  7. @NoArgsConstructor
  8. public class HotelDoc {
  9.     private Long id;
  10.     private String name;
  11.     private String address;
  12.     private Integer price;
  13.     private Integer score;
  14.     private String brand;
  15.     private String city;
  16.     private String starName;
  17.     private String business;
  18.     private String location;
  19.     private String pic;
  21.     public HotelDoc(Hotel hotel) {
  22.         this.id = hotel.getId();
  23.         this.name = hotel.getName();
  24.         this.address = hotel.getAddress();
  25.         this.price = hotel.getPrice();
  26.         this.score = hotel.getScore();
  27.         this.brand = hotel.getBrand();
  28.         this.city = hotel.getCity();
  29.         this.starName = hotel.getStarName();
  30.         this.business = hotel.getBusiness();
  31.         this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
  32.         this.pic = hotel.getPic();
  33.     }
  34. }

新增文档代码

  1.     @Test
  2.     void testAddDocument() throws IOException {
  3.         // 1.根据id查询酒店数据
  4.         Hotel hotel = hotelService.getById(61083L);
  6.         // 2.转换为文档类型
  7.         HotelDoc hotelDoc = new HotelDoc(hotel);
  9.         // 3.将HotelDoc转json
  10.         String json = JSON.toJSONString(hotelDoc);
  12.         // 1.准备Request对象
  13.         IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
  15.         // 2.准备Json文档
  16.         request.source(json, XContentType.JSON);
  18.         // 3.发送请求
  19.         client.index(request, RequestOptions.DEFAULT);
  20.     }

结果

去es查询一下
image.png

查询文档

  1.     @Test
  2.     void testGetDocumentById() throws IOException {
  3.         // 1.准备Request，查询的索引库和文档id
  4.         GetRequest request = new GetRequest("hotel", "61083");
  6.         // 2.发送请求，得到响应
  7.         GetResponse response = client.get(request, RequestOptions.DEFAULT);
  9.         // 3.解析响应结果，看上面的结果图，因为文档在响应结果的_source字段里面，所以要得到这个字段
  10.         String json = response.getSourceAsString();
  12.         //4.Json解析
  13.         HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
  14.         System.out.println(hotelDoc);
  15.     }

删除文档

  1.     @Test
  2.     void testDeleteDocument() throws IOException {
  3.         // 1.准备Request，删除的索引库和文档id
  4.         DeleteRequest request = new DeleteRequest("hotel", "61083");
  6.         // 2.发送请求
  7.         client.delete(request, RequestOptions.DEFAULT);
  8.     }

修改文档

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

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

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

  1.     @Test
  2.     void testUpdateDocument() throws IOException {
  3.         // 1.准备Request,增量修改的索引库和文档id
  4.         UpdateRequest request = new UpdateRequest("hotel", "61083");
  6.         // 2.准备请求参数，用都好隔开的一对一对的参数，两个一组，字段：值
  7.         request.doc(
  8.                 "price", "952",
  9.                 "starName", "四钻"
  10.         );
  12.         // 3.发送请求
  13.         client.update(request, RequestOptions.DEFAULT);
  14.     }

批量操作

批量处理BulkRequest，其本质就是将多个普通的CRUD请求组合在一起发送。
其中提供了一个add方法，用来添加其他请求：
能添加的请求包括：

  • IndexRequest，也就是新增
  • UpdateRequest，也就是修改
  • DeleteRequest，也就是删除

因此Bulk中添加了多个IndexRequest，就是批量新增功能了，如果添加多个DeleteRequest请求，那就是批量删除。
我们用批量添加来做例子：

  1.     @Test
  2.     void testBulkRequest() throws IOException {
  3.         // 批量查询酒店数据
  4.         List<Hotel> hotels = hotelService.list();
  6.         // 1.创建Request
  7.         BulkRequest request = new BulkRequest();
  9.         // 2.准备参数，添加多个新增的Request
  10.         for (Hotel hotel : hotels) {
  11.             // 2.1.转换为文档类型HotelDoc
  12.             HotelDoc hotelDoc = new HotelDoc(hotel);
  14.             // 2.2.创建新增文档的Request对象
  15.             request.add(new IndexRequest("hotel")
  16.                     .id(hotelDoc.getId().toString())
  17.                     .source(JSON.toJSONString(hotelDoc), XContentType.JSON));
  18.         }
  20.         // 3.发送请求
  21.         client.bulk(request, RequestOptions.DEFAULT);
  22.     }

:::success BulkRequest批量操作和循环发请求执行增删该操作的区别在于，BulkRequest只用发一次请求，而循环要发很多次请求 :::