【Elasticsearch】RestClient操作文档

新增文档

将数据库中的信息导入elasticsearch中
以商品数据为例

实体类

定义一个索引库结构对应的实体。

@Data
@ApiModel(description = "索引库实体")
public class ItemDoc{

    @ApiModelProperty("商品id")
    private String id;

    @ApiModelProperty("商品名称")
    private String name;

    @ApiModelProperty("价格（分）")
    private Integer price;

    @ApiModelProperty("商品图片")
    private String image;

    @ApiModelProperty("类目名称")
    private String category;

    @ApiModelProperty("品牌名称")
    private String brand;

    @ApiModelProperty("销量")
    private Integer sold;

    @ApiModelProperty("评论数")
    private Integer commentCount;

    @ApiModelProperty("是否是推广广告，true/false")
    private Boolean isAD;

    @ApiModelProperty("更新时间")
    private LocalDateTime updateTime;
}

API语法

新增文档的请求语法如下：

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

对应的JavaAPI如下：

   @Test
   void createIndex() throws IOException {
        //1.准备文档 
       Item item = itemService.getById("4294760");
       log.info(item.getId().toString());
       ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);

        //1.准备Request
       IndexRequest request = new IndexRequest("items").id(itemDoc.getId());
        //2.准备请求参数
       request.source(JSONUtil.toJsonStr(itemDoc), XContentType.JSON);
        //3.发送请求
       client.index(request,RequestOptions.DEFAULT);

   }

导入商品数据，还需要做几点准备工作：

• 商品数据来自于数据库，我们需要先查询出来，得到Item对象
• Item对象需要转为ItemDoc对象
• ItemDTO需要序列化为json格式
  代码整体步骤如下：
• 1）根据id查询商品数据Item
• 2）将Item封装为ItemDoc
• 3）将ItemDoc序列化为JSON
• 4）创建IndexRequest，指定索引库名和id
• 5）准备请求参数，也就是JSON文档
• 6）发送请求

可以看到与索引库操作的API非常类似，同样是三步走：

• 1）创建Request对象，这里是IndexRequest，因为添加文档就是创建倒排索引的过程
• 2）准备请求参数，本例中就是Json文档
• 3）发送请求

查询文档

我们以根据id查询文档为例
查询的请求语句如下：

GET /{索引库名}/_doc/{id}

与之前的流程类似，代码大概分2步：

• 创建Request对象
• 准备请求参数，这里是无参，直接省略
• 发送请求

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

其它代码与之前类似，流程如下：

• 1）准备Request对象。这次是查询，所以是GetRequest
• 2）发送请求，得到结果。因为是查询，这里调用client.get()方法
• 3）解析结果，就是对JSON做反序列化

    @Test
    void getIndex() throws IOException {

        //1.准备Request
        GetRequest request = new GetRequest("items","4294760");
        //2.发送请求
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        //3.解析结果
        ItemDoc bean = JSONUtil.toBean(response.getSourceAsString(), ItemDoc.class);
        log.info(bean.toString());

    }

DSL查询

查询的请求语句如下

GET /{索引库名}/_search
{
  "query": {
    "查询类型": {
      // .. 查询条件
    }
  }
}

首先以match_all查询为例，其DSL和JavaAPI的对比如图：

代码解读：

• 第一步，创建SearchRequest对象，指定索引库名
• 第二步，利用request.source()构建DSL，DSL中可以包含查询、分页、排序、高亮等
• query()：代表查询条件，利用QueryBuilders.matchAllQuery()构建一个match_all查询的DSL
• 第三步，利用client.search()发送请求，得到响应

这里关键的API有两个，一个是request.source()，它构建的就是DSL中的完整JSON参数。其中包含了query、sort、from、size、highlight等所有功能：

另一个是QueryBuilders，其中包含了各种叶子查询、复合查询等：

完整代码

    @Test
    void testSearch() throws IOException {
        //1.创建request对象
        SearchRequest request = new SearchRequest("items");
        //2.配置request 参数
        request.source().query(QueryBuilders.matchAllQuery());
        //3.发送请求
        SearchResponse response= client.search(request, RequestOptions.DEFAULT);

        //4.解析结果
        SearchHits searchHits = response.getHits();
        //4.1 总条数
        long total = searchHits.getTotalHits().value;
        log.info("-----总条数：{}",total);
        // 4.2 名中的数据
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            //4.2.1 获取source结果
            String json = hit.getSourceAsString();
            //4.2.2 转化为实体
            ItemDoc bean = JSONUtil.toBean(json, ItemDoc.class);
            log.info("-----实体：{}",bean.toString());

        }
    }

删除文档

删除的请求语句如下：

DELETE /hotel/_doc/{id}

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

• 1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id
• 2）准备参数，无参，直接省略
• 3）发送请求。因为是删除，所以是client.delete()方法

在item-service的DocumentTest测试类中，编写单元测试：

@Test
void testDeleteDocument() throws IOException {
    // 1.准备Request，两个参数，第一个是索引库名，第二个是文档id
    DeleteRequest request = new DeleteRequest("items", "4294760");
    // 2.发送请求
    client.delete(request, RequestOptions.DEFAULT);
}

修改文档

修改我们讲过两种方式：

• 全量修改：本质是先根据id删除，再新增
• 局部修改：修改文档中的指定字段值

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

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

这里不再赘述，我们主要关注局部修改的API即可。
局部修改的请求语法如下：

POST /{索引库名}/_update/{id}
{
  "doc": {
    "字段名": "字段值",
    "字段名": "字段值"
  }
}

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

• 1）准备Request对象。这次是修改，所以是UpdateRequest
• 2）准备参数。也就是JSON文档，里面包含要修改的字段
• 3）更新文档。这里调用client.update()方法

@Test
void testUpdateDocument() throws IOException {
    // 1.准备Request
    UpdateRequest request = new UpdateRequest("items", "4294760");
    // 2.准备请求参数
    request.doc(
            "price", 58800,
            "commentCount", 1
    );
    // 3.发送请求
    client.update(request, RequestOptions.DEFAULT);
}

批量导入文档

批处理与前面讲的文档的CRUD步骤基本一致：

• 创建Request，但这次用的是BulkRequest
• 准备请求参数
• 发送请求，这次要用到client.bulk()方法

BulkRequest本身其实并没有请求参数，其本质就是将多个普通的CRUD请求组合在一起发送。例如：

• 批量新增文档，就是给每个文档创建一个IndexRequest请求，然后封装到BulkRequest中，一起发出。
• 批量删除，就是创建N个DeleteRequest请求，然后封装到BulkRequest，一起发出

  @Test
    void testBulkIndex() throws IOException {
        BulkRequest request = new BulkRequest();

        request.add(new IndexRequest("items","4294760"));
//        ...省略重复操作
        request.add(new DeleteRequest("items", "429476X"));
        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
    }

小结

文档操作的基本步骤：

• 初始化RestHighLevelClient
• 创建XxxRequest。
  • XXX是Index、Get、Update、Delete、Bulk
• 准备参数（Index、Update、Bulk时需要）
• 发送请求。
  • 调用RestHighLevelClient#.xxx()方法，xxx是index、get、update、delete、bulk
• 解析结果（Get时需要）