java数据库连接池技术浅析

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：

1) 最小连接数

　　是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；

2) 最大连接数

　　是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。

3) 如果最小连接数与最大连接数相差太大，

　　那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。

连接池技术的核心思想是：连接复用，通过建立一个数据库连接池以及一套连接使用、分配、管理策略，使得该连接池中的连接可以得到高效、安全的复用，避免了数据库连接频繁建立、关闭的开销。另外，由于对JDBC中的原始连接进行了封装，从而方便了数据库应用对于连接的使用（特别是对于事务处理），提高了开发效率，也正是因为这个封装层的存在，隔离了应用的本身的处理逻辑和具体数据库访问逻辑，使应用本身的复用成为可能。连接池主要由三部分组成：连接池的建立、连接池中连接的使用管理、连接池的关闭。

连接池的建立

　　应用程序中建立的连接池其实是一个静态的。所谓静态连接池是指连接池中的连接在系统初始化时就已分配好，且不能随意关闭连接。Java中提供了很多容器类可以方便的构建连接池，如：Vector、Stack、Servlet、Bean等，通过读取连接属性文件Connections.properties与数据库实例建立连接。在系统初始化时，根据相应的配置创建连接并放置在连接池中，以便需要使用时能从连接池中获取，这样就可以避免连接随意的建立、关闭造成的开销。

连接池的管理

　　连接池管理策略是连接池机制的核心。当连接池建立后，如何对连接池中的连接进行管理，解决好连接池内连接的分配和释放，对系统的性能有很大的影响。连接的合理分配、释放可提高连接的复用，降低了系统建立新连接的开销，同时也加速了用户的访问速度。下面介绍连接池中连接的分配、释放策略。

　　连接池的分配、释放策略对于有效复用连接非常重要，我们采用的方法是一个很有名的设计模式：Reference Counting（引用记数）。该模式在复用资源方面应用的非常广泛，把该方法运用到对于连接的分配释放上，为每一个数据库连接，保留一个引用记数，用来记录该连接的使用者的个数。具体的实现方法是：

　　当客户请求数据库连接时，首先查看连接池中是否有空闲连接（指当前没有分配出去的连接）。如果存在空闲连接，则把连接分配给客户并作相应处理（即标记该连接为正在使用，引用计数加1）。如果没有空闲连接，则查看当前所开的连接数是不是已经达到maxConn（最大连接数），如果没达到就重新创建一个连接给请求的客户；如果达到就按设定的maxWaitTime（最大等待时间）进行等待，如果等待maxWaitTime后仍没有空闲连接，就抛出无空闲连接的异常给用户。

　　当客户释放数据库连接时，先判断该连接的引用次数是否超过了规定值，如果超过就删除该连接，并判断当前连接池内总的连接数是否小于minConn（最小连接数），若小于就将连接池充满；如果没超过就将该连接标记为开放状态，可供再次复用。可以看出正是这套策略保证了数据库连接的有效复用，避免频繁地建立、释放连接所带来的系统资源开销。

连接池的关闭

　　当应用程序退出时，应关闭连接池，此时应把在连接池建立时向数据库申请的连接对象统一归还给数据库（即关闭所有数据库连接），这与连接池的建立正好是一个相反过程。

连接池的配置

　　数据库连接池中到底要放置多少个连接，才能使系统的性能更佳，用minConn和maxConn来限制。minConn是当应用启动的时候连接池所创建的连接数，如果过大启动将变慢，但是启动后响应更快；如果过小启动加快，但是最初使用的用户将因为连接池中没有足够的连接不可避免的延缓了执行速度。因此应该在开发的过程中设定较小minConn，而在实际应用的中设定较大minConn。maxConn是连接池中的最大连接数，可以通过反复试验来确定此饱和点。为此在连接池类ConnectionPool中加入两个方法getActiveSize（）和getOpenSize（），ActiveSize
表示某一时间有多少连接正被使用，OpenSize表示连接池中有多少连接被打开，反映了连接池使用的峰值。将这两个值在日志信息中反应出来， minConn的值应该小于平均ActiveSize，而maxConn的值应该在activeSize和OpenSize之间。

