How to use

setTestOnBorrow

method

in

org.apache.commons.pool.impl.GenericObjectPool

objectPool.setMaxIdle(connectionMaxIlde);
objectPool.setMinIdle(connectionMinIlde);
objectPool.setTestOnBorrow(testOnBorrow);
objectPool.setTestWhileIdle(testWhileIdle);
objectPool.setMinEvictableIdleTimeMillis(evictionTimeMillis);

/**
 * Sets my configuration.
 *
 * @param conf configuration to use.
 * @see GenericObjectPool.Config
 */
public void setConfig(GenericObjectPool.Config conf) {
  synchronized (this) {
    setMaxIdle(conf.maxIdle);
    setMinIdle(conf.minIdle);
    setMaxActive(conf.maxActive);
    setMaxWait(conf.maxWait);
    setWhenExhaustedAction(conf.whenExhaustedAction);
    setTestOnBorrow(conf.testOnBorrow);
    setTestOnReturn(conf.testOnReturn);
    setTestWhileIdle(conf.testWhileIdle);
    setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
    setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
    setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
    setSoftMinEvictableIdleTimeMillis(conf.softMinEvictableIdleTimeMillis);
    setLifo(conf.lifo);
  }
  allocate();
}

/**
 * Sets the {@link #testOnBorrow} property. This property determines
 * whether or not the pool will validate objects before they are borrowed
 * from the pool. For a <code>true</code> value to have any effect, the 
 * <code>validationQuery</code> property must be set to a non-null string.
 * 
 * @param testOnBorrow new value for testOnBorrow property
 */
public synchronized void setTestOnBorrow(boolean testOnBorrow) {
  this.testOnBorrow = testOnBorrow;
  if (connectionPool != null) {
    connectionPool.setTestOnBorrow(testOnBorrow);
  }
}

/**
 * Sets the {@link #testOnBorrow} property. This property determines
 * whether or not the pool will validate objects before they are borrowed
 * from the pool. For a <code>true</code> value to have any effect, the
 * <code>validationQuery</code> property must be set to a non-null string.
 *
 * @param testOnBorrow new value for testOnBorrow property
 */
public synchronized void setTestOnBorrow(boolean testOnBorrow) {
  this.testOnBorrow = testOnBorrow;
  if (connectionPool != null) {
    connectionPool.setTestOnBorrow(testOnBorrow);
  }
}

/**
 * Sets the {@link #testOnBorrow} property. This property determines
 * whether or not the pool will validate objects before they are borrowed
 * from the pool. For a <code>true</code> value to have any effect, the 
 * <code>validationQuery</code> property must be set to a non-null string.
 * 
 * @param testOnBorrow new value for testOnBorrow property
 */
public synchronized void setTestOnBorrow(boolean testOnBorrow) {
  this.testOnBorrow = testOnBorrow;
  if (connectionPool != null) {
    connectionPool.setTestOnBorrow(testOnBorrow);
  }
}

/**
 * Sets the {@link #testOnBorrow} property. This property determines
 * whether or not the pool will validate objects before they are borrowed
 * from the pool. For a <code>true</code> value to have any effect, the 
 * <code>validationQuery</code> property must be set to a non-null string.
 * 
 * @param testOnBorrow new value for testOnBorrow property
 */
public synchronized void setTestOnBorrow(boolean testOnBorrow) {
  this.testOnBorrow = testOnBorrow;
  if (connectionPool != null) {
    connectionPool.setTestOnBorrow(testOnBorrow);
  }
}

/**
 * Sets the {@link #testOnBorrow} property. This property determines
 * whether or not the pool will validate objects before they are borrowed
 * from the pool. For a <code>true</code> value to have any effect, the 
 * <code>validationQuery</code> property must be set to a non-null string.
 * 
 * @param testOnBorrow new value for testOnBorrow property
 */
public void setTestOnBorrow(boolean testOnBorrow) {
  this.testOnBorrow = testOnBorrow;
  if (sessionPool != null) {
    sessionPool.setTestOnBorrow(testOnBorrow);
  }
}

 GenericObjectPool connectionPool = new GenericObjectPool(null);
