ES JAVA RestHighLevelClient客户端连接配置

首先导入相应的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
      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}")
    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;
    }


}