elasticsearch6 java_elasticsearch6.7版本常用的java API记录

/**

* 创建索引

* @param index

* @throws IOException

*/

public String createIndex(String index) {

String result = "成功";

try {

if (!checkIndexExists(index)) {

logger.info("开始新建索引【{}】", index);

CreateIndexRequest request = new CreateIndexRequest(index);

//如果有特殊字段-如日期等 需要自己定义字段类型

/*MapupdateTime = new HashMap<>(1);

updateTime.put("type", "date");

updateTime.put("format", "yyyy-MM-dd'T'HH:mm:ss");

Mapproperties = new HashMap<>(1);

properties.put("updateTime", updateTime);

Mapmapping = new HashMap<>(1);

mapping.put("properties", properties);

request.mapping(mapping);*/

CreateIndexResponse createIndexResponse = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);

logger.info("createIndex: {}", JSON.toJSONString(createIndexResponse));

if (!createIndexResponse.isAcknowledged()) {

result = "接口执行失败";

}

} else {

logger.info("索引【{}】已存在，无需重建", index);

result = "索引【" + index + "】已存在，无需重复创建";

}

} catch (Exception ex) {

logger.error("createIndex 索引创建接口异常，{}", ex);

result = "索引创建接口异常";

}

return result;

}

/**

* 删除索引

* @param index

* @return

* @throws IOException

*/

public boolean deleteIndex(String index) throws IOException {

/**

* 返回true是成功 反之失败

* 如果索引不存在会出异常 Elasticsearch exception [type=index_not_found_exception, reason=no such index]

*/

//先检查索引是否存在

if (!checkIndexExists(index)) {

logger.info("索引【{}】不存在，不走删除逻辑", index);

return false;

}

DeleteIndexRequest deleteRequest = new DeleteIndexRequest(index);

logger.info("开始删除索引，name=【{}】的数据", index);

AcknowledgedResponse dResponse = restHighLevelClient.indices().delete(deleteRequest, RequestOptions.DEFAULT);

logger.info("删除后返回结果：{}", dResponse.isAcknowledged());

return dResponse.isAcknowledged();

}

/**

* 验证索引是否存在

* @param index

* @return

* @throws IOException

*/

public boolean checkIndexExists(String index) throws IOException {

GetIndexRequest getIndexRequest = new GetIndexRequest(index);

boolean exists = restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);

logger.info("验证索引【{}】是否存在结果为: {}", index, exists);

return exists;

}

/**

* 文档内容写入es

* Ingest-Attachment

* Ingest Node

* test

*/

public int saveDocumentByIndex(String index, String type, DocumentVo vo, SyncDocumentLog syncDocumentLog) {

try {

if (vo.getUrl() == null) {

return ErrorUtil.ES_FILE_STATUS_3.getCode();

}

if (vo.getUrl().indexOf(ossUrl) == -1) {

//解决测试环境文档内容不匹配问题

return ErrorUtil.ES_FILE_STATUS_2.getCode();

}

if (!StringUtils.isEmpty(syncDocumentLog.getEsDocId())) {

//删除旧的数据

deleteDocumentById(index, type, syncDocumentLog.getEsDocId());

}

String path = vo.getUrl();

String butkey = path.substring(ossUrl.length() + 1, path.length());

path = path.replace("\\", "/");

//这里的base64要换成官方的方法 否则转化出错

String content = ossService.fileToBase64ByOssUrl(butkey);

Map paramMap = new HashMap<>(6);

paramMap.put(DocumentKey.doc_id.getKey(), vo.getId());

paramMap.put(DocumentKey.doc_fileName.getKey(), vo.getName());

paramMap.put(DocumentKey.doc_data.getKey(), content);

paramMap.put(DocumentKey.doc_updateTime.getKey(), vo.getUpdateTime());

paramMap.put(DocumentKey.doc_filePath.getKey(), path);

paramMap.put(DocumentKey.doc_postfix.getKey(), vo.getPostfix());

paramMap.put(DocumentKey.doc_chipCode.getKey(), vo.getChipCode());

paramMap.put(DocumentKey.doc_chipProjectCode.getKey(), vo.getChipProjectCode());

IndexRequest indexRequest = new IndexRequest(index, type);

indexRequest.source(paramMap, XContentType.JSON);

indexRequest.setPipeline(DocumentKey.doc_Pipeline.getKey());

indexRequest.timeout("60s");

IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);

logger.info("存入es执行完毕：docId=【{}】，code={}", vo.getId(), indexResponse.status().getStatus());

//保存es的id到这边 方便查询

syncDocumentLog.setEsDocId(indexResponse.getId());

return indexResponse.status().getStatus();

} catch (Exception ex) {

syncDocumentLog.setEsDocId("");

syncDocumentLog.setRemark(ex.getMessage());

logger.error("保存文档内容到es时出错，docId=【{}】，type=【{}】，error: {}", vo.getId(), vo.getPostfix(), ex.getMessage());

return ElasticStatus.SYNCING_CODE.getCode();

}

}