...
connectionPool.setTestOnBorrow(true); // test the connection before its made
ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI,username, password);

final String validationQuery = null;
KeyedObjectPoolFactory statementPool = new GenericKeyedObjectPoolFactory(null);
PoolableConnectionFactory factory = new PoolableConnectionFactory(connectionFactory, connectionPool,
    statementPool, validationQuery, defaultReadOnly, defaultAutoCommit);

factory.setValidationQuery("select 1");    // validate the connection with this statement

GenericObjectPool connectionPool = new GenericObjectPool(null);
 connectionPool.setMinEvictableIdleTimeMillis(1000 * 60 * 30);
 connectionPool.setTimeBetweenEvictionRunsMillis(1000 * 60 * 30);
 connectionPool.setNumTestsPerEvictionRun(3);
 connectionPool.setTestOnBorrow(true);
 connectionPool.setTestWhileIdle(false);
 connectionPool.setTestOnReturn(false);
 props = new Properties();
 props.put("user", username);
 props.put("password", password);
 ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(url, props);
 PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, connectionPool, null, "SELECT 1", false, true);
 PoolingDataSource dataSource = new PoolingDataSource(connectionPool);

public void afterPropertiesSet() throws Exception {
  if (pool == null) {
    GenericObjectPool goPool = new GenericObjectPool();
    goPool.setTestOnBorrow(true);
    goPool.setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_GROW);
    pool = goPool;
  }
  pool.setFactory(this);
}

 private ObjectPool getNewConnectionPool(DataSource mySqlDataSource) {
  try {
    GenericObjectPool pool = new GenericObjectPool(null, 10); 
    pool.setTestOnBorrow(true);
    ConnectionFactory factory = new DataSourceConnectionFactory(mySqlDataSource);
    PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(factory, pool, null, "SELECT 1 FROM DUAL", false, true);
    Class.forName("org.apache.commons.dbcp.PoolingDriver");
    PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
    driver.registerPool("myPool", pool);
    return poolableConnectionFactory.getPool();
  } catch (Exception e) {
    throw new RuntimeException("Unable to initialize connetion pooling", e);
  }
}

public static DataSource getPoolingDataSourceFromConf(Configuration conf) {
 final ConnectionFactory cf = new DriverManagerConnectionFactory(
   conf.get(LensConfConstants.SERVER_DB_JDBC_URL, LensConfConstants.DEFAULT_SERVER_DB_JDBC_URL),
   conf.get(LensConfConstants.SERVER_DB_JDBC_USER, LensConfConstants.DEFAULT_SERVER_DB_USER),
   conf.get(LensConfConstants.SERVER_DB_JDBC_PASS, LensConfConstants.DEFAULT_SERVER_DB_PASS));
 final GenericObjectPool connectionPool = new GenericObjectPool();
 connectionPool.setTestOnBorrow(false);
 connectionPool.setTestOnReturn(false);
 connectionPool.setTestWhileIdle(true);
 new PoolableConnectionFactory(cf, connectionPool, null,
   conf.get(LensConfConstants.SERVER_DB_VALIDATION_QUERY, LensConfConstants.DEFAULT_SERVER_DB_VALIDATION_QUERY),
   false, false).setDefaultAutoCommit(true);
 return new PoolingDataSource(connectionPool);
}

