1.项目地址

https://github.com/GuardFTC/elasticsearch-test.git

2.cat常用命令整合

包括查看集群状态，查看集群索引信息、别名信息、节点信息等

  1. import cn.hutool.core.lang.Assert;
  2. import cn.hutool.core.util.ObjectUtil;
  3. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  4. import co.elastic.clients.elasticsearch.cat.*;
  5. import co.elastic.clients.elasticsearch.cat.aliases.AliasesRecord;
  6. import co.elastic.clients.elasticsearch.cat.health.HealthRecord;
  7. import co.elastic.clients.elasticsearch.cat.indices.IndicesRecord;
  8. import co.elastic.clients.elasticsearch.cat.master.MasterRecord;
  9. import co.elastic.clients.elasticsearch.cat.nodes.NodesRecord;
  10. import org.junit.jupiter.api.Test;
  11. import org.springframework.beans.factory.annotation.Qualifier;
  12. import org.springframework.boot.test.context.SpringBootTest;
  14. import javax.annotation.Resource;
  15. import java.io.IOException;
  16. import java.util.List;
  18. @SpringBootTest
  19. class ElasticSearchCatAndClusterTest {
  21.     @Resource
  22.     @Qualifier("primaryElasticsearchClient")
  23.     private ElasticsearchClient primaryClient;
  25.     @Test
  26.     void testCat() throws IOException {
  28.         //1.获取cat客户端
  29.         ElasticsearchCatClient cat = primaryClient.cat();
  31.         //2.获取集群健康状况
  32.         HealthResponse health = cat.health();
  33.         List<HealthRecord> healthRecords = health.valueBody();
  35.         //3.结果校验
  36.         Assert.isTrue(ObjectUtil.isNotNull(healthRecords));
  37.         Assert.isTrue(1 == healthRecords.size());
  38.         HealthRecord healthRecord = healthRecords.get(0);
  39.         Assert.isTrue("ftc-es".equals(healthRecord.cluster()));
  40.         Assert.isTrue("3".equals(healthRecord.nodeTotal()));
  42.         //4.查询主节点信息并校验结果
  43.         MasterResponse master = cat.master();
  44.         List<MasterRecord> masterRecords = master.valueBody();
  45.         Assert.isTrue(ObjectUtil.isNotNull(masterRecords));
  46.         Assert.isTrue(1 == masterRecords.size());
  48.         //5.查询集群节点信息
  49.         NodesResponse nodes = cat.nodes();
  50.         List<NodesRecord> nodesRecords = nodes.valueBody();
  51.         Assert.isTrue(ObjectUtil.isNotNull(nodesRecords));
  52.         Assert.isTrue(3 == nodesRecords.size());
  54.         //6.查询集群别名信息
  55.         AliasesResponse aliases = cat.aliases();
  56.         List<AliasesRecord> aliasesRecords = aliases.valueBody();
  57.         Assert.isTrue(ObjectUtil.isNotNull(aliasesRecords));
  59.         //7.查询集群索引信息
  60.         IndicesResponse indices = cat.indices();
  61.         List<IndicesRecord> indicesRecords = indices.valueBody();
  62.         Assert.isTrue(ObjectUtil.isNotNull(indicesRecords));
  63.     }
  64. }

3.cluster常用命令整合