一个数据库连接池的设计的实例：

package org.com.dbpool;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Vector;

/*******************************************************************************
* 数据库连接池
******************************************************************************/
public class DbPoolDesign {
private String jdbcDriver = ""; // 数据库驱动

private String dbUrl = ""; // 数据 URL

private String dbUsername = ""; // 数据库用户名

private String dbPassword = ""; // 数据库用户密码

private String testTable = ""; // 测试连接是否可用的测试表名，默认没有测试表

private int initialConnections = 10; // 连接池的初始大小

private int incrementalConnections = 5;// 连接池自动增加的大小

private int maxConnections = 50; // 连接池最大的大小

private Vector<PooledConnection> connections = null; // 存放连接池中数据库连接的向量 ,初始时为 null 它中存放的对象为 PooledConnection 型

/**
*
* 构造函数
*
*
*
* @param jdbcDriver
*            String JDBC 驱动类串
*
* @param dbUrl
*            String 数据库 URL
*
* @param dbUsername
*            String 连接数据库用户名
*
* @param dbPassword
*            String 连接数据库用户的密码
*
*
*
*/

public DbPoolDesign(String jdbcDriver, String dbUrl, String dbUsername,
String dbPassword) {

this.jdbcDriver = jdbcDriver;

this.dbUrl = dbUrl;

this.dbUsername = dbUsername;

this.dbPassword = dbPassword;

}

/**
*
* 返回连接池的初始大小
*
*
*
* @return 初始连接池中可获得的连接数量
*
*/

public int getInitialConnections() {

return this.initialConnections;

}

/**
*
* 设置连接池的初始大小
*
*
*
* @param 用于设置初始连接池中连接的数量
*
*/

public void setInitialConnections(int initialConnections) {

this.initialConnections = initialConnections;

}

/**
*
* 返回连接池自动增加的大小
*
*
*
* @return 连接池自动增加的大小
*
*/

public int getIncrementalConnections() {

return this.incrementalConnections;

}

/**
*
* 设置连接池自动增加的大小
*
* @param 连接池自动增加的大小
*
*/

public void setIncrementalConnections(int incrementalConnections) {

this.incrementalConnections = incrementalConnections;

}

/**
*
* 返回连接池中最大的可用连接数量
*
* @return 连接池中最大的可用连接数量
*
*/

public int getMaxConnections() {

return this.maxConnections;

}

/**
*
* 设置连接池中最大可用的连接数量
*
*
*
* @param 设置连接池中最大可用的连接数量值
*
*/

public void setMaxConnections(int maxConnections) {

this.maxConnections = maxConnections;

}

/**
*
* 获取测试数据库表的名字
*
*
*
* @return 测试数据库表的名字
*
*/

public String getTestTable() {

return this.testTable;

}

/**
*
* 设置测试表的名字
*
* @param testTable
*            String 测试表的名字
*
*/

public void setTestTable(String testTable) {

this.testTable = testTable;

}

/**
*
*
*
* 创建一个数据库连接池，连接池中的可用连接的数量采用类成员
*
* initialConnections 中设置的值
*
*/

public synchronized void createPool() throws Exception {

// 确保连接池没有创建

// 如果连接池己经创建了，保存连接的向量 connections 不会为空

if (connections != null) {

return; // 如果己经创建，则返回

}

// 实例化 JDBC Driver 中指定的驱动类实例

Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());

DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序

// 创建保存连接的向量 , 初始时有 0 个元素

connections = new Vector<PooledConnection>();

// 根据 initialConnections 中设置的值，创建连接。

createConnections(this.initialConnections);

System.out.println(" 数据库连接池创建成功！ ");

}

/**
*
* 创建由 numConnections 指定数目的数据库连接 , 并把这些连接
*
* 放入 connections 向量中
*
*
*
* @param numConnections
*            要创建的数据库连接的数目
*
*/

