自己用Java编写的连接池

参考网上各方面的资料，自己编写了一个连接池，不过连接池存在一些问题，希望大神们指点，不多说了，直接在代码上有注释：

package com.tyxh.mypool;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
import java.util.Vector;

public class DBConnectFactory {
private static DBConnectFactory factory = null;

private static final int INIT_SIZE = 2; //连接池初始化大小

private static final int MAX_SIZE = 10; //连接池的最大值

private String driver;

private String url;

private String username;

private String password;

private long activeTime = 5000;

private Vector<DBConnection> connectPool = null;//存放数据库连接的向量

public DBConnectFactory() {
//初始化连接的配置
this.initProperties();
//初始化数据库的连接池
this.initPool();
}

private void initProperties() {
Properties dbPro = new Properties();
InputStream input = this.getClass().getResourceAsStream("db.properties");
try {
dbPro.load(input);
this.driver = dbPro.getProperty("driver");
this.url = dbPro.getProperty("url");
this.username = dbPro.getProperty("username");
this.password = dbPro.getProperty("password");

} catch (IOException e) {
e.printStackTrace();
}
}

private void initPool() {
if(null == connectPool) {
//创建数据库连接池
connectPool = new Vector<DBConnection>(INIT_SIZE);
//循环创建数据库连接
for (int i = 0; i < INIT_SIZE; i++) {
DBConnection db = new DBConnection(driver, url, username, password);
System.out.println("创建了DBConnection连接");
connectPool.add(db);
}
}
}

public static synchronized DBConnectFactory getDBConnectFactory() {
if(null == factory) {
factory = new DBConnectFactory();
}
return factory;
}

public DBConnection createNewConectionTimer() {
//此方法的作用是：当获取连接的时候，如果连接不够了，才会执行这个方法创建连接
synchronized (connectPool) {
DBConnection db = new DBConnectionTimer(driver, url, username, password, activeTime);
System.out.println("创建了DBConnectionTimer连接");
connectPool.add(db);
return db;
}
}

public Connection getConnection() {
System.out.println("此时连接池中还有的连接数： " + connectPool.size());
synchronized (connectPool) {
Connection conn = null;
DBConnection db = null;
while(true) {
//循环查找空闲的连接，直到找到位置
for (int i = 0; i < connectPool.size(); i++) {
db = connectPool.get(i);
if(!db.isUsed()) {
System.out.println("有空闲的连接");
//此连接处于空闲状态
if(db instanceof DBConnectionTimer) {
System.out.println("取得的链接是DBConnectionTimer");
//如果db是DBConnectionTimer对象
DBConnectionTimer dbTimer = (DBConnectionTimer)db;
dbTimer.cacel(); //取消定时
conn = db.getConn();
db.setUsed(true); //设置此链接繁忙状态
return conn;
} else {
System.out.println("取得的连接是DBConnection");
//如果db是DBConnection对象
conn = db.getConn();
db.setUsed(true); //设置此链接繁忙状态
return conn;
}
}

}
System.out.println("没有空闲的连接");
//如果没有找到空闲的连接，则创建连接
if(null == conn && connectPool.size() < this.MAX_SIZE) {
//如果连接池的大小小于要求的最大连接数,才可以创建
db = this.createNewConectionTimer();
conn = db.getConn();
db.setUsed(false);//新创建的连接设置为空闲状态
return conn;
}

//如果连接池的大小达到了最大连接数
if(null == conn && connectPool.size() == this.MAX_SIZE) {
System.out.println("连接池满了");
try {
//进行等待，知道有链接进入空闲状态
connectPool.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}
}

public void releaseConnection(Connection conn) {
synchronized (connectPool) {
for (int i = 0; i < connectPool.size(); i++) {
DBConnection db = connectPool.get(i);
if(db instanceof DBConnectionTimer) {
DBConnectionTimer dbTimer = (DBConnectionTimer) db;
DBConTimerTask task = new DBConTimerTask(connectPool, dbTimer);
dbTimer.tick(task);
System.out.println("释放了DBConnectionTimer的对象");
}else {
//固定的连接，一直存在
if(conn == db.getConn()) {
db.setUsed(false);
connectPool.notify();
System.out.println("释放了DBConnection的对象");
break;
}
}

}
}
}

}

package com.tyxh.mypool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBConnection {
private String driver;
private String url;
private String username;
private String password;
private boolean isUsed;
private Connection conn;

public DBConnection(String driver,String url,String username,String password){
this.driver = driver;
this.url = url;
this.username = username;
this.password = password;
this.isUsed = false;
//创建数据库连接
this.createConnection();
}

private void createConnection() {
try {
Class.forName(this.driver);
conn = DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}

}

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 getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public boolean isUsed() {
return isUsed;
}

public void setUsed(boolean isUsed) {
this.isUsed = isUsed;
}

public Connection getConn() {
return conn;
}

public void setConn(Connection conn) {
this.conn = conn;
}

}

package com.tyxh.mypool;

import java.util.Timer;

public class DBConnectionTimer extends DBConnection {

private long activeTime;
private Timer timer;

public DBConnectionTimer(String driver, String url, String username,
String password, long activeTime) {
super(driver, url, username, password);
this.activeTime = activeTime;
timer = new Timer();
}

public void tick(DBConTimerTask task) {
try{
this.timer.schedule(task, activeTime);
System.out.println("定时开始");
} catch(IllegalStateException e) {
//			e.printStackTrace();
System.err.println("已经存在task了");
}

}

public void cacel(){
this.timer.cancel();
System.out.println("取消定时");
}

}

package com.tyxh.mypool;

import java.sql.SQLException;
import java.util.TimerTask;
import java.util.Vector;

public class DBConTimerTask extends TimerTask {

private Vector<DBConnection> connectPool = null;
private DBConnectionTimer dbTimer;

public DBConTimerTask(Vector<DBConnection> connectPool,
DBConnectionTimer dbTimer) {
super();
this.connectPool = connectPool;
this.dbTimer = dbTimer;
}

@Override
public void run() {
//将过期的数据库连接移除
try {
dbTimer.getConn().close();
} catch (SQLException e) {
e.printStackTrace();
}
connectPool.remove(dbTimer);
System.out.println("移除超出生命周期的数据库连接！");
}

}

package com.tyxh.mypool;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class MulTest extends Thread {

@Override
public void run() {
DBConnectFactory factory = DBConnectFactory.getDBConnectFactory();
Connection conn = factory.getConnection();
try {
Statement state = conn.createStatement();
String sql = "select count(*) from employees";
ResultSet rs = state.executeQuery(sql);
while(rs.next()){
System.out.println(rs.getInt(1));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
factory.releaseConnection(conn);
}

}

}

package com.tyxh.mypool;

import java.sql.Connection;

public class MainTest {

public static void main(String[] args) {
MulTest mul1 = new MulTest();
mul1.start();
MulTest mul2 = new MulTest();
mul2.start();
MulTest mul3 = new MulTest();
mul3.start();
MulTest mul4 = new MulTest();
mul4.start();
MulTest mul5 = new MulTest();
mul5.start();
MulTest mul6 = new MulTest();
mul6.start();
MulTest mul7 = new MulTest();
mul7.start();
MulTest mul8 = new MulTest();
mul8.start();
MulTest mul9 = new MulTest();
mul9.start();
MulTest mul10 = new MulTest();
mul10.start();
MulTest mul11 = new MulTest();
mul11.start();
MulTest mul12 = new MulTest();
mul12.start();
}

}

#db.properties
#this properties is for database connect

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:XE
username=hr
password=hr