java 对象池 commons-pool2 的使用(创建influxDB连接池)

参考引用文档：https://www.jianshu.com/p/b45b96a61451
https://blog.csdn.net/qq_37186947/article/details/104227552

书接上文 Java连接influxDB，创建一个influxDB的连接池。

1、添加依赖

        
            org.apache.commons
            commons-pool2
            2.11.1

2、实现PooledObjectFactory，创建一个对象工厂

需要重写5个函数：

makeObject 方法：用于对象的新建，一般是 new 出来之后包装一下。而什么时候需要新建呢，根据策略不同则时机不同。例如在没有闲置资源对象，且已存在的资源数不超过所设置的最大资源时新建。

destroyObject 方法：销毁一个对象，除了很容易想到的闲置过长时间被清理掉了导致需要销毁之外，还有如果进行了第三个方法且返回了 false ，那么也是需要销毁的。

validateObject方法：检验这个对象是否还有有效，借出和归还时，以及内置后台线程检测闲置情况时，可以通过验证可以去除一些不符合业务逻辑的资源对象。默认这个方法是不被调用的，要开启则需要在PoolConfig中设置setTestOnBorrow , setTestOnReturn , setTestWhileIdle等属性。

activeObject 方法：在借用一个对象的时候调用，则可以在此重置其内部状态，那么返回的对象就像新的一样

passivateObject 方法：对应 activateObject 方法，是在归还一个对象的时候调用，注意不应与activateObject方法有业务逻辑上的冲突

import com.influxdb.client.InfluxDBClient;
import com.influxdb.client.InfluxDBClientFactory;
import com.influxdb.client.domain.HealthCheck;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;

/**
 * @author Jenson
 */
public class InfluxdbPooledObjectFactory implements PooledObjectFactory {

    /**
     * 重新初始化要由池返回的实例-即从池中借用一个对象时调用
     *
     * @param pooledObject 一个PooledObject包装要激活的实例
     * @throws Exception
     */
    @Override
    public void activateObject(PooledObject pooledObject) throws Exception {
        System.out.println("重新初始化要由池返回的实例-即从池中借用一个对象时调用");
    }

    /**
     * 使用默认 (NORMAL) DestroyMode 销毁池不再需要的实例。
     *
     * @param pooledObject
     * @throws Exception
     */
    @Override
    public void destroyObject(PooledObject pooledObject) throws Exception {
        InfluxDBClient influxDBClient = pooledObject.getObject();
        influxDBClient.close();
    }

    /**
     * 创建可由池提供服务的实例，并将其包装在由池管理的PooledObject中
     *
     * @return
     * @throws Exception
     */
    @Override
    public PooledObject makeObject() throws Exception {
        // 生成客户端
//        InfluxDBClient client = InfluxDBClientFactory.create(this.url, this.token.toCharArray());
        InfluxDBClient client = InfluxDBClientFactory.create("http://127.0.0.1:8086",
                "S9dKiPFvnSUd9p406aCkCdwZ_q5rke8mNWzxERaNOL6SW0Fl2JIHZ1V9B317BqmBxzdaFwxei2TcYwJu2RXnOg==".toCharArray());
        System.out.println("创建可由池提供服务的实例，并将其包装在由池管理的PooledObject中, hashcode :"+client.hashCode());
        return new DefaultPooledObject<>(client);
    }

    /**
     * 取消初始化要返回到空闲对象池的实例-即从池中归还一个对象时调用
     *
     * @param pooledObject
     * @throws Exception
     */
    @Override
    public void passivateObject(PooledObject pooledObject) throws Exception {
        System.out.println("取消初始化要返回到空闲对象池的实例-即从池中归还一个对象时调用");
    }

    /**
     * 确保实例可以安全地由池返回。
     *
     * @param pooledObject
     * @return 如果obj无效并且应该从池中删除，则为false ，否则为true
     */
    @Override
    public boolean validateObject(PooledObject pooledObject) {
        InfluxDBClient influxDBClient = pooledObject.getObject();
        HealthCheck health = influxDBClient.health();
        return HealthCheck.StatusEnum.PASS.equals(health.getStatus());
    }
}