@Override
public void afterPropertiesSet() throws Exception {
  // 对象池
  objectPool = new GenericObjectPool<TTransport>();
  //
  ((GenericObjectPool<TTransport>) objectPool).setMaxActive(maxActive);
  ((GenericObjectPool<TTransport>) objectPool).setMaxIdle(maxIdle);
  ((GenericObjectPool<TTransport>) objectPool).setMinIdle(minIdle);
  ((GenericObjectPool<TTransport>) objectPool).setMaxWait(maxWait);
  ((GenericObjectPool<TTransport>) objectPool).setTestOnBorrow(testOnBorrow);
  ((GenericObjectPool<TTransport>) objectPool).setTestOnReturn(testOnReturn);
  ((GenericObjectPool<TTransport>) objectPool).setTestWhileIdle(testWhileIdle);
  ((GenericObjectPool<TTransport>) objectPool).setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_BLOCK);
  // 设置factory
  ThriftPoolableObjectFactory thriftPoolableObjectFactory = new ThriftPoolableObjectFactory(serviceIP, servicePort, conTimeOut);
  ((GenericObjectPool<TTransport>) objectPool).setFactory(thriftPoolableObjectFactory);
}

/**
 * Sets my configuration.
 *
 * @param conf configuration to use.
 * @see GenericObjectPool.Config
 */
public synchronized void setConfig(GenericObjectPool.Config conf) {
  setMaxIdle(conf.maxIdle);
  setMinIdle(conf.minIdle);
  setMaxActive(conf.maxActive);
  setMaxWait(conf.maxWait);
  setWhenExhaustedAction(conf.whenExhaustedAction);
  setTestOnBorrow(conf.testOnBorrow);
  setTestOnReturn(conf.testOnReturn);
  setTestWhileIdle(conf.testWhileIdle);
  setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
  setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
  setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
  setSoftMinEvictableIdleTimeMillis(conf.softMinEvictableIdleTimeMillis);
  setLifo(conf.lifo);
  allocate();
}

/**
 * Sets my configuration.
 *
 * @param conf configuration to use.
 * @see GenericObjectPool.Config
 */
public void setConfig(GenericObjectPool.Config conf) {
  synchronized (this) {
    setMaxIdle(conf.maxIdle);
    setMinIdle(conf.minIdle);
    setMaxActive(conf.maxActive);
    setMaxWait(conf.maxWait);
    setWhenExhaustedAction(conf.whenExhaustedAction);
    setTestOnBorrow(conf.testOnBorrow);
    setTestOnReturn(conf.testOnReturn);
    setTestWhileIdle(conf.testWhileIdle);
    setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
    setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
    setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
    setSoftMinEvictableIdleTimeMillis(conf.softMinEvictableIdleTimeMillis);
    setLifo(conf.lifo);
  }
  allocate();
}

/**
 * Sets my configuration.
 *
 * @param conf configuration to use.
 * @see GenericObjectPool.Config
 */
public synchronized void setConfig(GenericObjectPool.Config conf) {
  setMaxIdle(conf.maxIdle);
  setMinIdle(conf.minIdle);
  setMaxActive(conf.maxActive);
  setMaxWait(conf.maxWait);
  setWhenExhaustedAction(conf.whenExhaustedAction);
  setTestOnBorrow(conf.testOnBorrow);
  setTestOnReturn(conf.testOnReturn);
  setTestWhileIdle(conf.testWhileIdle);
  setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
  setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
  setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
  setSoftMinEvictableIdleTimeMillis(conf.softMinEvictableIdleTimeMillis);
  setLifo(conf.lifo);
  allocate();
}

/**
 * Creates a connection pool for this datasource.  This method only exists
 * so subclasses can replace the implementation class.
 */
protected void createConnectionPool() {
  // Create an object pool to contain our active connections
  GenericObjectPool gop;
  if ((abandonedConfig != null) && (abandonedConfig.getRemoveAbandoned())) {
    gop = new AbandonedObjectPool(null,abandonedConfig);
  }
  else {
    gop = new GenericObjectPool();
  }
  gop.setMaxActive(maxActive);
  gop.setMaxIdle(maxIdle);
  gop.setMinIdle(minIdle);
  gop.setMaxWait(maxWait);
  gop.setTestOnBorrow(testOnBorrow);
  gop.setTestOnReturn(testOnReturn);
  gop.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
  gop.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
  gop.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
  gop.setTestWhileIdle(testWhileIdle);
  connectionPool = gop;
}

