参考引用文档：https://www.jianshu.com/p/b45b96a61451
https://blog.csdn.net/qq_37186947/article/details/104227552
书接上文 Java连接influxDB，创建一个influxDB的连接池。
1、添加依赖
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.11.1</version>
</dependency>
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<InfluxDBClient> {
/**
* 重新初始化要由池返回的实例-即从池中借用一个对象时调用
*
* @param pooledObject 一个PooledObject包装要激活的实例
* @throws Exception
*/
@Override
public void activateObject(PooledObject<InfluxDBClient> pooledObject) throws Exception {
System.out.println("重新初始化要由池返回的实例-即从池中借用一个对象时调用");
}
/**
* 使用默认 (NORMAL) DestroyMode 销毁池不再需要的实例。
*
* @param pooledObject
* @throws Exception
*/
@Override
public void destroyObject(PooledObject<InfluxDBClient> pooledObject) throws Exception {
InfluxDBClient influxDBClient = pooledObject.getObject();
influxDBClient.close();
}
/**
* 创建可由池提供服务的实例，并将其包装在由池管理的PooledObject中
*
* @return
* @throws Exception
*/
@Override
public PooledObject<InfluxDBClient> 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<InfluxDBClient> pooledObject) throws Exception {
System.out.println("取消初始化要返回到空闲对象池的实例-即从池中归还一个对象时调用");
}
/**
* 确保实例可以安全地由池返回。
*
* @param pooledObject
* @return 如果obj无效并且应该从池中删除，则为false ，否则为true
*/
@Override
public boolean validateObject(PooledObject<InfluxDBClient> 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<InfluxDBClient> {
public InluxdbClientPool(PooledObjectFactory<InfluxDBClient> factory) {
super(factory);
}
public InluxdbClientPool(PooledObjectFactory<InfluxDBClient> factory, GenericObjectPoolConfig<InfluxDBClient> config) {
super(factory, config);
}
public InluxdbClientPool(PooledObjectFactory<InfluxDBClient> factory, GenericObjectPoolConfig<InfluxDBClient> 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<InfluxDBClient> 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<FluxRecord> getInfluxData(@RequestParam Integer startTime) {
String query = "from(bucket: \"zzs\") |> range(start: -"+startTime+"h) |> filter(fn: (r) => r._measurement == \"mem\")";
List<FluxTable> 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<FluxRecord> fluxRecords = new ArrayList<>();
tables.forEach(fluxTable -> {
List<FluxRecord> records = fluxTable.getRecords();
fluxRecords.addAll(records);
});
return fluxRecords;
}
如果注释掉归还对象的这一步，可以看到每次调用接口控制它输出对象的hashcode都是不同的，超过三次后就会新建对象，当达到最大MaxTotal时，程序会等待直到有对象归还到池中，所以从池中取出对象使用完后务必要将对象归还。