3、创建对象池，继承GenericObjectPool

import com.influxdb.client.InfluxDBClient;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.AbandonedConfig;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

/**
 * @author Jenson
 */
public class InluxdbClientPool extends GenericObjectPool {
    public InluxdbClientPool(PooledObjectFactory factory) {
        super(factory);
    }

    public InluxdbClientPool(PooledObjectFactory factory, GenericObjectPoolConfig config) {
        super(factory, config);
    }

    public InluxdbClientPool(PooledObjectFactory factory, GenericObjectPoolConfig config, AbandonedConfig abandonedConfig) {
        super(factory, config, abandonedConfig);
    }
}

4、创建对象池自动装配配置类，将对象池做成一个Bean

import com.influxdb.client.InfluxDBClient;
import com.jenson.factory.InfluxdbPooledObjectFactory;
import com.jenson.pool.InluxdbClientPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PreDestroy;

/**
 * 对象池自动装配
 *
 * @author Jenson
 */
@Configuration
public class InfluxdbPoolAutoConfig {

    private InluxdbClientPool pool;

    @ConditionalOnClass({InfluxdbPooledObjectFactory.class})
    @Bean("inluxdbClientPool")
    protected InluxdbClientPool createInluxdbClientPool(){
        InfluxdbPooledObjectFactory factory = new InfluxdbPooledObjectFactory();
        // 设置对象池相关参数
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig<>();
        /**
         * 最大空闲
         */
        poolConfig.setMaxIdle(5);
        /**
         * 最大总数
         */
        poolConfig.setMaxTotal(10);
        /**
         * 最小空闲
         */
        poolConfig.setMinIdle(2);
        poolConfig.setBlockWhenExhausted(true);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(true);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setTimeBetweenEvictionRunsMillis(1000 * 60 * 30);
        //一定要关闭jmx，不然springboot启动会报已经注册了某个jmx的错误
        poolConfig.setJmxEnabled(false);

        // 新建一个对象池,传入对象工厂和配置
        pool = new InluxdbClientPool(factory, poolConfig);

        initPool(3, 5);

        return pool;
    }

    /**
     * 预先加载testObject对象到对象池中
     *
     * @param initialSize 初始化连接数
     * @param maxIdle     最大空闲连接数
     */
    private void initPool(int initialSize, int maxIdle) {
        if (initialSize <= 0) {
            return;
        }

        int size = Math.min(initialSize, maxIdle);
        for (int i = 0; i < size; i++) {
            try {
                pool.addObject();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    @PreDestroy
    public void destroy() {
        if (pool != null) {
            pool.close();
        }
    }
}

5、使用池

从池中取出对象使用，结束后再将对象归还

@GetMapping("/get-influx-data")
    public List getInfluxData(@RequestParam Integer startTime) {
        String query = "from(bucket: \"zzs\") |> range(start: -"+startTime+"h) |> filter(fn: (r) => r._measurement == \"mem\")";
        List tables = new ArrayList<>();
//        tables = influxdbClient.getQueryApi().query(query, "jenson");

        InfluxDBClient poolClient = null;
        try {
            poolClient = inluxdbClientPool.borrowObject();
            System.out.println("poolClient hashcode : "+poolClient.hashCode());
            tables = poolClient.getQueryApi().query(query, "jenson");
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            if (poolClient != null) {
                //最终归还对象到对象池
                inluxdbClientPool.returnObject(poolClient);
            }
        }

        List fluxRecords = new ArrayList<>();
        tables.forEach(fluxTable -> {
            List records = fluxTable.getRecords();
            fluxRecords.addAll(records);
        });
        return fluxRecords;
    }

如果注释掉归还对象的这一步，可以看到每次调用接口控制它输出对象的hashcode都是不同的，超过三次后就会新建对象，当达到最大MaxTotal时，程序会等待直到有对象归还到池中，所以从池中取出对象使用完后务必要将对象归还。

java 对象池 commons-pool2 的使用(创建influxDB连接池)

你可能感兴趣的:(java 对象池 commons-pool2 的使用(创建influxDB连接池))