自定义框架TFrameWork之自定义jdbc连接池

最近一直想自己封装下jdbc，写个orm，在此拿出来分享分享我的代码，让高人指点指点，共同进步，也做个备份
先上代码
DataSource.java
package org.tension.framework.common.das;

import java.io.InputStream;
import java.util.Iterator;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;


/**
* 数据源
* @author tension
*
*/
public class DataSource {
protected static String driverClassName;
protected static String url;
protected static String user;
protected static String password;
protected static int poolSize;
protected static int maxUseCount;
protected static int maxPoolSize;
protected static int minPoolSize;
protected static String transaction_Isolation;

static{
try {
InputStream ips = DataSource.class.getClassLoader().getResourceAsStream("user-config.xml");
SAXReader reader = new SAXReader();
Document doc = null;
doc = reader.read(ips);
Element root = doc.getRootElement();
Element  module = root.element("module");
Element group = module.element("group");
Iterator<?> configValue = group.elementIterator("configValue");
while(configValue.hasNext()){
Element e = (Element) configValue.next();
String key = e.attributeValue("key");
String value = e.getText();
if("DriverClass".equalsIgnoreCase(key)){
driverClassName = value;
}else if("Url".equalsIgnoreCase(key)){
url = value;
}else if("UserName".equalsIgnoreCase(key)){
user = value;
}else if("Password".equalsIgnoreCase(key)){
password = value;
}else if("PoolSize".equalsIgnoreCase(key)){
poolSize = Integer.valueOf(value);
}else if("MaxUseCount".equalsIgnoreCase(key)){
maxUseCount = Integer.valueOf(value);
}else if("MaxPoolSize".equalsIgnoreCase(key)){
maxPoolSize = Integer.valueOf(value);
}else if("MinPoolSize".equalsIgnoreCase(key)){
minPoolSize = Integer.valueOf(value);
}else if("Transaction-Isolation".equalsIgnoreCase(key)){
transaction_Isolation = value;
}
}
Class.forName(driverClassName);
} catch (Exception e) {
throw new ExceptionInInitializerError(e);
}
}
}
至于为什么没有去实现DataSource接口，我觉得我暂时不用它，所有没有去实现


ConnectionPool.java
package org.tension.framework.common.das;

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

/**
*
* 2012-9-12
*
* @author <a href="mailto:[e-mail]">tension</a>
*
*/
public class ConnectionPool extends DataSource{
/**当前连接数*/
int currentCount = 0;

LinkedList<Connection> connectionsPool = new LinkedList<Connection>();


    /**
     * 默认构造方法，一次性获得poolSize个连接放进connectionsPool连接池中
     */
public ConnectionPool() {
CreateConnectionPool(poolSize);
}
/**
* 获取连接记录当前连接个数
* 如果连接池还有连接则直接从连接池取连接，如果连接大于最大连接数
* @return
* @throws SQLException
*/
public Connection getConnection() throws SQLException {
synchronized (connectionsPool) {
if (this.connectionsPool.size() > 0){
this.currentCount++;
return this.connectionsPool.removeFirst();
}
            if(this.currentCount < maxPoolSize){
            int buffer = this.currentCount + minPoolSize;
            if (buffer < maxPoolSize || buffer == maxPoolSize) {
    this.currentCount++;
    CreateConnectionPool(minPoolSize);
    }else{
    this.currentCount++;
    CreateConnectionPool(buffer - maxPoolSize);
    }
            return this.connectionsPool.removeFirst();
            }

throw new SQLException("暂无连接可用");
}
}
/**
* 创建连接放入连接池中，缓冲连接池
* @param count 个数
*/
public void CreateConnectionPool(int count){
try {
for (int i = 0; i < count; i++) {
this.connectionsPool.addLast(this.createConnection());
this.currentCount++;
}
} catch (SQLException e) {
throw new ExceptionInInitializerError(e);
}
}
    /**
     * 释放连接方法
     * 把用完的连接重新放回连接池中
     * @param conn
     */
public void free(Connection conn) {
this.connectionsPool.addLast(conn);
}
    /**
     * 创建连接
     * @return warpedConnection
     * @throws SQLException
     * @author tension
     */
private Connection createConnection() throws SQLException {
Connection realConn = DriverManager.getConnection(url, user, password);
ConnectionHandler proxy = new ConnectionHandler(this);
return proxy.bind(realConn);
}
}
这个就是所谓的连接池了，简单，没有现在主流的那么NB，供学习

ConnectionHandler
package org.tension.framework.common.das;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;

/**
* 连接池的代理类
* 用于处理Connection的colse方法，把连接放回连接池
* @author tension
* 2012-09-12
*/
class ConnectionHandler  extends DataSource implements InvocationHandler{
/**真正的连接对象 */
private Connection realConnection;
/**代理的连接对象 */
private Connection warpedConnection;
/**连接池*/
private  ConnectionPool conn;
/**当前用户使用的次数*/
private int currentUserCount = 0;
    /**
     * 默认构造方法
     * @param conn 连接池
     */
ConnectionHandler(ConnectionPool conn) {
this.conn = conn;
}
    /**
     * java.sql.Connection的代理方法
     * @param realConn warpedConnection 代理后的对象
     * @return
     */
Connection bind(Connection realConn) {
this.realConnection = realConn;
this.warpedConnection = (Connection) Proxy.newProxyInstance(this
.getClass().getClassLoader(), new Class[] { Connection.class },
this);
return warpedConnection;
}
    /**
     * 方法拦截
     * 如果为close方法的话不直接调用真正Connection的close方法
     * 如果使用次数小于5次的话就放回连接池中否则关闭这个连接
     */
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if ("close".equals(method.getName())) {
this.currentUserCount++;
if (maxUseCount == 0 || this.currentUserCount < maxUseCount)
this.conn.connectionsPool.addLast(this.warpedConnection);
else {
this.realConnection.close();
this.conn.currentCount--;
}
}
return method.invoke(this.realConnection, args);
}

}
Connection的代理，主要是修改colse方法
user-config.xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<application>
    <module name="DataSource">
<group name="default">
<configValue key="DriverClass">oracle.jdbc.driver.OracleDriver</configValue>
<configValue key="Url">jdbc:oracle:thin:@tension:1521:ORCL</configValue>
<configValue key="UserName">xxx</configValue>
<configValue key="Password">ooo</configValue>
<configValue key="PoolSize">1</configValue><!-- 初始大小 -->
<configValue key="MaxUseCount">0</configValue> <!-- 最大连接数 使用次数-->
<configValue key="MaxPoolSize">3</configValue> <!-- 最大连接数 -->
<configValue key="MinPoolSize">2</configValue><!-- 每次增长 -->
<configValue key="Transaction-Isolation">ISOLATION_READ_COMMITTED</configValue><!-- 事物隔离级别 -->
</group>
    </module>

</application>