devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

ES高级客户端文档操作实战_requestoptions.default

作者：weixin_40725706 | 2024-03-26 19:54:50

赞

踩

requestoptions.default

在Elasticsearch中，高级客户端支持以下文档相关的API：

（1）Single document APIs——单文档操作API。（2）Index API——文档索引API。（3）Get API——文档获取API。（4）Exists API——文档存在性判断API。（5）Delete API——文档删除API。（6）Update API——文档更新API。（7）Term Vectors API——词向量API。（8）Bulk API——批量处理API。（9）Multi-Get API——多文档获取API。（10）ReIndex API——重新索引API。（11）Update By Query API——查询更新API。（12）Delete By Query API——查询删除API。（13）Multi Term Vectors API——多词条向量API。

其中，前7项较为简单，后6项较为复杂，因此我们将用两章介绍这些API的使用。

文档

在Elasticsearch中，使用JavaScript对象符号（JavaScript Object Notation），作为文档序列化格式，也就是我们常说的JSON。JSON对象由键值对组成，键（key）是字段或属性名称，值（value）可以是多种类型，如字符串、数字、布尔值、一个对象、值数组、日期的字符串、地理位置对象等。

例如：

在Elasticsearch中，存储并索引的JSON数据被称为文档，文档会以唯一ID进行标识并存储于Elasticsearch中。文档不仅有自身的键值对数据信息，还包含了元数据，即关于文档的信息。

文档一般包含三个必需的元数据信息：

（1）index：文档存储的数据结构，即索引。

（2）type：文档代表的对象类型。

（3）ID：文档的唯一标识。

index表示的是索引。这有点类似于开发人员常用的关系数据库中的“数据库”的概念，索引表示的是Elasticsearch存储和索引关联数据的数据结构。需要指出的是，文档数据最终是被存储和索引在分片中的，索引多个分片存储的逻辑空间。

type表示的是文档代表的对象类型。在实际使用时，type的命名是有一定规范的，名字中的字母可以是大写，也可以是小写；但不能包含下画线或逗号。

id表示的是文档的唯一标识，如ID，文档标识会以字符串形式出现。当在Elasticsearch中创建一个文档时，用户既可以自定义id，也可以让Elasticsearch自动生成。

id、index和type三个元素组合使用时，可以在Elasticsearch中唯一标识一个文档。

文档操作

Elasticsearch是面向文档的，它可以存储整个文档。但Elasticsearch对文档的操作不仅限于存储，Elasticsearch还会索引每个文档的内容使之可以被搜索。在Elasticsearch中，用户可以对文档数据进行索引、搜索、排序和过滤等操作，而这也是Elasticsearch能够执行复杂的全文搜索的原因之一。下面一一介绍在Elasticsearch中对文档操作的各类API。

文档索引操作

1-构建请求

es新增文档案例：_doc是默认的文档类型，es7之后去除文档类型概念。

    构建请求时，设置文档通过其index、type和ID确定其唯一存储所在。对于ID，用户可以自己提供一个ID，或者使用索引API自动生成。在IndexRequest中，除三个必选参数外，还有一些可选参数。可选参数包含路由、超时时间、版本、版本类型和索引管道名称等。

2-执行索引文档请求

    在JSON文档构建后，即可执行索引文档请求。在Elasticsearch中，索引文档有两种方式，即同步方式和异步方式。

    同步方式 以同步方式执行IndexRequest时，客户端必须等待返回结果IndexResponse。在收到IndexResponse之后，客户端方可继续执行代码。

                    restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);

    异步方式 当以异步方式执行IndexRequest时，高级客户端不必同步等待请求结果的返回，可以直接向接口调用方返回异步接口执行成功的结果。为了处理异步返回的响应信息或处理在请求执行过程中引发的异常信息，用户需要指定监听器ActionListener。如果请求执行成功，则调用ActionListener中的onResponse方法进行相应逻辑的处理。如果请求执行失败，则调用ActionListener中的onFailure方法进行相应逻辑的处理。

                    restHighLevelClient.indexAsync(indexRequest, RequestOptions.DEFAULT, actionListener);