包括查看集群健康状态，查看集群统计信息，查看集群状态等

  1. import cn.hutool.core.lang.Assert;
  2. import cn.hutool.core.util.ObjectUtil;
  3. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  4. import co.elastic.clients.elasticsearch._types.HealthStatus;
  5. import co.elastic.clients.elasticsearch.cluster.ElasticsearchClusterClient;
  6. import co.elastic.clients.elasticsearch.cluster.StateResponse;
  7. import co.elastic.clients.json.JsonData;
  8. import jakarta.json.JsonObject;
  9. import org.junit.jupiter.api.Test;
  10. import org.springframework.beans.factory.annotation.Qualifier;
  11. import org.springframework.boot.test.context.SpringBootTest;
  13. import javax.annotation.Resource;
  14. import java.io.IOException;
  16. @SpringBootTest
  17. class ElasticSearchCatAndClusterTest {
  19.     @Resource
  20.     @Qualifier("primaryElasticsearchClient")
  21.     private ElasticsearchClient primaryClient;
  23.     @Test
  24.     void testCluster() throws IOException {
  26.         //1.获取cluster客户端
  27.         ElasticsearchClusterClient cluster = primaryClient.cluster();
  29.         //2.查询集群健康状态
  30.         co.elastic.clients.elasticsearch.cluster.HealthResponse health = cluster.health();
  32.         //3.校验集群健康状态信息
  33.         Assert.isTrue(ObjectUtil.isNotNull(health));
  34.         Assert.isTrue("ftc-es".equals(health.clusterName()));
  35.         Assert.isTrue(3 == health.numberOfNodes());
  36.         Assert.isTrue(HealthStatus.Green.jsonValue().equals(health.status().jsonValue()));
  38.         //4.查询集群状态
  39.         StateResponse state = cluster.state();
  40.         JsonData jsonData = state.valueBody();
  42.         //5.校验集群状态
  43.         Assert.isTrue(ObjectUtil.isNotNull(jsonData));
  44.         JsonObject status = jsonData.toJson().asJsonObject();
  45.         Assert.isTrue("ftc-es".equals(status.getString("cluster_name")));
  46.         Assert.isTrue(3 == status.getJsonObject("nodes").size());
  47.     }
  48. }

4.索引常用命令整合

其实上述两个命令的整合，我本人并没有体验到JavaClientApi好用之处。直到索引整合这部分，哇哦！！！！！！这个客户端的API使用起来简直是太曼妙了！！！！！
我唯一想到的词就是曼妙！！！！！JavaClientApi把Elasticsearch的命令用java的形式完美的体现了出来。接下来上代码！！！！

创建索引

使用.indices().create()方法来创建索引。.indices()指定索引路由，.create()方法指定创建索引

创建索引无属性设置

  1. @Test
  2. void testCreateIndex() throws IOException {
  4.     //1.创建无参索引
  5.     CreateIndexResponse createIndexResponse = secondaryClient
  6.         .indices()
  7.         .create(i -> i.index(INDEX_NAME));
  8.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  9. }

索引别名设置

  1. @Test
  2. void testAlias() throws IOException {
  4.     //1.创建无参索引
  5.     CreateIndexResponse createIndexResponse = secondaryClient
  6.         .indices()
  7.         .create(i -> i.index(INDEX_NAME + "_1"));
  8.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  9.     createIndexResponse = secondaryClient
  10.         .indices()
  11.         .create(i -> i.index(INDEX_NAME + "_2"));
  12.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  14.     //2.多个索引添加一个别名
  15.     PutAliasResponse putAliasResponse = secondaryClient
  16.         .indices()
  17.         .putAlias(a -> a
  18.                   .index(INDEX_NAME + "_1")
  19.                   .name(INDEX_NAME)
  20.                  );
  21.     Assert.isTrue(putAliasResponse.acknowledged());
  23.     //3.更新索引别名
  24.     UpdateAliasesResponse updateAliasesResponse = secondaryClient
  25.         .indices()
  26.         .updateAliases(i -> i.actions(
  27.             Action.of(a -> a.remove(
  28.                 r -> r.indices(INDEX_NAME + "_1").aliases(INDEX_NAME)
  29.             )),
  30.             Action.of(a -> a.add(
  31.                 r -> r.indices(INDEX_NAME + "_2").aliases(INDEX_NAME)
  32.             ))
  33.         ));
  34.     Assert.isTrue(updateAliasesResponse.acknowledged());
  36.     //4.删除别名
  37.     DeleteAliasResponse deleteAliasResponse = secondaryClient
  38.         .indices()
  39.         .deleteAlias(i -> i
  40.                      .index(INDEX_NAME + "_1", INDEX_NAME + "_2")
  41.                      .name(CollUtil.newArrayList(INDEX_NAME))
  42.                     );
  43.     Assert.isTrue(deleteAliasResponse.acknowledged());
  45.     //5.查询别名
  46.     GetAliasResponse alias = secondaryClient
  47.         .indices()
  48.         .getAlias(i -> i.index(INDEX_NAME + "_1", INDEX_NAME + "_2"));
  50.     //6.校验查询结果
  51.     Set<String> indexNames = alias.result().keySet();
  52.     Assert.isTrue(2 == indexNames.size());
  53.     indexNames.forEach(indexName -> {
  54.         Set<String> aliases = alias.result().get(indexName).aliases().keySet();
  55.         Assert.isTrue(0 == aliases.size());
  56.     });
  57. }

