- 浏览: 5598 次
- 性别:
- 来自: 大连
文章分类
最新评论
-
xiaoniu001:
<div class="quote_title ...
Java实现数据库连接池 -
yinxiaoyong1987:
这个是struts2内部的一个文件..
spring+ibatis+struts的web项目 -
kimmking:
<div class="quote_title ...
Java实现数据库连接池 -
liaohexiang:
getconnection() 用 sync 关键字效率很低, ...
Java实现数据库连接池 -
pouyang:
http://yulon.iteye.com/blog/526 ...
Java实现数据库连接池
Java实现数据库连接池的代码
ConnectionPool.java
ConnectionParam.java
受教,谢谢!
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
2、刷新连接的时候,这里直接置空闲,行吗?
完全乱讲 你能继承java.sql.Connection 搞笑了
继承也不是最好的解决方案 最起码你该想到内聚 然后代理 。。。。
自己去扒扒 dbcp c3p0之类的东西去
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
2、刷新连接的时候,这里直接置空闲,行吗?
完全乱讲 你能继承java.sql.Connection 搞笑了
继承也不是最好的解决方案 最起码你该想到内聚 然后代理 。。。。
请把的代码贴出来,行么,不要光说不做。
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
2、刷新连接的时候,这里直接置空闲,行吗?
完全乱讲 你能继承java.sql.Connection 搞笑了
继承也不是最好的解决方案 最起码你该想到内聚 然后代理 。。。。
你的建议很好,但我有两点疑问:
1、连接池获得的connection应该是个proxy,不然close就完了,一定要代理吗?重写close应该也行。
2、实现连接池非常简单,核心就两个模式flyweight和proxy,能否来个具体的代码或者例子,谢谢。
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
2、刷新连接的时候,这里直接置空闲,行吗?
PooledConnection 没有继承 Connection ,并重写close方法
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
ConnectionPool.java
package com.kyo.connection; 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 ConnectionPool { private ConnectionParam param; private String testTable = ""; // 测试连接是否可用的测试表名,默认没有测试表 private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 // null,它中存放的对象为PooledConnection 型 public void setParam(ConnectionParam param) { this.param = param; } public ConnectionParam getParam() { return param; } /** * 构造函数 * * @param param */ public ConnectionPool(ConnectionParam param) { this.param = param; } /** * * 获取测试数据库表的名字 * * @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.param.getDriver()) .newInstance()); DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序 // 创建保存连接的向量 , 初始时有 0 个元素 connections = new Vector(); // 根据 initialConnections 中设置的值,创建连接。 createConnections(this.param.getMinConnection()); System.out.println(" 数据库连接池创建成功! "); } /** * * 创建由 numConnections 指定数目的数据库连接 , 并把这些连接 放入 connections 向量中 * * @param numConnections * 要创建的数据库连接的数目 */ private void createConnections(int numConnections) throws SQLException { // 循环创建指定数目的数据库连接 for (int x = 0; x < numConnections; x++) { // 是否连接池中的数据库连接的数量己经达到最大?最大值由类成员 maxConnections,指出,如果 maxConnections // 为 0 或负数,表示连接数量没有限制。 // 如果连接数己经达到最大,即退出。 if (this.param.getMaxConnection() > 0 && this.connections.size() >= this.param.getMaxConnection()) { 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(this.param.getUrl(), this.param.getUser(), this.param.getPassword()); // 如果这是第一次创建数据库连接,即检查数据库,获得此数据库允许支持的 // 最大客户连接数目 // connections.size()==0 表示目前没有连接己被创建 if (connections.size() == 0) { DatabaseMetaData metaData = conn.getMetaData(); int driverMaxConnections = metaData.getMaxConnections(); // 数据库返回的 driverMaxConnections 若为 0 ,表示此数据库没有最大 // 连接限制,或数据库的最大连接限制不知道 // driverMaxConnections 为返回的一个整数,表示此数据库允许客户连接的数 目 // 如果连接池中设置的最大连接数量大于数据库允许的连接数目 , 则置连接池 的最大 // 连接数目为数据库允许的最大数目 if (driverMaxConnections > 0 && this.param.getMaxConnection() > driverMaxConnections) { this.param.setMaxConnection(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(this.param.getIncrementalConnections()); // 重新从池中查找是否有可用连接 conn = findFreeConnection(); if (conn == null) { // 如果创建连接后仍获得不到可用的连接,则返回 null return null; } } return conn; } /** * * 查找连接池中所有的连接,查找一个可用的数据库连接, * * 如果没有可用的连接,返回 null * * @return 返回一个可用的数据库连接 */ private Connection findFreeConnection() throws SQLException { Connection conn = null; PooledConnection pConn = null; // 获得连接池向量中所有的对象 Enumeration 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 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 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 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; } } }
ConnectionParam.java
package com.kyo.connection; import java.io.Serializable; /** * @author niudongjie.pt 数据库连接池参数 */ public class ConnectionParam implements Serializable { /** * */ private static final long serialVersionUID = 1L; private String driver; // 数据库连接驱动 private String url; // 数据库连接URL private String user; // 数据库连接user private String password; // 数据库连接password private int minConnection; // 数据库连接池最小连接数 private int maxConnection; // 数据库连接池最大连接数 private long timeoutValue; // 连接的最大空闲时间 private long waitTime; // 取得连接的最大等待时间 private int incrementalConnections=5; //连接池自动增加连接的数量 public String getDriver() { return driver; } public void setDriver(String driver) { this.driver = driver; } public String getUrl() { return url; } public void setUrl(String url) { this.url = url; } public String getUser() { return user; } public void setUser(String user) { this.user = user; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public int getMinConnection() { return minConnection; } public void setMinConnection(int minConnection) { this.minConnection = minConnection; } public int getMaxConnection() { return maxConnection; } public void setMaxConnection(int maxConnection) { this.maxConnection = maxConnection; } public long getTimeoutValue() { return timeoutValue; } public void setTimeoutValue(long timeoutValue) { this.timeoutValue = timeoutValue; } public long getWaitTime() { return waitTime; } public void setWaitTime(long waitTime) { this.waitTime = waitTime; } public void setIncrementalConnections(int incrementalConnections) { this.incrementalConnections = incrementalConnections; } public int getIncrementalConnections() { return incrementalConnections; } }
评论
17 楼
xiaoniu001
2011-02-23
beeke 写道
连接池获得的connection应该是个proxy,不然close就完了
实现连接池非常简单,核心就两个模式flyweight和proxy
当然要实现工业强度的还是比较困难
实现连接池非常简单,核心就两个模式flyweight和proxy
当然要实现工业强度的还是比较困难
pouyang 写道
http://yulon.iteye.com/blog/526273
受教,谢谢!
16 楼
kimmking
2011-02-22
tonyruiyu 写道
pouyang 写道
kimmking 写道
PooledConnection 没有继承 Connection ,并重写close方法
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
class PooledConnection extends java.sql.Connection { @override public void close() { //回收到连接池里,并不是去关闭他,应该就是置状态为闲吧? } }
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
// 如果对象忙则等 5 秒 ,5 秒后直接刷新 if (pConn.isBusy()) { wait(5000); // 等 5 秒 } // 关闭此连接,用一个新的连接代替它。 closeConnection(pConn.getConnection()); pConn.setConnection(newConnection()); pConn.setBusy(false);
2、刷新连接的时候,这里直接置空闲,行吗?
// 先找到连接池中的要返回的连接对象 if (conn == pConn.getConnection()) { // 找到了 , 设置此连接为空闲状态 pConn.setBusy(false); break;
完全乱讲 你能继承java.sql.Connection 搞笑了
继承也不是最好的解决方案 最起码你该想到内聚 然后代理 。。。。
自己去扒扒 dbcp c3p0之类的东西去
15 楼
liaohexiang
2011-02-22
getconnection() 用 sync 关键字效率很低,考虑一下concurrent包里面threadpool的实现
赞同前面说的,需要proxy 真实的connection, ProxyConnection 在 close的时候应该是将 DBConnection放回池里,这要就可以实现重用了,看看dbcp的实现应该挺有帮助的
赞同前面说的,需要proxy 真实的connection, ProxyConnection 在 close的时候应该是将 DBConnection放回池里,这要就可以实现重用了,看看dbcp的实现应该挺有帮助的
14 楼
pouyang
2011-02-21
http://yulon.iteye.com/blog/526273
13 楼
pouyang
2011-02-21
tonyruiyu 写道
pouyang 写道
kimmking 写道
PooledConnection 没有继承 Connection ,并重写close方法
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
class PooledConnection implements java.sql.Connection { public void close() { //回收到连接池里,并不是去关闭他,应该就是置状态为闲吧? } }
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
// 如果对象忙则等 5 秒 ,5 秒后直接刷新 if (pConn.isBusy()) { wait(5000); // 等 5 秒 } // 关闭此连接,用一个新的连接代替它。 closeConnection(pConn.getConnection()); pConn.setConnection(newConnection()); pConn.setBusy(false);
2、刷新连接的时候,这里直接置空闲,行吗?
// 先找到连接池中的要返回的连接对象 if (conn == pConn.getConnection()) { // 找到了 , 设置此连接为空闲状态 pConn.setBusy(false); break;
完全乱讲 你能继承java.sql.Connection 搞笑了
继承也不是最好的解决方案 最起码你该想到内聚 然后代理 。。。。
请把的代码贴出来,行么,不要光说不做。
12 楼
kakaluyi
2011-02-21
楼主你要讲出这个连接池实现的要点,否则只是把网上经典的连接池实现贴出来,
1其实就是用flag来表示一个连接是否正在被使用。
2池化管理,回收。
3超时机制。
1其实就是用flag来表示一个连接是否正在被使用。
2池化管理,回收。
3超时机制。
11 楼
tonyruiyu
2011-02-21
pouyang 写道
kimmking 写道
PooledConnection 没有继承 Connection ,并重写close方法
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
class PooledConnection extends java.sql.Connection { @override public void close() { //回收到连接池里,并不是去关闭他,应该就是置状态为闲吧? } }
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
// 如果对象忙则等 5 秒 ,5 秒后直接刷新 if (pConn.isBusy()) { wait(5000); // 等 5 秒 } // 关闭此连接,用一个新的连接代替它。 closeConnection(pConn.getConnection()); pConn.setConnection(newConnection()); pConn.setBusy(false);
2、刷新连接的时候,这里直接置空闲,行吗?
// 先找到连接池中的要返回的连接对象 if (conn == pConn.getConnection()) { // 找到了 , 设置此连接为空闲状态 pConn.setBusy(false); break;
完全乱讲 你能继承java.sql.Connection 搞笑了
继承也不是最好的解决方案 最起码你该想到内聚 然后代理 。。。。
10 楼
pouyang
2011-02-21
beeke 写道
连接池获得的connection应该是个proxy,不然close就完了
实现连接池非常简单,核心就两个模式flyweight和proxy
当然要实现工业强度的还是比较困难
实现连接池非常简单,核心就两个模式flyweight和proxy
当然要实现工业强度的还是比较困难
你的建议很好,但我有两点疑问:
1、连接池获得的connection应该是个proxy,不然close就完了,一定要代理吗?重写close应该也行。
2、实现连接池非常简单,核心就两个模式flyweight和proxy,能否来个具体的代码或者例子,谢谢。
9 楼
xukehg
2011-02-21
楼上几位没必要对楼主这么刻薄,你们有更好的想法贴出来大家都瞅瞅嘛
8 楼
cs519051890
2011-02-19
LZ可劲的拿连接,用完也不还回去?
本来很简单的连接池技术,让LZ整这么复杂,把JAVA最重要的代码理念:简洁,给整没了。
捡芝麻丢西瓜,得不偿失。
本来很简单的连接池技术,让LZ整这么复杂,把JAVA最重要的代码理念:简洁,给整没了。
捡芝麻丢西瓜,得不偿失。
7 楼
beeke
2011-02-19
连接池获得的connection应该是个proxy,不然close就完了
实现连接池非常简单,核心就两个模式flyweight和proxy
当然要实现工业强度的还是比较困难
实现连接池非常简单,核心就两个模式flyweight和proxy
当然要实现工业强度的还是比较困难
6 楼
洪帮主
2011-02-19
我觉得LZ都没明白数据源是啥玩意了。明显的datasource接口都没实现。
5 楼
Loudyn
2011-02-18
印象中,某些数据库在连接超过一定时长,会自动关闭链接。
这时怎么办?重新启动?
这时怎么办?重新启动?
4 楼
evanzzy
2011-02-18
这个连接池有什么优势么?
3 楼
_numen
2011-02-18
没咋看明白。先膜拜下~~
2 楼
pouyang
2011-02-18
kimmking 写道
PooledConnection 没有继承 Connection ,并重写close方法
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
class PooledConnection implements java.sql.Connection { @override public void close() { //回收到连接池里,并不是去关闭他,应该就是置状态为闲吧? } }
我有两个问题:
1、这个5秒,怎么确定,真正的环境中,怎么确定这个时间?
如果5秒中之后,连接也仍处在忙的状态,强制关闭,会不会?
// 如果对象忙则等 5 秒 ,5 秒后直接刷新 if (pConn.isBusy()) { wait(5000); // 等 5 秒 } // 关闭此连接,用一个新的连接代替它。 closeConnection(pConn.getConnection()); pConn.setConnection(newConnection()); pConn.setBusy(false);
2、刷新连接的时候,这里直接置空闲,行吗?
// 先找到连接池中的要返回的连接对象 if (conn == pConn.getConnection()) { // 找到了 , 设置此连接为空闲状态 pConn.setBusy(false); break;
1 楼
kimmking
2011-02-18
xiaoniu001 写道
Java实现数据库连接池的代码
ConnectionPool.java
ConnectionParam.java
ConnectionPool.java
package com.kyo.connection; 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 ConnectionPool { private ConnectionParam param; private String testTable = ""; // 测试连接是否可用的测试表名,默认没有测试表 private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 // null,它中存放的对象为PooledConnection 型 public void setParam(ConnectionParam param) { this.param = param; } public ConnectionParam getParam() { return param; } /** * 构造函数 * * @param param */ public ConnectionPool(ConnectionParam param) { this.param = param; } /** * * 获取测试数据库表的名字 * * @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.param.getDriver()) .newInstance()); DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序 // 创建保存连接的向量 , 初始时有 0 个元素 connections = new Vector(); // 根据 initialConnections 中设置的值,创建连接。 createConnections(this.param.getMinConnection()); System.out.println(" 数据库连接池创建成功! "); } /** * * 创建由 numConnections 指定数目的数据库连接 , 并把这些连接 放入 connections 向量中 * * @param numConnections * 要创建的数据库连接的数目 */ private void createConnections(int numConnections) throws SQLException { // 循环创建指定数目的数据库连接 for (int x = 0; x < numConnections; x++) { // 是否连接池中的数据库连接的数量己经达到最大?最大值由类成员 maxConnections,指出,如果 maxConnections // 为 0 或负数,表示连接数量没有限制。 // 如果连接数己经达到最大,即退出。 if (this.param.getMaxConnection() > 0 && this.connections.size() >= this.param.getMaxConnection()) { 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(this.param.getUrl(), this.param.getUser(), this.param.getPassword()); // 如果这是第一次创建数据库连接,即检查数据库,获得此数据库允许支持的 // 最大客户连接数目 // connections.size()==0 表示目前没有连接己被创建 if (connections.size() == 0) { DatabaseMetaData metaData = conn.getMetaData(); int driverMaxConnections = metaData.getMaxConnections(); // 数据库返回的 driverMaxConnections 若为 0 ,表示此数据库没有最大 // 连接限制,或数据库的最大连接限制不知道 // driverMaxConnections 为返回的一个整数,表示此数据库允许客户连接的数 目 // 如果连接池中设置的最大连接数量大于数据库允许的连接数目 , 则置连接池 的最大 // 连接数目为数据库允许的最大数目 if (driverMaxConnections > 0 && this.param.getMaxConnection() > driverMaxConnections) { this.param.setMaxConnection(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(this.param.getIncrementalConnections()); // 重新从池中查找是否有可用连接 conn = findFreeConnection(); if (conn == null) { // 如果创建连接后仍获得不到可用的连接,则返回 null return null; } } return conn; } /** * * 查找连接池中所有的连接,查找一个可用的数据库连接, * * 如果没有可用的连接,返回 null * * @return 返回一个可用的数据库连接 */ private Connection findFreeConnection() throws SQLException { Connection conn = null; PooledConnection pConn = null; // 获得连接池向量中所有的对象 Enumeration 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 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 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 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; } } }
ConnectionParam.java
package com.kyo.connection; import java.io.Serializable; /** * @author niudongjie.pt 数据库连接池参数 */ public class ConnectionParam implements Serializable { /** * */ private static final long serialVersionUID = 1L; private String driver; // 数据库连接驱动 private String url; // 数据库连接URL private String user; // 数据库连接user private String password; // 数据库连接password private int minConnection; // 数据库连接池最小连接数 private int maxConnection; // 数据库连接池最大连接数 private long timeoutValue; // 连接的最大空闲时间 private long waitTime; // 取得连接的最大等待时间 private int incrementalConnections=5; //连接池自动增加连接的数量 public String getDriver() { return driver; } public void setDriver(String driver) { this.driver = driver; } public String getUrl() { return url; } public void setUrl(String url) { this.url = url; } public String getUser() { return user; } public void setUser(String user) { this.user = user; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public int getMinConnection() { return minConnection; } public void setMinConnection(int minConnection) { this.minConnection = minConnection; } public int getMaxConnection() { return maxConnection; } public void setMaxConnection(int maxConnection) { this.maxConnection = maxConnection; } public long getTimeoutValue() { return timeoutValue; } public void setTimeoutValue(long timeoutValue) { this.timeoutValue = timeoutValue; } public long getWaitTime() { return waitTime; } public void setWaitTime(long waitTime) { this.waitTime = waitTime; } public void setIncrementalConnections(int incrementalConnections) { this.incrementalConnections = incrementalConnections; } public int getIncrementalConnections() { return incrementalConnections; } }
PooledConnection 没有继承 Connection ,并重写close方法
这将导致每次获取到的是一个实际的Connection,close了就真close了,
达不到重用效果。
相关推荐
java实现数据库连接池,很实用,请大家给予意见
java实现数据库连接池的模拟
基于JAVA语言的一种有效的数据库连接池的实现代码。
JAVA 使用数据库连接池连接Oracle数据库,全代码,附加详细说明
在Java语言中,JDBC(Java DataBase Connection)是应用程序与数据库沟通的桥梁
主要介绍了Java实现数据库连接池的方法,涉及java数据库连接池的创建、连接、刷新、关闭及状态获取的常用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
主要为大家介绍了Java实现数据库连接池简易教程,感兴趣的小伙伴们可以参考一下
详细介绍常用Java各数据库连接池配置,包括C3P0,DBCP,Proxool等。
JAVA 完整的数据库连接池实现 可以配置根据自己需要
此类非常简单,免去了网上众多资料里所说的麻烦的tomcat配置,更强...不仅oracle,mysql,sqlserver2000都行,因为它依据的是你自己连接数据库的驱动。当然首先你要保证你拥有一个能连接自己数据库的对应驱动类。如下面以
使用JAVA中的动态代理实现数据库连接池
java手写数据库连接池,使用maven构建,一共有四个类方法,一个是测试类,测试类使用三个线程去操数据库连接
JAVA数据库连接池 能够减少对内存的消耗 提高了性能
java_jdbc数据库连接池总结 有讲原理,不错
。
。
基于Java的数据库连接池的研究与实现,谢俊,陈明,介绍了基于Java的数据库的访问机制,对实际应用中出现的问题进行了分析,提出了数据库连接池技术的解决方案,分析了连接池的工作原理,�
数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接, 当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后再放回去。 我们可以通过设定连接池最大连接数...