使用Java High Level REST Client操做elasticsearch

時間 2019-11-11

標籤使用 java high level rest client elasticsearch 欄目 Java 简体版

原文原文鏈接

Java高級別REST客戶端（The Java High Level REST Client）之後簡稱高級客戶端，內部仍然是基於低級客戶端。它提供了更多的API，接受請求對象做爲參數並返回響應對象，由客戶端本身處理編碼和解碼。html

每一個API均可以同步或異步調用。同步方法返回一個響應對象，而異步方法的名稱以async後綴結尾，須要一個監聽器參數，一旦收到響應或錯誤，就會被通知（由低級客戶端管理的線程池）。java

高級客戶端依賴於Elasticsearch core項目。它接受與TransportClient相同的請求參數並返回相同的響應對象。json

兼容性

高級客戶端須要Java 1.8並依賴於Elasticsearch core項目。客戶端版本須要與Elasticsearch版本相同。它與TransportClient請求的參數和返回響應對象相同。若是您須要將應用程序從TransportClient遷移到新的REST客戶端，請參閱「遷移指南」。app

要可以與Elasticsearch進行通訊，主版本號須要一致，次版本號沒必要相同，由於它是向前兼容的。次版本號小於等於elasticsearch的均可以。這意味着它支持與更高版本的Elasticsearch進行通訊。less

6.0客戶端可以與任何6.x Elasticsearch節點通訊，而6.1客戶端確定可以與6.1,6.2和任何後來的6.x版本進行通訊，但與舊版本的Elasticsearch節點通訊時可能會存在不兼容的問題，例如6.1和6.0之間，可能6.1客戶端支持elasticsearch 6.0還沒出來的API。異步

建議在將Elasticsearch集羣升級到新的主要版本時升級高級客戶端，由於REST API中斷更改可能會致使意料以外的結果，具體取決於請求所擊中的節點，以及新添加的API只能被更新的客戶端版本支持。應該在羣集中的全部節點都升級到新的主要版本以後，客戶端才更新。async

能夠在這裏找到高級客戶端的Javadoc。elasticsearch

Maven 倉庫

高級客戶端託管在Maven Central上。所需的最低Java版本是1.8。高級客戶端與Elasticsearch的發佈週期相同。maven

Maven配置ide

下面是使用maven做爲依賴管理器配置依賴項。將如下內容添加到您的pom.xml文件中：

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

Gradle 配置

下面是使用gradle做爲依賴項管理器來配置依賴項。在您的build.gradle中添加如下內容：

dependencies {
    compile 'org.elasticsearch.client:elasticsearch-rest-high-level-client:6.2.3'
}

Lucene Snapshot repository
任何主要版本(像beta版)的第一個版本可能都是在Lucene Snapshot版本之上構建的。在這種狀況下，您將沒法解析客戶端的Lucene依賴關係。

例如，若是您想使用依賴於Lucene 7.0.0-snapshot-00142c9的6.0.0-beta1版本，您必須定義如下repository。

Maven：

<repository>
    <id>elastic-lucene-snapshots</id>
    <name>Elastic Lucene Snapshots</name>
    <url>http://s3.amazonaws.com/download.elasticsearch.org/lucenesnapshots/00142c9</url>
    <releases><enabled>true</enabled></releases>
    <snapshots><enabled>false</enabled></snapshots>
</repository>

Gradle

maven {
    url 'http://s3.amazonaws.com/download.elasticsearch.org/lucenesnapshots/00142c9'
}

Dependencies

高級客戶端依賴於如下部件及其傳遞依賴關係：

org.elasticsearch.client:elasticsearch-rest-client
org.elasticsearch:elasticsearch

初始化

RestHighLevelClient實例須要低級客戶端構建器來構建，以下所示：

RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(
                new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http")));

高級客戶端將在內部建立低級客戶端，用來執行基於提供的構建器的請求，並管理其生命週期。
當再也不須要時，須要關閉高級客戶端實例，以便它所使用的全部資源以及底層的http客戶端實例及其線程獲得正確釋放。能夠經過close方法來完成，該方法將關閉內部的RestClient實例。

client.close();

在有關高級客戶端的其餘文檔中，RestHighLevelClient實例將使用client來代替。

支持的API

Indices APIs

Create Index API

RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http")));

        CreateIndexRequest request = new CreateIndexRequest("twitter_two");//建立索引
        //建立的每一個索引均可以有與之關聯的特定設置。
        request.settings(Settings.builder()
                .put("index.number_of_shards", 3)
                .put("index.number_of_replicas", 2)
        );
        //建立索引時建立文檔類型映射
        request.mapping("tweet",//類型定義
                "  {\n" +
                        "    \"tweet\": {\n" +
                        "      \"properties\": {\n" +
                        "        \"message\": {\n" +
                        "          \"type\": \"text\"\n" +
                        "        }\n" +
                        "      }\n" +
                        "    }\n" +
                        "  }",//類型映射，須要的是一個JSON字符串
                XContentType.JSON);

        //爲索引設置一個別名
        request.alias(
                new Alias("twitter_alias")
        );
        //可選參數
        request.timeout(TimeValue.timeValueMinutes(2));//超時,等待全部節點被確認(使用TimeValue方式)
        //request.timeout("2m");//超時,等待全部節點被確認(使用字符串方式)

        request.masterNodeTimeout(TimeValue.timeValueMinutes(1));//鏈接master節點的超時時間(使用TimeValue方式)
        //request.masterNodeTimeout("1m");//鏈接master節點的超時時間(使用字符串方式)

        request.waitForActiveShards(2);//在建立索引API返回響應以前等待的活動分片副本的數量，以int形式表示。
        //request.waitForActiveShards(ActiveShardCount.DEFAULT);//在建立索引API返回響應以前等待的活動分片副本的數量，以ActiveShardCount形式表示。

        //同步執行
        CreateIndexResponse createIndexResponse = client.indices().create(request);
        //異步執行
        //異步執行建立索引請求須要將CreateIndexRequest實例和ActionListener實例傳遞給異步方法：
        //CreateIndexResponse的典型監聽器以下所示：
        //異步方法不會阻塞並當即返回。
        ActionListener<CreateIndexResponse> listener = new ActionListener<CreateIndexResponse>() {
            @Override
            public void onResponse(CreateIndexResponse createIndexResponse) {
                //若是執行成功，則調用onResponse方法;
            }
            @Override
            public void onFailure(Exception e) {
                //若是失敗，則調用onFailure方法。
            }
        };
        client.indices().createAsync(request, listener);//要執行的CreateIndexRequest和執行完成時要使用的ActionListener

        //返回的CreateIndexResponse容許檢索有關執行的操做的信息，以下所示：
        boolean acknowledged = createIndexResponse.isAcknowledged();//指示是否全部節點都已確認請求
        boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();//指示是否在超時以前爲索引中的每一個分片啓動了必需的分片副本數

Delete Index API

 RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http")));

        DeleteIndexRequest request = new DeleteIndexRequest("twitter_two");//指定要刪除的索引名稱
        //可選參數：
        request.timeout(TimeValue.timeValueMinutes(2)); //設置超時，等待全部節點確認索引刪除（使用TimeValue形式）
        // request.timeout("2m"); //設置超時，等待全部節點確認索引刪除（使用字符串形式）

        request.masterNodeTimeout(TimeValue.timeValueMinutes(1));////鏈接master節點的超時時間(使用TimeValue方式)
        // request.masterNodeTimeout("1m");//鏈接master節點的超時時間(使用字符串方式)

        //設置IndicesOptions控制如何解決不可用的索引以及如何擴展通配符表達式
        request.indicesOptions(IndicesOptions.lenientExpandOpen());

        //同步執行
        DeleteIndexResponse deleteIndexResponse = client.indices().delete(request);

  /*    //異步執行刪除索引請求須要將DeleteIndexRequest實例和ActionListener實例傳遞給異步方法：
        //DeleteIndexResponse的典型監聽器以下所示：
        //異步方法不會阻塞並當即返回。
        ActionListener<DeleteIndexResponse> listener = new ActionListener<DeleteIndexResponse>() {
            @Override
            public void onResponse(DeleteIndexResponse deleteIndexResponse) {
                //若是執行成功，則調用onResponse方法;
            }

            @Override
            public void onFailure(Exception e) {
                //若是失敗，則調用onFailure方法。
            }
        };
        client.indices().deleteAsync(request, listener);*/

        //Delete Index Response
        //返回的DeleteIndexResponse容許檢索有關執行的操做的信息，以下所示：
        boolean acknowledged = deleteIndexResponse.isAcknowledged();//是否全部節點都已確認請求


        //若是找不到索引，則會拋出ElasticsearchException：
        try {
            request = new DeleteIndexRequest("does_not_exist");
            client.indices().delete(request);
        } catch (ElasticsearchException exception) {
            if (exception.status() == RestStatus.NOT_FOUND) {
                //若是沒有找到要刪除的索引，要執行某些操做
            }
        }

Open Index API

  RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http")));

        OpenIndexRequest request = new OpenIndexRequest("twitter");//打開索引
        //可選參數：
        request.timeout(TimeValue.timeValueMinutes(2)); //設置超時，等待全部節點確認索引已打開（使用TimeValue形式）
        // request.timeout("2m"); //設置超時，等待全部節點確認索引已打開（使用字符串形式）

        request.masterNodeTimeout(TimeValue.timeValueMinutes(1));////鏈接master節點的超時時間(使用TimeValue方式)
        // request.masterNodeTimeout("1m");//鏈接master節點的超時時間(使用字符串方式)

        request.waitForActiveShards(2);//在打開索引API返回響應以前等待的活動分片副本的數量，以int形式表示。
        //request.waitForActiveShards(ActiveShardCount.ONE);//在打開索引API返回響應以前等待的活動分片副本的數量，以ActiveShardCount形式表示。

        //設置IndicesOptions控制如何解決不可用的索引以及如何擴展通配符表達式
        request.indicesOptions(IndicesOptions.strictExpandOpen());

        //同步執行
        OpenIndexResponse openIndexResponse = client.indices().open(request);

        /*//異步執行打開索引請求須要將OpenIndexRequest實例和ActionListener實例傳遞給異步方法：
        //OpenIndexResponse的典型監聽器以下所示：
        //異步方法不會阻塞並當即返回。
        ActionListener<OpenIndexResponse> listener = new ActionListener<OpenIndexResponse>() {
            @Override
            public void onResponse(OpenIndexResponse openIndexResponse) {
                //若是執行成功，則調用onResponse方法;
            }

            @Override
            public void onFailure(Exception e) {
                //若是失敗，則調用onFailure方法。
            }
        };
        client.indices().openAsync(request, listener);*/

        //Open Index Response
        //返回的OpenIndexResponse容許檢索有關執行的操做的信息，以下所示：
        boolean acknowledged = openIndexResponse.isAcknowledged();//指示是否全部節點都已確認請求
        boolean shardsAcknowledged = openIndexResponse.isShardsAcknowledged();//指示是否在超時以前爲索引中的每一個分片啓動了必需的分片副本數

Close Index API

 RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http")));
        CloseIndexRequest request = new CloseIndexRequest("index");//關閉索引

        //可選參數：
        request.timeout(TimeValue.timeValueMinutes(2)); //設置超時，等待全部節點確認索引已關閉（使用TimeValue形式）
        // request.timeout("2m"); //設置超時，等待全部節點確認索引已關閉（使用字符串形式）

        request.masterNodeTimeout(TimeValue.timeValueMinutes(1));////鏈接master節點的超時時間(使用TimeValue方式)
        // request.masterNodeTimeout("1m");//鏈接master節點的超時時間(使用字符串方式)

        //設置IndicesOptions控制如何解決不可用的索引以及如何擴展通配符表達式
        request.indicesOptions(IndicesOptions.lenientExpandOpen());
        //同步執行
        CloseIndexResponse closeIndexResponse = client.indices().close(request);

         /*//異步執行打開索引請求須要將CloseIndexRequest實例和ActionListener實例傳遞給異步方法：
        //CloseIndexResponse的典型監聽器以下所示：
        //異步方法不會阻塞並當即返回。
        ActionListener<CloseIndexResponse> listener = new ActionListener<CloseIndexResponse>() {
            @Override
            public void onResponse(CloseIndexResponse closeIndexResponse) {
                 //若是執行成功，則調用onResponse方法;
            }

            @Override
            public void onFailure(Exception e) {
                 //若是失敗，則調用onFailure方法。
            }
        };
        client.indices().closeAsync(request, listener); */

        //Close Index Response
        //返回的CloseIndexResponse 容許檢索有關執行的操做的信息，以下所示：
        boolean acknowledged = closeIndexResponse.isAcknowledged(); //指示是否全部節點都已確認請求

Single document APIs

Index API

RestHighLevelClient client = new RestHighLevelClient(
               RestClient.builder(
                       new HttpHost("localhost", 9200, "http"),
                       new HttpHost("localhost", 9201, "http")));
       IndexRequest indexRequest1 = new IndexRequest(
               "posts",//索引名稱
               "doc",//類型名稱
               "1");//文檔ID

       //==============================提供文檔源========================================
       //方式1：以字符串形式提供
       String jsonString = "{" +
               "\"user\":\"kimchy\"," +
               "\"postDate\":\"2013-01-30\"," +
               "\"message\":\"trying out Elasticsearch\"" +
               "}";
       indexRequest1.source(jsonString, XContentType.JSON);

       //方式2：以Map形式提供
       Map<String, Object> jsonMap = new HashMap<>();
       jsonMap.put("user", "kimchy");
       jsonMap.put("postDate", new Date());
       jsonMap.put("message", "trying out Elasticsearch");
       //Map會自動轉換爲JSON格式的文檔源
       IndexRequest indexRequest2 = new IndexRequest("posts", "doc", "1")
               .source(jsonMap);

       // 方式3：文檔源以XContentBuilder對象的形式提供，Elasticsearch內部會幫咱們生成JSON內容

       XContentBuilder builder = XContentFactory.jsonBuilder();
       builder.startObject();
       {
           builder.field("user", "kimchy");
           builder.field("postDate", new Date());
           builder.field("message", "trying out Elasticsearch");
       }
       builder.endObject();
       IndexRequest indexRequest3 = new IndexRequest("posts", "doc", "1")
               .source(builder);

       //方式4：以Object key-pairs提供的文檔源，它會被轉換爲JSON格式
       IndexRequest indexRequest4 = new IndexRequest("posts", "doc", "1")
        .source("user", "kimchy",
               "postDate", new Date(),
               "message", "trying out Elasticsearch");

       //===============================可選參數start====================================
       indexRequest1.routing("routing");//設置路由值
       indexRequest1.parent("parent");//設置parent值

       //設置超時：等待主分片變得可用的時間
       indexRequest1.timeout(TimeValue.timeValueSeconds(1));//TimeValue方式
       indexRequest1.timeout("1s");//字符串方式

       //刷新策略
       indexRequest1.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);//WriteRequest.RefreshPolicy實例方式
       indexRequest1.setRefreshPolicy("wait_for");//字符串方式

       indexRequest1.version(2);//設置版本

       indexRequest1.versionType(VersionType.EXTERNAL);//設置版本類型

       //操做類型
       indexRequest1.opType(DocWriteRequest.OpType.CREATE);//DocWriteRequest.OpType方式
       indexRequest1.opType("create");//字符串方式, 能夠是 create 或 update (默認)

       //The name of the ingest pipeline to be executed before indexing the document
       indexRequest1.setPipeline("pipeline");
       
       //===============================執行====================================
       //同步執行
       IndexResponse indexResponse = client.index(indexRequest1);

       //異步執行
       //IndexResponse 的典型監聽器以下所示：
       //異步方法不會阻塞並當即返回。
       ActionListener<IndexResponse> listener = new ActionListener<IndexResponse>() {
           @Override
           public void onResponse(IndexResponse indexResponse) {
                //執行成功時調用。 Response以參數方式提供
           }

           @Override
           public void onFailure(Exception e) {
               //在失敗的狀況下調用。 引起的異常以參數方式提供
           }
       };
       //異步執行索引請求須要將IndexRequest實例和ActionListener實例傳遞給異步方法：
       client.indexAsync(indexRequest2, listener);

       //Index Response
       //返回的IndexResponse容許檢索有關執行操做的信息，以下所示：
       String index = indexResponse.getIndex();
       String type = indexResponse.getType();
       String id = indexResponse.getId();
       long version = indexResponse.getVersion();
       if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
            //處理（若是須要）第一次建立文檔的狀況
       } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
            //處理（若是須要）文檔被重寫的狀況
       }
       ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
       if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
            //處理成功分片數量少於總分片數量的狀況
       }
       if (shardInfo.getFailed() > 0) {
           for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {
               String reason = failure.reason();//處理潛在的失敗
           }
       }

       //若是存在版本衝突，則會拋出ElasticsearchException：
       IndexRequest request = new IndexRequest("posts", "doc", "1")
               .source("field", "value")
               .version(1);
       try {
           IndexResponse response = client.index(request);
       } catch(ElasticsearchException e) {
           if (e.status() == RestStatus.CONFLICT) {
                //引起的異常表示返回了版本衝突錯誤
           }
       }

       //若是opType設置爲建立可是具備相同索引，類型和ID的文檔已存在，則也會發生一樣的狀況：
       request = new IndexRequest("posts", "doc", "1")
               .source("field", "value")
               .opType(DocWriteRequest.OpType.CREATE);
       try {
           IndexResponse response = client.index(request);
       } catch(ElasticsearchException e) {
           if (e.status() == RestStatus.CONFLICT) {
                //引起的異常表示返回了版本衝突錯誤
           }
       }

