Java數(shù)據(jù)庫連接池之DBCP淺析_動力節(jié)點Java學院整理

public class SimplePoolDemo {
 //創(chuàng)建一個連接池
 private static LinkedList<Connection> pool = new LinkedList<Connection>(); 
 
 //初始化10個連接
 static{
  try {
   for (int i = 0; i < 10; i++) {
    Connection conn = DBUtils.getConnection();//得到一個連接
    pool.add(conn);
   }
  } catch (Exception e) {
   throw new ExceptionInInitializerError("數(shù)據(jù)庫連接失敗，請檢查配置");
  }
 }
 //從池中獲取一個連接
 public static Connection getConnectionFromPool(){
  return pool.removeFirst();//移除一個連接對象
 }
 //釋放資源
 public static void release(Connection conn){
  pool.addLast(conn);
 }
}

#連接設置
 driverClassName=com.mysql.jdbc.Driver
 url=jdbc:mysql://localhost:3306/bjpowernode
 username=root
 password=abc
 
 #<!-- 初始化連接 -->
 initialSize=10
 
#最大連接數(shù)量
maxActive=50
 
#<!-- 最大空閑連接 -->
maxIdle=20

#<!-- 最小空閑連接 -->
minIdle=5
 
#<!-- 超時等待時間以毫秒為單位 60000毫秒/1000等于60秒 -->
maxWait=60000

 
#JDBC驅動建立連接時附帶的連接屬性屬性的格式必須為這樣：[屬性名=property;] 
#注意："user" 與 "password" 兩個屬性會被明確地傳遞，因此這里不需要包含他們。
connectionProperties=useUnicode=true;characterEncoding=utf8
 
#指定由連接池所創(chuàng)建的連接的自動提交（auto-commit）狀態(tài)。
defaultAutoCommit=true

#driver default 指定由連接池所創(chuàng)建的連接的只讀（read-only）狀態(tài)。
#如果沒有設置該值，則“setReadOnly”方法將不被調用。（某些驅動并不支持只讀模式，如：Informix）
defaultReadOnly=
 
#driver default 指定由連接池所創(chuàng)建的連接的事務級別（TransactionIsolation）。
#可用值為下列之一：（詳情可見javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=REPEATABLE_READ

public class DBCPUtils {
 private static DataSource ds;//定義一個連接池對象
 static{
  try {
   Properties pro = new Properties();
   pro.load(DBCPUtils.class.getClassLoader().getResourceAsStream("dbcpconfig.properties"));
   ds = BasicDataSourceFactory.createDataSource(pro);//得到一個連接池對象
  } catch (Exception e) {
   throw new ExceptionInInitializerError("初始化連接錯誤，請檢查配置文件！");
  }
 }
 //從池中獲取一個連接
 public static Connection getConnection() throws SQLException{
  return ds.getConnection();
 }
 