具体代码：

  1. import org.apache.http.HttpHost;
  2. import org.elasticsearch.action.ActionListener;
  3. import org.elasticsearch.action.DocWriteRequest;
  4. import org.elasticsearch.action.index.IndexRequest;
  5. import org.elasticsearch.action.index.IndexResponse;
  6. import org.elasticsearch.action.support.WriteRequest;
  7. import org.elasticsearch.client.RequestOptions;
  8. import org.elasticsearch.client.RestClient;
  9. import org.elasticsearch.client.RestHighLevelClient;
  10. import org.elasticsearch.common.unit.TimeValue;
  11. import org.elasticsearch.common.xcontent.XContentType;
  12. import org.elasticsearch.index.VersionType;
  13. import org.springframework.web.bind.annotation.RequestMapping;
  14. import org.springframework.web.bind.annotation.RestController;
  15.  
  16. import javax.annotation.PostConstruct;
  17. import java.io.IOException;
  18.  
  19. @RestController
  20. @RequestMapping(value = "/rest/")
  21. public class EsRestController {
  22.  
  23.     /**
  24.      * 高级客户端
  25.      */
  26.     private RestHighLevelClient restHighLevelClient;
  27.  
  28.     /**
  29.      * 客户端初始化
  30.      */
  31.     @PostConstruct
  32.     public void initClient() {
  33.         restHighLevelClient = new RestHighLevelClient(RestClient.builder(new HttpHost("8.129.210.66", 9200, "http")));
  34.         System.out.println(String.format("客户端初始化 restHighLevelClient=(%s)", restHighLevelClient.toString()));
  35.     }
  36.  
  37.     public void closeEs() {
  38.         try {
  39.             restHighLevelClient.close();
  40.         } catch (IOException e) {
  41.             e.printStackTrace();
  42.             System.out.println(String.format("关闭客户端异常 ex=(%s)", e.getMessage()));
  43.         }
  44.     }
  45.  
  46.     @RequestMapping(value = "/add-index")
  47.     public String addDoc() {
  48.  
  49.         // 1-构建请求
  50.         IndexRequest indexRequest = new IndexRequest("item"); // 设置索引名称
  51.         indexRequest.id("1"); // 设置文档ID
  52.         indexRequest.source("{" + "\"name\": \"商品2\","
  53.                 + "\"price\": \"10\"," + "\"number\": \"10\"" + "}", XContentType.JSON); // 设置文档内容
  54.  
  55.         // 在IndexRequest中，除三个必选参数外，还有一些可选参数。可选参数包含路由、超时时间、版本、版本类型和索引管道名称等
  56.  
  57.         // 设置超时时间
  58.         indexRequest.timeout(TimeValue.timeValueSeconds(1));
  59.         // 设置超时策略
  60.         indexRequest.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);
  61.         // 设置版本 创建的时候不支持设置版本号
  62.         // indexRequest.version(Long.valueOf("1"));
  63.         // 设置版本类型
  64.         // indexRequest.versionType(VersionType.EXTERNAL);
  65.         // 设置操作类型
  66.         indexRequest.opType(DocWriteRequest.OpType.CREATE);
  67.         // 在索引文档之前要执行的接收的管道的名称
  68.         // indexRequest.setPipeline("pipeline");
  69.  
  70.         // 同步
  71.         index(indexRequest);
  72.         // 异步
  73.         // indexAsync(indexRequest);
  74.  
  75.         return null;
  76.     }
  77.  
  78.     /**
  79.      * 异步执行请求
  80.      *
  81.      * @param indexRequest
  82.      */
  83.     private void indexAsync(IndexRequest indexRequest) {
  84.         try {
  85.             ActionListener actionListener = new ActionListener<IndexResponse>() {
  86.                 @Override
  87.                 public void onResponse(IndexResponse indexResponse) {
  88.                     System.out.println("执行成功");
  89.                 }
  90.                 @Override
  91.                 public void onFailure(Exception e) {
  92.                     System.out.println("执行失败 + " + e.getMessage());
  93.                 }
  94.             };
  95.             restHighLevelClient.indexAsync(indexRequest, RequestOptions.DEFAULT, actionListener);
  96.         } catch (Exception e) {
  97.             System.out.println("执行失败1");
  98.         }
  99.     }
  100.  
  101.     /**
  102.      * 同步执行请求
  103.      *
  104.      * @param indexRequest
  105.      */
  106.     private IndexResponse index(IndexRequest indexRequest) {
  107.         try {
  108.             return restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
  109.         } catch (Exception e) {
  110.             System.out.println("执行失败" + e.getMessage());
  111.             return null;
  112.         }
  113.     }
  114.  
  115.  
  116. }

