Elastic Search 连接池实现

pom 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.16.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xiaoe</groupId>
    <artifactId>es</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>es</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <skipTests>true</skipTests>
        <java.version>1.8</java.version>
        <elasticsearch.version>6.8.2</elasticsearch.version>
        <commons-pool2.version>2.8.0</commons-pool2.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</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.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>${commons-pool2.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <finalName>es-service</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件

spring.application.name=es-server

server.port=8081

#elasticsearch配置
es.config.cluster-name=XXX
es.config.cluster-nodes=XXX
es.config.username=XXX
es.config.password=XXX
es.config.connect-timeout=5000
es.config.socket-timeout=30000
es.config.connection-request-timeout=30000

es.config.index=XXX

es.pool.max-total=8
es.pool.max-idle=8
es.pool.min-idle=1

配置类

package com.xiaoe.es.config;

import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.net.URL;

@Configuration
public class ESConfig implements InitializingBean {

    @Value("${es.config.cluster-name}")
    private String esClusterName;
    @Value("${es.config.cluster-nodes}")
    private String esClusterNodes;
    @Value("${es.config.username}")
    private String esUserName;
    @Value("${es.config.password}")
    private String esPassword;
    @Value("${es.config.index}")
    private String index;
    @Value("${es.config.connection-request-timeout}")
    private int esConnectionRequestTimeout;
    @Value("${es.config.connect-timeout}")
    private int esConnectTimeout;
    @Value("${es.config.socket-timeout}")
    private int esSocketTimeout;


    @Value("${es.pool.max-total}")
    private int maxTotal;
    @Value("${es.pool.max-idle}")
    private int maxIdle;
    @Value("${es.pool.min-idle}")
    private int minIdle ;

    public static String ES_CLUSTER_NAME = "";
    public static String ES_CLUSTER_NODES = "";
    public static String ES_USERNAME = "";
    public static String ES_PASSWORD = "";
    public static String ES_INDEX = "";
    public static int ES_CONNECTION_REQUEST_TIMEOUT = -1;
    public static int ES_CONNECT_TIMEOUT = -1;
    public static int ES_SOCKET_TIMEOUT = -1;


    public static int MAX_TOTAL = 8;
    public static int MAX_IDLE = 8;
    public static int MIN_IDLE = 1;


    @Override
    public void afterPropertiesSet() {
        ES_CLUSTER_NAME = esClusterName;
        ES_CLUSTER_NODES = esClusterNodes;
        ES_USERNAME = esUserName;
        ES_PASSWORD = esPassword;
        ES_INDEX = index;
        ES_CONNECTION_REQUEST_TIMEOUT = esConnectionRequestTimeout;
        ES_CONNECT_TIMEOUT = esConnectTimeout;
        ES_SOCKET_TIMEOUT = esSocketTimeout;

        MAX_TOTAL = maxTotal;
        MAX_IDLE = maxIdle;
        MIN_IDLE = minIdle;
    }

    @Bean
    public GenericObjectPoolConfig config() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMinIdle(ESConfig.MIN_IDLE);
        poolConfig.setMaxTotal(ESConfig.MAX_TOTAL);
        poolConfig.setMaxIdle(ESConfig.MAX_IDLE);
        poolConfig.setJmxEnabled(false);
        return poolConfig;
    }

    @Bean
    public GenericObjectPool<RestHighLevelClient> pool(
            PooledObjectFactory<RestHighLevelClient> factory,
            GenericObjectPoolConfig config) {
        return new GenericObjectPool<>(factory, config);
    }

    @Bean
    public PooledObjectFactory<RestHighLevelClient> factory() {
        return new BasePooledObjectFactory<RestHighLevelClient>() {

            @Override
            public void destroyObject(PooledObject<RestHighLevelClient> pooledObject) throws Exception {
                RestHighLevelClient highLevelClient = pooledObject.getObject();
                highLevelClient.close();
            }

            @Override
            public RestHighLevelClient create() throws Exception {

                String[] urlList = ESConfig.ES_CLUSTER_NODES.split(",");
                HttpHost[] nodes = new HttpHost[urlList.length];
                for (int i = 0; i < urlList.length; i++) {
                    URL url = new URL(urlList[i]);
                    HttpHost node = new HttpHost(url.getHost(), url.getPort(), url.getProtocol());
                    nodes[i] = node;
                }

                final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(ESConfig.ES_USERNAME, ESConfig.ES_PASSWORD));

                return new RestHighLevelClient(RestClient.builder(nodes)
                        .setRequestConfigCallback(
                                requestConfigBuilder -> {
                                    requestConfigBuilder.setConnectTimeout(ESConfig.ES_CONNECT_TIMEOUT);
                                    requestConfigBuilder.setSocketTimeout(ESConfig.ES_SOCKET_TIMEOUT);
                                    requestConfigBuilder.setConnectionRequestTimeout(ESConfig.ES_CONNECTION_REQUEST_TIMEOUT);
                                    return requestConfigBuilder;
                                }
                        ).setHttpClientConfigCallback(
                                httpAsyncClientBuilder -> httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider)
                        )
                );
            }

            @Override
            public PooledObject<RestHighLevelClient> wrap(RestHighLevelClient restHighLevelClient) {
                return new DefaultPooledObject<>(restHighLevelClient);
            }
        };
    }
}

连接池

package com.xiaoe.es.pool;

import org.apache.commons.pool2.impl.GenericObjectPool;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class EsClientPool {

    @Resource
    private GenericObjectPool<RestHighLevelClient> genericObjectPool;

    /**
     * 获得对象
     *
     * @return
     * @throws Exception
     */
    public RestHighLevelClient getClient() throws Exception {
        // 从池中取一个对象
        return genericObjectPool.borrowObject();
    }

    /**
     * 归还对象
     *
     * @param client
     */
    public void returnClient(RestHighLevelClient client) {
        // 使用完毕之后，归还对象
        genericObjectPool.returnObject(client);
    }

}

CRUD服务类

package com.xiaoe.es.service;

import com.xiaoe.es.pool.EsClientPool;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class EsClientService {

    private static final Logger logger = LoggerFactory.getLogger(EsClientService.class);

    @Resource
    private EsClientPool esClientPool;

    public SearchResponse search(SearchSourceBuilder sourceBuilder, String index) {
        SearchRequest searchRequest = new SearchRequest(index);
        searchRequest.source(sourceBuilder);
        RestHighLevelClient client = null;
        try {
            client = esClientPool.getClient();
            return client.search(searchRequest, RequestOptions.DEFAULT);
        } catch (Exception e) {
            logger.info("ES search fail", e);
        } finally {
            if (client != null) {
                esClientPool.returnClient(client);
            }
        }
        return null;
    }


}

测试类

package com.xiaoe.es;

import com.xiaoe.es.config.ESConfig;
import com.xiaoe.es.service.EsClientService;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class EsApplicationTests {

    private Logger logger = LoggerFactory.getLogger(EsApplicationTests.class);

    @Autowired
    private EsClientService esClientService;

    @Test
    public void test() {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        SearchResponse searchResponse = esClientService.search(searchSourceBuilder, ESConfig.ES_INDEX);
        if (searchResponse != null) {
            SearchHits hits = searchResponse.getHits();
            SearchHit[] hitsHits = hits.getHits();
            for (SearchHit searchHit : hitsHits) {
                logger.info(searchHit.getId());
            }
        }
    }

}