java 創建高可用 的elastic 連接池

第一步創建工廠類：

package com.whl.espool;

import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * EliasticSearch連接池工廠對象
 *
 * @author WEIHONGLAI
 */
public class ElasticFactory implements PooledObjectFactory<RestHighLevelClient> {

    private final static Logger LOGGER = LoggerFactory.getLogger( ElasticFactory.class );
    /**
     * es 集羣信息
     */
    private HttpHost[] hosts;


    public ElasticFactory(String hostName, String scheme) {
        String[] split = hostName.split( "," );
        this.hosts = new HttpHost[split.length];
        for (int i = 0; i < split.length; i++) {
            String[] host = split[i].split( ":" );
            HttpHost info = new HttpHost( host[0], Integer.parseInt( host[1] ), scheme );
            this.hosts[i] = info;
        }
    }

    @Override
    public void activateObject(PooledObject<RestHighLevelClient> arg0) throws Exception {
        //todo
    }

    /**
     * 銷燬對象
     */
    @Override
    public void destroyObject(PooledObject<RestHighLevelClient> pooledObject) throws Exception {
        RestHighLevelClient highLevelClient = pooledObject.getObject();
        highLevelClient.close();
    }

    /**
     * 生產對象
     */
    @Override
    public PooledObject<RestHighLevelClient> makeObject() throws Exception {
        RestHighLevelClient client = null;
        try {
            client = new RestHighLevelClient( RestClient.builder(
                    this.hosts ) );
        } catch (Exception e) {
            LOGGER.error( "elastic factory error:{}", e );
        }
        return new DefaultPooledObject<>( client );
    }

    @Override
    public void passivateObject(PooledObject<RestHighLevelClient> arg0) throws Exception {
        //todo
    }

    @Override
    public boolean validateObject(PooledObject<RestHighLevelClient> arg0) {
        //todo
        return true;
    }


}

第二步創建工具類：

package com.whl.espool;

import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.elasticsearch.client.RestHighLevelClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author WEIHONGLAI
 * @date 2019-7-18
 */
public class ElasticCacheTools {
    private final static Logger LOGGER = LoggerFactory.getLogger( ElasticCacheTools.class );
    /**
     * 默認連接池的大小爲8
     */
    private static final int MAX_TOTAL = 8;
    /**
     * 默認的scheme是http
     */
    private static final String SCHEME = "http";

    /**
     * 連接池的緩存
     */
    private final Map<String, GenericObjectPool<RestHighLevelClient>> elasticPool = new ConcurrentHashMap<>( 16 );

    /**
     * 獲取elastic 鏈接
     *
     * @param ip
     * @return
     */
    public RestHighLevelClient getElasticClient(String ip) {
        RestHighLevelClient client = null;
        synchronized (this.elasticPool) {
            GenericObjectPool<RestHighLevelClient> pool = elasticPool.get( ip.trim() );
            if (null == pool) {
                // 對象池配置類，不寫也可以，採用默認配置
                GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
                // 採用默認配置maxTotal是8，池中有8個client
                poolConfig.setMaxTotal( MAX_TOTAL );
                // 要池化的對象的工廠類，這個是我們要實現的類
                ElasticFactory esClientPoolFactory = new ElasticFactory( ip.trim(), SCHEME );
                // 利用對象工廠類和配置類生成對象池
                pool = new GenericObjectPool<>( esClientPoolFactory,
                        poolConfig );

                this.elasticPool.put( ip.trim(), pool );
            }
            // 從池中取一個對象
            try {
                client = pool.borrowObject();
            } catch (Exception e) {
                LOGGER.error( "elastic cache tool error:{}", e );
            }
        }
        return client;
    }

    /**
     * 釋放Elastic連接
     *
     * @param ip
     * @param restClient
     */
    public void releaseClient(String ip, RestHighLevelClient restClient) {
        GenericObjectPool<RestHighLevelClient> genericObjectPool = this.elasticPool.get( ip.trim() );
        if (null != genericObjectPool) {
            genericObjectPool.returnObject( restClient );
        }
    }
}