自定义连接池

最近自己写了一个数据库连接池，本来想用dpcp、c3p0数据库连接池，但是产品用的是oracle的数据仓库，给的驱动是jdbc驱动，但不是数据库连接驱动，不用以上连接池，自己写了一个，请大家看一下有问题没？
public class ConnectionPool implements ConPool{

/**
* 数据库连接池配置参数
*/
private ConConfig conConfig;

/**
* 数据库连接池
*/
private Stack<Connection> poolStack;

/**
* 活动连接数
*/
private int numActive = 0;

/**
* 数据库连接闲置数
*/
private int numIdle = 0;

public ConnectionPool(ConConfig conConfig){
this.conConfig = conConfig;
poolStack = new Stack<Connection>();
addConnection(conConfig.getInitConSize());
}


/**
* 数据库连接池添加连接
* @param count
*/
protected synchronized void addConnection(int count){
for (int i = 0; i < count; i++) {
Connection con;
try {
con = createConnection();
poolStack.push(con);
} catch (Exception e) {
e.printStackTrace();
}
}
}

/**
* 创建连接Connection
* @param conConfig
* @return
* @throws Exception
*/
protected Connection createConnection() throws Exception{
String driver = conConfig.getConDriver();
    String url = conConfig.getConUrl();
    String userName = conConfig.getUserName();
    String passWord = conConfig.getPassWord();
        Class.forName(driver).newInstance();  
        Connection conn = DriverManager.getConnection(url, userName, passWord);     
        
        return conn;  
}

/**
* 从数据库连接池中获取连接
*/
public synchronized Connection borrowConnection() throws Exception{
Connection con = null;
while(con == null){
if(!poolStack.isEmpty()){
con = poolStack.pop();
}else{
con = findConnection();
}
}
numActive++;
return con;
}

/**
* 获取可用连接
* @return
* @throws Exception
*/
public synchronized Connection findConnection() throws Exception{
Connection con = null;
if(poolStack.size() < conConfig.getMaxConSize()){
con = createConnection();
}else{
waitTime(conConfig.getMaxWaitTime());
if(poolStack.isEmpty())
throw new IllegalStateException("等待连接超时");
else
con = poolStack.pop();
if(con.isClosed())
throw new IllegalStateException("获取的连接已经关闭");
}

return con;
}

/**
* 关闭连接
*/
public void closeConnection(Connection con) {
try {
if(!con.isClosed()){
con.close();
}
} catch (SQLException e) {
e.printStackTrace();
}

}

/**
* 销毁连接
* @param con
*/
public synchronized void destroyedCon(Connection con){
closeConnection(con);
con = null;
}

/**
     * 清空连接池
     */
    public synchronized void clear() {
    Iterator it = poolStack.iterator();
         while(it.hasNext()) {
             try {
            Connection con =(Connection)it.next();
            destroyedCon(con);
             } catch(Exception e) {
             }
         }
         poolStack.clear();
    }

    /**
     * 将连接返回到连接池中
     */
public void returnConnection(Connection con) throws Exception{
boolean isClose = con.isClosed();
if(isClose){
destroyedCon(con);
return;
}

if(conConfig.getMaxConSize() <= poolStack.size()){
Connection bicon =poolStack.remove(0);
destroyedCon(bicon);
}else{
poolStack.push(con);
numActive--;
}


}

/**
* 超时等待时间
* @param time
*/
protected void waitTime(long time){
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

public ConConfig getConConfig() {
return conConfig;
}

public void setConConfig(ConConfig conConfig) {
this.conConfig = conConfig;
}

public Stack<Connection> getPoolStack() {
return poolStack;
}

public void setPoolStack(Stack<Connection> poolStack) {
this.poolStack = poolStack;
}

public int getNumActive() {
return numActive;
}

public void setNumActive(int numActive) {
this.numActive = numActive;
}

public int getNumIdle() {
return poolStack.size();
}

public void setNumIdle(int numIdle) {
this.numIdle = numIdle;
}

}


public class ConConfig {

public String conDriver;

public String conUrl;

public String userName;

public String passWord;

public int minConSize;

public int maxConSize;

public int acquireIncrement;

public int initConSize;

public int maxWaitTime;

public String getConDriver() {
return conDriver;
}

public void setConDriver(String conDriver) {
this.conDriver = conDriver;
}

public String getConUrl() {
return conUrl;
}

public void setConUrl(String conUrl) {
this.conUrl = conUrl;
}

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 int getMinConSize() {
return minConSize;
}

public void setMinConSize(int minConSize) {
this.minConSize = minConSize;
}

public int getMaxConSize() {
return maxConSize;
}

public void setMaxConSize(int maxConSize) {
this.maxConSize = maxConSize;
}

public int getAcquireIncrement() {
return acquireIncrement;
}

public void setAcquireIncrement(int acquireIncrement) {
this.acquireIncrement = acquireIncrement;
}

public int getInitConSize() {
return initConSize;
}

public void setInitConSize(int initConSize) {
this.initConSize = initConSize;
}

public int getMaxWaitTime() {
return maxWaitTime;
}

public void setMaxWaitTime(int maxWaitTime) {
this.maxWaitTime = maxWaitTime;
}


}

public class ConPoolFactory {

private static ConnectionPool conPool = null;

private static boolean flag = false;

private static ConConfig  config = null;

static{
if(!flag){
   config = new ConConfig();
   config.userName = SSConfig.getInstance().getProperty("biee.conUser"); //用户名
           config.passWord = SSConfig.getInstance().getProperty("biee.conPwd"); //密码  
           config.conDriver= SSConfig.getInstance().getProperty("biee.conDriver");//连接驱动
           config.conUrl= SSConfig.getInstance().getProperty("biee.conUrl");//连接URL
           config.initConSize = Integer.valueOf(SSConfig.getInstance().getProperty("biee.initialSize")); //初始化连接数
           config.acquireIncrement = Integer.valueOf(SSConfig.getInstance().getProperty("biee.acquireIncrement")); //初始化连接递增数
   config.maxConSize = Integer.valueOf(SSConfig.getInstance().getProperty("biee.maxConSize")); //最大激活连接数
           config.minConSize = Integer.valueOf(SSConfig.getInstance().getProperty("biee.minConSize")); //最小连接数,就这个有用.  
           config.maxWaitTime= Integer.valueOf(SSConfig.getInstance().getProperty("biee.maxWait"));//获得连接的最大等待毫秒数
           conPool = new ConnectionPool(config);
   flag = true;
}

}

public ConnectionPool getInstancePool(){
if(conPool == null){
conPool = new ConnectionPool(config);
}

return conPool;
}

}