文档索引查询

1-构建文档索引查询请求

在执行文档索引查询请求前，需要构建文档索引查询请求，即GetRequest。GetRequest有两个必选参数，即索引名称和文档ID。

        GetRequest getRequest = new GetRequest("item", "2");

在构建GetRequest的过程中，可以选择其他可选参数进行相应的配置。可选参数有禁用源检索、为特定字段配置源包含关系、为特定字段配置源排除关系、为特定存储字段配置检索、配置路由值、配置偏好值、配置在检索文档之前执行刷新、配置版本号、配置版本类型等

2-执行文档索引查询请求

在GetRequest构建后，即可执行文档索引查询请求。与文档索引请求类似，文档索引查询请求也有同步和异步两种执行方式。

同步方式  当以同步方式执行GetRequest时，客户端会等待Elasticsearch服务器返回的查询结果GetResponse。在收到GetResponse后

        GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);

异步方式 当以异步方式执行GetRequest时，高级客户端不必同步等待请求结果的返回，可以直接向接口调用方返回异步接口执行成功的结果。为了处理异步返回的响应信息或处理在请求执行过程中引发的异常信息，用户需要指定监听器ActionListener。如果请求执行成功，则调用ActionListener中的onResponse方法进行相应逻辑的处理。如果请求执行失败，则调用ActionListener中的onFailure方法进行相应逻辑的处理。

        restHighLevelClient.getAsync(getRequest, RequestOptions.DEFAULT, actionListener);

