Java進階别REST用戶端（The Java High Level REST Client）以後簡稱進階用戶端，内部仍然是基于低級用戶端。它提供了更多的API，接受請求對象作為參數并傳回響應對象，由用戶端自己處理編碼和解碼。
每個API都可以同步或異步調用。 同步方法傳回一個響應對象，而異步方法的名稱以async字尾結尾，需要一個監聽器參數，一旦收到響應或錯誤，就會被通知（由低級用戶端管理的線程池）。
進階用戶端依賴于Elasticsearch core項目。 它接受與TransportClient相同的請求參數并傳回相同的響應對象。
相容性
進階用戶端需要Java 1.8并依賴于Elasticsearch core項目。 用戶端版本需要與Elasticsearch版本相同。 它與TransportClient請求的參數和傳回響應對象相同。 如果您需要将應用程式從TransportClient遷移到新的REST用戶端，請參閱“遷移指南”。
要能夠與Elasticsearch進行通信，主版本号需要一緻，次版本号不必相同，因為它是向前相容的。次版本号小于等于elasticsearch的都可以。這意味着它支援與更高版本的Elasticsearch進行通信。
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隻能被更新的用戶端版本支援。應該在群集中的所有節點都更新到新的主要版本之後，用戶端才更新。
可以在這裡找到進階用戶端的Javadoc。
Maven 倉庫
進階用戶端托管在Maven Central上。所需的最低Java版本是1.8。進階用戶端與Elasticsearch的釋出周期相同。
Maven配置
下面是使用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) {
//引發的異常表示傳回了版本沖突錯誤
}
} 官方文檔：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.2/java-rest-high.html
![k8s部署es叢集和kibana[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)