@SuppressWarnings("unchecked")
private void createConnections(int numConnections) throws SQLException {

// 循环创建指定数目的数据库连接

for (int x = 0; x < numConnections; x++) {

// 是否连接池中的数据库连接的数量己经达到最大？最大值由类成员 maxConnections

// 指出，如果 maxConnections 为 0 或负数，表示连接数量没有限制。

// 如果连接数己经达到最大，即退出。

if (this.maxConnections > 0
&& this.connections.size() >= this.maxConnections) {

break;

}

// add a new PooledConnection object to connections vector

// 增加一个连接到连接池中（向量 connections 中）

try {

connections.addElement(new PooledConnection(newConnection()));

} catch (SQLException e) {

System.out.println(" 创建数据库连接失败！ " + e.getMessage());

throw new SQLException();

}

System.out.println(" 数据库连接己创建 ......"+x);

}

}

/**
*
* 创建一个新的数据库连接并返回它
*
*
*
* @return 返回一个新创建的数据库连接
*
*/

private Connection newConnection() throws SQLException {

// 创建一个数据库连接

Connection conn = DriverManager.getConnection(dbUrl, dbUsername,
dbPassword);

// 如果这是第一次创建数据库连接，即检查数据库，获得此数据库允许支持的

// 最大客户连接数目

// connections.size()==0 表示目前没有连接己被创建

if (connections.size() == 0) {

DatabaseMetaData metaData = conn.getMetaData();

int driverMaxConnections = metaData.getMaxConnections();

// 数据库返回的 driverMaxConnections 若为 0 ，表示此数据库没有最大

// 连接限制，或数据库的最大连接限制不知道

// driverMaxConnections 为返回的一个整数，表示此数据库允许客户连接的数目

// 如果连接池中设置的最大连接数量大于数据库允许的连接数目 , 则置连接池的最大

// 连接数目为数据库允许的最大数目

if (driverMaxConnections > 0
&& this.maxConnections > driverMaxConnections) {

this.maxConnections = driverMaxConnections;

}

}

return conn; // 返回创建的新的数据库连接

}

/**
*
* 通过调用 getFreeConnection() 函数返回一个可用的数据库连接 ,
*
* 如果当前没有可用的数据库连接，并且更多的数据库连接不能创
*
* 建（如连接池大小的限制），此函数等待一会再尝试获取。
*
*
*
* @return 返回一个可用的数据库连接对象
*
*/

public synchronized Connection getConnection() throws SQLException {

// 确保连接池己被创建

if (connections == null) {

return null; // 连接池还没创建，则返回 null

}

Connection conn = getFreeConnection(); // 获得一个可用的数据库连接

// 如果目前没有可以使用的连接，即所有的连接都在使用中

while (conn == null) {

// 等一会再试

wait(250);

conn = getFreeConnection(); // 重新再试，直到获得可用的连接，如果

// getFreeConnection() 返回的为 null

// 则表明创建一批连接后也不可获得可用连接

}

return conn;// 返回获得的可用的连接

}

/**
*
* 本函数从连接池向量 connections 中返回一个可用的的数据库连接，如果
*
* 当前没有可用的数据库连接，本函数则根据 incrementalConnections 设置
*
* 的值创建几个数据库连接，并放入连接池中。
*
* 如果创建后，所有的连接仍都在使用中，则返回 null
*
* @return 返回一个可用的数据库连接
*
*/

private Connection getFreeConnection() throws SQLException {

// 从连接池中获得一个可用的数据库连接

Connection conn = findFreeConnection();

if (conn == null) {

// 如果目前连接池中没有可用的连接

// 创建一些连接

createConnections(incrementalConnections);

// 重新从池中查找是否有可用连接

conn = findFreeConnection();

if (conn == null) {

// 如果创建连接后仍获得不到可用的连接，则返回 null

return null;

}

}

return conn;

}

/**
*
* 查找连接池中所有的连接，查找一个可用的数据库连接，
*
* 如果没有可用的连接，返回 null
*
*
*
* @return 返回一个可用的数据库连接
*
*/

