org.apache.commons.pool.KeyedObjectPoolFactory Java Examples

public final static void initConnection(String address, String user, String password) throws ClassNotFoundException {
	Class.forName("com.mysql.jdbc.Driver");
	GenericObjectPool connectionPool = new GenericObjectPool(null);
	ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(address, user, password);
	KeyedObjectPoolFactory keyed_factory = new StackKeyedObjectPoolFactory();
	new PoolableConnectionFactory(connectionFactory, connectionPool, keyed_factory, null, false, true);
	ds = new PoolingDataSource(connectionPool);
}
 

protected KeyedObjectPoolFactory createStatementPoolFactory() {
	return new GenericKeyedObjectPoolFactory(null, 
               -1, // unlimited maxActive (per key)
               GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW, 
               0, // maxWait
               1, // maxIdle (per key) 
               getPreparedStatementCacheSize()); 
}
 

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;
}
 

TraceablePoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory, String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit) {
  super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit);
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 * @deprecated AbandonedConfig is now deprecated.
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, AbandonedConfig config,
		boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, config);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 * @deprecated AbandonedConfig is now deprecated.
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		AbandonedConfig config, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation,
			config);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param defaultCatalog
 *        the default "catalog" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 * @deprecated AbandonedConfig is now deprecated.
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		String defaultCatalog, AbandonedConfig config, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation,
			defaultCatalog, config);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param defaultCatalog
 *        the default "catalog" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, Boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		String defaultCatalog, AbandonedConfig config, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation,
			defaultCatalog, config);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 * @deprecated AbandonedConfig is now deprecated.
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, AbandonedConfig config,
		boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, config);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 * @deprecated AbandonedConfig is now deprecated.
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		AbandonedConfig config, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation,
			config);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param defaultCatalog
 *        the default "catalog" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 * @deprecated AbandonedConfig is now deprecated.
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		String defaultCatalog, AbandonedConfig config, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation,
			defaultCatalog, config);
	m_rollbackOnReturn = rollbackOnReturn;
}
 

/**
 * Create a new <tt>PoolableConnectionFactory</tt>.
 * 
 * @param connFactory
 *        the {@link ConnectionFactory} from which to obtain base {@link Connection}s
 * @param pool
 *        the {@link ObjectPool} in which to pool those {@link Connection}s
 * @param stmtPoolFactory
 *        the {@link KeyedObjectPoolFactory} to use to create {@link KeyedObjectPool}s for pooling {@link java.sql.PreparedStatement}s, or <tt>null</tt> to disable {@link java.sql.PreparedStatement} pooling
 * @param validationQuery
 *        a query to use to {@link #validateObject validate} {@link Connection}s. Should return at least one row. Using <tt>null</tt> turns off validation.
 * @param defaultReadOnly
 *        the default "read only" setting for borrowed {@link Connection}s
 * @param defaultAutoCommit
 *        the default "auto commit" setting for returned {@link Connection}s
 * @param defaultTransactionIsolation
 *        the default "Transaction Isolation" setting for returned {@link Connection}s
 * @param defaultCatalog
 *        the default "catalog" setting for returned {@link Connection}s
 * @param config
 *        the AbandonedConfig if tracing SQL objects
 * @param rollbackOnReturn
 *        The rollback on borrow setting
 */
public SakaiPoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory,
		String validationQuery, Boolean defaultReadOnly, boolean defaultAutoCommit, int defaultTransactionIsolation,
		String defaultCatalog, AbandonedConfig config, boolean rollbackOnReturn)
{
	super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation,
			defaultCatalog, config);
	m_rollbackOnReturn = rollbackOnReturn;
}