 public static void closeAll(ResultSet rs,Statement stmt,Connection conn){
  if(rs!=null){
   try {
    rs.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
  
  if(stmt!=null){
   try {
    stmt.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
  
  if(conn!=null){
   try {
    conn.close();//關閉
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
 }
}

public Connection getConnection() throws SQLException {
  return createDataSource().getConnection();
}

protected synchronized DataSource createDataSource()
 throws SQLException {
 if (closed) {
  throw new SQLException("Data source is closed");
 }

 // Return the pool if we have already created it
 if (dataSource != null) {
  return (dataSource);
 }

 // create factory which returns raw physical connections
 ConnectionFactory driverConnectionFactory = createConnectionFactory();

 // create a pool for our connections
 createConnectionPool();

 // Set up statement pool, if desired
 GenericKeyedObjectPoolFactory statementPoolFactory = null;
 if (isPoolPreparedStatements()) {
  statementPoolFactory = new GenericKeyedObjectPoolFactory(null,
     -1, // unlimited maxActive (per key)
     GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL,
     0, // maxWait
     1, // maxIdle (per key)
     maxOpenPreparedStatements);
 }

 // Set up the poolable connection factory
 createPoolableConnectionFactory(driverConnectionFactory, statementPoolFactory, abandonedConfig);

 // Create and return the pooling data source to manage the connections
 createDataSourceInstance();
 
 try {
  for (int i = 0 ; i < initialSize ; i++) {
   connectionPool.addObject();
  }
 } catch (Exception e) {
  throw new SQLNestedException("Error preloading the connection pool", e);
 }
 
 return dataSource;
}

protected ConnectionFactory createConnectionFactory() throws SQLException {
 // Load the JDBC driver class
 Class driverFromCCL = null;
 if (driverClassName != null) {
  try {
   try {
    if (driverClassLoader == null) {
     Class.forName(driverClassName);
    } else {
     Class.forName(driverClassName, true, driverClassLoader);
    }
   } catch (ClassNotFoundException cnfe) {
    driverFromCCL = Thread.currentThread(
      ).getContextClassLoader().loadClass(
        driverClassName);
   }
  } catch (Throwable t) {
   String message = "Cannot load JDBC driver class '" +
    driverClassName + "'";
   logWriter.println(message);
   t.printStackTrace(logWriter);
   throw new SQLNestedException(message, t);
  }
 }

 // Create a JDBC driver instance
 Driver driver = null;
 try {
  if (driverFromCCL == null) {
   driver = DriverManager.getDriver(url);
  } else {
   // Usage of DriverManager is not possible, as it does not
   // respect the ContextClassLoader
   driver = (Driver) driverFromCCL.newInstance();
   if (!driver.acceptsURL(url)) {
    throw new SQLException("No suitable driver", "08001"); 
   }
  }
 } catch (Throwable t) {
  String message = "Cannot create JDBC driver of class '" +
   (driverClassName != null ? driverClassName : "") +
   "' for connect URL '" + url + "'";
  logWriter.println(message);
  t.printStackTrace(logWriter);
  throw new SQLNestedException(message, t);
 }

 // Can't test without a validationQuery
 if (validationQuery == null) {
  setTestOnBorrow(false);
  setTestOnReturn(false);
  setTestWhileIdle(false);
 }

 // Set up the driver connection factory we will use
 String user = username;
 if (user != null) {
  connectionProperties.put("user", user);
 } else {
  log("DBCP DataSource configured without a 'username'");
 }

 String pwd = password;
 if (pwd != null) {
  connectionProperties.put("password", pwd);
 } else {
  log("DBCP DataSource configured without a 'password'");
 }

 ConnectionFactory driverConnectionFactory = new DriverConnectionFactory(driver, url, connectionProperties);
 return driverConnectionFactory;
}

protected void createConnectionPool() {
  // Create an object pool to contain our active connections
  GenericObjectPool gop;
  if ((abandonedConfig != null) && (abandonedConfig.getRemoveAbandoned())) {
   gop = new AbandonedObjectPool(null,abandonedConfig);
  }
  else {
   gop = new GenericObjectPool();
  }
  gop.setMaxActive(maxActive);
  gop.setMaxIdle(maxIdle);
  gop.setMinIdle(minIdle);
  gop.setMaxWait(maxWait);
  gop.setTestOnBorrow(testOnBorrow);
  gop.setTestOnReturn(testOnReturn);
  gop.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
  gop.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
  gop.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
  gop.setTestWhileIdle(testWhileIdle);
  connectionPool = gop;
 }

protected void createPoolableConnectionFactory(ConnectionFactory driverConnectionFactory,
  KeyedObjectPoolFactory statementPoolFactory, AbandonedConfig configuration) throws SQLException {
 PoolableConnectionFactory connectionFactory = null;
 try {
  connectionFactory =
   new PoolableConnectionFactory(driverConnectionFactory,
           connectionPool,
           statementPoolFactory,
           validationQuery,
           validationQueryTimeout,
           connectionInitSqls,
           defaultReadOnly,
           defaultAutoCommit,
           defaultTransactionIsolation,
           defaultCatalog,
           configuration);
  validateConnectionFactory(connectionFactory);
 } catch (RuntimeException e) {
  throw e;
 } catch (Exception e) {
  throw new SQLNestedException("Cannot create PoolableConnectionFactory (" + e.getMessage() + ")", e);
 }
}

public PoolableConnectionFactory(
 ConnectionFactory connFactory,
 ObjectPool pool,
 KeyedObjectPoolFactory stmtPoolFactory,
 String validationQuery,
 int validationQueryTimeout,
 Collection connectionInitSqls,
 Boolean defaultReadOnly,
 boolean defaultAutoCommit,
 int defaultTransactionIsolation,
 String defaultCatalog,
 AbandonedConfig config) {

 _connFactory = connFactory;
 _pool = pool;
 _config = config;
 _pool.setFactory(this);
 _stmtPoolFactory = stmtPoolFactory;
 _validationQuery = validationQuery;
 _validationQueryTimeout = validationQueryTimeout;
 _connectionInitSqls = connectionInitSqls;
 _defaultReadOnly = defaultReadOnly;
 _defaultAutoCommit = defaultAutoCommit;
 _defaultTransactionIsolation = defaultTransactionIsolation;
 _defaultCatalog = defaultCatalog;
}

protected static void validateConnectionFactory(PoolableConnectionFactory connectionFactory) throws Exception {
 Connection conn = null;
 try {
  conn = (Connection) connectionFactory.makeObject();
  connectionFactory.activateObject(conn);
  connectionFactory.validateConnection(conn);
  connectionFactory.passivateObject(conn);
 }
 finally {
  connectionFactory.destroyObject(conn);
 }
}

public Object makeObject() throws Exception {
 Connection conn = _connFactory.createConnection();
 if (conn == null) {
  throw new IllegalStateException("Connection factory returned null from createConnection");
 }
 initializeConnection(conn); //初始化，這個過程可有可無
 if(null != _stmtPoolFactory) { 
  KeyedObjectPool stmtpool = _stmtPoolFactory.createPool();
  conn = new PoolingConnection(conn,stmtpool);
  stmtpool.setFactory((PoolingConnection)conn);
 }
 //這里是關鍵
 return new PoolableConnection(conn,_pool,_config); 
}

public PoolableConnection(Connection conn, ObjectPool pool, AbandonedConfig config) {
 super(conn, config);
 _pool = pool;
}

public synchronized void close() throws SQLException {
 if (_closed) {
  // already closed
  return;
 }

 boolean isUnderlyingConectionClosed;
 try {
  isUnderlyingConectionClosed = _conn.isClosed();
 } catch (SQLException e) {
  try {
   _pool.invalidateObject(this); // XXX should be guarded to happen at most once
  } catch(IllegalStateException ise) {
   // pool is closed, so close the connection
   passivate();
   getInnermostDelegate().close();
  } catch (Exception ie) {
   // DO NOTHING the original exception will be rethrown
  }
  throw (SQLException) new SQLException("Cannot close connection (isClosed check failed)").initCause(e);
 }

 if (!isUnderlyingConectionClosed) {
  // Normal close: underlying connection is still open, so we
  // simply need to return this proxy to the pool
  try {
   _pool.returnObject(this); // XXX should be guarded to happen at most once
  } catch(IllegalStateException e) {
   // pool is closed, so close the connection
   passivate();
   getInnermostDelegate().close();
  } catch(SQLException e) {
   throw e;
  } catch(RuntimeException e) {
   throw e;
  } catch(Exception e) {
   throw (SQLException) new SQLException("Cannot close connection (return to pool failed)").initCause(e);
  }
 } else {
  // Abnormal close: underlying connection closed unexpectedly, so we
  // must destroy this proxy
  try {
   _pool.invalidateObject(this); // XXX should be guarded to happen at most once
  } catch(IllegalStateException e) {
   // pool is closed, so close the connection
   passivate();
   getInnermostDelegate().close();
  } catch (Exception ie) {
   // DO NOTHING, "Already closed" exception thrown below
  }
  throw new SQLException("Already closed.");
 }
}

createDataSourceInstance();
 
try {
 for (int i = 0 ; i < initialSize ; i++) {
  connectionPool.addObject();
 }
 } catch (Exception e) {
  throw new SQLNestedException("Error preloading the connection pool", e);
 }

protected void createDataSourceInstance() throws SQLException {
 PoolingDataSource pds = new PoolingDataSource(connectionPool);
 pds.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed());
 pds.setLogWriter(logWriter);
 dataSource = pds;
}