Get API

RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http")));

        GetRequest getRequest = new GetRequest(
                "posts",//索引
                "doc",//類型
                "1");//文檔ID

        //===============================可選參數start====================================
        //禁用_source檢索，默認爲啓用
        getRequest.fetchSourceContext(new FetchSourceContext(false));


        //爲特定字段配置_source_include
        String[] includes = new String[]{"message", "*Date"};
        String[] excludes = Strings.EMPTY_ARRAY;
        FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
        getRequest.fetchSourceContext(fetchSourceContext);

        //爲指定字段配置_source_exclude
        String[] includes1 = Strings.EMPTY_ARRAY;
        String[] excludes1 = new String[]{"message"};
        FetchSourceContext fetchSourceContext1 = new FetchSourceContext(true, includes, excludes);
        getRequest.fetchSourceContext(fetchSourceContext);

        //配置指定stored_fields的檢索（要求字段在映射中單獨存儲）
        getRequest.storedFields("message");
        GetResponse getResponse = client.get(getRequest);
        //檢索message 存儲字段（要求將字段分開存儲在映射中）
        String message = getResponse.getField("message").getValue();

        getRequest.routing("routing");//設置routing值
        getRequest.parent("parent");//設置parent值
        getRequest.preference("preference");//設置preference值
        getRequest.realtime(false);//設置realtime爲false，默認是true
        getRequest.refresh(true);//在檢索文檔以前執行刷新（默認爲false）
        getRequest.version(2);//設置版本
        getRequest.versionType(VersionType.EXTERNAL);//設置版本類型
        //===============================可選參數end====================================

        //同步執行
        GetResponse getResponse1 = client.get(getRequest);


        //異步執行
        //GetResponse 的典型監聽器以下所示：
        //異步方法不會阻塞並當即返回。
        ActionListener<GetResponse> listener = new ActionListener<GetResponse>() {
            @Override
            public void onResponse(GetResponse getResponse) {
                //執行成功時調用。 Response以參數方式提供
            }

            @Override
            public void onFailure(Exception e) {
                //在失敗的狀況下調用。 引起的異常以參數方式提供
            }
        };
        //異步執行獲取索引請求須要將GetRequest 實例和ActionListener實例傳遞給異步方法：
        client.getAsync(getRequest, listener);


        //Get Response
        //返回的GetResponse容許檢索請求的文檔及其元數據和最終存儲的字段。
        String index = getResponse.getIndex();
        String type = getResponse.getType();
        String id = getResponse.getId();
        if (getResponse.isExists()) {
            long version = getResponse.getVersion();
            String sourceAsString = getResponse.getSourceAsString();//檢索文檔(String形式)
            Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();//檢索文檔(Map<String, Object>形式)
            byte[] sourceAsBytes = getResponse.getSourceAsBytes();//檢索文檔（byte[]形式）
        } else {
           /* 處理找不到文檔的狀況。 請注意，儘管返回404狀態碼，
            但返回的是有效的GetResponse，而不是拋出的異常。
            此類Response不包含任何源文檔，而且其isExists方法返回false。*/
        }


        //當針對不存在的索引執行獲取請求時，響應404狀態碼，將引起ElasticsearchException，須要按以下方式處理：
        GetRequest request = new GetRequest("does_not_exist", "doc", "1");
        try {
            GetResponse getResponse2 = client.get(request);
        } catch (ElasticsearchException e) {
            if (e.status() == RestStatus.NOT_FOUND) {
                //處理由於索引不存在而拋出的異常狀況
            }
        }

        //若是請求了特定的文檔版本，而且現有文檔具備不一樣的版本號，則會引起版本衝突：
        try {
            GetRequest request1 = new GetRequest("posts", "doc", "1").version(2);
            GetResponse getResponse3 = client.get(request);
        } catch (ElasticsearchException exception) {
            if (exception.status() == RestStatus.CONFLICT) {
                //引起的異常表示返回了版本衝突錯誤
            }
        }