具体代码

  1. package com.example.luu.es_demo.es;
  2.  
  3.  
  4. import org.apache.http.HttpHost;
  5. import org.elasticsearch.action.ActionListener;
  6. import org.elasticsearch.action.DocWriteRequest;
  7. import org.elasticsearch.action.get.GetRequest;
  8. import org.elasticsearch.action.get.GetRequestBuilder;
  9. import org.elasticsearch.action.get.GetResponse;
  10. import org.elasticsearch.action.index.IndexRequest;
  11. import org.elasticsearch.action.index.IndexResponse;
  12. import org.elasticsearch.action.support.WriteRequest;
  13. import org.elasticsearch.client.RequestOptions;
  14. import org.elasticsearch.client.RestClient;
  15. import org.elasticsearch.client.RestHighLevelClient;
  16. import org.elasticsearch.common.unit.TimeValue;
  17. import org.elasticsearch.common.xcontent.XContentType;
  18. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
  19. import org.springframework.web.bind.annotation.RequestMapping;
  20. import org.springframework.web.bind.annotation.RestController;
  21.  
  22. import javax.annotation.PostConstruct;
  23. import java.io.IOException;
  24.  
  25. @RestController
  26. @RequestMapping(value = "/rest/")
  27. public class EsRestController {
  28.  
  29.     /**
  30.      * 高级客户端
  31.      */
  32.     private RestHighLevelClient restHighLevelClient;
  33.  
  34.     /**
  35.      * 客户端初始化
  36.      */
  37.     @PostConstruct
  38.     public void initClient() {
  39.         restHighLevelClient = new RestHighLevelClient(RestClient.builder(new HttpHost("8.129.210.66", 9200, "http")));
  40.         System.out.println(String.format("客户端初始化 restHighLevelClient=(%s)", restHighLevelClient.toString()));
  41.     }
  42.  
  43.     public void closeEs() {
  44.         try {
  45.             restHighLevelClient.close();
  46.         } catch (IOException e) {
  47.             e.printStackTrace();
  48.             System.out.println(String.format("关闭客户端异常 ex=(%s)", e.getMessage()));
  49.         }
  50.     }
  51.  
  52.  
  53.     @RequestMapping(value = "/query-index")
  54.     public String queryDoc() {
  55.  
  56.         // 1-构建请求
  57.         GetRequest getRequest = new GetRequest("item", "2");
  58.  
  59.         // 在构建GetRequest的过程中，可以选择其他可选参数进行相应的配置。可选参数有禁用源检索、为特定字段配置源包含关系、
  60.         // 为特定字段配置源排除关系、为特定存储字段配置检索、配置路由值、配置偏好值、配置在检索文档之前执行刷新、配置版本号、配置版本类型等
  61.  
  62.         // 同步
  63.         indexGet(getRequest);
  64.         // 异步
  65.         // indexAsyncGet(getRequest);
  66.  
  67.         return null;
  68.     }
  69.  
  70.     /**
  71.      * 异步执行请求
  72.      *
  73.      * @param getRequest
  74.      */
  75.     private void indexAsyncGet(GetRequest getRequest) {
  76.         try {
  77.             ActionListener actionListener = new ActionListener<GetResponse>() {
  78.                 @Override
  79.                 public void onResponse(GetResponse getResponse) {
  80.                     System.out.println("结果" + getResponse.getSourceAsString());
  81.                 }
  82.  
  83.                 @Override
  84.                 public void onFailure(Exception e) {
  85.                     System.out.println("执行失败 + " + e.getMessage());
  86.                 }
  87.             };
  88.             restHighLevelClient.getAsync(getRequest, RequestOptions.DEFAULT, actionListener);
  89.         } catch (Exception e) {
  90.             System.out.println("执行失败" + e.getMessage());
  91.         }
  92.     }
  93.  
  94.     /**
  95.      * 同步执行请求
  96.      *
  97.      * @param getRequest
  98.      */
  99.     private void indexGet(GetRequest getRequest) {
  100.         try {
  101.             GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
  102.             System.out.println("结果" + getResponse.getSourceAsString());
  103.         } catch (IOException e) {
  104.             System.out.println("执行失败" + e.getMessage());
  105.         }
  106.  
  107.     }
  108. }

文档存在性校验

Elasticsearch还提供了校验文档是否存在于某索引中的接口API，即Exists API。当调用该接口时，如果被验证的文档存在，则Exists API会返回true，否则返回false。这个接口特别适合只检查某文档是否存在的场景。

1-构建文档存在性校验请求

Exists API依赖于GetRequest的实例，这点很像文档索引查询API，即Get API。同理，在Exists API中也会支持GetRequest的所有可选参数。由于在Exists API的返回结果中只有布尔型的值，即true或false，因此建议用户关闭提取源和任何存储字段，以使请求的构建是轻量级的。

  1.        // 1-构建请求
  2.        GetRequest getRequest = new GetRequest("item", "2");
  3.        // 禁用提取源
  4.        getRequest.fetchSourceContext(new FetchSourceContext(false));
  5.        // 禁用提取存储字段
  6.        getRequest.storedFields("_none_");

2.执行文档存在性校验请求

在GetRequest构建后，即可执行文档存在性校验请求。与文档索引请求和文档索引查询请求类似，文档存在性校验请求也有同步和异步两种执行方式。

