import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
/**
 * 索引的相关操作
 *
 * @param indicesAdminClient
 * @param indexName
 * @throws IOException
 */
private static void indexConfig(IndicesAdminClient indicesAdminClient, String indexName) throws IOException {
    //settings 设置
    String settings = getIndexSetting();
    // PUT /my_temp_index/_settings updatesettings
    showIndexSettings(indicesAdminClient,indexName);
    UpdateSettingsResponse updateSettingsResponse = indicesAdminClient.prepareUpdateSettings(indexName).setSettings(settings).execute().actionGet();
    log.info("更新 index setting:{}", updateSettingsResponse);


    //更新索引settings之前要关闭索引
    indicesAdminClient.close(new CloseIndexRequest().indices(indexName)).actionGet();
    //配置拼音自定义分析器
    indicesAdminClient.prepareUpdateSettings(indexName).setSettings(getIndexPinYinSetting()).execute().actionGet();
    //自定义分析器
    indicesAdminClient.prepareUpdateSettings(indexName).setSettings(getIndexDemoSetting()).execute().actionGet();
    //打开索引
    indicesAdminClient.open(new OpenIndexRequest().indices(indexName)).actionGet();

    //索引别名映射
    createAliasIndex(indicesAdminClient);

    showIndexSettings(indicesAdminClient,indexName);
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    OpenIndexRequest openIndexRequest = new OpenIndexRequest(Strings.splitStringByCommaToArray(request.param("index")));
    openIndexRequest.timeout(request.paramAsTime("timeout", openIndexRequest.timeout()));
    openIndexRequest.masterNodeTimeout(request.paramAsTime("master_timeout", openIndexRequest.masterNodeTimeout()));
    openIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, openIndexRequest.indicesOptions()));
    return channel -> client.admin().indices().open(openIndexRequest, new AcknowledgedRestListener<OpenIndexResponse>(channel));
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
public void testOpenIndex() {
    interceptTransportActions(OpenIndexAction.NAME);

    OpenIndexRequest openIndexRequest = new OpenIndexRequest(randomUniqueIndicesOrAliases());
    internalCluster().coordOnlyNodeClient().admin().indices().open(openIndexRequest).actionGet();

    clearInterceptedActions();
    assertSameIndices(openIndexRequest, OpenIndexAction.NAME);
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
    OpenIndexRequest openIndexRequest = new OpenIndexRequest(Strings.splitStringByCommaToArray(request.param("index")));
    openIndexRequest.timeout(request.paramAsTime("timeout", openIndexRequest.timeout()));
    openIndexRequest.masterNodeTimeout(request.paramAsTime("master_timeout", openIndexRequest.masterNodeTimeout()));
    openIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, openIndexRequest.indicesOptions()));
    client.admin().indices().open(openIndexRequest, new AcknowledgedRestListener<OpenIndexResponse>(channel));
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
@Test
public void should_open_index() throws Exception {
    CloseIndexResponse closeIndexResponse = transportClient.admin().indices().close(new CloseIndexRequest(THE_INDEX)).actionGet();
    Assertions.assertThat(closeIndexResponse.isAcknowledged()).isTrue();

    OpenIndexResponse openIndexResponse = httpClient.admin().indices().open(new OpenIndexRequest(THE_INDEX)).get();
    Assertions.assertThat(openIndexResponse.isAcknowledged()).isTrue();

    transportClient.admin().indices().recoveries(new RecoveryRequest(THE_INDEX)).actionGet();
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
@Test
public void should_fail_when_no_index_specified() throws Exception {
    CloseIndexResponse closeIndexResponse = transportClient.admin().indices().close(new CloseIndexRequest(THE_INDEX)).actionGet();
    Assertions.assertThat(closeIndexResponse.isAcknowledged()).isTrue();

    try {
        httpClient.admin().indices().open(new OpenIndexRequest()).get();
    } catch (Exception e) {
        Assertions.assertThat(e).hasMessageContaining("ActionRequestValidationException");
        Assertions.assertThat(e).hasMessageContaining("index is missing");
    }
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
@Override
protected XContentBuilder toXContent(OpenIndexRequest request, OpenIndexResponse response, XContentBuilder builder) throws IOException {
    return builder.startObject()
            .field(Fields.OK, true)
            .field(Fields.ACKNOWLEDGED, response.isAcknowledged())
            .endObject();
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
@Override
public ActionFuture<OpenIndexResponse> open(final OpenIndexRequest request) {
    return execute(OpenIndexAction.INSTANCE, request);
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
public ClusterState openIndices(ClusterState state, OpenIndexRequest request) {
    return execute(transportOpenIndexAction, request, state);
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
/**
 * Boots up a previously closed index
 */
private void bootIndices(Client client) {

  client.admin().indices().open(new OpenIndexRequest(
      Settings.META_INDEX));
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
public void open(OpenIndexRequest request, ActionListener<OpenIndexResponse> listener) {
    openIndexActionHandler.execute(request, listener);
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
public OpenIndexRequestBuilder(Client client, JsonToString<JsonInput> jsonToString, StringToJson<JsonOutput> stringToJson) {
    super(client, new OpenIndexRequest(null), jsonToString, stringToJson);
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
@Override
protected ActionFuture<OpenIndexResponse> doExecute(OpenIndexRequest request) {
    return client.admin().indices().open(request);
}
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
/**
 * Open an index based on the index name.
 *
 * @param request The close index request
 * @return The result future
 * @see org.elasticsearch.client.Requests#openIndexRequest(String)
 */
ActionFuture<OpenIndexResponse> open(OpenIndexRequest request);
 

import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; //导入依赖的package包/类
/**
 * Creates an open index request.
 *
 * @param index The index to open
 * @return The delete index request
 * @see org.elasticsearch.client.IndicesAdminClient#open(org.elasticsearch.action.admin.indices.open.OpenIndexRequest)
 */
public static OpenIndexRequest openIndexRequest(String index) {
    return new OpenIndexRequest(index);
}