Java AbandonedConfig类代码示例

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public DefaultSessionPool(final ConnectionService connect, final X509TrustManager trust, final X509KeyManager key,
                          final VaultRegistry registry, final Cache<Path> cache, final TranscriptListener transcript,
                          final Host bookmark) {
    this.connect = connect;
    this.registry = registry;
    this.cache = cache;
    this.bookmark = bookmark;
    this.transcript = transcript;
    final GenericObjectPoolConfig configuration = new GenericObjectPoolConfig();
    configuration.setJmxEnabled(false);
    configuration.setEvictionPolicyClassName(CustomPoolEvictionPolicy.class.getName());
    configuration.setBlockWhenExhausted(true);
    configuration.setMaxWaitMillis(BORROW_MAX_WAIT_INTERVAL);
    this.pool = new GenericObjectPool<Session>(new PooledSessionFactory(connect, trust, key, cache, bookmark, registry), configuration);
    final AbandonedConfig abandon = new AbandonedConfig();
    abandon.setUseUsageTracking(true);
    this.pool.setAbandonedConfig(abandon);
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
@Before
public void setUp() {
    log = new StringWriter();

    final PrintWriter pw = new PrintWriter(log);
    final AbandonedConfig abandonedConfig = new AbandonedConfig();
    abandonedConfig.setLogAbandoned(true);
    abandonedConfig.setRemoveAbandonedOnBorrow(true);
    abandonedConfig.setUseUsageTracking(true);
    abandonedConfig.setRemoveAbandonedTimeout(ABANDONED_TIMEOUT_SECS);
    abandonedConfig.setLogWriter(pw);

    final GenericObjectPoolConfig config = new GenericObjectPoolConfig();
    config.setMaxTotal(3);

    final PooledObjectFactory<TestObject> factory = new TestObjectFactory();

    final ObjectPool<TestObject> innerPool =
            new GenericObjectPool<>(factory, config, abandonedConfig);

    pool = new ProxiedObjectPool<>(innerPool, getproxySource());
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public JedisPool(final JedisPoolConfig poolConfig, final String host, final int port, final int timeout, String password) {
	super(poolConfig, host, port, timeout, formatPassword(password));
	this.initRedisConnectionListener(poolConfig, host, port, timeout);

	AbandonedConfig abandonedConfig = new AbandonedConfig();
	abandonedConfig.setRemoveAbandonedTimeout(10);
	abandonedConfig.setRemoveAbandonedOnBorrow(true);
	abandonedConfig.setRemoveAbandonedOnMaintenance(true);
	internalPool.setAbandonedConfig(abandonedConfig);
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public AbandonedConfig getAbandonedConfig() {
    AbandonedConfig abandonedConfig = new AbandonedConfig();
    abandonedConfig.setRemoveAbandonedOnBorrow(this.removeAbandonedOnBorrow);
    abandonedConfig.setRemoveAbandonedTimeout(this.removeAbandonedTimeout);
    abandonedConfig.setRemoveAbandonedOnMaintenance(this.removeAbandonedOnMaintenance);
    return abandonedConfig;
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
private DataLoaderFactory() {
    GenericObjectPoolConfig config=new GenericObjectPoolConfig();
    config.setMaxTotal(1024);
    config.setMaxIdle(50);
    config.setMinIdle(8);
    config.setBlockWhenExhausted(false);// 当Pool中没有对象时不等待，而是直接new个新的

    AbandonedConfig abandonConfig=new AbandonedConfig();
    abandonConfig.setRemoveAbandonedTimeout(300);
    abandonConfig.setRemoveAbandonedOnBorrow(true);
    abandonConfig.setRemoveAbandonedOnMaintenance(true);
    factory=new GenericObjectPool<DataLoader>(this, config, abandonConfig);
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public void init() {
    if (getContextPool() == null) {
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        PoolConfig.setConfig(config, "ldap.context.pool", "ldap.context.pool.", "global.pool.");
        config.setTestOnBorrow(true);
        LdapServiceContextPoolFactory serviceContextPoolFactory = new LdapServiceContextPoolFactory(getConstantsConfig());
        setContextPool(new GenericObjectPool<>(serviceContextPoolFactory, config));
        AbandonedConfig abandonedConfig = new AbandonedConfig();
        abandonedConfig.setUseUsageTracking(true);
        abandonedConfig.setRemoveAbandonedOnMaintenance(true);
        abandonedConfig.setRemoveAbandonedOnBorrow(true);
        abandonedConfig.setRemoveAbandonedTimeout(60);
        getContextPool().setAbandonedConfig(abandonedConfig);
    }
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
private static <T> ObjectPool<T> createObjectPool(final PooledObjectFactory<T> factory) {
    final GenericObjectPoolConfig objectPoolConfig = new GenericObjectPoolConfig();
    objectPoolConfig.setMinEvictableIdleTimeMillis(TimeUnit.HOURS.toMillis(1)); // arbitrary, but positive so objects do get evicted
    objectPoolConfig.setTimeBetweenEvictionRunsMillis(TimeUnit.MINUTES.toMillis(10)); // arbitrary, but positive so objects do get evicted
    objectPoolConfig.setJmxEnabled(false);
    objectPoolConfig.setBlockWhenExhausted(false);
    objectPoolConfig.setMaxTotal(-1); // uncapped number of objects in the pool
    final AbandonedConfig abandonedConfig = new AbandonedConfig();
    abandonedConfig.setRemoveAbandonedOnBorrow(true);
    abandonedConfig.setRemoveAbandonedTimeout((int) TimeUnit.MINUTES.toSeconds(30));
    return new GenericObjectPool<T>(factory, objectPoolConfig, abandonedConfig);
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
/**
 * Creates an object pool used to provide pooling support for {@link Connection JDBC connections}.
 *
 * @param factory         the object factory
 * @param poolConfig      the object pool configuration
 * @param abandonedConfig the abandoned objects configuration
 * @return a non-null instance
 */
protected  GenericObjectPool<PoolableConnection> createObjectPool(
        final PoolableConnectionFactory factory, final GenericObjectPoolConfig poolConfig,
        final AbandonedConfig abandonedConfig) {
    GenericObjectPool<PoolableConnection> gop;
    if (abandonedConfig != null &&
            (abandonedConfig.getRemoveAbandonedOnBorrow() ||
                    abandonedConfig.getRemoveAbandonedOnMaintenance())) {
        gop = new GenericObjectPool<>(factory, poolConfig, abandonedConfig);
    }
    else {
        gop = new GenericObjectPool<>(factory, poolConfig);
    }
    return gop;
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public KryoPoolCommonsImpl(GenericObjectPoolConfig genericObjectPoolConfig, PooledObjectFactory<Kryo> pooledObjectFactory, AbandonedConfig abandonedConfig, FKCExceptionHandler fkcExceptionHandler) {
    this.kryoPool = new GenericObjectPool<Kryo>(pooledObjectFactory, genericObjectPoolConfig, abandonedConfig);
    this.fkcExceptionHandler = fkcExceptionHandler;
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public CommonsBuilder abandonedStrategy(AbandonedConfig abandonedConfig) {
    this.abandonedConfig = abandonedConfig;
    return this;
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public HBaseResourcePoolDefault(final PooledObjectFactory<R> factory, final GenericObjectPoolConfig config, final AbandonedConfig abandonedConfig) {
    super(factory, config, abandonedConfig);
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public SmtpConnectionPool(SmtpConnectionFactory factory, GenericObjectPoolConfig config, AbandonedConfig abandonedConfig) {
  super(factory, config, abandonedConfig);
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
/**
 * Initializes a new ThriftClientPool.
 *
 * @param configuration The properties for this instance of the pool
 */
public ThriftClientPool(Properties configuration) {
    this.configuration = new EzProperties(configuration, true);
    /* We only need to use this to get the application name, so we want this to fall out of scope and get garbage
     collected */
    EzBakeApplicationConfigurationHelper appConfig = new EzBakeApplicationConfigurationHelper(configuration);
    this.applicationName = appConfig.getApplicationName();
    this.applicationSecurityId = appConfig.getSecurityID();
    if (Strings.isNullOrEmpty(applicationName)) {
        logger.warn("No application name was found.  Only common services will be discoverable");
    }

    this.thriftConfiguration = new ThriftConfigurationHelper(configuration);

    poolConfig = new GenericObjectPoolConfig();
    poolConfig.setMaxIdle(thriftConfiguration.getMaxIdleClients());
    poolConfig.setMaxTotal(thriftConfiguration.getMaxPoolClients());
    poolConfig.setMinEvictableIdleTimeMillis(thriftConfiguration.getMillisIdleBeforeEviction());
    poolConfig.setTimeBetweenEvictionRunsMillis(thriftConfiguration.getMillisIdleBeforeEviction());
    poolConfig.setTestOnBorrow(thriftConfiguration.getTestOnBorrow());
    poolConfig.setTestWhileIdle(thriftConfiguration.getTestWhileIdle());
    poolConfig.setBlockWhenExhausted(thriftConfiguration.getBlockWhenExhausted());

    abandonedConfig = new AbandonedConfig();
    abandonedConfig.setLogAbandoned(thriftConfiguration.getLogAbandoned());
    abandonedConfig.setRemoveAbandonedOnBorrow(thriftConfiguration.getRemoveAbandonedOnBorrow());
    abandonedConfig.setRemoveAbandonedOnMaintenance(thriftConfiguration.getRemoveAbandonedOnMaintenance());
    abandonedConfig.setRemoveAbandonedTimeout(thriftConfiguration.getRemoveAbandonedTimeout());

    if(!thriftConfiguration.actuallyPoolClients()) {
        logger.info("Thrift client pool is NOT actually pooling clients!");
    }

    ServiceDiscovery serviceDiscoveryClient = getServiceDiscoveryClient();
    try {
        this.commonServices.addAll(serviceDiscoveryClient.getServices());
    } catch(Exception e) {
        logger.warn("Could not obtain common services!");
        throw new RuntimeException(e);
    }

    RefreshEndpoints(serviceDiscoveryClient);
    RefreshCommonEndpoints(serviceDiscoveryClient);
    closeClient(serviceDiscoveryClient);
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
private void createDbcp(DbcpConfig conf)
{
	if (!dataSources.containsKey(conf.name))
	{
		try
	    {
			
			Class.forName(conf.driverClassName);
		    
		    DriverManagerConnectionFactory cf =  new DriverManagerConnectionFactory(conf.jdbc,conf.user,conf.password);
		    
		    PoolableConnectionFactory pcf  =  new PoolableConnectionFactory(cf,null);
		    pcf.setValidationQuery(conf.validationQuery);
		    //, pool, null, conf.validationQuery, false, true,abandondedConfig);
			
		    logger.info("Creating pool "+conf.toString());
		    // create a generic pool
		    GenericObjectPool<PoolableConnection> pool = new GenericObjectPool<PoolableConnection>(pcf);
		    pool.setMaxTotal(conf.maxTotal);
		    pool.setMaxIdle(conf.maxIdle);
		    pool.setMinIdle(conf.minIdle);
		    pool.setMaxWaitMillis(conf.maxWait);
		    pool.setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
		    pool.setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
		    pool.setTestWhileIdle(conf.testWhileIdle);
		    pool.setTestOnBorrow(conf.testOnBorrow);
	    
		    AbandonedConfig abandonedConfig = new AbandonedConfig();
		    abandonedConfig.setRemoveAbandonedOnMaintenance(conf.removeAbanadoned);
		    abandonedConfig.setRemoveAbandonedTimeout(conf.removeAbandonedTimeout);
		    abandonedConfig.setLogAbandoned(conf.logAbandonded);
	    
		    pool.setAbandonedConfig(abandonedConfig);
	    
		    pcf.setPool(pool);
		    DataSource ds = new PoolingDataSource(pool);
		    dataSources.put(conf.name, ds);

	    } catch (ClassNotFoundException e) {
			logger.error("Failed to create datasource for "+conf.name+ " with class "+conf.driverClassName);
		}
	   
	}
	else
	{
		logger.error("Pool "+conf.name+" already exists. Can't change existing datasource at present.");
	}
}
 

import org.apache.commons.pool2.impl.AbandonedConfig; //导入依赖的package包/类
public PoolClientInvocationHandler(Configuration conf) throws Exception {
  this.conf = conf;
  readConfiguration();
  poolFactory = new SentryServiceClientPoolFactory(conf);
  pool = new GenericObjectPool<SentryPolicyServiceClient>(poolFactory, poolConfig, new AbandonedConfig());
}