同步方式 当以同步方式执行文档存在性校验请求时，客户端会等待Elasticsearch服务器返回的查询结果。在收到查询结果后，客户端会继续执行相关的逻辑代码。

        Boolean flag = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);

异步方式 当以异步方式执行GetRequest时，高级客户端不必同步等待请求结果的返回，可以直接向接口调用方返回异步接口执行成功的结果。为了处理异步返回的响应信息或处理在请求执行过程中引发的异常信息，用户需要指定监听器ActionListener。在请求执行后，如果请求执行成功，则调用ActionListener类中的onResponse方法进行相关逻辑的处理；如果请求执行失败，则调用ActionListener类中的onFailure方法进行相关逻辑的处理。

        restHighLevelClient.existsAsync(getRequest, RequestOptions.DEFAULT, actionListener);

具体代码

  1. package com.example.luu.es_demo.es;
  2.  
  3.  
  4. import com.sun.org.apache.xpath.internal.operations.Bool;
  5. import org.apache.http.HttpHost;
  6. import org.elasticsearch.action.ActionListener;
  7. import org.elasticsearch.action.DocWriteRequest;
  8. import org.elasticsearch.action.get.GetRequest;
  9. import org.elasticsearch.action.get.GetRequestBuilder;
  10. import org.elasticsearch.action.get.GetResponse;
  11. import org.elasticsearch.action.index.IndexRequest;
  12. import org.elasticsearch.action.index.IndexResponse;
  13. import org.elasticsearch.action.support.WriteRequest;
  14. import org.elasticsearch.client.RequestOptions;
  15. import org.elasticsearch.client.RestClient;
  16. import org.elasticsearch.client.RestHighLevelClient;
  17. import org.elasticsearch.common.unit.TimeValue;
  18. import org.elasticsearch.common.xcontent.XContentType;
  19. import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
  20. import org.springframework.web.bind.annotation.RequestMapping;
  21. import org.springframework.web.bind.annotation.RestController;
  22.  
  23. import javax.annotation.PostConstruct;
  24. import java.io.IOException;
  25.  
  26. @RestController
  27. @RequestMapping(value = "/rest/")
  28. public class EsRestController {
  29.  
  30.     /**
  31.      * 高级客户端
  32.      */
  33.     private RestHighLevelClient restHighLevelClient;
  34.  
  35.     /**
  36.      * 客户端初始化
  37.      */
  38.     @PostConstruct
  39.     public void initClient() {
  40.         restHighLevelClient = new RestHighLevelClient(RestClient.builder(new HttpHost("8.129.210.66", 9200, "http")));
  41.         System.out.println(String.format("客户端初始化 restHighLevelClient=(%s)", restHighLevelClient.toString()));
  42.     }
  43.  
  44.     public void closeEs() {
  45.         try {
  46.             restHighLevelClient.close();
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.             System.out.println(String.format("关闭客户端异常 ex=(%s)", e.getMessage()));
  50.         }
  51.     }
  52.  
  53.     @RequestMapping(value = "/exists-index")
  54.     public String existsDoc() {
  55.  
  56.         // 1-构建请求
  57.         GetRequest getRequest = new GetRequest("item", "2");
  58.  
  59.         // 禁用提取源
  60.         getRequest.fetchSourceContext(new FetchSourceContext(false));
  61.         // 禁用提取存储字段
  62.         getRequest.storedFields("_none_");
  63.  
  64.         // 同步
  65.         indexExist(getRequest);
  66.         // 异步
  67.         indexAsyncExist(getRequest);
  68.  
  69.         return null;
  70.     }
  71.  
  72.     /**
  73.      * 异步执行请求
  74.      *
  75.      * @param getRequest
  76.      */
  77.     private void indexAsyncExist(GetRequest getRequest) {
  78.         try {
  79.             ActionListener actionListener = new ActionListener<Boolean>() {
  80.                 @Override
  81.                 public void onResponse(Boolean exist) {
  82.                     System.out.println("结果" + exist);
  83.                 }
  84.  
  85.                 @Override
  86.                 public void onFailure(Exception e) {
  87.                     System.out.println("执行失败 + " + e.getMessage());
  88.                 }
  89.             };
  90.             restHighLevelClient.existsAsync(getRequest, RequestOptions.DEFAULT, actionListener);
  91.         } catch (Exception e) {
  92.             System.out.println("执行失败" + e.getMessage());
  93.         }
  94.     }
  95.  
  96.     /**
  97.      * 同步执行请求
  98.      *
  99.      * @param getRequest
  100.      */
  101.     private void indexExist(GetRequest getRequest) {
  102.         try {
  103.             Boolean flag = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
  104.             System.out.println("结果" + flag);
  105.         } catch (IOException e) {
  106.             System.out.println("执行失败" + e.getMessage());
  107.         }
  108.  
  109.     }
  110. }

