elasticsearch客户端嗅探器

POM

<elasticsearch.version>6.2.3</elasticsearch.version>

<!-- elasticsearch -->
<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>${elasticsearch.version}</version>
</dependency>
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>${elasticsearch.version}</version>
</dependency>

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client</artifactId>
    <version>${elasticsearch.version}</version>
</dependency>

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-client-sniffer</artifactId>
    <version>${elasticsearch.version}</version>
</dependency>

客户端嗅探器代码

import org.apache.commons.io.IOUtils;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.sniff.SniffOnFailureListener;
import org.elasticsearch.client.sniff.Sniffer;

public class EsClientFactory {
    private  String host = "127.0.0.1";
    private  String scheme="http";
    private  int port=9200;
    private  int maxRetryTimeout=30000;
    private  int connectTimeOut = 2000;
    private  int socketTimeOut = 15000;
    private  int connectionRequestTimeOut = 500;
    private  int maxConnectNum = 100;
    private  int maxConnectPerRoute = 100;
    private  HttpHost[] httpHosts;
    private  boolean uniqueConnectTimeConfig = true;
    private  boolean uniqueConnectNumConfig = true;
    private boolean  enableSniff=true;
    private  RestClientBuilder builder;
    private Sniffer sniffer = null;
    private RestClient restClient = null;
    private volatile RestHighLevelClient highClient;
    private static volatile EsClientFactory esClientFactory;

    private EsClientFactory() {

    }

    public static EsClientFactory getInstance() {
        if (esClientFactory == null) {
            synchronized (EsClientFactory.class) {
                if (esClientFactory == null) {
                    esClientFactory = new EsClientFactory();
                    esClientFactory.init();
                }
            }
        }
        return esClientFactory;
    }

    /**
     * 初始化builder
     * @return
     */
    public RestClientBuilder init() {
        String[] hosts = host.split(",");
        httpHosts = new HttpHost[hosts.length];
        for (int i = 0; i < hosts.length; i++) {
            httpHosts[i] = new HttpHost(hosts[i], port, scheme);
        }

        builder = RestClient.builder(httpHosts);

        Header[] defaultHeaders = new Header[] {
                new BasicHeader("Content-Type", "application/json")
        };
        builder.setDefaultHeaders(defaultHeaders);
        builder.setMaxRetryTimeoutMillis(maxRetryTimeout);

        if (uniqueConnectTimeConfig) {
            setConnectTimeOutConfig();
        }

        if (uniqueConnectNumConfig) {
            setMutiConnectConfig();
        }

        restClient = builder.build();

        //启用嗅探器
        if(enableSniff){
            SniffOnFailureListener sniffOnFailureListener = new SniffOnFailureListener();
            builder.setFailureListener(sniffOnFailureListener);
            sniffer = Sniffer.builder(restClient).setSniffIntervalMillis(60000).setSniffAfterFailureDelayMillis(30000).build();
            sniffOnFailureListener.setSniffer(sniffer);
        }
        return builder;
    }

    /**
     * 获取高级api
     * @return
     */
    public RestHighLevelClient getHighLevelClient() {
        if (highClient == null) {
            synchronized (EsClientFactory.class) {
                if (highClient == null) {
                    highClient = new RestHighLevelClient(builder);
                }
            }
        }
        return highClient;
    }

    /**
     * 获取低级api
     * @return
     */
    public RestClient getLowLevelClient() {
        return restClient;
    }

    /**
     * 异步httpclient的连接延时配置
     */
    public void setConnectTimeOutConfig() {
        builder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
            @Override
            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                requestConfigBuilder.setConnectTimeout(connectTimeOut);
                requestConfigBuilder.setSocketTimeout(socketTimeOut);
                requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeOut);
                return requestConfigBuilder;
            }
        });
    }


    /**
     * 异步httpclient的连接数配置
     */
    public void setMutiConnectConfig() {
        builder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                httpClientBuilder.setMaxConnTotal(maxConnectNum);
                httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
                return httpClientBuilder;
            }
        });
    }

    /**
     * 关闭连接
     */
    public void close() {
        IOUtils.closeQuietly(restClient);
        IOUtils.closeQuietly(highClient);
    }

用法获取ES高级和低级客户端

/**
 * 获取高级api
 * @return
 */
public static RestHighLevelClient getEsHighClient() {
    return EsClientFactory.getInstance().getHighLevelClient();
}

/**
 * 获取低级api
 * @return
 */
public static RestClient getEsLowClient() {
    return EsClientFactory.getInstance().getLowLevelClient();
}