当前页面: 开发资料首页 → Java 专题 → Java模拟.NET的连接池

Java模拟.NET的连接池

摘要: Java模拟.NET的连接池

在之前:
.NET的ADO.NET的本身包含连接池功能,而java是在第三方开发包中提高的连
接池功能因此,需要去下载第三方的连接池包,但是java的连接池一般都是在EJB或者
B/S系统中使用的(虽然也有C/S下的连接池如Borland 在Jbuilder中提供的),在一个
服务性系统中使用起来不是很方便.再说使用第三方的开发包也不利于维护.因此决
定自己写一个连接池的开发包.此连接池中主要解决的是提高数据库访问性能,并且
尽可能减少连接数目. 说明:
此连接池有三个类和一个接口组成,三个类分别是:
DBConnectionPool 数据库连接池,用户可以通过此类来使用连接池的功能.
PoolConnection 一个实现了java.sql.Connection的warp类,用来和数据库进行通讯.
theOnClose 实现了接口OnConnectionClose的一个类用还处理释放数据库连接的是
动作决定是关闭数据库还是返回池中接口 :
OnConnectionClose:此接口是一个声明,因为本人很不喜欢java的事件机制因此,
我经常自己写一些接口来模拟时间,没有java的事件机制那么强大也没有那么复杂.
但是效率要比java的事件机制要高那么一点点(笑:).
本来要上传这几个小类的UML图的但是我一点IE就死,所以算了.就只上传代码.还望方家指正. 代码:
package DBTools; /**
*

T数据库连接池工具

模拟.NET的连接池,俺一直以为.NET比java优秀

Company:自己作品

* @author董平雷
* @version 1.0 */
import java.sql.*;
import java.util.*;
import java.io.*;
interface OnConnectionClose {
public void Action(PoolConnection sender); }
public class DBConnectionPool {
private static Vector pConnectionVector = new Vector();
// private static int Count=0;
private static int minCount = 1;
private static String URL = "";
private static String User = "";
private static String Password = "";
private static String DriverName="";
synchronized public static void setMinCount(int Value) {
minCount = Value; }
synchronized public static int getMinCount() {
return minCount; }
synchronized public static int getCout() {
return pConnectionVector.size(); }
synchronized public static Connection getConnection() throws
SQLException {
PoolConnection pConnection = null;
// int aCount=pConnectionVector.size();
for (int i = 0; i < pConnectionVector.size(); i++) {
Object oCon = pConnectionVector.elementAt(i);
if (oCon instanceof PoolConnection) {
PoolConnection aCon = (PoolConnection) oCon;
if (!aCon.isUsed()) {
pConnection = aCon;
break; } } }
if (pConnection == null) {
pConnection = getNewConnection();
pConnectionVector.add(pConnection); }
return pConnection; }
private static PoolConnection getNewConnection() throws SQLException { try {
Class.forName( DriverName);
}catch(ClassNotFoundException ex) {
ex.printStackTrace(); }
PoolConnection con = new PoolConnection(URL, User, Password);
con.setOnClose(new theOnClose(pConnectionVector));
return con; }
synchronized public static void SetJDBC(String url, String user, String
password) {
URL = url;
User = user;
Password = password; }
synchronized public static void setURL(String url) {
URL = url; }
synchronized public static String getUrl() {
return URL; }
synchronized public static void setUser(String user) {
User=user; }
synchronized public static String getUser() {
return User; }
synchronized public static void setPassword(String password) {
Password=password; }
synchronized public static String getPassword() {
return Password; }
synchronized public static void setDriverName(String dName) {
DriverName=dName; }
synchronized public static String getDriverName() {
return DriverName; } }
class theOnClose
implements OnConnectionClose {
private Vector v;
public theOnClose(Vector vt) { v = vt; }
public void Action(PoolConnection sender) {
v.remove(sender); } }
class PoolConnection
implements Connection , Serializable{
private Connection aCon = null;
private boolean closed = false;
private boolean inUse = false;
private String DriverName;
private OnConnectionClose onClose = null;
private void writeObject(ObjectOutputStream oos) throws IOException {
oos.defaultWriteObject(); }
private void readObject(ObjectInputStream ois) throws
ClassNotFoundException, IOException {
ois.defaultReadObject(); }
protected PoolConnection() { }
public PoolConnection(String Url, String User, String Password) throws
SQLException {
aCon = DriverManager.getConnection(Url, User, Password);
closed = false;
inUse=true; }
public PoolConnection(String Url) throws Exception {
aCon = DriverManager.getConnection(Url);
closed = false;
inUse=true; }
public Statement createStatement() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
createStatement() not yet implemented.");
return aCon.createStatement(); }
public PreparedStatement prepareStatement(String sql) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
prepareStatement() not yet implemented.");
return aCon.prepareStatement(sql); }
public CallableStatement prepareCall(String sql) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
prepareCall() not yet implemented.");
return aCon.prepareCall(sql); }
public String nativeSQL(String sql) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
nativeSQL() not yet implemented.");
return aCon.nativeSQL(sql); }
public void setAutoCommit(boolean autoCommit) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
setAutoCommit() not yet implemented.");
aCon.setAutoCommit(autoCommit); }
public boolean getAutoCommit() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
getAutoCommit() not yet implemented.");
return aCon.getAutoCommit(); }
public void commit() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method commit()
not yet implemented.");
aCon.commit(); }
public void rollback() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method rollback
() not yet implemented.");
aCon.rollback(); }
public void close() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method close()
not yet implemented.");
if(DBConnectionPool.getCout()<=DBConnectionPool.getMinCount()) {
inUse = false; }else {
closeConnection(); } }
public boolean isClosed() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method isClosed
() not yet implemented.");
return closed; }
public DatabaseMetaData getMetaData() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
getMetaData() not yet implemented.");
return aCon.getMetaData(); }
public void setReadOnly(boolean readOnly) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
setReadOnly() not yet implemented.");
aCon.setReadOnly(readOnly); }
public boolean isReadOnly() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
isReadOnly() not yet implemented.");
return isReadOnly(); }
public void setCatalog(String catalog) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
setCatalog() not yet implemented.");
aCon.setCatalog(catalog); }
public String getCatalog() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
getCatalog() not yet implemented.");
return aCon.getCatalog(); }
public void setTransactionIsolation(int level) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
setTransactionIsolation() not yet implemented.");
aCon.setTransactionIsolation(level); }
public int getTransactionIsolation() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
getTransactionIsolation() not yet implemented.");
return aCon.getTransactionIsolation(); }
public SQLWarning getWarnings() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
getWarnings() not yet implemented.");
return aCon.getWarnings(); }
public void clearWarnings() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
clearWarnings() not yet implemented.");
aCon.clearWarnings(); }
public Statement createStatement(int resultSetType, int
resultSetConcurrency) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
createStatement() not yet implemented.");
return aCon.createStatement(resultSetType, resultSetConcurrency); }
public PreparedStatement prepareStatement(String sql, int
resultSetType,
int resultSetConcurrency) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
prepareStatement() not yet implemented.");
return aCon.prepareStatement(sql, resultSetType,
resultSetConcurrency); }
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
prepareCall() not yet implemented.");
return aCon.prepareCall(sql, resultSetType, resultSetConcurrency); }
public Map getTypeMap() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
getTypeMap() not yet implemented.");
return aCon.getTypeMap(); }
public void setTypeMap(Map map) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
setTypeMap() not yet implemented.");
aCon.setTypeMap(map); }
public void setHoldability(int holdability) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
setHoldability() not yet implemented.");
aCon.setHoldability(holdability); }
public int getHoldability() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
getHoldability() not yet implemented.");
return aCon.getHoldability(); }
public Savepoint setSavepoint() throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
setSavepoint() not yet implemented.");
return setSavepoint(); }
public Savepoint setSavepoint(String name) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
setSavepoint() not yet implemented.");
return setSavepoint(name); }
public void rollback(Savepoint savepoint) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method rollback
() not yet implemented.");
aCon.rollback(savepoint); }
public void releaseSavepoint(Savepoint savepoint) throws SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
releaseSavepoint() not yet implemented.");
aCon.releaseSavepoint(savepoint); }
public Statement createStatement(int resultSetType, int
resultSetConcurrency,
int resultSetHoldability) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
createStatement() not yet implemented.");
return aCon.createStatement(resultSetType, resultSetConcurrency,
resultSetHoldability); }
public PreparedStatement prepareStatement(String sql, int
resultSetType,
int resultSetConcurrency,
int resultSetHoldability) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
prepareStatement() not yet implemented.");
return aCon.prepareStatement(sql, resultSetType,
resultSetConcurrency,
resultSetHoldability); }
public CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency,
int resultSetHoldability) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
prepareCall() not yet implemented.");
return aCon.prepareCall(sql, resultSetType, resultSetConcurrency,
resultSetHoldability); }
public PreparedStatement prepareStatement(String sql, int
autoGeneratedKeys) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
prepareStatement() not yet implemented.");
return aCon.prepareStatement(sql, autoGeneratedKeys); }
public PreparedStatement prepareStatement(String sql, int[]
columnIndexes) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
// throw new java.lang.UnsupportedOperationException("Method
prepareStatement() not yet implemented.");
return aCon.prepareStatement(sql, columnIndexes); }
public PreparedStatement prepareStatement(String sql, String[]
columnNames) throws
SQLException {
/**@todo Implement this java.sql.Connection method*/
//throw new java.lang.UnsupportedOperationException("Method
prepareStatement() not yet implemented.");
return aCon.prepareStatement(sql, columnNames); }
public void closeConnection() throws SQLException {
if (onClose != null) {
onClose.Action(this); }
aCon.close(); }
public boolean isUsed() {
return inUse; }
public void use() {
inUse = true; }
public void setOnClose(OnConnectionClose Action) {
onClose = Action; } }
以上就是我所写的连接池代码.
使用方法:
DBTools.DBConnectionPool.SetJDBC("jdbc:mysql://fireBird/trmg?
useUnicode=true&characterEncoding=GB2312",
"Administrator","");
DBTools.DBConnectionPool.setDriverName("com.mysql.jdbc.Driver");
java.sql.Connection con = DBTools.DBConnectionPool.getConnection();
当使用完毕了别忘记将con关闭:).
好像现在使用java的人不允许人说java的问题,java的内存回收存在大问题.内存泄
漏的厉害,建议如非必要不要使用new来生成新的对象.这样可能可以让我们的系统可
以活的更长久一些.还有linux下java性能惨不忍睹,在俺测试的平台中win32反而是
最高的.郁闷郁闷不是罪.
对该文的评论人气：48
lifejoy(2003-9-16 14:23:40)
joachimz 谢谢,我知道我的一资源是放在stack中的(static)但是也没有想象的那么
多,多数这种资源都是Collection容器,而不是实际的资源.至于socket我所使用的
Socket中,也采用了缓冲机制.
joachimz(2003-9-16 13:50:12)
确实，Java在Linux平台上有很多问题：主要是
1。Linux得多线程问题。Linux采用进程模拟线程，自然造成资源消耗大、性能低下。
2。Linux平台的虚拟机(JVM)。由于主流JVM提供商(SUN, IBM)都有自己的Unix平台
，对linux平台下重视程度不够。
至于兄台所说的"内存泄漏的厉害"，我就不明白是怎么回事?恐怕要找找程序的原因
了，如果你的程序中到处都是HashMap、static域，对象不能在正常的生命周期内被
清除，特别是一些关键资源例如流、网络连接等不能释放，自然会问题多多。
我自己开始写程序的时候也有这个问题，Linux下的服务器几乎每天都要重起，但是
修改调整后，虽然应用添加了很多、使用的人数和频率也增加了不少，除了更新程
序，从来都不需要重起。
[建议：你可以使用top, pstree, netstat等linux命令查看各种资源的情况，找出
性能问题的所在
↑返回目录
前一篇: Java内部类
后一篇: JAVA命名和目录服务(JNDI) c