private Connection findFreeConnection() throws SQLException {

Connection conn = null;

PooledConnection pConn = null;

// 获得连接池向量中所有的对象

Enumeration<PooledConnection> enumerate = connections.elements();

// 遍历所有的对象，看是否有可用的连接

while (enumerate.hasMoreElements()) {

pConn = (PooledConnection) enumerate.nextElement();

if (!pConn.isBusy()) {

// 如果此对象不忙，则获得它的数据库连接并把它设为忙

conn = pConn.getConnection();

pConn.setBusy(true);

// 测试此连接是否可用

if (!testConnection(conn)) {

// 如果此连接不可再用了，则创建一个新的连接，

// 并替换此不可用的连接对象，如果创建失败，返回 null

try {

conn = newConnection();

} catch (SQLException e) {

System.out.println(" 创建数据库连接失败！ " + e.getMessage());

return null;

}

pConn.setConnection(conn);

}

break; // 己经找到一个可用的连接，退出

}

}

return conn;// 返回找到到的可用连接

}

/**
*
* 测试一个连接是否可用，如果不可用，关掉它并返回 false
*
* 否则可用返回 true
*
*
*
* @param conn
*            需要测试的数据库连接
*
* @return 返回 true 表示此连接可用， false 表示不可用
*
*/

private boolean testConnection(Connection conn) {

try {

// 判断测试表是否存在

if (testTable.equals("")) {

// 如果测试表为空，试着使用此连接的 setAutoCommit() 方法

// 来判断连接否可用（此方法只在部分数据库可用，如果不可用 ,

// 抛出异常）。注意：使用测试表的方法更可靠

conn.setAutoCommit(true);

} else {// 有测试表的时候使用测试表测试

// check if this connection is valid

Statement stmt = conn.createStatement();

stmt.execute("select count(*) from " + testTable);

}

} catch (SQLException e) {

// 上面抛出异常，此连接己不可用，关闭它，并返回 false;

closeConnection(conn);

return false;

}

// 连接可用，返回 true

return true;

}

/**
*
* 此函数返回一个数据库连接到连接池中，并把此连接置为空闲。
*
* 所有使用连接池获得的数据库连接均应在不使用此连接时返回它。
*
*
*
* @param 需返回到连接池中的连接对象
*
*/

public void returnConnection(Connection conn) {

// 确保连接池存在，如果连接没有创建（不存在），直接返回

if (connections == null) {

System.out.println(" 连接池不存在，无法返回此连接到连接池中 !");

return;

}

PooledConnection pConn = null;

Enumeration<PooledConnection> enumerate = connections.elements();

// 遍历连接池中的所有连接，找到这个要返回的连接对象

while (enumerate.hasMoreElements()) {

pConn = (PooledConnection) enumerate.nextElement();

// 先找到连接池中的要返回的连接对象

if (conn == pConn.getConnection()) {

// 找到了 , 设置此连接为空闲状态

pConn.setBusy(false);

break;

}

}

}

/**
*
* 刷新连接池中所有的连接对象
*
*
*
*/

public synchronized void refreshConnections() throws SQLException {

// 确保连接池己创新存在

if (connections == null) {

System.out.println(" 连接池不存在，无法刷新 !");

return;

}

PooledConnection pConn = null;

Enumeration<PooledConnection> enumerate = connections.elements();

while (enumerate.hasMoreElements()) {

// 获得一个连接对象

pConn = (PooledConnection) enumerate.nextElement();

// 如果对象忙则等 5 秒 ,5 秒后直接刷新

if (pConn.isBusy()) {

wait(5000); // 等 5 秒

}

// 关闭此连接，用一个新的连接代替它。

closeConnection(pConn.getConnection());

pConn.setConnection(newConnection());

pConn.setBusy(false);

}

}

/**
*
* 关闭连接池中所有的连接，并清空连接池。
*
*/

public synchronized void closeConnectionPool() throws SQLException {

// 确保连接池存在，如果不存在，返回

if (connections == null) {

System.out.println(" 连接池不存在，无法关闭 !");

return;

}

PooledConnection pConn = null;

Enumeration<PooledConnection> enumerate = connections.elements();

while (enumerate.hasMoreElements()) {

pConn = (PooledConnection) enumerate.nextElement();

// 如果忙，等 5 秒

if (pConn.isBusy()) {

wait(5000); // 等 5 秒

}

// 5 秒后直接关闭它

closeConnection(pConn.getConnection());

// 从连接池向量中删除它

connections.removeElement(pConn);

}

// 置连接池为空

connections = null;

}