/**

* 根据关键字查找文档内容

* 返回 page

* @param queryVo

* @return

*/

public PageList findDocument(PageSortHighLight page, IndexData index, DocQueryVo queryVo) throws IOException {

PageList result = new PageList<>();

List queryList = new ArrayList<>(page.getPageSize());

String field_id = DocumentKey.doc_id.getKey();

String field_fileName = DocumentKey.doc_fileName.getKey();

String field_content = "attachment.content";

//高亮截取部分

int splitSize = 400;

//1.分页

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

//从第0个开始

sourceBuilder.from(page.getCurrentPage()*page.getPageSize());

//相当于 limit

sourceBuilder.size(page.getPageSize());

// 获取的字段(列)和不需要获取的列

sourceBuilder.fetchSource(new String[]{DocumentKey.doc_id.getKey(), DocumentKey.doc_fileName.getKey(),

DocumentKey.doc_Pipeline.getKey(), DocumentKey.doc_filePath.getKey(), DocumentKey.doc_postfix.getKey(),

DocumentKey.doc_updateTime.getKey(), DocumentKey.doc_chipProjectCode.getKey(), DocumentKey.doc_chipCode.getKey()},

new String[]{DocumentKey.doc_data.getKey()});

// 设置排序规则--默认是命中分数最高者排前面

sourceBuilder.sort(new ScoreSortBuilder());

// 设置超时时间为2s

sourceBuilder.timeout(new TimeValue(10000));

//文件名称 也能匹配--fileName

MatchQueryBuilder matchQueryBuilder2 = QueryBuilders.matchQuery(field_fileName, queryVo.getKeyWord());

//文档内容匹配

MatchQueryBuilder matchQueryBuilder1 = QueryBuilders.matchQuery(field_content, queryVo.getKeyWord());

BoolQueryBuilder shouldQuery1 = QueryBuilders.boolQuery();

BoolQueryBuilder boolBuilder = QueryBuilders.boolQuery();

if (!StringUtils.isEmpty(queryVo.getChipProjectCode())) {

//按项目CODE查询

BoolQueryBuilder shouldProject = QueryBuilders.boolQuery();

BoolQueryBuilder shouldChipAndPro = QueryBuilders.boolQuery();

// matchPhraseQuery

MatchPhraseQueryBuilder matchPhraseQueryBuilderPro = QueryBuilders.matchPhraseQuery(DocumentKey.doc_chipProjectCode.getKey(), queryVo.getChipProjectCode());

//or 还有一种情况

MatchPhraseQueryBuilder matchPhraseQueryBuilderChip1 = QueryBuilders.matchPhraseQuery(DocumentKey.doc_chipCode.getKey(), queryVo.getChipCode());

MatchPhraseQueryBuilder matchPhraseQueryBuilderChip2 = QueryBuilders.matchPhraseQuery(DocumentKey.doc_chipProjectCode.getKey(), "");

boolBuilder.must(shouldProject.should(matchPhraseQueryBuilderPro).should(shouldChipAndPro.must(matchPhraseQueryBuilderChip1).must(matchPhraseQueryBuilderChip2)));

} else {

//全盘查询

TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery(field_id, queryVo.getDocIdList());

boolBuilder.must(termsQueryBuilder);

}

//按时间段查询

if (!StringUtils.isEmpty(queryVo.getTimeStr())) {

//rangeQuery--当前时间

RangeQueryBuilder rangeQueryTime = QueryBuilders.rangeQuery(DocumentKey.doc_updateTime.getKey()).from(DateFormatUtil.formatDateByStr(queryVo.getTimeStr()))

.to(DateFormatUtil.formatDate(new Date()));

boolBuilder.must(rangeQueryTime);

}

//or 查询 其下满足其一即可BoolQueryBuilder 嵌套

boolBuilder.must(shouldQuery1.should(matchQueryBuilder2).should(matchQueryBuilder1));

sourceBuilder.query(boolBuilder);

//3.设置查询高亮显示--使用默认后缀

HighlightBuilder highlightBuilder = new HighlightBuilder();

String preTags = "";

String postTags = "";

//设置前缀-后缀

highlightBuilder.preTags(preTags);

highlightBuilder.postTags(postTags);

//使用默认标签包裹

//highlightBuilder.highlighterType("Unified");

//设置高亮的字段名

highlightBuilder.field(field_content, splitSize);

highlightBuilder.field(field_fileName, 0);

sourceBuilder.highlighter(highlightBuilder);

// 4.创建并设置SearchRequest对象

SearchRequest searchRequest = new SearchRequest();

// 设置request要搜索的索引和类型

searchRequest.indices(index.getIndexName()).types(index.getIndexType());

// 设置SearchSourceBuilder查询属性

searchRequest.source(sourceBuilder);

long start = System.currentTimeMillis();

// 5.查询

SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

//取出结果对象

SearchHits hits = searchResponse.getHits();

logger.info("命中总数=【{}】，命中的最高分数=【{}】", hits.getTotalHits(), hits.getMaxScore());

result.setList(dealResult(queryList, hits, field_fileName, field_content, splitSize));

result.setTotalElements(hits.getTotalHits());

result.setTotalPages(getTotalPages(hits.getTotalHits(), page.getPageSize()));

long end = System.currentTimeMillis();

logger.info("根据search方法查询，耗时：{} 秒", (end-start)/1000);

return result;

}