Delete API

RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http")));

        DeleteRequest request = new DeleteRequest (
                "posts",//索引
                "doc",//類型
                "1");//文檔ID

        //===============================可選參數====================================
        request.routing("routing");//設置routing值
        request.parent("parent");//設置parent值

        //設置超時：等待主分片變得可用的時間
        request.timeout(TimeValue.timeValueMinutes(2));//TimeValue方式
        request.timeout("1s");//字符串方式

        //刷新策略
        request.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);//WriteRequest.RefreshPolicy實例方式
        request.setRefreshPolicy("wait_for");//字符串方式

        request.version(2);//設置版本
        request.versionType(VersionType.EXTERNAL);//設置版本類型

        //同步執行
        DeleteResponse deleteResponse = client.delete(request);


        //異步執行
        //DeleteResponse  的典型監聽器以下所示：
        //異步方法不會阻塞並當即返回。
        ActionListener<DeleteResponse > listener = new ActionListener<DeleteResponse >() {
            @Override
            public void onResponse(DeleteResponse  getResponse) {
                //執行成功時調用。 Response以參數方式提供
            }

            @Override
            public void onFailure(Exception e) {
                //在失敗的狀況下調用。 引起的異常以參數方式提供
            }
        };
        //異步執行獲取索引請求須要將DeleteRequest  實例和ActionListener實例傳遞給異步方法：
        client.deleteAsync(request, listener);

        //Delete Response
        //返回的DeleteResponse容許檢索有關執行操做的信息，以下所示：
        String index = deleteResponse.getIndex();
        String type = deleteResponse.getType();
        String id = deleteResponse.getId();
        long version = deleteResponse.getVersion();
        ReplicationResponse.ShardInfo shardInfo = deleteResponse.getShardInfo();
        if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
            //處理成功分片數量少於總分片數量的狀況
        }
        if (shardInfo.getFailed() > 0) {
            for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {
                String reason = failure.reason();//處理潛在的失敗
            }
        }

        //還能夠檢查文檔是否被找到：
        DeleteRequest request1 = new DeleteRequest("posts", "doc", "does_not_exist");
        DeleteResponse deleteResponse1 = client.delete(request);
        if (deleteResponse.getResult() == DocWriteResponse.Result.NOT_FOUND) {
           //若是找不到要刪除的文檔，執行某些操做
        }

        //若是存在版本衝突，則會拋出ElasticsearchException：
        try {
            DeleteRequest request2 = new DeleteRequest("posts", "doc", "1").version(2);
            DeleteResponse deleteResponse2 = client.delete(request);
        } catch (ElasticsearchException exception) {
            if (exception.status() == RestStatus.CONFLICT) {
                //引起的異常表示返回了版本衝突錯誤
            }
        }