/**
*
* 关闭一个数据库连接
*
*
*
* @param 需要关闭的数据库连接
*
*/

private void closeConnection(Connection conn) {

try {

conn.close();

} catch (SQLException e) {

System.out.println(" 关闭数据库连接出错： " + e.getMessage());

}

}

/**
*
* 使程序等待给定的毫秒数
*
*
*
* @param 给定的毫秒数
*
*/

private void wait(int mSeconds) {

try {

Thread.sleep(mSeconds);

} catch (InterruptedException e) {

}

}

/**
*
*
*
* 内部使用的用于保存连接池中连接对象的类
*
* 此类中有两个成员，一个是数据库的连接，另一个是指示此连接是否
*
* 正在使用的标志。
*
*/

class PooledConnection {

Connection connection = null;// 数据库连接

boolean busy = false; // 此连接是否正在使用的标志，默认没有正在使用

// 构造函数，根据一个 Connection 构告一个 PooledConnection 对象

public PooledConnection(Connection connection) {

this.connection = connection;

}

// 返回此对象中的连接

public Connection getConnection() {

return connection;

}

// 设置此对象的，连接

public void setConnection(Connection connection) {

this.connection = connection;

}

// 获得对象连接是否忙

public boolean isBusy() {

return busy;

}

// 设置对象的连接正在忙

public void setBusy(boolean busy) {

this.busy = busy;

}

}

public static void main(String[] args) {
DbPoolDesign connPool = new DbPoolDesign("com.mysql.jdbc.Driver",
"jdbc:mysql://127.0.0.1:3306/test", "SGY", "SGYSBYZBZ");

try {
connPool .createPool();
Connection conn = connPool.getConnection();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

在Java中开源的数据库连接池有以下几种 ：

　　1, C3P0 C3P0是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate一起发布,包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象。

　　2,Proxool 这是一个Java SQL Driver驱动程序，提供了对你选择的其它类型的驱动程序的连接池封装。

可以非常简单的移植到现存的代码中。完全可配置。快速，成熟，健壮。可以透明地为你现存的JDBC驱动程序增加连接池功能。

　　3,Jakarta DBCP DBCP是一个依赖Jakarta commons-pool对象池机制的数据库连接池.DBCP可以直接的在应用程序用使用。

　　4,DDConnectionBroker DDConnectionBroker是一个简单，轻量级的数据库连接池。

　　5,DBPool DBPool是一个高效的易配置的数据库连接池。它除了支持连接池应有的功能之外，还包括了一个对象池使你能够开发一个满足自已需求的数据库连接池。

　　6,XAPool XAPool是一个XA数据库连接池。它实现了javax.sql.XADataSource并提供了连接池工具。

　　7,Primrose Primrose是一个Java开发的数据库连接池。当前支持的容器包括Tomcat4&5,Resin3与JBoss3.它同样也有一个独立的版本可以在应用程序中使用而不必运行在容器中。Primrose通过一个web接口来控制SQL处理的追踪，配置，动态池管理。在重负荷的情况下可进行连接请求队列处理。

　　8,SmartPool SmartPool是一个连接池组件，它模仿应用服务器对象池的特性。SmartPool能够解决一些临界问题如连接泄漏(connection leaks),连接阻塞,打开的JDBC对象如Statements,PreparedStatements等. SmartPool的特性包括支持多个pools,自动关闭相关联的JDBC对象, 在所设定time-outs之后察觉连接泄漏,追踪连接使用情况, 强制启用最近最少用到的连接,把SmartPool"包装"成现存的一个pool等。

　　9,MiniConnectionPoolManager MiniConnectionPoolManager是一个轻量级JDBC数据库连接池。它只需要Java1.5（或更高）并且没有依赖第三方包。

　　10,BoneCP BoneCP是一个快速，开源的数据库连接池。帮你管理数据连接让你的应用程序能更快速地访问数据库。比C3P0/DBCP连接池快25倍。