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 );
        }
    }
}