创建索引时指定别名

  1. @Test
  2. void testCreateIndexWithAlias() throws IOException {
  4.     //1.创建单个别名索引
  5.     Alias alias = Alias.of(a -> a);
  6.     CreateIndexResponse createIndexResponse = secondaryClient
  7.         .indices()
  8.         .create(i -> i
  9.                 .index(INDEX_NAME + "_1")
  10.                 .aliases(INDEX_NAME, alias)
  11.                );
  12.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  14.     //2.创建多个别名索引
  15.     Map<String, Alias> aliasMap = MapUtil.newHashMap(2);
  16.     aliasMap.put(INDEX_NAME, Alias.of(a -> a));
  17.     aliasMap.put(INDEX_NAME + "_bak", Alias.of(a -> a));
  18.     createIndexResponse = secondaryClient
  19.         .indices()
  20.         .create(i -> i
  21.                 .index(INDEX_NAME + "_2")
  22.                 .aliases(aliasMap)
  23.                );
  24.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  26.     //3.查询索引别名
  27.     GetAliasResponse aliasResponse = secondaryClient
  28.         .indices()
  29.         .getAlias(i -> i.index(INDEX_NAME + "_1", INDEX_NAME + "_2"));
  31.     //4.校验索引别名
  32.     Map<String, IndexAliases> result = aliasResponse.result();
  33.     Set<String> aliasNames = result.get(INDEX_NAME + "_1").aliases().keySet();
  34.     Assert.isTrue("[\"test_index\"]".equals(JSONUtil.toJsonStr(aliasNames)));
  35.     aliasNames = result.get(INDEX_NAME + "_2").aliases().keySet();
  36.     Assert.isTrue("[\"test_index_bak\",\"test_index\"]".equals(JSONUtil.toJsonStr(aliasNames)));
  37. }

创建索引时指定mapping

直到这步，哇，真的，这种使用方法太曼妙了！！！！！

  1. @Test
  2. void testCreateIndexWithMapping() throws IOException {
  4.     //1.创建索引
  5.     CreateIndexResponse createIndexResponse = primaryClient
  6.         .indices()
  7.         .create(i -> i
  8.                 .index(INDEX_NAME)
  9.                 .mappings(m -> m
  10.                           .properties("name", p -> p.text(t -> t.analyzer("ik_max_word")))
  11.                           .properties("age", p -> p.integer(in -> in))
  12.                           .properties("tags", p -> p.keyword(k -> k))
  13.                          )
  14.                );
  15.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  16. }

创建索引时指定setting

  1. @Test
  2. void testCreateIndexWithSetting() throws IOException {
  4.     //1.创建索引
  5.     CreateIndexResponse createIndexResponse = primaryClient
  6.         .indices()
  7.         .create(i -> i
  8.                 .index(INDEX_NAME)
  9.                 .settings(s -> s
  10.                           .refreshInterval(r -> r.time("1s"))
  11.                           .numberOfShards("3")
  12.                           .numberOfReplicas("1")
  13.                          )
  14.                );
  15.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  16. }

创建索引时指定全部参数

  1. @Test
  2. void testCreateIndexWithAllArgs() throws IOException {
  4.     //1.创建索引
  5.     CreateIndexResponse createIndexResponse = secondaryClient
  6.         .indices()
  7.         .create(i -> i
  8.                 .index(INDEX_NAME + "_1")
  9.                 .aliases(INDEX_NAME, a -> a)
  10.                 .mappings(m -> m
  11.                           .properties("name", p -> p.text(t -> t.analyzer("ik_max_word")))
  12.                           .properties("age", p -> p.integer(in -> in))
  13.                           .properties("tags", p -> p.keyword(k -> k))
  14.                          )
  15.                 .settings(s -> s
  16.                           .refreshInterval(r -> r.time("1s"))
  17.                           .numberOfShards("3")
  18.                           .numberOfReplicas("1")
  19.                          )
  20.                );
  21.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  22. }

