ElasticSearch 滚动索引
一个【读索引别名】关联多个索引
一个【写索引名】关联一个【最新的索引】，触发【条件阈值】后，调用滚动索引，自动【生成】新索引
注:1、最新索引同时有【写索引名】和【读索引别名】
2、【读索引别名】关联所有索引(按照业务取舍,可选择性舍弃)
完整demo如下
1.基础准备
<!-- elasticsearch -->
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>7.17.2</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-client</artifactId>
<version>7.17.2</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.17.2</version>
</dependency>
public class EsClientConstant {
public static RestHighLevelClient ES_CLIENT = null;
static {
CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("elastic", "密码"));
RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost("192.168.31.1", 9200, "http"))
.setHttpClientConfigCallback((httpAsyncClientBuilder) -> httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider))
;
ES_CLIENT = new RestHighLevelClient(restClientBuilder);
}
}
2、模板
2.1 创建模板（createTemplate）
//templateName:模板名
//templateAliases:模板别名
public static void createTemplate(String templateName,String templateAliases, List<String> patterns) throws Exception {
PutIndexTemplateRequest request = new PutIndexTemplateRequest(templateName);
request.patterns( patterns);
request.alias(new Alias(templateAliases));
// request.settings(Settings.builder()
// .put("index.number_of_shards", 3)
// .put("index.number_of_replicas", 0)
// );
request.mapping(TemplateConstant.getTemplate());
// request.create(true);
// request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
// request.masterNodeTimeout("1m");
ES_CLIENT.indices().putTemplate(request, RequestOptions.DEFAULT);
AcknowledgedResponse putTemplateResponse = ES_CLIENT.indices().putTemplate(request, RequestOptions.DEFAULT);
System.out.println("创建模板 response:" + putTemplateResponse );
System.out.println("创建模板isAcknowledged:" + putTemplateResponse.isAcknowledged() );
}
public class TemplateConstant {
public static XContentBuilder getTemplate() throws Exception{
XContentBuilder mapping = XContentFactory.jsonBuilder();
mapping.startObject();
{
mapping.startObject("properties");
{
//1、创建文档字段-id
mapping.startObject("id");
{
mapping.field("type", "text");
}
mapping.endObject();
}
mapping.endObject();
}
mapping.endObject();
return mapping;
}
}
2.2 删除模板
public static void deleteTemplate(String templateName) throws IOException {
DeleteIndexTemplateRequest request = new DeleteIndexTemplateRequest(templateName);
AcknowledgedResponse putTemplateResponse = ES_CLIENT.indices().deleteTemplate(request, RequestOptions.DEFAULT);
;
System.out.println("删除模板 response:" + putTemplateResponse );
System.out.println("删除模板 isAcknowledged:" + putTemplateResponse.isAcknowledged() );
}
2.3 查询模板
public static void queryTemplate(String templateName) throws IOException {
GetIndexTemplatesRequest request=new GetIndexTemplatesRequest( templateName);
GetIndexTemplatesResponse template = ES_CLIENT.indices().getIndexTemplate(request, RequestOptions.DEFAULT);
List<IndexTemplateMetadata> templates = template.getIndexTemplates();
System.out.println("查询模板>>>>>>>>>>>>>>>>>>>>>>>>>> ");
for (IndexTemplateMetadata metadata : templates) {
System.out.println("name "+metadata.name());
System.out.println("aliases "+metadata.aliases());
System.out.println("version "+metadata.version());
System.out.println("mappings getSourceAsMap-- "+metadata.mappings().getSourceAsMap());
System.out.println("mappings type-- "+metadata.mappings().type());
System.out.println("mappings routing-- "+metadata.mappings().routing());
System.out.println("settings "+metadata.settings());
System.out.println("order "+metadata.order());
System.out.println("patterns "+metadata.patterns());
}
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>> ");
}
2.4 模板是否存在
public static void indexTemplateExist(String templateName) throws IOException {
IndexTemplatesExistRequest request = new IndexTemplatesExistRequest(templateName);
boolean exists = ES_CLIENT.indices().existsTemplate(request, RequestOptions.DEFAULT);
System.out.println("模板是否存在:" + exists );
}
3.索引，索引别名
3.1创建索引，同时创建索引别名
public static void createIndex(String indexName) throws IOException {
// 1.创建索引名
CreateIndexRequest request = new CreateIndexRequest(indexName);
CreateIndexResponse response = ES_CLIENT.indices().create(request, RequestOptions.DEFAULT);
//返回响应是否得到确认 返回：如果响应已确认，则为 true，否则为 false。
System.out.println("创建索引 response:" + response.isAcknowledged());
//如果在从索引创建操作返回之前启动了所需数量的分片，则返回 true。如果 isAcfirmd（） 为 false，则这也返回 false。
System.out.println("创建索引 response:" + response.isShardsAcknowledged());
}
3.2 删除索引
//deleteIndex 索引名
public static void deleteIndex(String... deleteIndex) throws IOException {
// 1.创建索引名
DeleteIndexRequest request = new DeleteIndexRequest(deleteIndex);
AcknowledgedResponse response = ES_CLIENT.indices().delete(request, RequestOptions.DEFAULT);
//返回响应是否得到确认 返回：如果响应已确认，则为 true，否则为 false。
System.out.println("删除索引 response:" + response.isAcknowledged());
}
3.3 向索引写入数据
// indexAlias 别名
public static void wirteIndex(String indexAlias) throws IOException {
IndexRequest request = new IndexRequest(indexAlias, "_doc");
// 2、准备文档数据
Map<String, Object> jsonMap = new HashMap<>();
jsonMap.put("id", LocalDateTime.now());
request.source(jsonMap, XContentType.JSON);
// .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
//3、发送请求 同步方式
IndexResponse indexResponse = ES_CLIENT.index(request, RequestOptions.DEFAULT);
System.out.println("添加数据 indexResponse:" + indexResponse);
System.out.println("添加数据 "+indexResponse.status());
}
// /**
// * 默认，不刷新
// * 不消耗资源
// * 连续操作容易导致数据不同步
// */
// NONE("false"),
// /**
// * 强制刷新，立即刷新数据，刷新成功后结束
// * 保证最终数据同步
// * 耗资源
// */
// IMMEDIATE("true"),
// /**
// * 延迟刷新数据，刷新成功后结束
// * 保证最终数据同步
// * 耗时（根据refresh_interval配置决定等待时间
// */
// WAIT_UNTIL("wait_for");
3.4 根据索引别名查询
public static void indexAliasSearch(String indexAlias) throws IOException {
//查询索引
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(new BoolQueryBuilder());
SearchRequest searchRequest = new SearchRequest();
searchRequest.indices(indexAlias).source(searchSourceBuilder);
System.out.println(searchSourceBuilder.toString());
SearchResponse resp = ES_CLIENT.search(searchRequest, RequestOptions.DEFAULT);
//打印结果信息
SearchHits hits = resp.getHits();
System.out.println("查询结果 "+hits.getHits().length);
System.out.println("查询结果 "+resp.getSuccessfulShards());
System.out.println("查询结果 "+resp.getClusters().toString());
//关闭ES客户端
ES_CLIENT.close();
}
3.5删除索引别名
public static void main(String[] args) throws IOException {
DeleteAliasRequest deleteAliasRequest = new DeleteAliasRequest("test-index-100001","test-index-alias");
ES_CLIENT.indices().deleteAlias(deleteAliasRequest, RequestOptions.DEFAULT);
// 6.关闭 client
ES_CLIENT.close();
}
4.滚动索引
public static void main(String[] args) throws Exception {
//写索引别名
String writeIndexAlias ="test-index-alias-write";
//读索引别名
String readIndexAlias ="test-index-alias-read";
createRollover(writeIndexAlias,readIndexAlias);
}
public static void createRollover(String writeIndexAlias,String readIndexAlias) throws IOException {
//指向要翻转的索引的别名（第一个参数），以及执行翻转操作时新索引的名称。新的索引参数是可选的，可以设置为 null
RolloverRequest request = new RolloverRequest(writeIndexAlias, null);
//request.addMaxIndexAgeCondition(new TimeValue(1, TimeUnit.SECONDS)); //指数年龄的条件
request.addMaxIndexDocsCondition(4); //索引中文档数量的条件
request.addMaxIndexSizeCondition(new ByteSizeValue(1, ByteSizeUnit.GB)); //索引大小的条件
//todo添加索引映射
CreateIndexRequest createIndexRequest = request.getCreateIndexRequest();
//createIndexRequest.mapping(); //添加索引映射
//request.dryRun(true);
//request.setTimeout(TimeValue.timeValueMinutes(2));
//request.setMasterTimeout(TimeValue.timeValueMinutes(1));
//request.getCreateIndexRequest().waitForActiveShards(ActiveShardCount.from(2));
// request.getCreateIndexRequest().waitForActiveShards(ActiveShardCount.DEFAULT);
request.getCreateIndexRequest().alias(new Alias(readIndexAlias));
RolloverResponse rollover = ES_CLIENT.indices().rollover(request, RequestOptions.DEFAULT);
System.out.println("滚动索引=======================");
Map<String, Boolean> status = rollover.getConditionStatus();
System.out.println(status);
String newIndex = rollover.getNewIndex();
System.out.println("newIndex " + newIndex);
String oldIndex = rollover.getOldIndex();
System.out.println("oldIndex " + oldIndex);
System.out.println("设置滚动索引成功!");
System.out.println("isRolledOver:" + rollover.isRolledOver());
System.out.println("isDryRun:" + rollover.isDryRun());
System.out.println("acknowledged:" + rollover.isAcknowledged());
System.out.println("shardsAcked:" + rollover.isShardsAcknowledged());
System.out.println("===============================");
}
5. 测试
public class MainTest {
public static void main(String[] args) throws Exception {
//模板名
String templateName ="my-template";
//模板别名
String templateAliases ="my-template-alias";
//滚动索引范围
List<String> patterns = Arrays.asList("test-index-*");
//索引名后几位是数组 如果是1会称为000001 逐渐递增
String indexName ="test-index-100000";
//写索引别名
String writeIndexAlias ="test-index-alias-write";
//读索引别名
String readIndexAlias ="test-index-alias-read";
//
//deleteTemplate(templateName);
// deleteIndex(indexName);
//todo 模板是否存在
indexTemplateExist(templateName);
//创建模板
createTemplate(templateName,templateAliases,patterns);
//查询模板
queryTemplate(templateName);
//使用模板创建索引
createIndex(indexName);
//给索引加别名
createAlias(indexName,writeIndexAlias,readIndexAlias);
createRollover(writeIndexAlias,readIndexAlias);
for (int i = 0; i <3 ; i++) {
//向索引写入数据
wirteIndex(writeIndexAlias);
}
for (int i = 0; i <4 ; i++) {
wirteIndex(writeIndexAlias);
}
//触发滚动条件
createRollover(writeIndexAlias,readIndexAlias);
//查询索引情况
indexAliasSearch(readIndexAlias);
}
}
114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