删除文档索引

Elasticsearch提供了在索引中删除文档接口的API。

1-构建删除文档索引

请求在执行删除文档索引请求前，需要构建删除文档索引请求，即DeleteRequest。在DeleteRequest中有两个必选参数，即索引名称和文档ID。

  1. // 1-构建请求
  2. DeleteRequest deleteRequest = new DeleteRequest("item", "2");

在DeleteRequest的构建过程中，可以设置一些可选参数。可选参数有路由设置参数、超时设置参数、刷新策略设置参数、版本设置参数和版本类型设置参数等。

2-执行删除文档索引请求

在DeleteRequest构建后，即可执行删除文档索引请求。与文档索引请求类似，删除文档索引请求也有同步和异步两种执行方式。

同步方式 当以同步方式执行删除文档索引请求时，客户端会等待Elasticsearch服务器返回的查询结果DeleteResponse。在收到DeleteResponse后，客户端继续执行相关的逻辑代码。

DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);

异步方式 当以异步方式执行删除文档索引请求时，高级客户端不必同步等待请求结果的返回，可以直接向接口调用方返回异步接口执行成功的结果。在删除文档索引请求执行后，如果请求执行成功，则调用ActionListener类中的onResponse方法进行相关逻辑的处理；如果请求执行失败，则调用ActionListener类中的onFailure方法进行相关逻辑的处理。

restHighLevelClient.deleteAsync(deleteRequest, RequestOptions.DEFAULT, actionListener);

具体代码：

  1. @RequestMapping(value = "/del-index")
  2.     public String delDoc() {
  3.  
  4.         // 1-构建请求
  5.         DeleteRequest deleteRequest = new DeleteRequest("item", "2");
  6.  
  7.         // 同步
  8.         indexDel(deleteRequest);
  9.         // 异步
  10.         // indexAsyncDel(deleteRequest);
  11.  
  12.         return null;
  13.     }
  14.  
  15.     /**
  16.      * 异步执行请求
  17.      *
  18.      * @param deleteRequest
  19.      */
  20.     private void indexAsyncDel(DeleteRequest deleteRequest) {
  21.         try {
  22.             ActionListener actionListener = new ActionListener<Boolean>() {
  23.                 @Override
  24.                 public void onResponse(Boolean exist) {
  25.                     System.out.println("结果" + exist);
  26.                 }
  27.  
  28.                 @Override
  29.                 public void onFailure(Exception e) {
  30.                     System.out.println("执行失败 + " + e.getMessage());
  31.                 }
  32.             };
  33.             restHighLevelClient.deleteAsync(deleteRequest, RequestOptions.DEFAULT, actionListener);
  34.         } catch (Exception e) {
  35.             System.out.println("执行失败" + e.getMessage());
  36.         }
  37.     }
  38.  
  39.     /**
  40.      * 同步执行请求
  41.      *
  42.      * @param deleteRequest
  43.      */
  44.     private void indexDel(DeleteRequest deleteRequest) {
  45.         try {
  46.             DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
  47.             System.out.println("结果" + deleteResponse);
  48.         } catch (IOException e) {
  49.             System.out.println("执行失败" + e.getMessage());
  50.         }
  51.     }

