package org.xml.upload;
import java.sql.*;
import java.util.*;
/**
*
* ConnectionPool 类创建了一个对特定数据库指定大小的连接池。连接池对象
*
* 允许客户端指定 JDBC 驱动程序，数据库，使用数据库的用户名和密码。而且，
*
* 客户端能指定连接池的在初始创建是产生数据库连接的数量，和指定当连接
*
* 不够时每次自动增加连接的数量及连接池最多的数据库连接的数量。
*
*
*
* 对外提供的方法有： ConnectionPool ：构造函数
*
* getInitialConnections: 返回连接池初始化大小
*
* setInitialConnections: 设置连接池初始化大小
*
* getIncrementalConnections: 返回连接池自动增加的增量
*
* setIncrementalConnections: 设置连接池自动增加的大小
*
* getMaxConnections ：获得连接池的最大可允许的连接数
*
* setMaxConnections ：设置连接池的最大可允许的连接数
*
* getTestTable ：获得测试表的名字
*
* setTestTable ：设置测试表的名字
*
* createPool: 创建连接池 , 线程己同步
*
* getConnection: 从连接池中获得一个数据库连接
*
* returnConnection: 返回一个连接到连接池中
*
* refreshConnections: 刷新连接池
*
* closeConnectionPool: 关闭连接池
*
*
*
*
*
* @author abnerchai Email: josserchai@yahoo.com
*
* @version 1.0.0
*
*
*
*/
public class ConnectionPool {
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 int delayTime=5000;
private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 null
// 它中存放的对象为 PooledConnection 型
public Vector getConnections() {
return connections;
}
public void setConnections(Vector connections) {
this.connections = connections;
}
public String getDbPassword() {
return dbPassword;
}
public void setDbPassword(String dbPassword) {
this.dbPassword = dbPassword;
}
public String getDbUrl() {
return dbUrl;
}
public void setDbUrl(String dbUrl) {
this.dbUrl = dbUrl;
}
public String getDbUsername() {
return dbUsername;
}
public void setDbUsername(String dbUsername) {
this.dbUsername = dbUsername;
}
public int getDelayTime() {
return delayTime;
}
public void setDelayTime(int delayTime) {
this.delayTime = delayTime;
}
public String getJdbcDriver() {
return jdbcDriver;
}
public void setJdbcDriver(String jdbcDriver) {
this.jdbcDriver = jdbcDriver;
}
/**
*
* 构造函数
*
*
*
* @param jdbcDriver
* String JDBC 驱动类串
*
* @param dbUrl
* String 数据库 URL
*
* @param dbUsername
* String 连接数据库用户名
*
* @param dbPassword
* String 连接数据库用户的密码
*
*
*
*/
public ConnectionPool(String jdbcDriver, String dbUrl, String dbUsername,
String dbPassword) {
this.jdbcDriver = jdbcDriver;
this.dbUrl = dbUrl;
this.dbUsername = dbUsername;
this.dbPassword = dbPassword;
}
public ConnectionPool(){
}
/**
*
* 返回连接池的初始大小
*
*
*
* @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();
// 根据 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(" 数据库连接己创建 ......");
}
}
/**
*
* 创建一个新的数据库连接并返回它
*
*
*
* @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) {
// 等一会再试
System.out.println("正在等待可用的数据库连接");
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();
while (conn == null) {
conn = findFreeConnection();// 如果创建连接后仍获得不到可用的连接，则返回 null
wait(250);
System.out.println("正在等待可以用的数据库连接");
}
}
return conn;
}
/**
*
* 查找连接池中所有的连接，查找一个可用的数据库连接，
*
* 如果没有可用的连接，返回 null
*
*
*
* @return 返回一个可用的数据库连接
*
*/
private Connection findFreeConnection() throws SQLException {
Connection conn = null;
PooledConnection pConn = null;
// 获得连接池向量中所有的对象
Enumeration en = connections.elements();
// 遍历所有的对象，看是否有可用的连接
while (en.hasMoreElements()) {
pConn = (PooledConnection) en.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);
// System.out.println("数据库连接正常");
} 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 en = connections.elements();
// 遍历连接池中的所有连接，找到这个要返回的连接对象
while (en.hasMoreElements()) {
pConn = (PooledConnection) en.nextElement();
// 先找到连接池中的要返回的连接对象
if (conn == pConn.getConnection()) {
// 找到了 , 设置此连接为空闲状态
pConn.setBusy(false);
// System.out.println("数据库连接返回成功");
break;
}
}
}
/**
*
* 刷新连接池中所有的连接对象
*
*
*
*/
public synchronized void refreshConnections() throws SQLException {
// 确保连接池己创新存在
if (connections == null) {
System.out.println(" 连接池不存在，无法刷新 !");
return;
}
PooledConnection pConn = null;
Enumeration en = connections.elements();
while (en.hasMoreElements()) {
// 获得一个连接对象
pConn = (PooledConnection) en.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 en = connections.elements();
while (en.hasMoreElements()) {
pConn = (PooledConnection) en.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[]) throws Exception {
ConnectionPool pool = new ConnectionPool("com.mysql.jdbc.Driver",
"jdbc:mysql://localhost/xml", "root", "root");
pool.createPool();
Connection conn = pool.getConnection();
pool.testConnection(conn);
pool.returnConnection(conn);
pool.refreshConnections();
}
}
import java.sql.*;
import java.util.*;
/**
*
* ConnectionPool 类创建了一个对特定数据库指定大小的连接池。连接池对象
*
* 允许客户端指定 JDBC 驱动程序，数据库，使用数据库的用户名和密码。而且，
*
* 客户端能指定连接池的在初始创建是产生数据库连接的数量，和指定当连接
*
* 不够时每次自动增加连接的数量及连接池最多的数据库连接的数量。
*
*
*
* 对外提供的方法有： ConnectionPool ：构造函数
*
* getInitialConnections: 返回连接池初始化大小
*
* setInitialConnections: 设置连接池初始化大小
*
* getIncrementalConnections: 返回连接池自动增加的增量
*
* setIncrementalConnections: 设置连接池自动增加的大小
*
* getMaxConnections ：获得连接池的最大可允许的连接数
*
* setMaxConnections ：设置连接池的最大可允许的连接数
*
* getTestTable ：获得测试表的名字
*
* setTestTable ：设置测试表的名字
*
* createPool: 创建连接池 , 线程己同步
*
* getConnection: 从连接池中获得一个数据库连接
*
* returnConnection: 返回一个连接到连接池中
*
* refreshConnections: 刷新连接池
*
* closeConnectionPool: 关闭连接池
*
*
*
*
*
* @author abnerchai Email: josserchai@yahoo.com
*
* @version 1.0.0
*
*
*
*/
public class ConnectionPool {
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 int delayTime=5000;
private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 null
// 它中存放的对象为 PooledConnection 型
public Vector getConnections() {
return connections;
}
public void setConnections(Vector connections) {
this.connections = connections;
}
public String getDbPassword() {
return dbPassword;
}
public void setDbPassword(String dbPassword) {
this.dbPassword = dbPassword;
}
public String getDbUrl() {
return dbUrl;
}
public void setDbUrl(String dbUrl) {
this.dbUrl = dbUrl;
}
public String getDbUsername() {
return dbUsername;
}
public void setDbUsername(String dbUsername) {
this.dbUsername = dbUsername;
}
public int getDelayTime() {
return delayTime;
}
public void setDelayTime(int delayTime) {
this.delayTime = delayTime;
}
public String getJdbcDriver() {
return jdbcDriver;
}
public void setJdbcDriver(String jdbcDriver) {
this.jdbcDriver = jdbcDriver;
}
/**
*
* 构造函数
*
*
*
* @param jdbcDriver
* String JDBC 驱动类串
*
* @param dbUrl
* String 数据库 URL
*
* @param dbUsername
* String 连接数据库用户名
*
* @param dbPassword
* String 连接数据库用户的密码
*
*
*
*/
public ConnectionPool(String jdbcDriver, String dbUrl, String dbUsername,
String dbPassword) {
this.jdbcDriver = jdbcDriver;
this.dbUrl = dbUrl;
this.dbUsername = dbUsername;
this.dbPassword = dbPassword;
}
public ConnectionPool(){
}
/**
*
* 返回连接池的初始大小
*
*
*
* @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();
// 根据 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(" 数据库连接己创建 ......");
}
}
/**
*
* 创建一个新的数据库连接并返回它
*
*
*
* @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) {
// 等一会再试
System.out.println("正在等待可用的数据库连接");
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();
while (conn == null) {
conn = findFreeConnection();// 如果创建连接后仍获得不到可用的连接，则返回 null
wait(250);
System.out.println("正在等待可以用的数据库连接");
}
}
return conn;
}
/**
*
* 查找连接池中所有的连接，查找一个可用的数据库连接，
*
* 如果没有可用的连接，返回 null
*
*
*
* @return 返回一个可用的数据库连接
*
*/
private Connection findFreeConnection() throws SQLException {
Connection conn = null;
PooledConnection pConn = null;
// 获得连接池向量中所有的对象
Enumeration en = connections.elements();
// 遍历所有的对象，看是否有可用的连接
while (en.hasMoreElements()) {
pConn = (PooledConnection) en.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);
// System.out.println("数据库连接正常");
} 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 en = connections.elements();
// 遍历连接池中的所有连接，找到这个要返回的连接对象
while (en.hasMoreElements()) {
pConn = (PooledConnection) en.nextElement();
// 先找到连接池中的要返回的连接对象
if (conn == pConn.getConnection()) {
// 找到了 , 设置此连接为空闲状态
pConn.setBusy(false);
// System.out.println("数据库连接返回成功");
break;
}
}
}
/**
*
* 刷新连接池中所有的连接对象
*
*
*
*/
public synchronized void refreshConnections() throws SQLException {
// 确保连接池己创新存在
if (connections == null) {
System.out.println(" 连接池不存在，无法刷新 !");
return;
}
PooledConnection pConn = null;
Enumeration en = connections.elements();
while (en.hasMoreElements()) {
// 获得一个连接对象
pConn = (PooledConnection) en.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 en = connections.elements();
while (en.hasMoreElements()) {
pConn = (PooledConnection) en.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[]) throws Exception {
ConnectionPool pool = new ConnectionPool("com.mysql.jdbc.Driver",
"jdbc:mysql://localhost/xml", "root", "root");
pool.createPool();
Connection conn = pool.getConnection();
pool.testConnection(conn);
pool.returnConnection(conn);
pool.refreshConnections();
}
}
分享到：
发表评论
-
mysql分页查询
2010-11-03 17:01 3355MySql分页存储过程 MySql测试版本：5.0.41-co ... -
svn 权限分配
2010-09-19 11:39 2373转自：http://bbs.iusesvn.com/threa ... -
svn 安装配置-1
2010-09-19 11:38 1064转自：http://minedoc.iteye.c ... -
mysql数据库同步
2008-04-25 16:19 3883windows xp 下设置数据库 ... -
inverse
2008-01-17 10:31 1417前不久在搭建系统框架的时候遇到one-many与many-on ... -
CVSNT
2007-12-31 13:22 1648转自：http://blog.csdn.net/k ... -
mysql备份命令
2007-11-06 20:12 16105还原或者导入数据库命令： mysql -u root --p ... -
spry
2007-06-10 01:03 1570这几天给系统做页面级别的验证，主要是对一些输入参数进行控制。在 ... -
spring 发送html邮件
2007-05-05 19:00 8319对于spring发送邮件的部分看了几天,给小组的项目中添加了 ... -
lucene
2007-04-19 14:29 23131。今天研究了一下lucene ... -
outOfMemory
2006-12-31 16:17 2781收藏源地址：http://blog.s ... -
notify,wait,sleep
2006-12-29 22:29 2432转载别人的http://dev.cs ... -
ThreadPool
2006-12-25 21:33 1260package org.xml.upload; import ... -
arrayList
2006-12-25 21:28 1033private pool=new ArrayList(); p ... -
ArrayList 同步问题
2006-12-25 20:49 3593转载！ [JAVA技术集锦]Java技巧：拷贝枚举器以加强效 ...
相关推荐
数据库连接池是数据库管理中的重要概念，特别是在高并发和大数据量的应用场景下，它能显著提升性能并降低系统资源消耗。在C#编程环境中，我们可以使用自定义的数据库连接池来实现这一功能。本篇文章将深入探讨“C#...
对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接的配置，实现数据库连接池技术。某一应用最大可用数据库连接数的限制，避免某一应用独占所有数据库资源。 在较为完备的数据库连接池实现中，可根据...
数据库连接池是数据库管理中的一个重要概念，它在C#编程中扮演着优化数据库操作的关键角色。C#数据库连接池是一种管理数据库连接的技术，通过复用已存在的连接而不是每次请求时都创建新的连接，从而提高数据库操作的...
本资源集合了常用的JDBC数据库连接jar包，以及一些知名的数据库连接池实现，如dbcp和c3p0，这对于开发人员来说是非常宝贵的资源。 首先，让我们了解一下JDBC。JDBC提供了一套标准的API，包括接口和类，使得开发者...
数据库连接池是现代应用程序开发中的重要组成部分，尤其是在处理大量数据交互的应用中，它极大地提高了数据库操作的效率和系统的稳定性。本资源"03-数据库连接池驱动"包含了三种常用的数据库连接池驱动：C3P0、Druid...
本文将深入探讨如何在C#中使用MySQL数据库连接池。 首先，我们需要了解什么是数据库连接池。数据库连接池是一种资源管理技术，它预先创建并维护一定数量的数据库连接，当应用需要时，可以从池中获取连接，使用完毕...
Java JDBC 数据库连接池总结 Java 语言中，JDBC（Java DataBase Connection）是应用程序与数据库沟通的桥梁。在 Web 应用开发的早期，主要使用的技术是 CGIASPPHP 等。之后，Sun 公司推出了基于 Java 语言的 ...
* 数据库连接池特点: * 获取连接时不需要了解连接的名字，连接池内部维护连接的名字 * 支持多线程，保证获取到的连接一定是没有被其他线程正在使用 * 按需创建连接,可以创建多个连接,可以控制连接的数量 * 连接...
MySQL数据库连接池是提高应用程序性能的一种重要技术，它允许开发者管理多个数据库连接并高效地复用这些连接，而不是每次需要时都创建新的连接。在C#编程中，我们可以使用自定义的连接池或者第三方库如ADO.NET的...
数据库连接池在Java中的实现是提高应用程序性能的关键技术之一，它通过复用已存在的数据库连接，避免了频繁创建和销毁连接导致的系统资源浪费。本文将深入探讨如何使用Java代码来实现一个简单的数据库连接池，并解释...
在IT领域，数据库连接池是优化数据库访问性能的关键技术之一，尤其在高并发的应用场景下，合理配置数据库连接池能够显著提升系统响应速度并降低资源消耗。本文将深入解析几种常用的数据库连接池——Apache DBCP、C3P...
数据库连接池是数据库管理系统中的一个重要概念，主要用于优化数据库的连接操作。在C#编程中，数据库连接池可以高效地管理数据库连接，避免频繁创建和销毁连接导致的性能开销。本文将详细介绍C#中数据库连接池的工作...
数据库连接池是Java开发中非常重要的一个组件，它在处理多线程环境下对数据库资源的高效利用和管理中起着关键作用。C3P0是一个开源的Java连接池实现，它提供了一种灵活且功能强大的数据库连接管理方式。在本文中，...
数据库连接池是现代Java应用程序中不可或缺的组件，它在提高数据库操作效率和资源管理方面扮演着重要角色。Druid是一个高效、强大且功能丰富的数据库连接池实现，由阿里巴巴开源并维护。标题提到的"数据库连接池jar...
Delphi数据库连接池是一种高效的数据库资源管理技术，它允许应用程序在多用户环境下共享数据库连接，以提高性能并减少系统资源的消耗。连接池的核心思想是重用已建立的数据库连接，而不是每次需要时都创建新的连接，...
context.xml， 数据库连接池配置文
数据库连接池是现代应用程序中管理数据库连接的一种高效方式，它能显著提高系统性能，减少资源消耗。在给定的标题“配置数据库连接池”中，我们可以深入探讨数据库连接池的概念、工作原理，以及如何配置Oracle9i和...
### JAVA 使用数据库连接池连接Oracle数据库全代码解析 #### 一、概述 本文将详细介绍如何在Java项目中使用Apache DBCP（Database Connection Pool）来连接Oracle数据库，并提供完整的示例代码。通过这种方式，我们...