Java GenericObjectPool.setTestOnBorrow方法代码示例

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
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());
}
 

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
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());
}
 

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
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);
}
 

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
private DataSource setupDataSource(String driver, String connectURI,
                                   String userName, String passwd) throws ClassNotFoundException {

    // driver
    Class.forName(driver);

    //
    // First, we'll need a ObjectPool that serves as the
    // actual pool of connections.
    //
    // We'll use a GenericObjectPool instance, although
    // any ObjectPool implementation will suffice.
    //
    GenericObjectPool connectionPool = new GenericObjectPool(null);
    // 设置在getConnection时验证Connection是否有效
    connectionPool.setTestOnBorrow(true);

    //
    // Next, we'll create a ConnectionFactory that the
    // pool will use to create Connections.
    // We'll use the DriverManagerConnectionFactory,
    // using the connect string passed in the command line
    // arguments.
    //
    ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
            connectURI, userName, passwd);

    // null can be used as parameter because this parameter is set in
    // PoolableConnectionFactory when creating a new PoolableConnection
    KeyedObjectPoolFactory statementPool = new GenericKeyedObjectPoolFactory(
            null);

    //
    // Now we'll create the PoolableConnectionFactory, which wraps
    // the "real" Connections created by the ConnectionFactory with
    // the classes that implement the pooling functionality.
    //
    new PoolableConnectionFactory(connectionFactory, connectionPool,
            statementPool, "select now()", false, true);

    //
    // Finally, we create the PoolingDriver itself,
    // passing in the object pool we created.
    //
    PoolingDataSource dataSource = new PoolingDataSource(connectionPool);

    return dataSource;
}
 

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
public void addNewPool(String dbDriver, String dbServer, String dbLogin, String dbPassword,
    int minConns, int maxConns, double maxConnTime, String dbSessionConfig, String _rdbms,
    String name) throws Exception {

  if (this.defaultPoolName == null || this.defaultPoolName.equals("")) {
    this.defaultPoolName = name;
    this.bbdd = dbServer;
    this.rdbms = _rdbms;
  }
  if (externalConnectionPool != null) {
    // No need to create and add a new pool
    return;
  }

  log4j.debug("Loading underlying JDBC driver.");
  try {
    Class.forName(dbDriver);
  } catch (ClassNotFoundException e) {
    throw new Exception(e);
  }
  log4j.debug("Done.");

  GenericObjectPool connectionPool = new GenericObjectPool(null);
  connectionPool.setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_GROW);
  connectionPool.setMaxActive(maxConns);
  connectionPool.setTestOnBorrow(false);
  connectionPool.setTestOnReturn(false);
  connectionPool.setTestWhileIdle(false);

  KeyedObjectPoolFactory keyedObject = new StackKeyedObjectPoolFactory();
  ConnectionFactory connectionFactory = new OpenbravoDriverManagerConnectionFactory(dbServer,
      dbLogin, dbPassword, dbSessionConfig, _rdbms);
  @SuppressWarnings("unused")
  // required by dbcp
  PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(
      connectionFactory, connectionPool, keyedObject, null, false, true);

  Class.forName("org.apache.commons.dbcp.PoolingDriver");
  PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
  driver.registerPool(contextName + "_" + name, connectionPool);

}
 

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
/**
 * Configures the database connection pool and sets the pool configuration.
 * 
 * @param connectionPool
 *          The ObjectPool
 * @param connectURI
 *          The url specifying the database to which it
 *          connects using JDBC
 * @param pUserId
 *          The user id attribute
 * @param pPassword
 *          The password attribute
 * 
 * @throws java.lang.Exception
 *           Throws an SQL exception that provides
 *           information on a database access error
 *           or other errors
 * 
 * @todo Make the pool access dynamic (use the dynamic class loader?)
 *       so that the application will compile/run without the Apache
 *       commons library.
 */