/**
 * Sets my configuration.
 *
 * @param conf configuration to use.
 * @see GenericObjectPool.Config
 */
public void setConfig(GenericObjectPool.Config conf) {
  synchronized (this) {
    setMaxIdle(conf.maxIdle);
    setMinIdle(conf.minIdle);
    setMaxActive(conf.maxActive);
    setMaxWait(conf.maxWait);
    setWhenExhaustedAction(conf.whenExhaustedAction);
    setTestOnBorrow(conf.testOnBorrow);
    setTestOnReturn(conf.testOnReturn);
    setTestWhileIdle(conf.testWhileIdle);
    setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
    setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
    setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
    setSoftMinEvictableIdleTimeMillis(conf.softMinEvictableIdleTimeMillis);
    setLifo(conf.lifo);
  }
  allocate();
}

protected void configureGenericObjectPool(GenericObjectPool genericObjectPool) throws SyslogRuntimeException {
  SyslogPoolConfigIF poolConfig = null;
  try {
    poolConfig = (SyslogPoolConfigIF) this.syslog.getConfig();
  } catch (ClassCastException cce) {
    throw new SyslogRuntimeException("config must implement interface SyslogPoolConfigIF");
  }
  genericObjectPool.setMaxActive(poolConfig.getMaxActive());
  genericObjectPool.setMaxIdle(poolConfig.getMaxIdle());
  genericObjectPool.setMaxWait(poolConfig.getMaxWait());
  genericObjectPool.setMinEvictableIdleTimeMillis(poolConfig.getMinEvictableIdleTimeMillis());
  genericObjectPool.setMinIdle(poolConfig.getMinIdle());
  genericObjectPool.setNumTestsPerEvictionRun(poolConfig.getNumTestsPerEvictionRun());
  genericObjectPool.setSoftMinEvictableIdleTimeMillis(poolConfig.getSoftMinEvictableIdleTimeMillis());
  genericObjectPool.setTestOnBorrow(poolConfig.isTestOnBorrow());
  genericObjectPool.setTestOnReturn(poolConfig.isTestOnReturn());
  genericObjectPool.setTestWhileIdle(poolConfig.isTestWhileIdle());
  genericObjectPool.setTimeBetweenEvictionRunsMillis(poolConfig.getTimeBetweenEvictionRunsMillis());
  genericObjectPool.setWhenExhaustedAction(poolConfig.getWhenExhaustedAction());
}

protected void configureGenericObjectPool(GenericObjectPool<AbstractSyslogWriter> genericObjectPool) throws SyslogRuntimeException {
  SyslogPoolConfigIF poolConfig = null;
  try {
    poolConfig = (SyslogPoolConfigIF) this.syslog.getConfig();
  } catch (ClassCastException cce) {
    throw new SyslogRuntimeException("config must implement interface SyslogPoolConfigIF");
  }
  genericObjectPool.setMaxActive(poolConfig.getMaxActive());
  genericObjectPool.setMaxIdle(poolConfig.getMaxIdle());
  genericObjectPool.setMaxWait(poolConfig.getMaxWait());
  genericObjectPool.setMinEvictableIdleTimeMillis(poolConfig.getMinEvictableIdleTimeMillis());
  genericObjectPool.setMinIdle(poolConfig.getMinIdle());
  genericObjectPool.setNumTestsPerEvictionRun(poolConfig.getNumTestsPerEvictionRun());
  genericObjectPool.setSoftMinEvictableIdleTimeMillis(poolConfig.getSoftMinEvictableIdleTimeMillis());
  genericObjectPool.setTestOnBorrow(poolConfig.isTestOnBorrow());
  genericObjectPool.setTestOnReturn(poolConfig.isTestOnReturn());
  genericObjectPool.setTestWhileIdle(poolConfig.isTestWhileIdle());
  genericObjectPool.setTimeBetweenEvictionRunsMillis(poolConfig.getTimeBetweenEvictionRunsMillis());
  genericObjectPool.setWhenExhaustedAction(poolConfig.getWhenExhaustedAction());
}