查询索引

  1. @Test
  2. void testGetIndexes() throws IOException {
  4.     //1.创建测试索引
  5.     CreateIndexResponse response = primaryClient.indices().create(i -> i.index(INDEX_NAME));
  6.     Assert.isTrue(Boolean.TRUE.equals(response.acknowledged()));
  8.     //2.查询全部索引
  9.     IndicesResponse indices = primaryClient.cat().indices();
  10.     List<String> indexNames = CollStreamUtil.toList(indices.valueBody(), IndicesRecord::index);
  11.     Assert.isTrue(indexNames.contains(INDEX_NAME));
  13.     //3.查询单个索引
  14.     GetIndexResponse getIndexResponse = primaryClient.indices().get(i -> i.index(INDEX_NAME));
  15.     Map<String, IndexState> result = getIndexResponse.result();
  16.     IndexState indexState = result.get(INDEX_NAME);
  17.     Assert.isTrue(ObjectUtil.isNotNull(indexState));
  19.     //4.获取索引单个属性
  20.     Map<String, Alias> aliases = indexState.aliases();
  21.     TypeMapping mappings = indexState.mappings();
  22.     IndexSettings settings = indexState.settings();
  23.     Assert.isTrue(ObjectUtil.isNotNull(aliases));
  24.     Assert.isTrue(ObjectUtil.isNotNull(mappings));
  25.     Assert.isTrue(ObjectUtil.isNotNull(settings));
  26. }

验证索引是否存在

  1. @Test
  2. void testExistIndex() throws IOException {
  4.     //1.验证是否存在
  5.     BooleanResponse exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME));
  7.     //2.校验结果
  8.     Assert.isFalse(exists.value());
  9. }

删除索引

  1. @Test
  2. void testDeleteIndex() throws IOException {
  4.     //1.创建索引
  5.     CreateIndexResponse createIndexResponse = primaryClient
  6.         .indices()
  7.         .create(i -> i.index(INDEX_NAME));
  8.     Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  10.     //2.验证是否存在
  11.     BooleanResponse exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME));
  12.     Assert.isTrue(exists.value());
  14.     //3.删除索引
  15.     DeleteIndexResponse delete = primaryClient
  16.         .indices()
  17.         .delete(d -> d.index(INDEX_NAME));
  18.     Assert.isTrue(delete.acknowledged());
  20.     //4.验证是否存在
  21.     exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME));
  22.     Assert.isFalse(exists.value());
  23. }

修改索引

在这一步，明确的体会到了，refresh的影响。因为之前是用kibana的Devtool，全程人工，所以refresh那点时间差是完全可以忽略的。
但是一旦到了代码的世界，那这1s简直就是一眼万年了。。。。

  1. @Test
  2. void testUpdateIndex() throws IOException, InterruptedException {
  4.     //1.创建老索引
  5.     CreateIndexResponse response = primaryClient
  6.             .indices()
  7.             .create(i -> i
  8.                     .index(INDEX_NAME + "_1")
  9.                     .aliases(INDEX_NAME, a -> a)
  10.                     .settings(s -> s
  11.                             .refreshInterval(r -> r.time("1s"))
  12.                     )
  13.             );
  14.     Assert.isTrue(Boolean.TRUE.equals(response.acknowledged()));
  16.     //2.创建新索引
  17.     response = primaryClient
  18.             .indices()
  19.             .create(i -> i
  20.                     .index(INDEX_NAME + "_2")
  21.                     .aliases(INDEX_NAME, a -> a)
  22.                     .settings(s -> s
  23.                             .refreshInterval(r -> r.time("1s"))
  24.                             .numberOfShards("3")
  25.                             .numberOfReplicas("1")
  26.                     )
  27.             );
  28.     Assert.isTrue(Boolean.TRUE.equals(response.acknowledged()));
  30.     //3.老索引存入一条文档
  31.     JSONObject entries = new JSONObject();
  32.     entries.set("age", 1);
  33.     IndexResponse index = primaryClient.index(i -> i
  34.             .index(INDEX_NAME + "_1")
  35.             .document(entries)
  36.     );
  37.     String id = index.id();
  38.     Assert.isTrue(StrUtil.isNotBlank(id));
  40.     //4.线程睡一会，给分片一个refresh的时间
  41.     TimeUnit.SECONDS.sleep(1);
  43.     //5.老索引数据迁移到新索引
  44.     ReindexResponse reindex = primaryClient.reindex(r -> r
  45.             .source(s -> s.index(INDEX_NAME + "_1"))
  46.             .dest(d -> d.index(INDEX_NAME + "_2"))
  47.     );
  48.     Assert.isTrue(1 == reindex.batches());
  50.     //6.删除老索引
  51.     DeleteIndexResponse delete = primaryClient.indices().delete(d -> d.index(INDEX_NAME + "_1"));
  52.     Assert.isTrue(delete.acknowledged());
  54.     //7.验证老索引不存在
  55.     BooleanResponse exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME + "_1"));
  56.     Assert.isFalse(exists.value());
  58.     //8.线程再睡一会，给新索引一个refresh的时间
  59.     TimeUnit.SECONDS.sleep(1);
  61.     //9.查询数据在新索引
  62.     SearchResponse<JSONObject> search = primaryClient.search(s -> s
  63.                     .index(INDEX_NAME + "_2")
  64.             , JSONObject.class);
  65.     String resultId = search.hits().hits().get(0).id();
  66.     Assert.isTrue(id.equals(resultId));
  67. }