/**

* 批量操作

* 支持 新增 修改 删除

* 只支持文档类型

* @param request

* @return

*/

public int bulkDocuments(BulkRequest request) {

//管道声明

request.pipeline(DocumentKey.doc_Pipeline.getKey());

//10分钟后超时

request.timeout("10m");

try {

logger.info("开始执行ES批量操作接口...");

BulkResponse bulkResponse = restHighLevelClient.bulk(request, RequestOptions.DEFAULT);

logger.info("执行返回结果(200是成功)：code={},异常日志：{}", bulkResponse.status().getStatus(), bulkResponse.buildFailureMessage());

return bulkResponse.status().getStatus();

} catch (IOException e) {

e.printStackTrace();

}

return 0;

}

/**

* 查询索引分类下的总记录数

* @param indexData

* @return

*/

public int countByIndexType(IndexData indexData) {

logger.info("开始查询索引【{}】分类【{}】下的总记录数.", indexData.getIndexName(), indexData.getIndexType());

try {

SearchRequest searchRequest = new SearchRequest();

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

//关闭检索内容--只关心数量，不关心字段值

sourceBuilder.fetchSource(false);

//设置一个可选的超时，控制允许搜索的时间

sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

searchRequest.source(sourceBuilder);

// 设置request要搜索的索引和类型

searchRequest.indices(indexData.getIndexName()).types(indexData.getIndexType());

SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

//获取匹配的总数量

long total = search.getHits().getTotalHits();

logger.info("查询结束，总数：{}", total);

return (int) total;

} catch (Exception ex) {

logger.error("countByIndexType 查询总记录出错...{}", ex);

}

return 0;

}