Java DriverAdapterCPDS.setDriver方法代码示例

import org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS; //导入方法依赖的package包/类
public void setUp() throws Exception {
    super.setUp();
    DriverAdapterCPDS pcds = new DriverAdapterCPDS();
    pcds.setDriver("org.apache.commons.dbcp.TesterDriver");
    pcds.setUrl("jdbc:apache:commons:testdriver");
    pcds.setUser("foo");
    pcds.setPassword("bar");
    pcds.setAccessToUnderlyingConnectionAllowed(true);

    PerUserPoolDataSource tds = new PerUserPoolDataSource();
    tds.setConnectionPoolDataSource(pcds);
    tds.setDefaultMaxActive(getMaxActive());
    tds.setDefaultMaxWait((int)(getMaxWait()));
    tds.setPerUserMaxActive("foo",new Integer(getMaxActive()));
    tds.setPerUserMaxWait("foo",new Integer((int)(getMaxWait())));
    tds.setDefaultTransactionIsolation(
        Connection.TRANSACTION_READ_COMMITTED);

    ds = tds;
}
 

import org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS; //导入方法依赖的package包/类
public void setUp() throws Exception {
    super.setUp();
    pcds = new DriverAdapterCPDS();
    pcds.setDriver("org.apache.commons.dbcp.TesterDriver");
    pcds.setUrl("jdbc:apache:commons:testdriver");
    pcds.setUser("foo");
    pcds.setPassword("bar");
    pcds.setPoolPreparedStatements(false);
    pcds.setAccessToUnderlyingConnectionAllowed(true);

    SharedPoolDataSource tds = new SharedPoolDataSource();
    tds.setConnectionPoolDataSource(pcds);
    tds.setMaxActive(getMaxActive());
    tds.setMaxWait((int)(getMaxWait()));
    tds.setDefaultTransactionIsolation(
        Connection.TRANSACTION_READ_COMMITTED);

    ds = tds;
}
 

import org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS; //导入方法依赖的package包/类
public void setUp() throws Exception {
    cpds = new ConnectionPoolDataSourceProxy(new DriverAdapterCPDS());
    DriverAdapterCPDS delegate = (DriverAdapterCPDS) cpds.getDelegate();
    delegate.setDriver("org.apache.commons.dbcp.TesterDriver");
    delegate.setUrl("jdbc:apache:commons:testdriver");
    delegate.setUser("username");
    delegate.setPassword("password");
}
 

import org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS; //导入方法依赖的package包/类
public static Connection getConnection( ServletContext servContext ) throws Exception
{
	if( !loaded )
	{
		String dbdriver = ConfigUtils.get("DBDriver");
		ConfigUtils.clear("DBDriver");
		String dbuser = ConfigUtils.get("DBUser");
		ConfigUtils.clear("DBUser");
		String dbpass = ConfigUtils.get("DBPass");
		ConfigUtils.clear("DBPass");
		String dburl = ConfigUtils.get("DBUrl");
		ConfigUtils.clear("DBUrl");

		try
		{
			DriverAdapterCPDS cpds = new DriverAdapterCPDS();
			cpds.setDriver(dbdriver);
			cpds.setUrl(dburl);
			
			Properties info = new Properties();
			info.put("user", dbuser);
			info.put("password", dbpass);
			cpds.setConnectionProperties(info);
			
			SharedPoolDataSource tds = new SharedPoolDataSource();
			tds.setConnectionPoolDataSource(cpds);
			
			/// TODO: Complete it with other parameters, also, benchmark
			/// Configuring other stuff
			tds.setValidationQuery("SELECT 1 FROM DUAL");
			tds.setTestOnBorrow(true);
			tds.setTestWhileIdle(true);
			tds.setDefaultTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
			
			String maxwait = ConfigUtils.get("DB.MaxWait");
			String maxtotal = ConfigUtils.get("DB.MaxTotal");
			String minidle = ConfigUtils.get("DB.MinIdle");
			String maxidle = ConfigUtils.get("DB.MaxIdle");
			String waiteviction = ConfigUtils.get("DB.WaitEviction");
			String numtesteviction =  ConfigUtils.get("DB.NumTestEviction");
			/// In case something hasn't been set
			if( maxwait == null ) maxwait = "1000";
			if( maxtotal == null ) maxtotal = "1000";
			if( minidle == null ) minidle = "1";
			if( maxidle == null ) maxidle = "1000";
			if( waiteviction == null ) waiteviction = "60000";
			if( numtesteviction == null ) numtesteviction = "10";
			
			tds.setMaxWait(Integer.decode(maxwait));
			tds.setMaxActive(Integer.decode(maxtotal));
			tds.setMaxIdle(Integer.decode(maxidle));
			tds.setTimeBetweenEvictionRunsMillis(Integer.decode(waiteviction));
			tds.setNumTestsPerEvictionRun(Integer.decode(numtesteviction));
			
			ds = tds;
		}
		catch( Exception e )
		{
			e.printStackTrace();
		}
		loaded = true;
	}
	return ds.getConnection();
}
 

import org.apache.commons.dbcp.cpdsadapter.DriverAdapterCPDS; //导入方法依赖的package包/类
private void doTestPoolPreparedStatements(PrepareStatementCallback callBack)
throws Exception {
    DriverAdapterCPDS mypcds = new DriverAdapterCPDS();
    DataSource myds = null;
    mypcds.setDriver("org.apache.commons.dbcp.TesterDriver");
    mypcds.setUrl("jdbc:apache:commons:testdriver");
    mypcds.setUser("foo");
    mypcds.setPassword("bar");
    mypcds.setPoolPreparedStatements(true);
    mypcds.setMaxPreparedStatements(10);

    SharedPoolDataSource tds = new SharedPoolDataSource();
    tds.setConnectionPoolDataSource(mypcds);
    tds.setMaxActive(getMaxActive());
    tds.setMaxWait((int)(getMaxWait()));
    tds.setDefaultTransactionIsolation(
        Connection.TRANSACTION_READ_COMMITTED);

    myds = tds;

    Connection conn = ds.getConnection();
    callBack.setConnection(conn);
    PreparedStatement stmt = null;
    ResultSet rset = null;

    assertNotNull(conn);

    stmt = callBack.getPreparedStatement();
    assertNotNull(stmt);
    long l1HashCode = stmt.hashCode();
    rset = stmt.executeQuery();
    assertNotNull(rset);
    assertTrue(rset.next());
    rset.close();
    stmt.close();

    stmt = callBack.getPreparedStatement();
    assertNotNull(stmt);
    long l2HashCode = stmt.hashCode();
    rset = stmt.executeQuery();
    assertNotNull(rset);
    assertTrue(rset.next());
    rset.close();
    stmt.close();

    // statement pooling is not enabled, we should get different statements
    assertTrue(l1HashCode != l2HashCode);
    conn.close();
    conn = null;

    conn = myds.getConnection();
    callBack.setConnection(conn);

    stmt = callBack.getPreparedStatement();
    assertNotNull(stmt);
    long l3HashCode = stmt.hashCode();
    rset = stmt.executeQuery();
    assertNotNull(rset);
    assertTrue(rset.next());
    rset.close();
    stmt.close();

    stmt = callBack.getPreparedStatement();
    assertNotNull(stmt);
    long l4HashCode = stmt.hashCode();
    rset = stmt.executeQuery();
    assertNotNull(rset);
    assertTrue(rset.next());
    rset.close();
    stmt.close();

    // prepared statement pooling is working
    assertTrue(l3HashCode == l4HashCode);
    conn.close();
    conn = null;
}