ElasticSearch连接池创建

ElasticSearch连接池创建

创建ElasticSearch连接

package com.kingyea.common.data.utils;

import com.kingyea.boot.exception.KYException;
import com.kingyea.common.data.config.ConfigIni;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.InetAddress;

public class EsClientPoolFactory implements PooledObjectFactory<PreBuiltTransportClient>{

    private final static Logger LOG = LoggerFactory.getLogger(EsClientPoolFactory.class);

    @Override
    public void activateObject(PooledObject<PreBuiltTransportClient> arg0) {
        System.out.println("activateObject");
    }
    /**
     * 销毁对象
     */
    @Override
    public void destroyObject(PooledObject<PreBuiltTransportClient> pooledObject){
        try{
            PreBuiltTransportClient preBuiltTransportClient = pooledObject.getObject();
            preBuiltTransportClient.close();
        }catch (Exception e){}
    }
    /**
     * 生产对象
     */
    @Override
    public PooledObject<PreBuiltTransportClient> makeObject(){

        PreBuiltTransportClient client;
        try {
            String ip = ConfigIni.getEsProperty("ip");
            String clusterName = ConfigIni.getEsProperty("cluster.name");
            int port = Integer.parseInt(ConfigIni.getEsProperty("port"));
            LOG.info("clusterName {}", clusterName);
            Settings settings = Settings.builder()
                    .put("cluster.name", clusterName)
                    .put("client.transport.sniff", true)
                    .build();
            client = new PreBuiltTransportClient(settings);
            String[] esIps = ip.split(",");
            client.addTransportAddresses(new TransportAddress(InetAddress.getByName(esIps[0]), port));
            LOG.info("client {}", client);
        } catch (Exception e) {
            LOG.info("ES连接错误，请检查配置", e);
            throw new KYException("ES连接错误，请检查配置");
        }
        return new DefaultPooledObject<PreBuiltTransportClient>(client);
    }

    @Override
    public void passivateObject(PooledObject<PreBuiltTransportClient> arg0){
        LOG.info("passivateObject");
     }

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

}

ElasticSearch连接池对象配置

package com.kingyea.common.data.utils;

import com.kingyea.boot.exception.KYException;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.elasticsearch.transport.client.PreBuiltTransportClient;

public class ElasticSearchPoolUtil {

    // 对象池配置类，不写也可以，采用默认配置
    private static GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();

    // 采用默认配置maxTotal是8，池中有8个client
    static {
        poolConfig.setMaxTotal(8);
    }
    // 要池化的对象的工厂类，这个是我们要实现的类
    private static EsClientPoolFactory esClientPoolFactory = new EsClientPoolFactory();
    // 利用对象工厂类和配置类生成对象池
    private static GenericObjectPool<PreBuiltTransportClient> clientPool = new GenericObjectPool<>(esClientPoolFactory,
            poolConfig);

    /**
     * 获得对象
     *
     * @return
     * @throws Exception
     */
    public static PreBuiltTransportClient getClient(){
        try{
            // 从池中取一个对象
            PreBuiltTransportClient client = clientPool.borrowObject();
            return client;
        }catch (Exception e){
            throw new KYException("获取ES连接失败");
        }
    }

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

}