import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public static void shutdownDriver(String poolName) throws Exception {
	PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
	driver.closePool(poolName);
	
	if (ConnInfoList.containsKey(poolName)) {
		ConnInfoList.remove(poolName);
	}		
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public static void shutdownAllDriver() {
	try {
		PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
		for (String poolName : driver.getPoolNames()) {
			driver.closePool(poolName);
			
			if (ConnInfoList.containsKey(poolName)) {
				ConnInfoList.remove(poolName);
			}	
		}
	}catch(Exception e){
		LogUtils.error(CommonUtil.getStackTrace(e), DBCPPoolManager.class);
	}
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
@Override
protected void serviceInit(Configuration conf) throws Exception {
    LOG.info("initialize service - " + getName());

    Class.forName("org.apache.commons.dbcp2.PoolingDriver");
    Class.forName("kr.co.bitnine.octopus.engine.calcite.Driver"); // FIXME:
    poolingDriver = (PoolingDriver) DriverManager.getDriver(DRIVER_PREFIX);

    super.serviceInit(conf);
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
private void createConnectionPool(String url, String user, String propertyKey,
    Properties properties) throws SQLException, ClassNotFoundException {
  ConnectionFactory connectionFactory =
    new DriverManagerConnectionFactory(url, properties);

  PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(
    connectionFactory, null);
  ObjectPool connectionPool = new GenericObjectPool(poolableConnectionFactory);

  poolableConnectionFactory.setPool(connectionPool);
  Class.forName(properties.getProperty(DRIVER_KEY));
  PoolingDriver driver = new PoolingDriver();
  driver.registerPool(propertyKey + user, connectionPool);
  getJDBCConfiguration(user).saveDBDriverPool(propertyKey, driver);
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public static void setupDriver(String connectURI) throws Exception {
    //
    // First, 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,null);

    //
    // Next, we'll create the PoolableConnectionFactory, which wraps
    // the "real" Connections created by the ConnectionFactory with
    // the classes that implement the pooling functionality.
    //
    PoolableConnectionFactory poolableConnectionFactory =
        new PoolableConnectionFactory(connectionFactory, null);

    //
    // Now 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.
    //
    ObjectPool<PoolableConnection> connectionPool =
        new GenericObjectPool<>(poolableConnectionFactory);
    
    // Set the factory's pool property to the owning pool
    poolableConnectionFactory.setPool(connectionPool);

    //
    // Finally, we create the PoolingDriver itself...
    //
    Class.forName("org.apache.commons.dbcp2.PoolingDriver");
    PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");

    //
    // ...and register our pool with it.
    //
    driver.registerPool("example",connectionPool);

    //
    // Now we can just use the connect string "jdbc:apache:commons:dbcp:example"
    // to access our pool of Connections.
    //
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public static void printDriverStats() throws Exception {
    PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
    ObjectPool<? extends Connection> connectionPool = driver.getConnectionPool("example");

    System.out.println("NumActive: " + connectionPool.getNumActive());
    System.out.println("NumIdle: " + connectionPool.getNumIdle());
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
private PoolingDriver getPoolingDriver() throws SQLException {
    final PoolingDriver driver = (PoolingDriver) DriverManager.getDriver(URL_PREFIX);
    if (driver == null) {
        getLogger().error("No JDBC driver for '{}'", URL_PREFIX);
    }
    return driver;
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
@Override
public boolean stop(long timeout, TimeUnit timeUnit) {
    try {
        final PoolingDriver driver = getPoolingDriver();
        if (driver != null) {
            getLogger().debug("Closing DBCP pool '{}'", poolName);
            driver.closePool(poolName);
        }
        return true;
    } catch (Exception e) {
        getLogger().error("Exception stopping connection source for '{}' → '{}'", getConnectionString(),
                getActualConnectionString(), e);
        return false;
    }
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public static String[] GetPoolNameList() throws Exception {
	PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
	return driver.getPoolNames();
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
private static void shutdownDriver() throws Exception {
    PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
    driver.closePool(POOL_NAME);
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public void saveDBDriverPool(String key, PoolingDriver driver) throws SQLException {
  poolingDriverMap.put(key, driver);
  isSuccessful.put(key, false);
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public PoolingDriver removeDBDriverPool(String key) throws SQLException {
  isSuccessful.remove(key);
  return poolingDriverMap.remove(key);
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
private void closeDBPool(String user, String propertyKey) throws SQLException {
  PoolingDriver poolingDriver = getJDBCConfiguration(user).removeDBDriverPool(propertyKey);
  if (poolingDriver != null) {
    poolingDriver.closePool(propertyKey + user);
  }
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
public static void shutdownDriver() throws Exception {
    PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
    driver.closePool("example");
}
 

import org.apache.commons.dbcp2.PoolingDriver; //导入依赖的package包/类
private void setupDriver(final String connectionString) throws SQLException {
    //
    // First, 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.
    //
    final ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectionString, null);

    //
    // Next, we'll create the PoolableConnectionFactory, which wraps
    // the "real" Connections created by the ConnectionFactory with
    // the classes that implement the pooling functionality.
    //
    final PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,
            null);

    //
    // Now 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.
    //
    @SuppressWarnings("resource")
    // This GenericObjectPool will be closed on shutown
    final ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnectionFactory);

    // Set the factory's pool property to the owning pool
    poolableConnectionFactory.setPool(connectionPool);

    loadDriver(poolingDriverClassName);
    final PoolingDriver driver = getPoolingDriver();
    if (driver != null) {
        getLogger().debug("Registering DBCP pool '{}'", poolName);
        driver.registerPool(poolName, connectionPool);
    }
    //
    // Now we can just use the connect string "jdbc:apache:commons:dbcp:example"
    // to access our pool of Connections.
    //
}