更新文档索引

Elasticsearch提供了在索引中更新文档接口的API。

1-构建更新文档索引

请求在执行更新索引文档请求前，需要构建更新文档索引请求，即UpdateRequest。UpdateRequest有两个必选参数，即索引名称和文档ID。

  1. // 1-构建请求
  2. UpdateRequest updateRequest = new UpdateRequest("item", "1").doc("{" + "\"name\": \"商品222222住过你家祖国强大\","
  3.         + "\"price\": \"10\"," + "\"number\": \"10\"" + "}", XContentType.JSON);

在构建UpdateRequest的过程中，还需要配置一些可选参数。可选参数有路由设置参数和超时设置参数，另外，还可以配置并发对同一文档更新时的重试次数。此外，用户可以配置启用源检索参数，为特定字段配置源包含关系，为特定字段配置源排除关系。

2-执行更新文档索引请求

在UpdateRequest构建后，即可执行更新文档索引请求。与文档索引请求类似，更新文档索引请求也有同步和异步两种执行方式。

同步方式 当以同步方式执行更新文档索引请求时，客户端会等待Elasticsearch服务器返回的查询结果UpdateResponse。在收到UpdateResponse后，客户端继续执行相关的逻辑代码。

UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);

异步方式 当以异步方式执行UpdateRequest时，高级客户端不必同步等待请求结果的返回，可以直接向接口调用方返回异步接口执行成功的结果。在UpdateRequest执行后，如果请求执行成功，则调用ActionListener类中的onResponse方法执行相关逻辑；如果请求执行失败，则调用ActionListener类中的onFailure方法执行相关逻辑。

restHighLevelClient.updateAsync(updateRequest, RequestOptions.DEFAULT, actionListener);

具体代码

  1.     @RequestMapping(value = "/update-index")
  2.     public String dpdateDoc() {
  3.  
  4.         // 1-构建请求
  5.         UpdateRequest updateRequest = new UpdateRequest("item", "1").doc("{" + "\"name\": \"商品222222住过你家祖国强大\","
  6.                 + "\"price\": \"10\"," + "\"number\": \"10\"" + "}", XContentType.JSON);
  7.  
  8.         // 同步
  9.         indexUpdate(updateRequest);
  10.         // 异步
  11.         // indexAsyncUpdate(updateRequest);
  12.  
  13.         return null;
  14.     }
  15.  
  16.     /**
  17.      * 异步执行请求
  18.      *
  19.      * @param updateRequest
  20.      */
  21.     private void indexAsyncUpdate(UpdateRequest updateRequest) {
  22.         try {
  23.             ActionListener actionListener = new ActionListener<Boolean>() {
  24.                 @Override
  25.                 public void onResponse(Boolean exist) {
  26.                     System.out.println("结果" + exist);
  27.                 }
  28.  
  29.                 @Override
  30.                 public void onFailure(Exception e) {
  31.                     System.out.println("执行失败 + " + e.getMessage());
  32.                 }
  33.             };
  34.             restHighLevelClient.updateAsync(updateRequest, RequestOptions.DEFAULT, actionListener);
  35.         } catch (Exception e) {
  36.             System.out.println("执行失败" + e.getMessage());
  37.         }
  38.     }
  39.  
  40.     /**
  41.      * 同步执行请求
  42.      *
  43.      * @param updateRequest
  44.      */
  45.     private void indexUpdate(UpdateRequest updateRequest) {
  46.         try {
  47.             UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
  48.             System.out.println("结果" + updateResponse);
  49.         } catch (IOException e) {
  50.             System.out.println("执行失败" + e.getMessage());
  51.         }
  52.     }

其实高级客户端还提供了很多API，具体的我们可以查看文档进行使用，主要我们还是需要了解es的特性。

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/319329
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号