1.引入Elasticsearch依赖
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.12.0</version>
</dependency>
2.创建Elasticsearch客户端
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost("ruowu.com", 9200, "http"))
);
3.实际使用
(1).批量添加
public R<Boolean> insert(@RequestBody EsInsertListVo esInsertListVo) {
// 获取插入数据的索引名称和数据
String indexName = esInsertListVo.getIndexName();
List<EsInsertVo> list = esInsertListVo.getList();
// 检查索引是否存在,如果不存在则抛出异常或返回错误信息
esIndexService.checkParms(indexName, true);
// 查询索引是否存在,如果不存在则返回错误信息
R<Boolean> booleanR = esIndexService.selectEsIndex(new SelectEsIndex(indexName));
if (!booleanR.getData()){
return R.ok(false,"索引不存在,请先创建索引");
}
// 判断list是否为空,如果为空将抛出异常
if (CollectionUtils.isEmpty(list)){
throw new ServiceException("添加数据不能为空");
}
// 创建 BulkRequest 对象,用于批量处理请求
BulkRequest bulkRequest = new BulkRequest();
// 遍历list,将每个EsInsertVo对象封装成对应的IndexRequest请求,并添加到BulkRequest中
list.stream().forEach(res -> {
IndexRequest indexRequest = new IndexRequest(indexName);
// 获取文档ID,并设置到IndexRequest对象中
String indexId = res.getIndexId();
if (StringUtils.isNotEmpty(indexId)){
indexRequest.id(indexId);
}
// 获取文档内容,并设置到IndexRequest对象中
Map<String, Object> parms = res.getParms();
indexRequest.source(parms);
bulkRequest.add(indexRequest);
});
try {
// 使用BulkRequest对象发送请求,获取Elasticsearch服务返回的响应
BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
// 判断响应中是否包含失败信息,如果有则返回错误信息
if (bulk.hasFailures()){
return R.ok(false,"添加失败");
}
} catch (Exception e) {
// 发生异常时,抛出ServiceException并返回错误信息
throw new ServiceException("批添错误");
}
// 如果所有文档都成功插入,则返回成功信息
return R.ok(true,"添加成功");
}
(2).批量删除
public R<Boolean> delete(EsDeleteListVo esDeleteListVo) {
// 获取删除数据的索引名称和数据
String indexName = esDeleteListVo.getIndexName();
List<EsDeleteVo> list = esDeleteListVo.getList();
// 检查索引是否存在,如果不存在则抛出异常或返回错误信息
esIndexService.checkParms(indexName, true);
// 查询索引是否存在,如果不存在则返回错误信息
R<Boolean> booleanR = esIndexService.selectEsIndex(new SelectEsIndex(indexName));
if (!booleanR.getData()){
return R.ok(false,"索引不存在,请先创建索引");
}
// 判断list是否为空,如果为空将抛出异常
if (CollectionUtils.isEmpty(list)){
throw new ServiceException("删除数据不能为空");
}
// 创建 BulkRequest 对象,用于批量处理请求
BulkRequest bulkRequest = new BulkRequest();
// 遍历list,将每个EsDeleteVo对象封装成对应的DeleteRequest请求,并添加到BulkRequest中
list.stream().forEach(res -> {
DeleteRequest deleteRequest = new DeleteRequest(indexName);
// 获取删除文档的ID,并设置到DeleteRequest对象中
String indexId = res.getIndexId();
if (StringUtils.isNotEmpty(indexId)){
deleteRequest.id(indexId);
}
bulkRequest.add(deleteRequest);
});
try {
// 使用BulkRequest对象发送请求,获取Elasticsearch服务返回的响应
BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
// 判断响应中是否包含失败信息,如果有则返回错误信息
if (bulk.hasFailures()){
return R.ok(false,"删除失败");
}
} catch (Exception e) {
// 发生异常时,抛出ServiceException并返回错误信息
throw new ServiceException("批删错误");
}
// 如果所有文档都成功删除,则返回成功信息
return R.ok(true,"删除成功");
}
(3).条件查询(因为要支持不同的数据类型进行查询)
public R find(EsQueryVo esQueryVo) {
// 定义 total 数量为零
long total = 0;
// 定义一个 ArrayList 集合,用来存储查询到的结果
ArrayList<Map<String, Object>> list = new ArrayList<>();
// 获取索引名称
String indexName = esQueryVo.getIndexName();
// 获取当前页码数和每页显示数量
Integer pageNum = esQueryVo.getPageNum();
Integer pageSize = esQueryVo.getPageSize();
// 获取查询参数
Map<String, Map<String, Object>> parms = esQueryVo.getParms();
// 创建一个查询请求对象
SearchRequest searchRequest = new SearchRequest(indexName);
// 创建一个查询构造器
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
// 创建一个布尔查询构造器
BoolQueryBuilder builder = QueryBuilders.boolQuery();
// 检查参数是否为空,如果为空则进行全量查询
esIndexService.checkParms(indexName, true);
if (MapUtil.isEmpty(parms)) {
// 如果参数为空,则进行全量查询
sourceBuilder.query(QueryBuilders.matchAllQuery());
}
if (MapUtil.isNotEmpty(parms)) {
// 如果参数不为空
// 获取模糊匹配的参数,并添加到查询构造器中
Map<String, Object> match = parms.get("match");
if (MapUtil.isNotEmpty(match)) {
match.keySet().stream().forEach(key -> {
MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder(key, match.get(key));
builder.must(matchQueryBuilder);
sourceBuilder.query(builder);
});
}
// 获取精准匹配的参数,并添加到查询构造器中
Map<String, Object> term = parms.get("term");
if (MapUtil.isNotEmpty(term)) {
term.keySet().stream().forEach(key -> {
TermQueryBuilder termQueryBuilder = new TermQueryBuilder(key, term.get(key));
builder.must(termQueryBuilder);
sourceBuilder.query(builder);
});
}
// 获取排序参数,并添加到查询构造器中
Map<String, Object> order = parms.get("order");
if (MapUtil.isNotEmpty(order)) {
order.keySet().stream().forEach(key -> {
String orders = (String) order.get(key);
if ("desc".equals(orders)) {
sourceBuilder.sort(key, SortOrder.DESC);
}
if ("asc".equals(orders)) {
sourceBuilder.sort(key, SortOrder.ASC);
}
});
}
// 获取数据过滤参数,并添加到查询构造器中
Map<String, Object> filter = parms.get("filter");
if (MapUtil.isNotEmpty(filter)) {
String[] a = new String[1];
String[] b = new String[1];
filter.keySet().stream().forEach(key -> {
ArrayList<String> includes = null;
ArrayList<String> excludes = null;
if ("includes".equals(key)) {
includes = (ArrayList<String>) filter.get(key);
}
if ("excludes".equals(key)) {
excludes = (ArrayList<String>) filter.get(key);
}
if (includes != null) {
for (int i = 0; i < includes.size(); i++) {
a[i] = includes.get(i);
}
System.err.println("a:" + a);
}
if (excludes != null) {
for (int i = 0; i < excludes.size(); i++) {
b[i] = excludes.get(i);
}
}
});
sourceBuilder.fetchSource(a, b);
}
// 获取布尔查询and参数,并添加到查询构造器中
Map<String, Object> boolAnd = parms.get("boolAnd");
if (MapUtil.isNotEmpty(boolAnd)) {
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
boolAnd.keySet().stream().forEach(key -> {
ArrayList o = (ArrayList) boolAnd.get(key);
boolQuery.must(QueryBuilders.matchQuery(key, o));
sourceBuilder.query(boolQuery);
});
}
// 获取布尔查询or参数,并添加到查询构造器中
Map<String, Object> boolOr = parms.get("boolOr");
if (MapUtil.isNotEmpty(boolOr)) {
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
boolOr.keySet().stream().forEach(key -> {
ArrayList o = (ArrayList) boolOr.get(key);
boolQuery.should(QueryBuilders.matchQuery(key, o));
sourceBuilder.query(boolQuery);
});
}
// 获取高亮查询参数,并添加到查询构造器中
Map<String, Object> highlight = parms.get("highlight");
if (MapUtil.isNotEmpty(highlight)) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags("<font color='#00FFF0'>");
highlightBuilder.postTags("</font>");
highlight.keySet().stream().forEach(key -> {
sourceBuilder.query(builder);
highlightBuilder.field(key);
if (highlight.size() > 1) {
highlightBuilder.requireFieldMatch(false);
}
});
sourceBuilder.highlighter(highlightBuilder);
}
// 获取区间查询参数,并添加到查询构造器中
Map<String, Object> range = parms.get("range");
if (MapUtil.isNotEmpty(range)) {
range.keySet().stream().forEach(key -> {
ArrayList o = (ArrayList) range.get(key);
RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(key);
rangeQueryBuilder.gte(o.get(0));
rangeQueryBuilder.lt(o.get(1));
sourceBuilder.query(rangeQueryBuilder);
});
}
}
// 设置分页信息
sourceBuilder.from((pageNum - 1) * pageSize);
sourceBuilder.size(pageSize);
searchRequest.source(sourceBuilder);
try {
// 发起查询请求,并获取返回结果
SearchResponse search = client.search(searchRequest, RequestOptions.DEFAULT);
SearchHits hits = search.getHits();
total = hits.getTotalHits().value;
// 遍历查询结果,并设置高亮字段
for (SearchHit hit : hits.getHits()) {
Map<String, Object> sourceAsMap = hit.getSourceAsMap();
Map<String, Object> highlight = parms.get("highlight");
highlight.keySet().stream().forEach(key -> {
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if (highlightFields != null) {
HighlightField highlightField = highlightFields.get(key);
if (highlightField != null) {
Text[] fragments = highlightField.getFragments();
String str = "";
for (Text fragment : fragments) {
str += fragment;
}
sourceAsMap.put(key, str);
}
}
});
list.add(sourceAsMap);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
// 返回查询结果
return R.ok(PageResult.toPageResult(total, list));
}