Update API

RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http")));

        UpdateRequest request = new UpdateRequest  (
                "test",//索引
                "_doc",//類型
                "1");//文檔ID

        //更新API容許經過使用腳本或傳遞部分文檔來更新現有文檔。

        //使用腳本
        //方式1：該腳本能夠做爲內聯腳本提供：
        Map<String, Object> parameters = singletonMap("count", 4);//腳本參數
        //使用painless語言和上面的參數建立一個內聯腳本
        Script inline = new Script(ScriptType.INLINE, "painless", "ctx._source.field += params.count", parameters);
        request.script(inline);

        //方式2：引用名稱爲increment-field的腳本,改腳本定義的位置還沒搞清楚。
        Script stored =
                new Script(ScriptType.STORED, null, "increment-field", parameters);
        request.script(stored);

        //只更新部分
        //更新部分文檔時，更新的部分文檔將與現有文檔合併。

        //方式1：使用字符串形式
        UpdateRequest request1 = new UpdateRequest("posts", "doc", "1");
        String jsonString = "{" +
                "\"updated\":\"2017-01-01\"," +
                "\"reason\":\"daily update\"" +
                "}";
        request1.doc(jsonString, XContentType.JSON);

        //方式2：使用Map形式，會被自動轉爲json格式
        Map<String, Object> jsonMap = new HashMap<>();
        jsonMap.put("updated", new Date());
        jsonMap.put("reason", "daily update");
        UpdateRequest request2 = new UpdateRequest("posts", "doc", "1")
                .doc(jsonMap);


        //方式3：使用XContentBuilder形式
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("updated", new Date());
            builder.field("reason", "daily update");
        }
        builder.endObject();
        UpdateRequest request3 = new UpdateRequest("posts", "doc", "1")
                .doc(builder);


        //方式4：使用Object key-pairs形式
        UpdateRequest request4 = new UpdateRequest("posts", "doc", "1")
                .doc("updated", new Date(),
                        "reason", "daily update");


        //若是文檔尚不存在，則可使用upsert方法定義一些將做爲新文檔插入的內容：
        //與部分文檔更新相似，可使用接受String，Map，XContentBuilder或Object key-pairs的方式來定義upsert文檔的內容。
        String jsonString1 = "{\"created\":\"2017-01-01\"}";
        request.upsert(jsonString1, XContentType.JSON);

        //=========================可選參數===========================
        request.routing("routing");//設置routing值
        request.parent("parent");//設置parent值

        //設置超時：等待主分片變得可用的時間
        request.timeout(TimeValue.timeValueSeconds(1));//TimeValue方式
        request.timeout("1s");//字符串方式

        //刷新策略
        request.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);//WriteRequest.RefreshPolicy實例方式
        request.setRefreshPolicy("wait_for");//字符串方式

        //若是要更新的文檔在獲取或者索引階段已被另外一操做更改，則重試更新操做的次數
        request.retryOnConflict(3);

        request.version(2);//設置版本

        request.fetchSource(true); //啓用_source檢索，默認爲禁用

        //爲特定字段配置_source_include
        String[] includes = new String[]{"updated", "r*"};
        String[] excludes = Strings.EMPTY_ARRAY;
        request.fetchSource(new FetchSourceContext(true, includes, excludes));

        //爲指定字段配置_source_exclude
        String[] includes1 = Strings.EMPTY_ARRAY;
        String[] excludes1 = new String[]{"updated"};
        request.fetchSource(new FetchSourceContext(true, includes1, excludes1));

        request.detectNoop(false);//禁用noop檢測

        //不管文檔是否存在，腳本都必須運行，即若是腳本尚不存在，則腳本負責建立文檔。
        request.scriptedUpsert(true);

        //若是不存在，則代表部分文檔必須用做upsert文檔。
        request.docAsUpsert(true);

        //設置在繼續更新操做以前必須激活的分片副本的數量。
        request.waitForActiveShards(2);
        //使用ActiveShardCount方式，能夠是ActiveShardCount.ALL，ActiveShardCount.ONE或ActiveShardCount.DEFAULT（默認值）
        request.waitForActiveShards(ActiveShardCount.ALL);

        //同步執行
        UpdateResponse updateResponse = client.update(request);


        //異步執行
        //DeleteResponse  的典型監聽器以下所示：
        //異步方法不會阻塞並當即返回。
        ActionListener<UpdateResponse > listener = new ActionListener<UpdateResponse >() {
            @Override
            public void onResponse(UpdateResponse  updateResponse) {
                //執行成功時調用。 Response以參數方式提供
            }

            @Override
            public void onFailure(Exception e) {
                //在失敗的狀況下調用。 引起的異常以參數方式提供
            }
        };
        //異步執行獲取索引請求須要將UpdateRequest  實例和ActionListener實例傳遞給異步方法：
        client.updateAsync(request, listener);

        //Update Response
        //返回的UpdateResponse容許檢索有關執行操做的信息，以下所示：
        String index = updateResponse.getIndex();
        String type = updateResponse.getType();
        String id = updateResponse.getId();
        long version = updateResponse.getVersion();
        if (updateResponse.getResult() == DocWriteResponse.Result.CREATED) {
            //處理第一次建立文檔的狀況（upsert）
        } else if (updateResponse.getResult() == DocWriteResponse.Result.UPDATED) {
            //處理文檔被更新的狀況
        } else if (updateResponse.getResult() == DocWriteResponse.Result.DELETED) {
            //處理文檔已被刪除的狀況
        } else if (updateResponse.getResult() == DocWriteResponse.Result.NOOP) {
            //處理文檔未受更新影響的狀況，即文檔上未執行任何操做（noop）
        }

        //當經過fetchSource方法在UpdateRequest中啓用源檢索時，響應會包含已更新文檔：
        GetResult result = updateResponse.getGetResult();//獲取已更新的文檔
        if (result.isExists()) {
            String sourceAsString = result.sourceAsString();//獲取已更新的文檔源（String方式）
            Map<String, Object> sourceAsMap = result.sourceAsMap();//獲取已更新的文檔源（Map方式）
            byte[] sourceAsBytes = result.source();//獲取已更新的文檔源（byte[]方式）
        } else {
            //處理不返回文檔源的場景（默認就是這種狀況）
        }


        //也能夠檢查分片失敗：
        ReplicationResponse.ShardInfo shardInfo = updateResponse.getShardInfo();
        if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
            //處理成功分片數量少於總分片數量的狀況
        }
        if (shardInfo.getFailed() > 0) {
            for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {
                String reason = failure.reason();//處理潛在的失敗
            }
        }

        //當針對文檔不存在時，響應404狀態碼，將引起ElasticsearchException，須要按以下方式處理：
        UpdateRequest request5 = new UpdateRequest("posts", "type", "does_not_exist").doc("field", "value");
        try {
            UpdateResponse updateResponse5 = client.update(request);
        } catch (ElasticsearchException e) {
            if (e.status() == RestStatus.NOT_FOUND) {
                //處理因爲文檔不存在拋出的異常
            }
        }

        //若是存在版本衝突，則會拋出ElasticsearchException：
        UpdateRequest request6 = new UpdateRequest("posts", "doc", "1")
                .doc("field", "value")
                .version(1);
        try {
            UpdateResponse updateResponse6 = client.update(request);
        } catch(ElasticsearchException e) {
            if (e.status() == RestStatus.CONFLICT) {
                //引起的異常表示返回了版本衝突錯誤
            }
        }