完整版单元测试

  1. import cn.hutool.core.collection.CollStreamUtil;
  2. import cn.hutool.core.collection.CollUtil;
  3. import cn.hutool.core.lang.Assert;
  4. import cn.hutool.core.map.MapUtil;
  5. import cn.hutool.core.util.ObjectUtil;
  6. import cn.hutool.core.util.StrUtil;
  7. import cn.hutool.json.JSONObject;
  8. import cn.hutool.json.JSONUtil;
  9. import co.elastic.clients.elasticsearch.ElasticsearchClient;
  10. import co.elastic.clients.elasticsearch._types.mapping.TypeMapping;
  11. import co.elastic.clients.elasticsearch.cat.IndicesResponse;
  12. import co.elastic.clients.elasticsearch.cat.indices.IndicesRecord;
  13. import co.elastic.clients.elasticsearch.core.IndexResponse;
  14. import co.elastic.clients.elasticsearch.core.ReindexResponse;
  15. import co.elastic.clients.elasticsearch.core.SearchResponse;
  16. import co.elastic.clients.elasticsearch.indices.*;
  17. import co.elastic.clients.elasticsearch.indices.get_alias.IndexAliases;
  18. import co.elastic.clients.elasticsearch.indices.update_aliases.Action;
  19. import co.elastic.clients.transport.endpoints.BooleanResponse;
  20. import org.junit.jupiter.api.BeforeEach;
  21. import org.junit.jupiter.api.Test;
  22. import org.springframework.beans.factory.annotation.Qualifier;
  23. import org.springframework.boot.test.context.SpringBootTest;
  25. import javax.annotation.Resource;
  26. import java.io.IOException;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.Set;
  30. import java.util.concurrent.TimeUnit;
  31. import java.util.stream.Collectors;
  33. @SpringBootTest
  34. class ElasticSearchIndexTest {
  36.     @Resource
  37.     @Qualifier("primaryElasticsearchClient")
  38.     private ElasticsearchClient primaryClient;
  40.     @Resource
  41.     @Qualifier("secondaryElasticsearchClient")
  42.     private ElasticsearchClient secondaryClient;
  44.     /**
  45.      * 测试Mock索引名称常量
  46.      */
  47.     private static final String INDEX_NAME = "test_index";
  49.     @BeforeEach
  50.     void removeApplicationIndex() throws IOException {
  52.         //1.查询所有索引
  53.         IndicesResponse catIndies = primaryClient.cat().indices();
  54.         List<IndicesRecord> indicesRecords = catIndies.valueBody();
  56.         //2.获取所有自定义索引名称
  57.         List<String> applicationIndexNames = indicesRecords.stream()
  58.                 .map(IndicesRecord::index)
  59.                 .filter(index -> !index.startsWith(StrUtil.DOT))
  60.                 .collect(Collectors.toList());
  62.         //3.判空返回
  63.         if (CollUtil.isEmpty(applicationIndexNames)) {
  64.             return;
  65.         }
  67.         //4.删除
  68.         ElasticsearchIndicesClient indicesClient = primaryClient.indices();
  69.         DeleteIndexResponse delete = indicesClient.delete(i -> i.index(applicationIndexNames));
  70.         Assert.isTrue(delete.acknowledged());
  71.     }
  73.     @Test
  74.     void testCreateIndex() throws IOException {
  76.         //1.创建无参索引
  77.         CreateIndexResponse createIndexResponse = secondaryClient
  78.                 .indices()
  79.                 .create(i -> i.index(INDEX_NAME));
  80.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  81.     }
  83.     @Test
  84.     void testAlias() throws IOException {
  86.         //1.创建无参索引
  87.         CreateIndexResponse createIndexResponse = secondaryClient
  88.                 .indices()
  89.                 .create(i -> i.index(INDEX_NAME + "_1"));
  90.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  91.         createIndexResponse = secondaryClient
  92.                 .indices()
  93.                 .create(i -> i.index(INDEX_NAME + "_2"));
  94.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  96.         //2.多个索引添加一个别名
  97.         PutAliasResponse putAliasResponse = secondaryClient
  98.                 .indices()
  99.                 .putAlias(a -> a
  100.                         .index(INDEX_NAME + "_1")
  101.                         .name(INDEX_NAME)
  102.                 );
  103.         Assert.isTrue(putAliasResponse.acknowledged());
  105.         //3.更新索引别名
  106.         UpdateAliasesResponse updateAliasesResponse = secondaryClient
  107.                 .indices()
  108.                 .updateAliases(i -> i.actions(
  109.                         Action.of(a -> a.remove(
  110.                                 r -> r.indices(INDEX_NAME + "_1").aliases(INDEX_NAME)
  111.                         )),
  112.                         Action.of(a -> a.add(
  113.                                 r -> r.indices(INDEX_NAME + "_2").aliases(INDEX_NAME)
  114.                         ))
  115.                 ));
  116.         Assert.isTrue(updateAliasesResponse.acknowledged());
  118.         //4.删除别名
  119.         DeleteAliasResponse deleteAliasResponse = secondaryClient
  120.                 .indices()
  121.                 .deleteAlias(i -> i
  122.                         .index(INDEX_NAME + "_1", INDEX_NAME + "_2")
  123.                         .name(CollUtil.newArrayList(INDEX_NAME))
  124.                 );
  125.         Assert.isTrue(deleteAliasResponse.acknowledged());
  127.         //5.查询别名
  128.         GetAliasResponse alias = secondaryClient
  129.                 .indices()
  130.                 .getAlias(i -> i.index(INDEX_NAME + "_1", INDEX_NAME + "_2"));
  132.         //6.校验查询结果
  133.         Set<String> indexNames = alias.result().keySet();
  134.         Assert.isTrue(2 == indexNames.size());
  135.         indexNames.forEach(indexName -> {
  136.             Set<String> aliases = alias.result().get(indexName).aliases().keySet();
  137.             Assert.isTrue(0 == aliases.size());
  138.         });
  139.     }
  141.     @Test
  142.     void testCreateIndexWithAlias() throws IOException {
  144.         //1.创建单个别名索引
  145.         Alias alias = Alias.of(a -> a);
  146.         CreateIndexResponse createIndexResponse = secondaryClient
  147.                 .indices()
  148.                 .create(i -> i
  149.                         .index(INDEX_NAME + "_1")
  150.                         .aliases(INDEX_NAME, alias)
  151.                 );
  152.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  154.         //2.创建多个别名索引
  155.         Map<String, Alias> aliasMap = MapUtil.newHashMap(2);
  156.         aliasMap.put(INDEX_NAME, Alias.of(a -> a));
  157.         aliasMap.put(INDEX_NAME + "_bak", Alias.of(a -> a));
  158.         createIndexResponse = secondaryClient
  159.                 .indices()
  160.                 .create(i -> i
  161.                         .index(INDEX_NAME + "_2")
  162.                         .aliases(aliasMap)
  163.                 );
  164.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  166.         //3.查询索引别名
  167.         GetAliasResponse aliasResponse = secondaryClient
  168.                 .indices()
  169.                 .getAlias(i -> i.index(INDEX_NAME + "_1", INDEX_NAME + "_2"));
  171.         //4.校验索引别名
  172.         Map<String, IndexAliases> result = aliasResponse.result();
  173.         Set<String> aliasNames = result.get(INDEX_NAME + "_1").aliases().keySet();
  174.         Assert.isTrue("[\"test_index\"]".equals(JSONUtil.toJsonStr(aliasNames)));
  175.         aliasNames = result.get(INDEX_NAME + "_2").aliases().keySet();
  176.         Assert.isTrue("[\"test_index_bak\",\"test_index\"]".equals(JSONUtil.toJsonStr(aliasNames)));
  177.     }
  179.     @Test
  180.     void testCreateIndexWithMapping() throws IOException {
  182.         //1.创建索引
  183.         CreateIndexResponse createIndexResponse = primaryClient
  184.                 .indices()
  185.                 .create(i -> i
  186.                         .index(INDEX_NAME)
  187.                         .mappings(m -> m
  188.                                 .properties("name", p -> p.text(t -> t.analyzer("ik_max_word")))
  189.                                 .properties("age", p -> p.integer(in -> in))
  190.                                 .properties("tags", p -> p.keyword(k -> k))
  191.                         )
  192.                 );
  193.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  194.     }
  196.     @Test
  197.     void testCreateIndexWithSetting() throws IOException {
  199.         //1.创建索引
  200.         CreateIndexResponse createIndexResponse = primaryClient
  201.                 .indices()
  202.                 .create(i -> i
  203.                         .index(INDEX_NAME)
  204.                         .settings(s -> s
  205.                                 .refreshInterval(r -> r.time("1s"))
  206.                                 .numberOfShards("3")
  207.                                 .numberOfReplicas("1")
  208.                         )
  209.                 );
  210.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  211.     }
  213.     @Test
  214.     void testCreateIndexWithAllArgs() throws IOException {
  216.         //1.创建索引
  217.         CreateIndexResponse createIndexResponse = secondaryClient
  218.                 .indices()
  219.                 .create(i -> i
  220.                         .index(INDEX_NAME + "_1")
  221.                         .aliases(INDEX_NAME, a -> a)
  222.                         .mappings(m -> m
  223.                                 .properties("name", p -> p.text(t -> t.analyzer("ik_max_word")))
  224.                                 .properties("age", p -> p.integer(in -> in))
  225.                                 .properties("tags", p -> p.keyword(k -> k))
  226.                         )
  227.                         .settings(s -> s
  228.                                 .refreshInterval(r -> r.time("1s"))
  229.                                 .numberOfShards("3")
  230.                                 .numberOfReplicas("1")
  231.                         )
  232.                 );
  233.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  234.     }
  236.     @Test
  237.     void testGetIndexes() throws IOException {
  239.         //1.创建测试索引
  240.         CreateIndexResponse response = primaryClient.indices().create(i -> i.index(INDEX_NAME));
  241.         Assert.isTrue(Boolean.TRUE.equals(response.acknowledged()));
  243.         //2.查询全部索引
  244.         IndicesResponse indices = primaryClient.cat().indices();
  245.         List<String> indexNames = CollStreamUtil.toList(indices.valueBody(), IndicesRecord::index);
  246.         Assert.isTrue(indexNames.contains(INDEX_NAME));
  248.         //3.查询单个索引
  249.         GetIndexResponse getIndexResponse = primaryClient.indices().get(i -> i.index(INDEX_NAME));
  250.         Map<String, IndexState> result = getIndexResponse.result();
  251.         IndexState indexState = result.get(INDEX_NAME);
  252.         Assert.isTrue(ObjectUtil.isNotNull(indexState));
  254.         //4.获取索引单个属性
  255.         Map<String, Alias> aliases = indexState.aliases();
  256.         TypeMapping mappings = indexState.mappings();
  257.         IndexSettings settings = indexState.settings();
  258.         Assert.isTrue(ObjectUtil.isNotNull(aliases));
  259.         Assert.isTrue(ObjectUtil.isNotNull(mappings));
  260.         Assert.isTrue(ObjectUtil.isNotNull(settings));
  261.     }
  263.     @Test
  264.     void testExistIndex() throws IOException {
  266.         //1.验证是否存在
  267.         BooleanResponse exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME));
  269.         //2.校验结果
  270.         Assert.isFalse(exists.value());
  271.     }
  273.     @Test
  274.     void testDeleteIndex() throws IOException {
  276.         //1.创建索引
  277.         CreateIndexResponse createIndexResponse = primaryClient
  278.                 .indices()
  279.                 .create(i -> i.index(INDEX_NAME));
  280.         Assert.isTrue(Boolean.TRUE.equals(createIndexResponse.acknowledged()));
  282.         //2.验证是否存在
  283.         BooleanResponse exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME));
  284.         Assert.isTrue(exists.value());
  286.         //3.删除索引
  287.         DeleteIndexResponse delete = primaryClient
  288.                 .indices()
  289.                 .delete(d -> d.index(INDEX_NAME));
  290.         Assert.isTrue(delete.acknowledged());
  292.         //4.验证是否存在
  293.         exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME));
  294.         Assert.isFalse(exists.value());
  295.     }
  297.     @Test
  298.     void testUpdateIndex() throws IOException, InterruptedException {
  300.         //1.创建老索引
  301.         CreateIndexResponse response = primaryClient
  302.                 .indices()
  303.                 .create(i -> i
  304.                         .index(INDEX_NAME + "_1")
  305.                         .aliases(INDEX_NAME, a -> a)
  306.                         .settings(s -> s
  307.                                 .refreshInterval(r -> r.time("1s"))
  308.                         )
  309.                 );
  310.         Assert.isTrue(Boolean.TRUE.equals(response.acknowledged()));
  312.         //2.创建新索引
  313.         response = primaryClient
  314.                 .indices()
  315.                 .create(i -> i
  316.                         .index(INDEX_NAME + "_2")
  317.                         .aliases(INDEX_NAME, a -> a)
  318.                         .settings(s -> s
  319.                                 .refreshInterval(r -> r.time("1s"))
  320.                                 .numberOfShards("3")
  321.                                 .numberOfReplicas("1")
  322.                         )
  323.                 );
  324.         Assert.isTrue(Boolean.TRUE.equals(response.acknowledged()));
  326.         //3.老索引存入一条文档
  327.         JSONObject entries = new JSONObject();
  328.         entries.set("age", 1);
  329.         IndexResponse index = primaryClient.index(i -> i
  330.                 .index(INDEX_NAME + "_1")
  331.                 .document(entries)
  332.         );
  333.         String id = index.id();
  334.         Assert.isTrue(StrUtil.isNotBlank(id));
  336.         //4.线程睡一会，给分片一个refresh的时间
  337.         TimeUnit.SECONDS.sleep(1);
  339.         //5.老索引数据迁移到新索引
  340.         ReindexResponse reindex = primaryClient.reindex(r -> r
  341.                 .source(s -> s.index(INDEX_NAME + "_1"))
  342.                 .dest(d -> d.index(INDEX_NAME + "_2"))
  343.         );
  344.         Assert.isTrue(1 == reindex.batches());
  346.         //6.删除老索引
  347.         DeleteIndexResponse delete = primaryClient.indices().delete(d -> d.index(INDEX_NAME + "_1"));
  348.         Assert.isTrue(delete.acknowledged());
  350.         //7.验证老索引不存在
  351.         BooleanResponse exists = primaryClient.indices().exists(e -> e.index(INDEX_NAME + "_1"));
  352.         Assert.isFalse(exists.value());
  354.         //8.线程再睡一会，给新索引一个refresh的时间
  355.         TimeUnit.SECONDS.sleep(1);
  357.         //9.查询数据在新索引
  358.         SearchResponse<JSONObject> search = primaryClient.search(s -> s
  359.                         .index(INDEX_NAME + "_2")
  360.                 , JSONObject.class);
  361.         String resultId = search.hits().hits().get(0).id();
  362.         Assert.isTrue(id.equals(resultId));
  363.     }
  364. }