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,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()) {
                String value = (String) entry.getValue();
                if (StringUtils.isNotBlank(value)) {
                    MatchPhraseQueryBuilder must = QueryBuilders.
                            matchPhraseQuery(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;
    }


}