Elasticsearch7.x——High Level REST Client（三）Index APIs

于 2023-10-25 22:49:55 发布
阅读量279 收藏 2
点赞数 1
分类专栏： ElasticSearch 文章标签： elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/134024970
版权

目录

9、Index APIs

9.1、Analyze API

@Test
public void analyze() throws IOException {
    //最简单的形式
    AnalyzeRequest request1 = AnalyzeRequest.withGlobalAnalyzer("english",
            "Some text to analyze", "Some more text to analyze");
    //自定义配置
    //自定义token filter
    Map<String, Object> stopFilter = new HashMap<>();
    stopFilter.put("type", "stop");
    stopFilter.put("stopwords", new String[]{ "to" });
    AnalyzeRequest request2 = AnalyzeRequest.buildCustomAnalyzer("standard")
            .addCharFilter("html_strip")//字符过滤器
            .addTokenFilter("lowercase")//添加一个内置的token filter
            .addTokenFilter(stopFilter)
            .build("<b>Some text to analyze</b>");

    //也可以通过只包含字符过滤器和记号过滤器来构建一个自定义的规范化器:
    AnalyzeRequest request3 = AnalyzeRequest.buildCustomNormalizer()
            .addTokenFilter("lowercase")
            .build("<b>BaR</b>");

    //可以使用在现有索引中定义的分析器来分析文本:
    AnalyzeRequest request4 = AnalyzeRequest.withIndexAnalyzer(
            "my_index",
            "my_analyzer",
            "some text to analyze"
    );

    //可以使用索引中特定字段的映射来分析文本:
    AnalyzeRequest request5 = AnalyzeRequest.withField("my_index", "my_field", "some text to analyze");

    //可选参数
    request1.explain(false);
    request1.attributes("keyword", "type");

    //同步请求
    AnalyzeResponse response = client.indices().analyze(request1, RequestOptions.DEFAULT);

    //异步请求
    client.indices().analyzeAsync(request2, RequestOptions.DEFAULT, new ActionListener<AnalyzeResponse>() {
        @Override
        public void onResponse(AnalyzeResponse analyzeResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //获取Tokens
    List<AnalyzeResponse.AnalyzeToken> tokens = response.getTokens();
    //如果explain被设置为true，那么信息将从detail()方法返回:
    DetailAnalyzeResponse detail = response.detail();

    for (AnalyzeResponse.AnalyzeToken token : tokens) {
        System.out.println(token.getTerm());
    }
    // System.out.println(detail.toString());
}

9.2、Create Index API

@Test
public void create_index() throws IOException {
    //构建createIndex请求
    //方式一：分段构建
    CreateIndexRequest request = new CreateIndexRequest("twitter");

    //settings
    request.settings(Settings.builder()
            .put("index.number_of_shards", 1)
            .put("index.number_of_replicas", 1)
    );

    //mappings
    //第一种方式：通过JSON字符串设置
    request.mapping(
            "{\n" +
                    "  \"properties\": {\n" +
                    "    \"message\": {\n" +
                    "      \"type\": \"text\"\n" +
                    "    }\n" +
                    "  }\n" +
                    "}",
            XContentType.JSON);

    //第二种方式：通过嵌套Map设置
    Map<String, Object> message = new HashMap<>();
    message.put("type", "text");
    Map<String, Object> properties = new HashMap<>();
    properties.put("message", message);
    Map<String, Object> mapping = new HashMap<>();
    mapping.put("properties", properties);
    request.mapping(mapping);

    //第三种方式：通过Elasticsearch内置帮助器生成JSON内容
    XContentBuilder builder = XContentFactory.jsonBuilder();
    builder.startObject();
    {
        builder.startObject("properties");
        {
            builder.startObject("message");
            {
                builder.field("type", "text");
            }
            builder.endObject();
        }
        builder.endObject();
    }
    builder.endObject();
    request.mapping(builder);

    //别名
    request.alias(
            new Alias("twitter_alias")
                    .filter(QueryBuilders.termQuery("user", "kimchy")));


    //方式二：通过JSON字符串整体设置（包括settings,mappings,alias）
    request.source("{\n" +
            "    \"settings\" : {\n" +
            "        \"number_of_shards\" : 1,\n" +
            "        \"number_of_replicas\" : 0\n" +
            "    },\n" +
            "    \"mappings\" : {\n" +
            "        \"properties\" : {\n" +
            "            \"message\" : { \"type\" : \"text\" }\n" +
            "        }\n" +
            "    },\n" +
            "    \"aliases\" : {\n" +
            "        \"twitter_alias\" : {}\n" +
            "    }\n" +
            "}", XContentType.JSON);


    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.waitForActiveShards(ActiveShardCount.from(2));
    request.waitForActiveShards(ActiveShardCount.DEFAULT);

    //同步请求
    CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().createAsync(request, RequestOptions.DEFAULT, new ActionListener<CreateIndexResponse>() {
        @Override
        public void onResponse(CreateIndexResponse createIndexResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //是否所有节点都已确认请求
    boolean acknowledged = createIndexResponse.isAcknowledged();
    //索引中每个分片在超时前是否启动了所需数量的分片拷贝
    boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();
    System.out.println(acknowledged);
    System.out.println(shardsAcknowledged);
}

9.3、Delete Index API

@Test
public void delete_index() throws IOException {
    DeleteIndexRequest request = new DeleteIndexRequest("twitter");
    //可选参数
    request.timeout(TimeValue.timeValueMinutes(2));
    request.timeout("2m");
    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.masterNodeTimeout("1m");
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    AcknowledgedResponse deleteIndexResponse = client.indices().delete(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().deleteAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = deleteIndexResponse.isAcknowledged();
    //如果没有找到索引，将抛出ElasticsearchException
    try {
        DeleteIndexRequest request1 = new DeleteIndexRequest("does_not_exist");
        client.indices().delete(request, RequestOptions.DEFAULT);
    } catch (ElasticsearchException exception) {
        if (exception.status() == RestStatus.NOT_FOUND) {
            System.out.println("index not found!");
        }
    }
}

9.4、Index Exists API

@Test
public void index_exists() throws IOException {
    //高级REST客户端使用GetIndexRequest for Index Exists API。索引名(或索引名)是必需的。
    GetIndexRequest request = new GetIndexRequest("twitter");
    //可选参数
    request.local(false);
    request.humanReadable(true);
    request.includeDefaults(false);
    request.indicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN);

    //同步请求
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().existsAsync(request, RequestOptions.DEFAULT, new ActionListener<Boolean>() {
        @Override
        public void onResponse(Boolean aBoolean) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    System.out.println(exists);
}

9.5、Open Index API

@Test
public void open_index() throws IOException {
    OpenIndexRequest request = new OpenIndexRequest("bank");
    //可选参数
    request.timeout(TimeValue.timeValueMinutes(2));
    request.timeout("2m");
    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.masterNodeTimeout("1m");
    request.waitForActiveShards(2);
    request.waitForActiveShards(ActiveShardCount.DEFAULT);
    request.indicesOptions(IndicesOptions.strictExpandOpen());

    //同步请求
    OpenIndexResponse openIndexResponse = client.indices().open(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().openAsync(request, RequestOptions.DEFAULT, new ActionListener<OpenIndexResponse>() {
        @Override
        public void onResponse(OpenIndexResponse openIndexResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //指示是否所有节点都已确认请求
    boolean acknowledged = openIndexResponse.isAcknowledged();
    //指示索引中每个分片在超时前是否启动了所需数量的分片拷贝
    boolean shardsAcked = openIndexResponse.isShardsAcknowledged();
    System.out.println(acknowledged);
    System.out.println(shardsAcked);
}

9.6、Close Index API

@Test
public void close_index() throws IOException {
    CloseIndexRequest request = new CloseIndexRequest("bank");
    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    AcknowledgedResponse closeIndexResponse = client.indices().close(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().closeAsync(request, RequestOptions.DEFAULT, new ActionListener<CloseIndexResponse>() {
        @Override
        public void onResponse(CloseIndexResponse closeIndexResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    System.out.println(closeIndexResponse);
}

9.7、Shrink Index API

@Test
public void shrink_index() throws IOException {
    //ResizeRequest需要两个字符串参数:源索引和目标索引
    ResizeRequest request = new ResizeRequest("target_index","source_index");
    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.setWaitForActiveShards(2);
    request.setWaitForActiveShards(ActiveShardCount.DEFAULT);
    request.setSettings(Settings.builder()
            .put("index.number_of_shards", 2)//目标索引上的分片数
            .putNull("index.routing.allocation.require._name")//删除从源索引复制的分配需求
            .build());
    List<Alias> list = new ArrayList<>();
    list.add(new Alias("target_alias"));
    request.setAliases(list);//要与目标索引关联的别名

    //同步请求
    ResizeResponse resizeResponse = client.indices().shrink(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().shrinkAsync(request, RequestOptions.DEFAULT, new ActionListener<ResizeResponse>() {
        @Override
        public void onResponse(ResizeResponse resizeResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = resizeResponse.isAcknowledged();
    boolean shardsAcked = resizeResponse.isShardsAcknowledged();
}

9.8、Split Index API

@Test
public void split_index() throws IOException {
    //ResizeRequest需要两个字符串参数：目标索引和源索引
    ResizeRequest request = new ResizeRequest("target_index","source_index");
    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.setWaitForActiveShards(2);
    request.setWaitForActiveShards(ActiveShardCount.DEFAULT);
    request.setSettings(Settings.builder()
            .put("index.number_of_shards", 4).build());
    List<Alias> list = new ArrayList<>();
    list.add(new Alias("target_alias"));
    request.setAliases(list);

    //同步请求
    ResizeResponse resizeResponse = client.indices().split(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().splitAsync(request, RequestOptions.DEFAULT, new ActionListener<ResizeResponse>() {
        @Override
        public void onResponse(ResizeResponse resizeResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = resizeResponse.isAcknowledged();
    boolean shardsAcked = resizeResponse.isShardsAcknowledged();
}

9.9、Clone Index API

@Test
public void clone_index() throws IOException {
    //ResizeRequest需要两个字符串参数:目标索引和源索引
    ResizeRequest request = new ResizeRequest("target_index","source_index");
    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.setWaitForActiveShards(2);
    request.setWaitForActiveShards(ActiveShardCount.DEFAULT);
    request.setSettings(Settings.builder()
            .put("index.number_of_shards", 4).build());
    List<Alias> list = new ArrayList<>();
    list.add(new Alias("target_alias"));
    request.setAliases(list);

    //同步请求
    ResizeResponse resizeResponse = client.indices().clone(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().cloneAsync(request, RequestOptions.DEFAULT, new ActionListener<ResizeResponse>() {
        @Override
        public void onResponse(ResizeResponse resizeResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = resizeResponse.isAcknowledged();
    boolean shardsAcked = resizeResponse.isShardsAcknowledged();
}

9.10、Refresh API

@Test
public void refresh_request() throws IOException {
    //RefreshRequest可以应用于一个或多个索引，甚至可以应用于所有索引
    RefreshRequest request = new RefreshRequest("bank");
    RefreshRequest requestMultiple = new RefreshRequest("index1", "index2");
    RefreshRequest requestAll = new RefreshRequest();

    //可选参数
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    RefreshResponse refreshResponse = client.indices().refresh(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().refreshAsync(request, RequestOptions.DEFAULT, new ActionListener<RefreshResponse>() {
        @Override
        public void onResponse(RefreshResponse refreshResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //刷新请求命中的分片总数
    int totalShards = refreshResponse.getTotalShards();
    //刷新成功的分片数
    int successfulShards = refreshResponse.getSuccessfulShards();
    //刷新失败的分片数
    int failedShards = refreshResponse.getFailedShards();
    //如果在一个或多个分片上操作失败，则列出失败列表
    DefaultShardOperationFailedException[] failures = refreshResponse.getShardFailures();
    System.out.println(totalShards);
    System.out.println(successfulShards);
    System.out.println(failedShards);
}

9.11、Flush API

@Test
public void flush() throws IOException {
    //FlushRequest可以应用于一个或多个索引，甚至可以应用于所有索引
    FlushRequest request = new FlushRequest("bank");
    FlushRequest requestMultiple = new FlushRequest("index1", "index2");
    FlushRequest requestAll = new FlushRequest();
    //可选参数
    request.indicesOptions(IndicesOptions.lenientExpandOpen());
    request.waitIfOngoing(true);
    request.force(true);

    //同步请求
    FlushResponse flushResponse = client.indices().flush(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().flushAsync(request, RequestOptions.DEFAULT, new ActionListener<FlushResponse>() {
        @Override
        public void onResponse(FlushResponse flushResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //刷新请求命中的分片总数
    int totalShards = flushResponse.getTotalShards();
    //已成功刷新的分片数
    int successfulShards = flushResponse.getSuccessfulShards();
    //刷新失败的分片数
    int failedShards = flushResponse.getFailedShards();
    //如果在一个或多个分片上操作失败，则列出失败列表
    DefaultShardOperationFailedException[] failures = flushResponse.getShardFailures();

    System.out.println(totalShards);
    System.out.println(successfulShards);
}

9.12、Flush Synced API

@Test
public void flush_synced() throws IOException {
    //SyncedFlushRequest可以应用于一个或多个索引，甚至可以应用于所有索引
    SyncedFlushRequest request = new SyncedFlushRequest("person");
    SyncedFlushRequest requestMultiple = new SyncedFlushRequest("index1", "index2");
    SyncedFlushRequest requestAll = new SyncedFlushRequest();
    //可选参数
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    SyncedFlushResponse flushSyncedResponse = client.indices().flushSynced(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().flushSyncedAsync(request, RequestOptions.DEFAULT, new ActionListener<SyncedFlushResponse>() {
        @Override
        public void onResponse(SyncedFlushResponse syncedFlushResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //刷新请求命中的分片总数
    int totalShards = flushSyncedResponse.totalShards();
    //已成功刷新的分片数
    int successfulShards = flushSyncedResponse.successfulShards();
    //刷新失败的分片数
    int failedShards = flushSyncedResponse.failedShards();

    for (Map.Entry<String, SyncedFlushResponse.IndexResult> responsePerIndexEntry:
            flushSyncedResponse.getIndexResults().entrySet()) {
        //要计算其结果的索引的名称
        String indexName = responsePerIndexEntry.getKey();
        SyncedFlushResponse.IndexResult indexResult = responsePerIndexEntry.getValue();
        //索引的分片总数
        int totalShardsForIndex = indexResult.totalShards();
        //成功的分片数
        int successfulShardsForIndex = indexResult.successfulShards();
        //失败的分片数
        int failedShardsForIndex = indexResult.failedShards();
        if (failedShardsForIndex > 0) {
            //包含分片相关的信息，如id，状态，版本等，为失败的分片副本。如果整个分片失败，则返回一个空映射。
            for (SyncedFlushResponse.ShardFailure failureEntry: indexResult.failures()) {
                int shardId = failureEntry.getShardId();
                String failureReason = failureEntry.getFailureReason();
                Map<String, Object> routing = failureEntry.getRouting();
            }
        }
    }
}

9.13、Clear Cache API

@Test
public void clear_cache() throws IOException {
    //ClearIndicesCacheRequest可以应用于一个或多个索引，甚至可以应用于所有索引
    ClearIndicesCacheRequest request = new ClearIndicesCacheRequest("person");
    ClearIndicesCacheRequest requestMultiple = new ClearIndicesCacheRequest("index1", "index2");
    ClearIndicesCacheRequest requestAll = new ClearIndicesCacheRequest();
    //可选参数
    request.indicesOptions(IndicesOptions.lenientExpandOpen());
    request.queryCache(true);
    request.fieldDataCache(true);
    request.requestCache(true);
    request.fields("field1", "field2", "field3");

    //同步请求
    ClearIndicesCacheResponse clearCacheResponse = client.indices().clearCache(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().clearCacheAsync(request, RequestOptions.DEFAULT, new ActionListener<ClearIndicesCacheResponse>() {
        @Override
        public void onResponse(ClearIndicesCacheResponse clearIndicesCacheResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //请求命中的分片总数
    int totalShards = clearCacheResponse.getTotalShards();
    //成功的分片数
    int successfulShards = clearCacheResponse.getSuccessfulShards();
    //失败的分片数
    int failedShards = clearCacheResponse.getFailedShards();
    //如果在一个或多个分片上操作失败，则列出失败列表
    DefaultShardOperationFailedException[] failures = clearCacheResponse.getShardFailures();

    //默认情况下，如果没有找到索引，将抛出ElasticsearchException:
    // try {
    //     ClearIndicesCacheRequest request1 = new ClearIndicesCacheRequest("does_not_exist");
    //     client.indices().clearCache(request, RequestOptions.DEFAULT);
    // } catch (ElasticsearchException exception) {
    //     if (exception.status() == RestStatus.NOT_FOUND) {
    //
    //     }
    // }
}

9.14、Force Merge API

@Test
public void force_merge() throws IOException {
    //forcergerequest可以应用于一个或多个索引，甚至可以应用于所有索引
    ForceMergeRequest request = new ForceMergeRequest("index1");
    ForceMergeRequest requestMultiple = new ForceMergeRequest("index1", "index2");
    ForceMergeRequest requestAll = new ForceMergeRequest();
    //可选参数
    request.indicesOptions(IndicesOptions.lenientExpandOpen());
    request.maxNumSegments(1);
    request.onlyExpungeDeletes(true);
    request.flush(true);

    //同步请求
    ForceMergeResponse forceMergeResponse = client.indices().forcemerge(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().forcemergeAsync(request, RequestOptions.DEFAULT, new ActionListener<ForceMergeResponse>() {
        @Override
        public void onResponse(ForceMergeResponse forceMergeResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //命中的分片总数
    int totalShards = forceMergeResponse.getTotalShards();
    //成功的分片数
    int successfulShards = forceMergeResponse.getSuccessfulShards();
    //失败的分片数
    int failedShards = forceMergeResponse.getFailedShards();
    //如果在一个或多个分片上操作失败，则列出失败列表
    DefaultShardOperationFailedException[] failures = forceMergeResponse.getShardFailures();

    //默认情况下，如果没有找到索引，将抛出ElasticsearchException
    // try {
    //     ForceMergeRequest request1 = new ForceMergeRequest("does_not_exist");
    //     client.indices().forcemerge(request, RequestOptions.DEFAULT);
    // } catch (ElasticsearchException exception) {
    //     if (exception.status() == RestStatus.NOT_FOUND) {
    //
    //     }
    // }
}

9.15、Rollover Index API

@Test
public void rollover() throws IOException {
    //RolloverRequest在构造时需要两个字符串参数（别名、新的索引），以及一个或多个决定何时滚转索引的条件
    RolloverRequest request = new RolloverRequest("alias", "index-2");
    //age
    request.addMaxIndexAgeCondition(new TimeValue(7, TimeUnit.DAYS));
    //docs
    request.addMaxIndexDocsCondition(1000);
    //size
    request.addMaxIndexSizeCondition(new ByteSizeValue(5, ByteSizeUnit.GB));

    //可选参数
    request.dryRun(true);
    request.timeout(TimeValue.timeValueMinutes(2));
    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.getCreateIndexRequest().waitForActiveShards(ActiveShardCount.from(2));
    request.getCreateIndexRequest().waitForActiveShards(ActiveShardCount.DEFAULT);
    request.getCreateIndexRequest().settings(Settings.builder()
            .put("index.number_of_shards", 4));
    String mappings = "{\"properties\":{\"field-1\":{\"type\":\"keyword\"}}}";
    request.getCreateIndexRequest().mapping(mappings, XContentType.JSON);
    request.getCreateIndexRequest().alias(new Alias("another_alias"));

    //同步请求
    RolloverResponse rolloverResponse = client.indices().rollover(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().rolloverAsync(request, RequestOptions.DEFAULT, new ActionListener<RolloverResponse>() {
        @Override
        public void onResponse(RolloverResponse rolloverResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //是否所有节点都已确认请求
    boolean acknowledged = rolloverResponse.isAcknowledged();
    //索引中每个分片在超时前是否启动了所需数量的分片拷贝
    boolean shardsAcked = rolloverResponse.isShardsAcknowledged();
    String oldIndex = rolloverResponse.getOldIndex();
    String newIndex = rolloverResponse.getNewIndex();
    boolean isRolledOver = rolloverResponse.isRolledOver();
    boolean isDryRun = rolloverResponse.isDryRun();
    Map<String, Boolean> conditionStatus = rolloverResponse.getConditionStatus();
}

9.16、Put Mapping API

@Test
public void put_mapping() throws IOException {
    PutMappingRequest request = new PutMappingRequest("twitter");

    //提供mapping的源
    //方式一：
    request.source(
            "{\n" +
                    "  \"properties\": {\n" +
                    "    \"message\": {\n" +
                    "      \"type\": \"text\"\n" +
                    "    }\n" +
                    "  }\n" +
                    "}",
            XContentType.JSON);

    //方式二：
    Map<String, Object> jsonMap = new HashMap<>();
    Map<String, Object> message = new HashMap<>();
    message.put("type", "text");
    Map<String, Object> properties = new HashMap<>();
    properties.put("message", message);
    jsonMap.put("properties", properties);
    request.source(jsonMap);

    //方式三：
    XContentBuilder builder = XContentFactory.jsonBuilder();
    builder.startObject();
    {
        builder.startObject("properties");
        {
            builder.startObject("message");
            {
                builder.field("type", "text");
            }
            builder.endObject();
        }
        builder.endObject();
    }
    builder.endObject();
    request.source(builder);

    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));

    //同步请求
    AcknowledgedResponse putMappingResponse = client.indices().putMapping(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().putMappingAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = putMappingResponse.isAcknowledged();
    System.out.println(acknowledged);
}

9.17、Get Mappings API

@Test
public void get_mappings() throws IOException {
    GetMappingsRequest request = new GetMappingsRequest();
    request.indices("twitter");

    //可选参数
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    GetMappingsResponse getMappingResponse = client.indices().getMapping(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().getMappingAsync(request, RequestOptions.DEFAULT, new ActionListener<GetMappingsResponse>() {
        @Override
        public void onResponse(GetMappingsResponse getMappingsResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    Map<String, MappingMetadata> allMappings = getMappingResponse.mappings();
    MappingMetadata indexMapping = allMappings.get("twitter");
    Map<String, Object> mapping = indexMapping.sourceAsMap();
    System.out.println(mapping);
    //{properties={message={type=text}}}
}

9.18、Get Field Mappings API

@Test
public void get_field_mappings() throws IOException {
    GetFieldMappingsRequest request = new GetFieldMappingsRequest();
    request.indices("twitter");
    request.fields("message", "timestamp");

    //可选参数
    request.indicesOptions(IndicesOptions.lenientExpandOpen());
    request.local(true);

    //同步请求
    GetFieldMappingsResponse response = client.indices().getFieldMapping(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().getFieldMappingAsync(request, RequestOptions.DEFAULT, new ActionListener<GetFieldMappingsResponse>() {
        @Override
        public void onResponse(GetFieldMappingsResponse getFieldMappingsResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //返回所有请求的索引字段的映射
    final Map<String, Map<String, GetFieldMappingsResponse.FieldMappingMetadata>> mappings = response.mappings();
    //检索特定索引的映射
    final Map<String, GetFieldMappingsResponse.FieldMappingMetadata> fieldMappings = mappings.get("twitter");
    //获取消息字段的映射元数据
    final GetFieldMappingsResponse.FieldMappingMetadata metadata = fieldMappings.get("message");
    //获取字段的全名
    final String fullName = metadata.fullName();
    //获取字段的映射源
    final Map<String, Object> source = metadata.sourceAsMap();
    System.out.println(source);
    //{message={type=text}}
}

9.19、Index Aliases API

Index Aliases API允许使用名称对索引进行别名，所有API都会自动将别名转换为实际索引名称。

@Test
public void index_aliases() throws IOException {
    //IndicesAliasesRequest必须至少有一个AliasActions
    IndicesAliasesRequest request = new IndicesAliasesRequest();
    //别名alias1指向index1
    IndicesAliasesRequest.AliasActions aliasAction =
            new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.ADD)
                    .index("person")
                    .alias("p");
    request.addAliasAction(aliasAction);

    //支持以下操作类型:
    //add：添加别名
    //remove：删除别名
    //remove_index：删除索引。
    IndicesAliasesRequest.AliasActions addIndexAction =
            new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.ADD)
                    .index("index1")
                    .alias("alias1")
                    .filter("{\"term\":{\"year\":2016}}");//过滤器
    IndicesAliasesRequest.AliasActions addIndicesAction =
            new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.ADD)
                    .indices("index1", "index2")
                    .alias("alias2")
                    .routing("1");//路由
    IndicesAliasesRequest.AliasActions removeAction =
            new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.REMOVE)
                    .index("index3")
                    .alias("alias3");
    IndicesAliasesRequest.AliasActions removeIndexAction =
            new IndicesAliasesRequest.AliasActions(IndicesAliasesRequest.AliasActions.Type.REMOVE_INDEX)
                    .index("index4");

    //可选参数
    request.timeout(TimeValue.timeValueMinutes(2));
    request.timeout("2m");
    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.masterNodeTimeout("1m");

    //同步请求
    AcknowledgedResponse indicesAliasesResponse =
            client.indices().updateAliases(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().updateAliasesAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = indicesAliasesResponse.isAcknowledged();
    System.out.println(acknowledged);
}

9.20、Delete Alias API

@Test
public void delete_alias() throws IOException {
    //DeleteAliasRequest需要一个索引和一个别名参数
    DeleteAliasRequest request = new DeleteAliasRequest("person", "p");

    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));

    //同步请求
    org.elasticsearch.client.core.AcknowledgedResponse deleteAliasResponse = client.indices().deleteAlias(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().deleteAliasAsync(request, RequestOptions.DEFAULT, new ActionListener<org.elasticsearch.client.core.AcknowledgedResponse>() {
        @Override
        public void onResponse(org.elasticsearch.client.core.AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = deleteAliasResponse.isAcknowledged();
    System.out.println(acknowledged);
}

9.21、Exists Alias API

@Test
public void exists_alias() throws IOException {
    //Exists Alias API使用GetAliasesRequest作为它的请求对象。
    //一个或多个别名可以在构造时可选地提供，也可以稍后通过相关的setter方法提供。
    GetAliasesRequest request = new GetAliasesRequest();
    GetAliasesRequest requestWithAlias = new GetAliasesRequest("alias1");
    GetAliasesRequest requestWithAliases = new GetAliasesRequest(new String[]{"alias1", "alias2"});

    //可选参数
    request.aliases("alias");
    request.indices("index");
    request.indicesOptions(IndicesOptions.lenientExpandOpen());
    request.local(true);

    //同步请求
    boolean exists = client.indices().existsAlias(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().existsAliasAsync(request, RequestOptions.DEFAULT, new ActionListener<Boolean>() {
        @Override
        public void onResponse(Boolean aBoolean) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    System.out.println(exists);
}

9.22、Get Alias API

@Test
public void get_alisa() throws IOException {
    //获取别名API使用GetAliasesRequest作为它的请求对象。
    //一个或多个别名可以在构造时可选地提供，也可以稍后通过相关的setter方法提供。
    GetAliasesRequest request = new GetAliasesRequest();
    GetAliasesRequest requestWithAlias = new GetAliasesRequest("alias1");
    GetAliasesRequest requestWithAliases = new GetAliasesRequest(new String[]{"alias1", "alias2"});

    //可选参数
    request.aliases("alias");
    request.indices("index");
    request.indicesOptions(IndicesOptions.lenientExpandOpen());
    request.local(true);

    //同步请求
    GetAliasesResponse response = client.indices().getAlias(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().getAliasAsync(request, RequestOptions.DEFAULT, new ActionListener<GetAliasesResponse>() {
        @Override
        public void onResponse(GetAliasesResponse getAliasesResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    Map<String, Set<AliasMetadata>> aliases = response.getAliases();
}

9.23、Update Indices Settings API

@Test
public void update_indices_settings() throws IOException {
    UpdateSettingsRequest request = new UpdateSettingsRequest("index1");
    UpdateSettingsRequest requestMultiple = new UpdateSettingsRequest("index1", "index2");
    UpdateSettingsRequest requestAll = new UpdateSettingsRequest();

    //settings
    //第一种方式：
    String settingKey = "index.number_of_replicas";
    int settingValue = 0;
    Settings settings = Settings.builder()
                    .put(settingKey, settingValue)
                    .build();

    //第二种方式：
    Settings.Builder settingsBuilder = Settings.builder()
                    .put(settingKey, settingValue);
    request.settings(settingsBuilder);

    //第三种方式：
    request.settings(
            "{\"index.number_of_replicas\": \"2\"}"
            , XContentType.JSON);

    //第四种方式：
    Map<String, Object> map = new HashMap<>();
    map.put(settingKey, settingValue);
    request.settings(map);

    //可选参数
    request.setPreserveExisting(false);
    request.timeout(TimeValue.timeValueMinutes(2));
    request.timeout("2m");
    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.masterNodeTimeout("1m");
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    AcknowledgedResponse updateSettingsResponse = client.indices().putSettings(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().putSettingsAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = updateSettingsResponse.isAcknowledged();
    System.out.println(acknowledged);
}

9.24、Get Settings API

@Test
public void get_settings() throws IOException {
    GetSettingsRequest request = new GetSettingsRequest().indices("person");
    //可选参数
    request.names("index.number_of_shards");
    request.includeDefaults(true);
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    GetSettingsResponse getSettingsResponse = client.indices().getSettings(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().getSettingsAsync(request, RequestOptions.DEFAULT, new ActionListener<GetSettingsResponse>() {
        @Override
        public void onResponse(GetSettingsResponse getSettingsResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //可以直接从响应中以字符串的形式检索特定索引的设置值
    String numberOfShardsString = getSettingsResponse.getSetting("person", "index.number_of_shards");
    //可以检索特定索引的Settings对象，以便进一步检查
    Settings indexSettings = getSettingsResponse.getIndexToSettings().get("person");
    //返回的Settings对象为非String类型提供了方便的方法
    Integer numberOfShards = indexSettings.getAsInt("index.number_of_shards", null);
    System.out.println(numberOfShards);
}

9.25、Put Template API

@Test
public void put_template() throws IOException {
    //PutIndexTemplateRequest指定模板和模式的名称，这些模式控制模板是否应该应用于新索引。
    PutIndexTemplateRequest request = new PutIndexTemplateRequest("my-template");
    request.patterns(Arrays.asList("pattern-1", "log-*"));

    //settings
    request.settings(Settings.builder()
            .put("index.number_of_shards", 3)
            .put("index.number_of_replicas", 1)
    );

    //mappings
    request.mapping(
            "{\n" +
                    "  \"properties\": {\n" +
                    "    \"message\": {\n" +
                    "      \"type\": \"text\"\n" +
                    "    }\n" +
                    "  }\n" +
                    "}",
            XContentType.JSON);

    //aliases
    request.alias(new Alias("twitter_alias").filter(QueryBuilders.termQuery("user", "kimchy")));
    request.alias(new Alias("{index}_alias").searchRouting("xyz"));

    //order
    request.order(20);
    //version
    request.version(4);


    //或者直接提供整个请求体
    request.source("{\n" +
            "  \"index_patterns\": [\n" +
            "    \"log-*\",\n" +
            "    \"pattern-1\"\n" +
            "  ],\n" +
            "  \"order\": 1,\n" +
            "  \"settings\": {\n" +
            "    \"number_of_shards\": 1\n" +
            "  },\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"message\": {\n" +
            "        \"type\": \"text\"\n" +
            "      }\n" +
            "    }\n" +
            "  },\n" +
            "  \"aliases\": {\n" +
            "    \"alias-1\": {},\n" +
            "    \"{index}-alias\": {}\n" +
            "  }\n" +
            "}", XContentType.JSON);


    //可选参数
    request.create(true);
    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.masterNodeTimeout("1m");

    //同步请求
    AcknowledgedResponse putTemplateResponse = client.indices().putTemplate(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().putTemplateAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = putTemplateResponse.isAcknowledged();
    System.out.println(acknowledged);
}

9.26、Validate Query API

@Test
public void validate_query() throws IOException {
    //ValidateQueryRequest需要对查询进行验证的一个或多个索引。如果没有提供索引，则在所有索引上执行请求。
    ValidateQueryRequest request = new ValidateQueryRequest("bank");
    //添加请求
    QueryBuilder builder = QueryBuilders
            .boolQuery()
            .must(QueryBuilders.queryStringQuery("*:*"))
            .filter(QueryBuilders.termQuery("user", "kimchy"));
    request.query(builder);

    //可选参数
    request.explain(true);
    request.allShards(true);
    request.rewrite(true);

    //同步请求
    ValidateQueryResponse response = client.indices().validateQuery(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().validateQueryAsync(request, RequestOptions.DEFAULT, new ActionListener<ValidateQueryResponse>() {
        @Override
        public void onResponse(ValidateQueryResponse validateQueryResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean isValid = response.isValid();
    int totalShards = response.getTotalShards();
    int successfulShards = response.getSuccessfulShards();
    int failedShards = response.getFailedShards();
    if (failedShards > 0) {
        for(DefaultShardOperationFailedException failure: response.getShardFailures()) {
            String failedIndex = failure.index();
            int shardId = failure.shardId();
            String reason = failure.reason();
        }
    }
    for(QueryExplanation explanation: response.getQueryExplanation()) {
        String explanationIndex = explanation.getIndex();
        int shardId = explanation.getShard();
        String explanationString = explanation.getExplanation();
    }
}

9.27、Get Templates API

@Test
public void get_template() throws IOException {
    GetIndexTemplatesRequest request = new GetIndexTemplatesRequest("my-template");
    request = new GetIndexTemplatesRequest("template-1", "template-2");
    request = new GetIndexTemplatesRequest("my-*");
    //可选参数
    request.setMasterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.setMasterNodeTimeout("1m");

    //同步请求
    GetIndexTemplatesResponse getTemplatesResponse = client.indices().getIndexTemplate(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().getIndexTemplateAsync(request, RequestOptions.DEFAULT, new ActionListener<GetIndexTemplatesResponse>() {
        @Override
        public void onResponse(GetIndexTemplatesResponse getIndexTemplatesResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    List<IndexTemplateMetadata> templates = getTemplatesResponse.getIndexTemplates();
    for (IndexTemplateMetadata metadata : templates) {
        System.out.println(metadata.toString());
    }
}

9.28、Templates Exist API

@Test
public void templates_exist() throws IOException {
    IndexTemplatesExistRequest request;
    request = new IndexTemplatesExistRequest("my-template");
    request = new IndexTemplatesExistRequest("template-1", "template-2");
    request = new IndexTemplatesExistRequest("my-*");

    //可选参数
    request.setLocal(true);
    request.setMasterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.setMasterNodeTimeout("1m");

    //同步请求
    boolean exists = client.indices().existsTemplate(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().existsTemplateAsync(request, RequestOptions.DEFAULT, new ActionListener<Boolean>() {
        @Override
        public void onResponse(Boolean aBoolean) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    System.out.println(exists);
}

9.29、Get Index API

@Test
public void get_index() throws IOException {
    GetIndexRequest request = new GetIndexRequest("person");
    //可选参数
    request.includeDefaults(true);
    request.indicesOptions(IndicesOptions.lenientExpandOpen());

    //同步请求
    GetIndexResponse getIndexResponse = client.indices().get(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().getAsync(request, RequestOptions.DEFAULT, new ActionListener<GetIndexResponse>() {
        @Override
        public void onResponse(GetIndexResponse getIndexResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //person的mapping设置
    MappingMetadata indexMappings = getIndexResponse.getMappings().get("person");
    Map<String, Object> indexTypeMappings = indexMappings.getSourceAsMap();
    //person的别名设置
    List<AliasMetadata> indexAliases = getIndexResponse.getAliases().get("person");
    //person分片数
    String numberOfShardsString = getIndexResponse.getSetting("person", "index.number_of_shards");
    //index的settings设置
    Settings indexSettings = getIndexResponse.getSettings().get("person");
    Integer numberOfShards = indexSettings.getAsInt("index.number_of_shards", null);
    TimeValue time = getIndexResponse.getDefaultSettings().get("person")
            .getAsTime("index.refresh_interval", null);
}

9.30、Freeze Index API

@Test
public void freeze_index() throws IOException {
    FreezeIndexRequest request = new FreezeIndexRequest("person");
    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.setWaitForActiveShards(ActiveShardCount.DEFAULT);
    request.setIndicesOptions(IndicesOptions.strictExpandOpen());

    //同步请求
    ShardsAcknowledgedResponse openIndexResponse = client.indices().freeze(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().freezeAsync(request, RequestOptions.DEFAULT, new ActionListener<ShardsAcknowledgedResponse>() {
        @Override
        public void onResponse(ShardsAcknowledgedResponse shardsAcknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = openIndexResponse.isAcknowledged();
    boolean shardsAcked = openIndexResponse.isShardsAcknowledged();
    System.out.println(acknowledged);
    System.out.println(shardsAcked);
}

9.31、Unfreeze Index API

@Test
public void unfreeze_inex() throws IOException {
    UnfreezeIndexRequest request = new UnfreezeIndexRequest("person");
    //可选参数
    request.setTimeout(TimeValue.timeValueMinutes(2));
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));
    request.setWaitForActiveShards(ActiveShardCount.DEFAULT);
    request.setIndicesOptions(IndicesOptions.strictExpandOpen());

    //同步请求
    ShardsAcknowledgedResponse openIndexResponse = client.indices().unfreeze(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().unfreezeAsync(request, RequestOptions.DEFAULT, new ActionListener<ShardsAcknowledgedResponse>() {
        @Override
        public void onResponse(ShardsAcknowledgedResponse shardsAcknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = openIndexResponse.isAcknowledged();
    boolean shardsAcked = openIndexResponse.isShardsAcknowledged();
    System.out.println(acknowledged);
    System.out.println(shardsAcked);
}

9.32、Delete Template API

@Test
public void delete_template() throws IOException {
    DeleteIndexTemplateRequest request = new DeleteIndexTemplateRequest();
    request.name("my-template");

    //同步请求
    AcknowledgedResponse deleteTemplateAcknowledge = client.indices().deleteTemplate(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().deleteTemplateAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = deleteTemplateAcknowledge.isAcknowledged();
    System.out.println(acknowledged);
}

9.33、Reload Search Analyzers API

@Test
public void reload_serach_analyzers() throws IOException {
    ReloadAnalyzersRequest request = new ReloadAnalyzersRequest("person");

    //可选参数
    request.setIndicesOptions(IndicesOptions.strictExpandOpen());

    //同步请求
    ReloadAnalyzersResponse reloadResponse = client.indices().reloadAnalyzers(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().reloadAnalyzersAsync(request, RequestOptions.DEFAULT, new ActionListener<ReloadAnalyzersResponse>() {
        @Override
        public void onResponse(ReloadAnalyzersResponse reloadAnalyzersResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    //碎片的统计数据。请注意，重新加载不是发生在索引的每个分片上，而是发生在索引上有分片的每个节点上。因此，报告的碎片计数可能与索引碎片的数量不同
    BroadcastResponse.Shards shards = reloadResponse.shards();
    //重新加载执行请求的所有索引的详细信息
    Map<String, ReloadAnalyzersResponse.ReloadDetails> reloadDetails = reloadResponse.getReloadedDetails();
    //可以通过索引名称检索详细信息
    ReloadAnalyzersResponse.ReloadDetails details = reloadDetails.get("index");
    //重新加载的索引名
    String indexName = details.getIndexName();
    //重新加载索引的节点
    Set<String> indicesNodes = details.getReloadedIndicesNodes();
    //重新加载的分析器名称
    Set<String> analyzers = details.getReloadedAnalyzers();
}

9.34、Get Composable Index Templates API

Get Index Templates API允许检索一个或多个索引模板的信息。

@Test
public void get_composable_index_templates() throws IOException {
    //GetComposableIndexTemplateRequest需要指定一个，或要获取的索引模板名称的通配符表达式。若要返回所有索引模板，请完全省略名称或使用值*。
    GetComposableIndexTemplateRequest request = new GetComposableIndexTemplateRequest("my-template");
    request = new GetComposableIndexTemplateRequest("my-*");

    //可选参数
    request.setMasterNodeTimeout(TimeValue.timeValueMinutes(1));
    request.setMasterNodeTimeout("1m");

    //同步请求
    GetComposableIndexTemplatesResponse getTemplatesResponse = client.indices().getIndexTemplate(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().getIndexTemplateAsync(request, RequestOptions.DEFAULT, new ActionListener<GetComposableIndexTemplatesResponse>() {
        @Override
        public void onResponse(GetComposableIndexTemplatesResponse getComposableIndexTemplatesResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    Map<String, ComposableIndexTemplate> templates = getTemplatesResponse.getIndexTemplates();
    ComposableIndexTemplate composableIndexTemplate = templates.get("my-template");
    System.out.println(composableIndexTemplate.toString());
}

9.35、Put Composable Index Template API

@Test
public void put_composable_index_template() throws IOException {
    //PutComposableIndexTemplateRequest指定模板的名称和索引模板配置，
    //其中包括控制模板是否应应用于新索引的模式，以及可选的映射、设置和别名配置。
    PutComposableIndexTemplateRequest request = new PutComposableIndexTemplateRequest()
            .name("my-template");
    //创建一个组件模板，指定此模板将匹配的索引名称模式的索引模板配置
    ComposableIndexTemplate composableIndexTemplate = new ComposableIndexTemplate(Arrays.asList("pattern-1", "log-*"), null, null, null, null, null);
    request.indexTemplate(composableIndexTemplate);

    //settings
    PutComposableIndexTemplateRequest request1 = new PutComposableIndexTemplateRequest()
            .name("my-template");
    Settings settings = Settings.builder()
            .put("index.number_of_shards", 3)
            .put("index.number_of_replicas", 1)
            .build();
    Template template1 = new Template(settings, null, null);
    ComposableIndexTemplate composableIndexTemplate1 = new ComposableIndexTemplate(Arrays.asList("pattern-1", "log-*"),
            template1, null, null, null, null);
    request1.indexTemplate(composableIndexTemplate);

    //mappings
    String mappingJson = "{\n" +
            "  \"properties\": {\n" +
            "    \"message\": {\n" +
            "      \"type\": \"text\"\n" +
            "    }\n" +
            "  }\n" +
            "}";
    PutComposableIndexTemplateRequest request2 = new PutComposableIndexTemplateRequest()
            .name("my-template");
    Template template2 = new Template(null, new CompressedXContent(mappingJson), null);
    ComposableIndexTemplate composableIndexTemplate2 = new ComposableIndexTemplate(Arrays.asList("pattern-1", "log-*"),
            template2, null, null, null, null);
    request2.indexTemplate(composableIndexTemplate);

    //aliases
    PutComposableIndexTemplateRequest request3 = new PutComposableIndexTemplateRequest()
            .name("my-template");
    AliasMetadata twitterAlias3 = AliasMetadata.builder("twitter_alias").build();
    AliasMetadata placeholderAlias3 = AliasMetadata.builder("{index}_alias").searchRouting("xyz").build();
    Map<String, AliasMetadata> aliases3 = new HashMap<>();
    aliases3.put("twitter_alias", twitterAlias3);
    aliases3.put("{index}_alias", placeholderAlias3);
    Template template3 = new Template(null, null, aliases3);
    ComposableIndexTemplate composableIndexTemplate3 = new ComposableIndexTemplate(Arrays.asList("pattern-1", "log-*"),
            template3, null, null, null, null);
    request3.indexTemplate(composableIndexTemplate);

    //组件模板可以用作指定映射、设置或别名配置的构建块，但它们不适用于索引本身。
    //要应用于索引，组件模板必须在IndexTemplateV2索引模板定义对象的componentTemplates列表中指定。
    //它们在列表中指定的顺序就是应用组件模板的顺序。
    PutComposableIndexTemplateRequest request4 = new PutComposableIndexTemplateRequest()
            .name("my-template");
    ComposableIndexTemplate composableIndexTemplate4 =
            new ComposableIndexTemplate(Arrays.asList("pattern-1", "log-*"), null,
                    Collections.singletonList("ct1"), null, null, null);
    request4.indexTemplate(composableIndexTemplate);

    //当多个模板匹配一个索引时，匹配模板的优先级决定将应用哪个索引模板。
    //优先级高的索引模板“胜过”优先级低的索引模板。
    PutComposableIndexTemplateRequest request5 = new PutComposableIndexTemplateRequest()
            .name("my-template");
    ComposableIndexTemplate composableIndexTemplate5 = new ComposableIndexTemplate(Arrays.asList("pattern-1", "log-*"),
            null, null, 20L, null, null);
    request5.indexTemplate(composableIndexTemplate);

    //version
    //模板可以选择指定版本号，该版本号可用于简化外部系统对模板的管理。
    PutComposableIndexTemplateRequest request6 = new PutComposableIndexTemplateRequest()
            .name("my-template");
    ComposableIndexTemplate composableIndexTemplate6 = new ComposableIndexTemplate(Arrays.asList("pattern-1", "log-*"),
            null, null, null, 3L, null);
    request6.indexTemplate(composableIndexTemplate);


    //可选参数
    request.create(true);
    request.setMasterTimeout(TimeValue.timeValueMinutes(1));

    //同步请求
    AcknowledgedResponse putTemplateResponse = client.indices().putIndexTemplate(request, RequestOptions.DEFAULT);

    //异步请求
    client.indices().putIndexTemplateAsync(request, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = putTemplateResponse.isAcknowledged();
    System.out.println(acknowledged);
}

9.36、Delete Composable Index Template API

@Test
public void delete_composable_index_template() throws IOException {
    DeleteComposableIndexTemplateRequest deleteRequest = new DeleteComposableIndexTemplateRequest("my-template");

    //同步请求
    AcknowledgedResponse acknowledgedResponse = client.indices().deleteIndexTemplate(deleteRequest, RequestOptions.DEFAULT);
    //异步提交
    client.indices().deleteIndexTemplateAsync(deleteRequest, RequestOptions.DEFAULT, new ActionListener<AcknowledgedResponse>() {
        @Override
        public void onResponse(AcknowledgedResponse acknowledgedResponse) {

        }

        @Override
        public void onFailure(Exception e) {

        }
    });

    //响应
    boolean acknowledged = acknowledgedResponse.isAcknowledged();
    System.out.println(acknowledged);
}
吴声子夜歌
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
elasticsearch-rest-high-level-client-6.8.3-API文档-中文版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar； 赠送Maven依赖信息文件：elasticsearch-rest-high-level-client-6.8.3.pom； 包含翻译后的API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.elasticsearch.client:elasticsearch-rest-high-level-client:6.8.3； 标签：elasticsearch、client、rest、high、level、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵
elasticsearch 6.0java api的使用
star的博客
03-27 3045
elasticsearch 6.0java api的使用转自：https://www.cnblogs.com/liyafei/p/8543309.htmlelasticsearch 6.0 中java api的使用1：使用java api创建elasticsearch客户端      package com.search.elasticsearch; import org.elasticsear...
ElasticSearch学习笔记-JavaAPI操作记录
PURSUE ONE PIECE
11-04 3465
客户端连接代码： ElasticSearch版本：2.4.x <!-- ElasticSearch依赖包--> <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <...
5.索引APIS(一)Index APIs
折剑听雨落
05-26 797
1.Analyze API 分词器API 2. Index 索引API 创建 修改 删除 查找
ElasticSearch实战之JAVA操作(六)
小陈之JAVA
04-12 862
Java操作ES 1.1 引入maven依赖 <dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version>6.2.4</version> ...
一个Json文件让你快速入门 ElasticSearch 7.9.1 API ，速度上手，慢慢了解
巴休特的风之剑
09-23 248
如题，ElasticSearch 实际上就是通过Http请求进行增删改查的数据库。 相信看到这篇文章的人都知道它是用来干啥的，但是很难快速入门，网上都是散乱粘贴的博客。 找起来、整合很费事，也不注明大小版本，经常版本不统一。 所以，我整理了一个postman的导出json，可以帮助未入门者，快速学会ES的增删改查、及常用的搜索代码。 使用方法：另存为静态文件，下载个postman，然后import即可，不多说。 静态文件地址：https://anyongliang.oss-cn-beijin...
SpringBoot知识体系（四）springboot整合Elasticsearch（4）
风雨的博客
10-17 1174
suggest的自动补全与IK分词 AnalyzeRequestBuilder实现IK分词 Java代码 // 调用 IK 分词 AnalyzeRequestBuilder requestBuilder= new AnalyzeRequestBuilder(this.esClient,AnalyzeAction.INSTANCE,INDEX_NAME, “title”, ...
ElasticSearch构建分词与自动补全功能
m0_73414953的博客
05-19 311
standard analyzer是ElasticSearch自带的分词器，可以看出该分词器对大小写不敏感，你输入大写最后也会被转换成小写。我们举一个很常见的例子：当我们在百度中输入字符时，会有一个下拉列表来给出用户提示，这个功能就是自动补全。1. 目前我们只能通过原生API的方式赖进行分词功能的实现，过程比较繁琐，但编写方式统一。实现自动补全功能，该功能同分词一样，使用的是原生API的方式，过程较繁琐，但比较统一。在发送分词请求的时候会抛出一个异常，这里选择lombok下的。接下来就是分词功能的实现了。
elasticsearch获取分词结果
【模棱博客】 – Java技术博客
02-27 9187
原创于 【模棱博客】ES 中默认配置 IK 后，通过 Rest HTTP 的方式我们可以进行得到分词结果。那么在 Spring Boot 和提供的客户端依赖 spring-data-elasticsearch 中如何获取到分词结果。加入依赖 pom.xmlorg.springframework.bootspring-boot-starter-data-elasticsearch在 applicat...
Elasticsearch-RestHighLevelClient基础操作
会走的鱼
07-19 2034
*** 更新索引结构//你已经创建好的索引名称 PutMappingRequest putMappingRequest = new PutMappingRequest(idx);
elasticsearch-rest-high-level-client-6.8.3-API文档-中英对照版.zip
07-13
赠送jar包：elasticsearch-rest-high-level-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-high-level-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-high-level-client-6.8.3-sources.jar；...
elasticsearch-rest-high-level-client-7.5.1.jar
02-24
java运行依赖jar包
elasticsearch-rest-client-6.8.3-API文档-中文版.zip
07-13
赠送jar包：elasticsearch-rest-client-6.8.3.jar； 赠送原API文档：elasticsearch-rest-client-6.8.3-javadoc.jar； 赠送源代码：elasticsearch-rest-client-6.8.3-sources.jar； 赠送Maven依赖信息文件：elastic...
东软单片机-ES7P213x——IIC从机配置.zip
07-03
东软单片机-ES7P213x——IIC从机配置
java 使用RestHighLevelClient获取ES的所有索引名
热门推荐
qq_35164294的博客
05-30 1万+
工作有个业务需求是需要获取ES中的所有索引名，之前是使用TransportClent去获取，但是ES加密了，而且TransportClient官方也不推荐使用，所以用了RestHighLevelClient去获取。 版本如下： jdk版本：1.8 elasticsearch.client版本：6.4.0 附上代码： 这是获取高级客户端的方法 @Getter @Setter private static RestHighLevelClient restClient = null; pu.
springboot 操作es 之elasticsearch-rest-high-level-client
爱钻研的小张
01-19 8835
springboot 操作es 之elasticsearch-rest-high-level-client
SpringBoot整合ElasticSearch
weixin_45818966的博客
07-12 940
关于springboot整合elasticSearch操作
原生语言操作和spring data中RestHighLevelClient操作Elasticsearch，索引，文档的基本操作，es的高级查询.查询结果处理. 数据聚合.相关性系数打分
最新发布
qq_62357662的博客
09-25 3782
​ Elasticsearch 是一个分布式、高扩展、高实时的搜索与数据分析引擎。它能很方便的使大量数据具有搜索、分析和探索的能力。充分利用Elasticsearch的水平伸缩性，能使数据在生产环境变得更有价值。Elasticsearch 的实现原理主要分为以下几个步骤，首先用户将数据提交到Elasticsearch 数据库中，再通过分词控制器去将对应的语句分词，将其权重和分词结果一并存入数据，当用户搜索数据时候，再根据权重将结果排名，打分，再将返回结果呈现给用户。​ RestHighLevelClient
ElasticSearch学习；RestClient 操作索引库；RestClient 查询文档
時間的博客
09-25 2002
docker 中安装 elasticsearch 和 kibana；安装 IK 分词器；正向索引和倒排索引；mapping常见属性有哪些?；索引操作；文档操作；RestClient 操作索引库；RestClient 操作索引；RestClient 操作文档
怎么用Java High Level REST Client 6.2.3的版本查询Elasticsearch 中索引的映射
06-07
使用Java High Level REST Client 6.2.3版本可以通过以下步骤查询Elasticsearch中索引的映射： 1. 创建Elasticsearch客户端： ```java RestHighLevelClient client = new RestHighLevelClient( RestClient.builder( new HttpHost("localhost", 9200, "http"))); ``` 2. 构建获取索引映射的请求： ```java GetMappingsRequest request = new GetMappingsRequest(); request.indices("your_index_name"); ``` 3. 发送请求并处理响应： ```java try { GetMappingsResponse response = client.indices().getMapping(request, RequestOptions.DEFAULT); Map<String, MappingMetaData> mappings = response.mappings(); // 处理Mappings } catch (IOException e) { e.printStackTrace(); } finally { try { client.close(); } catch (IOException e) { e.printStackTrace(); } } ``` 在上面的代码中，我们首先创建了一个Elasticsearch客户端。然后，我们构建了一个获取索引映射的请求，并指定了要获取映射的索引名称。最后，我们发送请求并处理响应。响应中包含了所有映射信息，我们可以从响应中获取映射相关的元数据并进行处理。 需要注意的是，以上代码中的`your_index_name`需要替换为你要查询映射的索引名称。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值