首先导入相应的maven包
<!-- https://mvnrepository.com/artifact/org.elasticsearch.client/elasticsearch-rest-client -->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-client</artifactId>
<version>7.2.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.elasticsearch.client/elasticsearch-rest-high-level-client -->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.2.0</version>
</dependency>
项目配置文件application.yml,加入以下配置
spring:
data:
elasticsearch:
// 连接方式
scheme: http
// 集群名称
cluster-name: es-cluster
// 集群节点
cluster-nodes: 192.168.0.1:9200,192.168.0.2:9200
connection-request-timeout: 500
socket-timeout: 30000
connect-timeout: 1000
repositories:
enabled: true
ElasticsearchConfig配置类
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.elasticsearch.client.Node;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Arrays;
import java.util.Objects;
/**
* @author
* @date 2020-01-06 11:48
* @description
*/
@Configuration
public class ElasticsearchConfig {
private static final int ADDRESS_LENGTH = 2;
@Value("${spring.data.elasticsearch.scheme:http}")
private String scheme;
@Value("${spring.data.elasticsearch.cluster-nodes:192.168.0.1:9200}")
private String[] ipAddress;
@Value("${spring.data.elasticsearch.connection-request-timeout}")
private Integer connectionRequestTimeout;
@Value("${spring.data.elasticsearch.socket-timeout}")
private Integer socketTimeout;
@Value("${spring.data.elasticsearch.connect-timeout}")
private Integer connectTimeout;
@Bean
public RestClientBuilder restClientBuilder() {
HttpHost[] hosts = Arrays.stream(ipAddress)
.map(this::makeHttpHost)
.filter(Objects::nonNull)
.toArray(HttpHost[]::new);
RestClientBuilder restClientBuilder = RestClient.builder(hosts);
// 设置一个监听器,每次节点出现故障时都会收到通知,以防需要采取措施,
// 当启用故障嗅探时在内部使用。
restClientBuilder.setFailureListener(new RestClient.FailureListener() {
@Override
public void onFailure(Node node) {
}
});
// 设置允许修改默认请求配置的回调
//(例如请求超时,身份验证或org.apache.http.client.config.RequestConfig.Builder允许设置的任何内容)。
restClientBuilder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
@Override
public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
return requestConfigBuilder
.setConnectionRequestTimeout(connectionRequestTimeout)
.setSocketTimeout(socketTimeout)
.setConnectTimeout(connectTimeout);
}
});
return restClientBuilder;
}
@Bean(name = "highLevelClient")
public RestHighLevelClient highLevelClient(@Autowired RestClientBuilder restClientBuilder) {
// TODO 此处可以进行其它操作
return new RestHighLevelClient(restClientBuilder);
}
/**
* 根据配置创建HttpHost
* @param s
* @return
*/
private HttpHost makeHttpHost(String s) {
String[] address = s.split(":");
if (address.length == ADDRESS_LENGTH) {
String ip = address[0];
int port = Integer.parseInt(address[1]);
return new HttpHost(ip, port, scheme);
} else {
return null;
}
}
}
ES查询数据工具类
import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest;
import org.elasticsearch.action.admin.indices.settings.get.GetSettingsResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.*;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.cluster.metadata.AliasMetaData;
import org.elasticsearch.common.collect.ImmutableOpenMap;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.util.CollectionUtils;
import org.elasticsearch.index.query.*;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.metrics.ValueCount;
import org.elasticsearch.search.aggregations.metrics.ValueCountAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.ScoreSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* @author
* @date 2020-01-06 11:48
* @description
*/
@Component
public class EsUtils {
private static final long TIME_OUT = 60;
private static final String KEY_WORD = ".keyword";
private static final String COUNT = "count";
private static final String INDEX_CREATION_DATE = "index.creation_date";
private static final String KIBANA = ".kibana";
@Autowired
RestHighLevelClient highLevelClient;
/**
* 创建索引
* @param index
*/
public void createIndex(String index) {
if (!existsIndex(index)) {
try {
CreateIndexRequest request = new CreateIndexRequest(index);
mappings(request);
settings(request);
highLevelClient.indices().create(request, RequestOptions.DEFAULT);
} catch (IOException io) {
io.printStackTrace();
}
}
}
/**
* 设置setting
* @param request
*/
public void settings(CreateIndexRequest request) {
try {
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject()
.startObject("settings")
.field("number_of_shards", 5)
.field("number_of_replicas", 1)
.endObject()
.endObject();
request.settings(builder);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 设置mapping
* @param request
*/
public void mappings(CreateIndexRequest request){
try {
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject()
.startObject("mappings")
.field("properties")
.startObject()
.field("orderTime")
.startObject()
.field("type", "long")
.endObject()
.endObject()
.endObject()
.endObject();
request.mapping(builder);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 判断ES索引是否存在
* @param indexName
* @return
*/
public boolean existsIndex(String indexName) {
try{
GetIndexRequest request = new GetIndexRequest(indexName);
return highLevelClient.indices().exists(request, RequestOptions.DEFAULT);
}catch (IOException e){
e.printStackTrace();
}
return false;
}
/**
* 查出ES所有索引,根据settings中的创建时间倒序排序
* @return
*/
public Set<String> getSortIndices(){
GetSettingsRequest getSettingsRequest = new GetSettingsRequest();
GetSettingsResponse getResponse = null;
try {
getResponse = highLevelClient.indices().getSettings(getSettingsRequest, RequestOptions.DEFAULT);
} catch (IOException e) {
e.printStackTrace();
}
ImmutableOpenMap<String, Settings> settings = getResponse.getIndexToSettings();
Iterator<ObjectObjectCursor<String, Settings>> iterator = settings.iterator();
Map<String,String> map = new HashMap<>();
while (iterator.hasNext()) {
ObjectObjectCursor<String, Settings> objectCursor = iterator.next();
String key = objectCursor.key;
Settings value = objectCursor.value;
String creationDate = value.get(INDEX_CREATION_DATE);
if (key.contains(KIBANA)) {
continue;
}
map.put(key,creationDate);
}
return SortUtils.sortMapValue(map).keySet();
}
/**
* 查询ES所有索引
* @return
*/
public Set getIndices() {
try {
GetAliasesRequest request = new GetAliasesRequest();
GetAliasesResponse getAliasesResponse = highLevelClient.indices().getAlias(request,RequestOptions.DEFAULT);
Map<String, Set<AliasMetaData>> map = getAliasesResponse.getAliases();
Set<String> set = map.keySet();
return set;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 查出最小值
* @param name
* @param field
* @return
*/
private AggregationBuilder min(String name,String field) {
return AggregationBuilders.min(name).field(field);
}
/**
* 查出最大值
* @param name
* @param field
* @return
*/
private AggregationBuilder max(String name,String field) {
return AggregationBuilders.max(name).field(field);
}
/**
* 统计条数
* @param name
* @param field
* @return
*/
private ValueCountAggregationBuilder count(String name,String field) {
return AggregationBuilders.count(name).field(field);
}
/**
* 多条件模糊查询
* @param map (key为ES索引的字段,value为需要查询的值)
* @return
*/
public BoolQueryBuilder fuzzyQuery(Map<String,Object> map){
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
if (map != null && map.size() > 0) {
for (Map.Entry<String,Object> entry : map.entrySet()) {
Object value = entry.getValue();
if (value instanceof String) {
if (StringUtils.isNotBlank(value.toString())) {
try{
// 当值转换不了数字时,try catch实现模糊查询
Long.parseLong(value.toString());
MatchPhraseQueryBuilder must = QueryBuilders.matchPhraseQuery(entry.getKey(), value);
queryBuilder.must(must);
} catch (Exception e) {
// 需要模糊查询时,value.toString()的值原本为:test 需要前后加上星号最后封装查询条件时变为:*test*
WildcardQueryBuilder must = QueryBuilders.wildcardQuery(entry.getKey()+KEY_WORD, value.toString());
queryBuilder.must(must);
}
}
} else if (value instanceof Boolean) {
value = Boolean.parseBoolean(value.toString());
MatchPhraseQueryBuilder must = QueryBuilders.matchPhraseQuery(entry.getKey(), value);
queryBuilder.must(must);
} else {
TermsQueryBuilder must = QueryBuilders.termsQuery(entry.getKey(), value);
queryBuilder.must(must);
}
}
}
return queryBuilder;
}
/**
* 根据指定字段范围查询
* @param name
* @param start 开始值
* @param end 结束值
* @param format 格式化
* @param queryBuilder
*/
public void rangeQuery(String name,String start,String end,String format,
BoolQueryBuilder queryBuilder){
if (StringUtils.isNotBlank(name) && StringUtils.isNotBlank(start)
&& StringUtils.isNotBlank(end)) {
if (StringUtils.isBlank(start)) {
start = "1990-01-01 00:00:00";
}
if (StringUtils.isBlank(end)) {
end = "2099-01-01 00:00:00";
}
queryBuilder.must(QueryBuilders.rangeQuery(name+KEY_WORD).
from(start).to(end).format(format));
}
}
/**
* 根据条件获取索引总数
* @param index
* @param query
* @return
*/
public long getTotalHits(String index,String field,QueryBuilder query){
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder().query(query);
ValueCountAggregationBuilder aggregation =
AggregationBuilders
.count(COUNT)
.field(field+KEY_WORD);
sourceBuilder.aggregation(aggregation);
SearchRequest request = new SearchRequest(index).source(sourceBuilder);
try {
SearchResponse response = highLevelClient.search(request, RequestOptions.DEFAULT);
ValueCount agg = response.getAggregations().get(COUNT);
return agg.getValue();
} catch (IOException e) {
e.printStackTrace();
}
return 0;
}
/**
* 根据条件查询指定索引数据
* @param index ES索引
* @param from 开始数
* @param size 大小
* @param orderName 排序字段名
* @param sortOrder 排序方式
* @param includes 返回字段
* @param query 查询条件
* @return
*/
public List<Map<String, Object>> searchIndex(String index, int from, int size, String orderName, String sortOrder,
String[] includes, QueryBuilder query) {
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(query).from((from - 1) * size).size(size)
.timeout(new TimeValue(TIME_OUT, TimeUnit.SECONDS));
if (StringUtils.isNotBlank(orderName) && StringUtils.isNotBlank(sortOrder)) {
sourceBuilder.sort(new FieldSortBuilder(orderName).order(SortOrder.fromString(sortOrder)));
} else {
sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
}
// 返回列和排除列,排除列可设置为null
if (!CollectionUtils.isEmpty(includes)) {
sourceBuilder.fetchSource(includes,null);
}
SearchRequest searchRequest = new SearchRequest(index).source(sourceBuilder);
try{
SearchResponse response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
List<Map<String, Object>> data = new ArrayList<>();
for(SearchHit hit : response.getHits().getHits()){
Map<String, Object> map = hit.getSourceAsMap();
data.add(map);
}
return data;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
转载来自https://blog.csdn.net/m0_37845840/article/details/103856827