Dynamic Connection Pooling

Connecting to database is very common in most of the project and if number of connection to database is high it better to have database connection pooling.This asset contains code sample for creating connection during run time.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Time;
import java.util.Date;
import java.util.Hashtable;
import java.util.Properties;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.DataSource;
import javax.sql.PooledConnection;

import oracle.jdbc.pool.OracleConnectionCacheImpl;
import oracle.jdbc.pool.OracleConnectionPoolDataSource;

import org.apache.commons.dbcp.AbandonedConfig;
import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDataSource;
import org.apache.commons.dbcp.PoolingDriver;
import org.apache.commons.pool.impl.GenericObjectPool;

import weblogic.jndi.Environment;
import weblogic.management.MBeanHome;
import weblogic.management.configuration.JDBCConnectionPoolMBean;
import weblogic.management.configuration.JDBCTxDataSourceMBean;
import weblogic.management.configuration.ServerMBean;
import weblogic.t3.srvr.ServerRuntime;
/**
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class PoolDemo {

      public static GenericObjectPool pool ;

      public static OracleConnectionCacheImpl iotConPool; 
      
      
        public static void main(String args[]) throws Exception {
 
            try { 
     
             // get the connection using dpcp connection pooling mach
                DataSource ds =getDpCpPool("oracle.jdbc.OracleDriver","jdbc:oracle:thin:@suznd264.qintra.com:1563:uesott03","esot","esot");
                
                for (int i =0; i<8; i++){
                    System.out.println(ds.getConnection()); System.out.println(" pool no"+ pool.getNumActive());
                  
                }
                   
                // get the connection using oracle pooling
         System.out.println(getOraclePoolConnection("oracle.jdbc.OracleDriver","jdbc:oracle:thin:@suznd264.qintra.com:1563:uesott03","esot","esot"));
                 
         } catch (Throwable e) {
             e.printStackTrace();
             // a failure occurred log message;
         } finally {
  
         }  
                   
        }
       
      
      public static DataSource getDpCpPool(String driver, String connectURI,
            String username, String password) {

        PoolingDataSource dataSource = null;
        try {

            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.
            //

         
            //
            // 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, password);

            //  
            // Now we'll create the PoolableConnectionFactory, which wraps
            // the "real" Connections created by the ConnectionFactory with
            // the classes that implement the pooling functionality.
            //
            
            pool = new GenericObjectPool(
                    null, // PoolableObjectFactory, can be null
                    5, // max active
                    GenericObjectPool.WHEN_EXHAUSTED_BLOCK, // action when exhausted
                    3000, // max wait (milli seconds)
                    2, // max idle
                    false, // test on borrow
                    false  // test on return                    
                    ); 
                // create a PoolableConnectionFactory
                AbandonedConfig abandonedConfig = new AbandonedConfig();
                // flag to remove abandoned connections from pool
                abandonedConfig.setRemoveAbandoned(true);
                // timeout (seconds) before removing abandoned connections
                abandonedConfig.setRemoveAbandonedTimeout(30);
                // Flag to log stack traces for application code which abandoned a
                // Statement or Connection
                abandonedConfig.setLogAbandoned(true);
                PoolableConnectionFactory poolableConnectionFactory
                    = new PoolableConnectionFactory(
                        // the connection factory
                        connectionFactory,
                        // the object pool
                        pool,
                        // statement pool factory for pooling prepared statements,
                        // or null for no pooling
                        null,
                        // validation query (must return at least 1 row e.g. Oracle:
                        // select count(*) from dual) to test connection, can be
                        // null
                        null,
                        // default "read only" setting for borrowed connections
                        false,
                        // default "auto commit" setting for returned connections
                        true,
                        // AbandonedConfig object configures how to handle abandoned
                        // connections
                        abandonedConfig
                );
 

             dataSource = new PoolingDataSource(pool);
             
            return dataSource ;
        } catch (Throwable e) { 
            e.printStackTrace();
        } finally {

        }
        return null;
        
    }
 
    public static Connection getOraclePoolConnection(String driver, String connectURI,
    String username, String password) {
  
try {
    if (iotConPool == null) {

        Class.forName(driver);

        // Create a OracleConnectionPoolDataSource instance
        OracleConnectionPoolDataSource ocpds = new OracleConnectionPoolDataSource();

        // Set connection parameters
        ocpds.setURL(connectURI);
        ocpds.setUser(username);
        ocpds.setPassword(password);

        // Associate it with the Cache
        iotConPool = new OracleConnectionCacheImpl(ocpds);

        // Set the Max Limit
        iotConPool.setMinLimit(10);

        // Set the Scheme
        //  ods.setCacheScheme(OracleConnectionCacheImpl.FIXED_RETURN_NULL_SCHEME);

    }                
    return iotConPool.getConnection();
} catch (Throwable e) {
    e.printStackTrace();
} finally {

}
return null;
}  
}