private void configurePool(GenericObjectPool connectionPool,
    String connectURI, String pUserId, String pPassword) throws
    Exception {
  String lowerCaseConnectURI;
  String validationQuery;

  lowerCaseConnectURI = connectURI.toLowerCase();
  validationQuery = null;

  if (lowerCaseConnectURI.startsWith("jdbc:sybase")) {
    validationQuery = "select getdate()";
  } else if (lowerCaseConnectURI.startsWith("jdbc:mysql")) {
    validationQuery = "select 1";
  } else if (lowerCaseConnectURI.startsWith("jdbc:oracle")) {
    validationQuery = "select sysdate from dual";
  } else if (lowerCaseConnectURI.startsWith("jdbc:mssql")) {
    validationQuery = "select 1";
  }

  // Pool settings - someday a dialog and persistence should be
  // added to put these under user control
  connectionPool.setMaxActive(1);
  connectionPool.setWhenExhaustedAction(GenericObjectPool.
      WHEN_EXHAUSTED_BLOCK);
  connectionPool.setMaxWait(CONN_POOL_MAX_WAIT_MS);
  connectionPool.setMaxIdle(CONN_POOL_MAX_IDLE_CONNECTIONS);
  connectionPool
      .setTimeBetweenEvictionRunsMillis(CONN_POOL_TIME_BETWEEN_EVICT_RUNS_MS);
  connectionPool.setNumTestsPerEvictionRun(CONN_POOL_NUM_TESTS_PER_EVICT_RUN);
  connectionPool.setMinEvictableIdleTimeMillis(CONN_POOL_EVICT_IDLE_TIME_MS);

  final DriverManagerConnectionFactory connectionFactory = new
      DriverManagerConnectionFactory(connectURI, pUserId, pPassword);
  final PoolableConnectionFactory poolableConnectionFactory = new
      PoolableConnectionFactory(connectionFactory, connectionPool, null,
          null, false, true);

  if (validationQuery != null) {
    connectionPool.setTestOnBorrow(true);
    connectionPool.setTestWhileIdle(true);
    poolableConnectionFactory.setValidationQuery(validationQuery);
  }
}
 

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
private synchronized void registerPool(
    String username, String password) 
    throws javax.naming.NamingException, SQLException {

    ConnectionPoolDataSource cpds = testCPDS(username, password);

    Integer userMax = getPerUserMaxActive(username);
    int maxActive = (userMax == null) ? 
        getDefaultMaxActive() : userMax.intValue();
    userMax = getPerUserMaxIdle(username);
    int maxIdle =  (userMax == null) ?
        getDefaultMaxIdle() : userMax.intValue();
    userMax = getPerUserMaxWait(username);
    int maxWait = (userMax == null) ?
        getDefaultMaxWait() : userMax.intValue();

    // Create an object pool to contain our PooledConnections
    GenericObjectPool pool = new GenericObjectPool(null);
    pool.setMaxActive(maxActive);
    pool.setMaxIdle(maxIdle);
    pool.setMaxWait(maxWait);
    pool.setWhenExhaustedAction(whenExhaustedAction(maxActive, maxWait));
    pool.setTestOnBorrow(getTestOnBorrow());
    pool.setTestOnReturn(getTestOnReturn());
    pool.setTimeBetweenEvictionRunsMillis(
        getTimeBetweenEvictionRunsMillis());
    pool.setNumTestsPerEvictionRun(getNumTestsPerEvictionRun());
    pool.setMinEvictableIdleTimeMillis(getMinEvictableIdleTimeMillis());
    pool.setTestWhileIdle(getTestWhileIdle());
            
    // Set up the factory we will use (passing the pool associates
    // the factory with the pool, so we do not have to do so
    // explicitly)
    CPDSConnectionFactory factory = new CPDSConnectionFactory(cpds, pool, getValidationQuery(),
            isRollbackAfterValidation(), username, password);
       
    Object old = managers.put(getPoolKey(username,password), factory);
    if (old != null) {
        throw new IllegalStateException("Pool already contains an entry for this user/password: "+username);
    }
}
 

import org.apache.commons.pool.impl.GenericObjectPool; //导入方法依赖的package包/类
private void run(int nrIterations, int nrThreads, int maxActive, int maxIdle) {
    this.nrIterations = nrIterations;
    init();
    
    SleepingObjectFactory factory = new SleepingObjectFactory();
    if (logLevel >= 4) { factory.setDebug(true); } 
    pool = new GenericObjectPool(factory);
    pool.setMaxActive(maxActive);
    pool.setMaxIdle(maxIdle);
    pool.setTestOnBorrow(true);

    Thread[] threads = new Thread[nrThreads];
    for (int i = 0; i < threads.length; i++) {
        threads[i]= new Thread(new MyThread(), Integer.toString(i));
        Thread.yield();
    }
    if (logLevel >= 1) { System.out.println("created"); } 
    Thread.yield();

    for (int i = 0; i < threads.length; i++) {
        threads[i].start();
        Thread.yield();
    }
    if (logLevel >= 1) { System.out.println("started"); }
    Thread.yield();

    start = true;
    if (logLevel >= 1) { System.out.println("go"); }
    Thread.yield();

    for (int i = 0; i < threads.length; i++) {
        try {
            threads[i].join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    if (logLevel >= 1) { System.out.println("finish"); }
    System.out.println("-----------------------------------------");
    System.out.println("nrIterations: " + nrIterations);
    System.out.println("nrThreads: " + nrThreads);
    System.out.println("maxActive: " + maxActive);
    System.out.println("maxIdle: " + maxIdle);
    System.out.println("nrSamples: " + nrSamples);
    System.out.println("totalBorrowTime: " + totalBorrowTime);
    System.out.println("totalReturnTime: " + totalReturnTime);
    System.out.println("avg BorrowTime: " + totalBorrowTime/nrSamples);
    System.out.println("avg ReturnTime: " + totalReturnTime/nrSamples);
}