Elasticsearch 初始化客户端 Java（已解决es链接偶尔断开问题）

一.前言

        目前所使用的皆基于Elasticsearch7.6.X版本，使用的客户端连接是官方推荐的Java High Level REST Client；其他连接方式，如需介绍，后面再加入。

二.SpringBoot集成

1.引入pom依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

这里引入这个依赖就够了，在网上看见很多文章，还分别引入了elasticsearh依赖和elasticsearch-rest-high-level-client依赖，只需查看依赖关系图，或者在pom.xml点入以上代码引入，便可以发现，以上依赖里面引入了elasticsearh和elasticsearch-rest-high-level-client。

2.配置application.yml

# 这里没有使用spring data的默认配置，后面代码写配置文件，自己读取
# 需列出所有的ES服务器，并且注意使用9200端口
elasticsearch:
ip: 10.120.213.xx:9200, 10.120.214.xx:9200

3.写配置文件

ConfigElasticsearchRestClient.java

package com.demo.config;

import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HttpContext;
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 org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

@Configuration
public class ConfigElasticsearchRestClient {

    private static final int ADDRESS_LENGTH = 2;

    private static final String HTTP_SCHEME = "http";

    @Value("${elasticsearch.ip}")
    String[] ipAddress;

    @Bean
    public RestClientBuilder restClientBuilder() {
        HttpHost[] hosts = Arrays.stream(ipAddress)
                .map(this::generateHttpHost)
                .filter(Objects::nonNull)
                .toArray(HttpHost[]::new);
        RestClientBuilder builder = RestClient.builder(hosts);
        // 异步httpclient连接超时配置
        builder.setRequestConfigCallback(requestConfigBuilder -> {
            // 从connect Manager（连接池）获取链接的超时时间，单位毫秒
            requestConfigBuilder.setConnectionRequestTimeout(30000);
            // 连接目标url的超时时间
            requestConfigBuilder.setConnectTimeout(30000);
            // 请求获取数据的超时时间
            requestConfigBuilder.setSocketTimeout(60_000);
            return requestConfigBuilder;
        });
        // 异步httpclient连接数配置
        builder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setMaxConnTotal(100);
            httpClientBuilder.setMaxConnPerRoute(50);
            List<Header> headers = new ArrayList<>(2);
            headers.add(new BasicHeader("Connection", "keep-alive"));
            headers.add(new BasicHeader("Keep-Alive", "720"));
            httpClientBuilder.setDefaultHeaders(headers);
            httpClientBuilder.setKeepAliveStrategy(CustomKeepAliveStrategy.INSTANCE);
            return httpClientBuilder;
        });
        return builder;
    }

    @Bean("restHighLevelClient")
    public RestHighLevelClient highLevelClient(@Autowired RestClientBuilder restClientBuilder) {
        return new RestHighLevelClient(restClientBuilder);
    }

    private static class CustomKeepAliveStrategy extends DefaultConnectionKeepAliveStrategy {
        public static final CustomKeepAliveStrategy INSTANCE = new CustomKeepAliveStrategy();

        private CustomKeepAliveStrategy() {
            super();
        }

        @Override
        public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
            long keepAliveDuration = super.getKeepAliveDuration(response, context);
            // <0 无限期keepalive
            // 讲无限期替换成一个默认时间
            if (keepAliveDuration < 0) {
                /**
                 * 最大keep alive的时间（分钟）
                 * 这里默认为10分钟，可以根据实际情况设置。可以观察客户端机器状态为TIME_WAIT的TCP连接数，如果太多，可以增大此值。
                 */
                long maxKeepAliveSeconds = 600;
                return TimeUnit.SECONDS.toMillis(maxKeepAliveSeconds);
            }
            return keepAliveDuration;
        }
    }

    private HttpHost generateHttpHost(String s) {
        assert !StringUtils.isEmpty(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, HTTP_SCHEME);
        } else {
            return null;

        }
    }
}

参考：ConnectionTimeout异常