Java KeyedObjectPoolFactory类代码示例

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
/**
 * 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
 */
public PoolableConnectionFactory(
    ConnectionFactory connFactory,
    ObjectPool pool,
    KeyedObjectPoolFactory stmtPoolFactory,
    String validationQuery,
    boolean defaultReadOnly,
    boolean defaultAutoCommit,
    AbandonedConfig config) {

    _connFactory = connFactory;
    _pool = pool;
    _config = config;
    _pool.setFactory(this);
    _stmtPoolFactory = stmtPoolFactory;
    _validationQuery = validationQuery;
    _defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
    _defaultAutoCommit = defaultAutoCommit;
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
public void testStmtPool() throws Exception {
    new TesterDriver();
    ConnectionFactory connFactory = new DriverManagerConnectionFactory(
            "jdbc:apache:commons:testdriver","u1","p1");

    ObjectPool connPool = new GenericObjectPool();
    KeyedObjectPoolFactory stmtPoolFactory = new GenericKeyedObjectPoolFactory(null);

    new PoolableConnectionFactory(connFactory, connPool, stmtPoolFactory,
            null, false, true);

    DataSource ds = new PoolingDataSource(connPool);

    Connection conn = ds.getConnection();
    Statement stmt1 = conn.prepareStatement("select 1 from dual");
    Statement ustmt1 = ((DelegatingStatement) stmt1).getInnermostDelegate();
    stmt1.close();
    Statement stmt2 = conn.prepareStatement("select 1 from dual");
    Statement ustmt2 = ((DelegatingStatement) stmt2).getInnermostDelegate();
    stmt2.close();
    assertSame(ustmt1, ustmt2);
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
/**
 * Default superclass constructor.
 *
 * @throws Exception When there is an error in the PoolableConnectionFactory constructor.
 */
public StatementClosingPoolableConnectionFactory(ConnectionFactory factory,
												 ObjectPool pool,
												 KeyedObjectPoolFactory stmtPoolFactory,
												 String validationQuery,
												 boolean defaultReadOnly,
												 boolean defaultAutoCommit)
	throws Exception {

	super(factory, pool, stmtPoolFactory, validationQuery,
		  defaultReadOnly, defaultAutoCommit);
}
 

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

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
protected KeyedObjectPoolFactory createStatementPoolFactory() {
	return new GenericKeyedObjectPoolFactory(null, 
               -1, // unlimited maxActive (per key)
               GenericKeyedObjectPool.WHEN_EXHAUSTED_GROW, 
               0, // maxWait
               1, // maxIdle (per key) 
               getPreparedStatementCacheSize()); 
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
public void testCallableStatementPooling() throws Exception {
    new TesterDriver();
    ConnectionFactory connFactory = new DriverManagerConnectionFactory(
            "jdbc:apache:commons:testdriver","u1","p1");

    ObjectPool connPool = new GenericObjectPool();
    KeyedObjectPoolFactory stmtPoolFactory = new GenericKeyedObjectPoolFactory(null);

    new PoolableConnectionFactory(connFactory, connPool, stmtPoolFactory,
            null, false, true);

    DataSource ds = new PoolingDataSource(connPool);

    Connection conn = ds.getConnection();
    Statement stmt1 = conn.prepareStatement("select 1 from dual");
    Statement ustmt1 = ((DelegatingStatement) stmt1).getInnermostDelegate();
    Statement cstmt1 = conn.prepareCall("{call home}");
    Statement ucstmt1 = ((DelegatingStatement) cstmt1).getInnermostDelegate();
    stmt1.close();  // Return to pool
    cstmt1.close(); // ""
    Statement stmt2 = conn.prepareStatement("select 1 from dual"); // Check out from pool
    Statement ustmt2 = ((DelegatingStatement) stmt2).getInnermostDelegate();
    Statement cstmt2 = conn.prepareCall("{call home}");
    Statement ucstmt2 = ((DelegatingStatement) cstmt2).getInnermostDelegate();
    stmt2.close();  // Return to pool
    cstmt2.close(); // ""
    assertSame(ustmt1, ustmt2);
    assertSame(ucstmt1, ucstmt2);
    // Verify key distinguishes Callable from Prepared Statements in the pool
    Statement stmt3 = conn.prepareCall("select 1 from dual");
    Statement ustmt3 = ((DelegatingStatement) stmt3).getInnermostDelegate();
    stmt3.close();
    assertNotSame(ustmt1, ustmt3);
    assertNotSame(ustmt3, ucstmt1);
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
public void testClosePool() throws Exception {
    new TesterDriver();
    ConnectionFactory connFactory = new DriverManagerConnectionFactory(
            "jdbc:apache:commons:testdriver","u1","p1");

    ObjectPool connPool = new GenericObjectPool();
    KeyedObjectPoolFactory stmtPoolFactory = new GenericKeyedObjectPoolFactory(null);

    new PoolableConnectionFactory(connFactory, connPool, stmtPoolFactory,
            null, false, true);

    DataSource ds = new PoolingDataSource(connPool);
    ((PoolingDataSource) ds).setAccessToUnderlyingConnectionAllowed(true);

    Connection conn = ds.getConnection();
    conn.prepareStatement("select 1 from dual");
    
    Connection poolableConnection = ((DelegatingConnection) conn).getDelegate();
    Connection poolingConnection = 
        ((DelegatingConnection) poolableConnection).getDelegate();
    poolingConnection.close();
    try {
        conn.prepareStatement("select 1 from dual");
        fail("Expecting SQLException");
    } catch (SQLException ex) {
        assertTrue(ex.getMessage().endsWith("invalid PoolingConnection."));
    }     
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的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.KeyedObjectPoolFactory; //导入依赖的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.KeyedObjectPoolFactory; //导入依赖的package包/类
TraceablePoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory, String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit) {
  super(connFactory, pool, stmtPoolFactory, validationQuery, defaultReadOnly, defaultAutoCommit);
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
/**
 * Create a PoolableManagedConnectionFactory and attach it to a connection pool.
 * 
 * @param connFactory XAConnectionFactory
 * @param pool connection pool 
 * @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 validationQueryTimeout the number of seconds that validation queries will wait for database response
 * before failing. Use a value less than or equal to 0 for no timeout.
 * @param connectionInitSqls a Collection of SQL statements to initialize {@link Connection}s.
 * Using <tt>null</tt> turns off initialization.
 * @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
 */
public PoolableManagedConnectionFactory(XAConnectionFactory connFactory,
        ObjectPool pool,
        KeyedObjectPoolFactory stmtPoolFactory,
        String validationQuery,
        int validationQueryTimeout,
        Collection connectionInitSqls,
        Boolean defaultReadOnly,
        boolean defaultAutoCommit,
        int defaultTransactionIsolation,
        String defaultCatalog,
        AbandonedConfig config) {
    super(connFactory, pool, stmtPoolFactory, validationQuery, validationQueryTimeout, connectionInitSqls,
            defaultReadOnly, defaultAutoCommit, defaultTransactionIsolation, defaultCatalog, config);
    this.transactionRegistry = connFactory.getTransactionRegistry();
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
protected KeyedObjectPoolFactory makeFactory(final KeyedPoolableObjectFactory objectFactory) {
    return new GenericKeyedObjectPoolFactory(objectFactory);
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
protected KeyedObjectPoolFactory makeFactory(final KeyedPoolableObjectFactory objectFactory) throws UnsupportedOperationException {
    return new StackKeyedObjectPoolFactory(objectFactory);
}
 

import org.apache.commons.pool.KeyedObjectPoolFactory; //导入依赖的package包/类
/**
 * 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;
}