5、JAVA数据库连接池实现

转：http://greemranqq.iteye.com/blog/1969273
在一个成套的web系统中，不能更改源代码的情况下，要进行频繁的数据库操作，需要进行数据库连接管理而不影响原系统运行，这里就是一个java实现连接池的demo：
主要是对连接数的控制，比如最大20，最小2的连接。

package pool;  
import java.sql.Connection;  
import java.sql.SQLException;  

public interface IConnectionPool {  
    // 获得连接  
    public Connection  getConnection();  
    // 获得当前连接  
    public Connection getCurrentConnecton();  
    // 回收连接  
    public void releaseConn(Connection conn) throws SQLException;  
    // 销毁清空  
    public void destroy();  
    // 连接池是活动状态  
    public boolean isActive();  
    // 定时器，检查连接池  
    public void cheackPool();  
}  

package pool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;

public class ConnectionPool implements IConnectionPool {
// 连接池配置属性
private DBbean dbBean;
private boolean isActive = false; // 连接池活动状态
private int contActive = 0;// 记录创建的总的连接数

// 空闲连接
private List<Connection> freeConnection = new Vector<Connection>();
// 活动连接
private List<Connection> activeConnection = new Vector<Connection>();
// 将线程和连接绑定，保证事务能统一执行
private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

public ConnectionPool(DBbean dbBean) {
super();
this.dbBean = dbBean;
init();
cheackPool();
}

// 初始化
public void init() {
try {
Class.forName(dbBean.getDriverName());
for (int i = 0; i < dbBean.getInitConnections(); i++) {
Connection conn;
conn = newConnection();
// 初始化最小连接数
if (conn != null) {
freeConnection.add(conn);
contActive++;
}
}
isActive = true;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}

// 获得当前连接
public Connection getCurrentConnecton(){
// 默认线程里面取
Connection conn = threadLocal.get();
if(!isValid(conn)){
conn = getConnection();
}
return conn;
}

// 获得连接
public synchronized Connection getConnection() {
Connection conn = null;
try {
// 判断是否超过最大连接数限制
if(contActive < this.dbBean.getMaxActiveConnections()){
if (freeConnection.size() > 0) {
conn = freeConnection.get(0);
if (conn != null) {
threadLocal.set(conn);
}
freeConnection.remove(0);
} else {
conn = newConnection();
}

}else{
// 继续获得连接,直到从新获得连接
wait(this.dbBean.getConnTimeOut());
conn = getConnection();
}
if (isValid(conn)) {
activeConnection.add(conn);
contActive ++;
}
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
return conn;
}

// 获得新连接
private synchronized Connection newConnection()
throws ClassNotFoundException, SQLException {
Connection conn = null;
if (dbBean != null) {
Class.forName(dbBean.getDriverName());
conn = DriverManager.getConnection(dbBean.getUrl(),
dbBean.getUserName(), dbBean.getPassword());
}
return conn;
}

// 释放连接
public synchronized void releaseConn(Connection conn) throws SQLException {
if (isValid(conn)&& !(freeConnection.size() > dbBean.getMaxConnections())) {
freeConnection.add(conn);
activeConnection.remove(conn);
contActive --;
threadLocal.remove();
// 唤醒所有正待等待的线程，去抢连接
notifyAll();
}
}

// 判断连接是否可用
private boolean isValid(Connection conn) {
try {
if (conn == null || conn.isClosed()) {
return false;
}
} catch (SQLException e) {
e.printStackTrace();
}
return true;
}

// 销毁连接池
public synchronized void destroy() {
for (Connection conn : freeConnection) {
try {
if (isValid(conn)) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
for (Connection conn : activeConnection) {
try {
if (isValid(conn)) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
isActive = false;
contActive = 0;
}

// 连接池状态
@Override
public boolean isActive() {
return isActive;
}

// 定时检查连接池情况
@Override
public void cheackPool() {
if(dbBean.isCheakPool()){
new Timer().schedule(new TimerTask() {
@Override
public void run() {
// 1.对线程里面的连接状态
// 2.连接池最小 最大连接数
// 3.其他状态进行检查，因为这里还需要写几个线程管理的类，暂时就不添加了
System.out.println("空线池连接数："+freeConnection.size());
System.out.println("活动连接数：："+activeConnection.size());
System.out.println("总的连接数："+contActive);
}
},dbBean.getLazyCheck(),dbBean.getPeriodCheck());
}
}
}

package pool;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Hashtable;
/**
* 连接管理类
* @author Ran
*
*/
public class ConnectionPoolManager {


// 连接池存放
public Hashtable<String,IConnectionPool> pools = new Hashtable<String, IConnectionPool>();

// 初始化
private ConnectionPoolManager(){
init();
}
// 单例实现
public static ConnectionPoolManager getInstance(){
return Singtonle.instance;
}
private static class Singtonle {
private static ConnectionPoolManager instance = new ConnectionPoolManager();
}


// 初始化所有的连接池
public void init(){
for(int i =0;i<DBInitInfo.beans.size();i++){
DBbean bean = DBInitInfo.beans.get(i);
ConnectionPool pool = new ConnectionPool(bean);
if(pool != null){
pools.put(bean.getPoolName(), pool);
System.out.println("Info:Init connection successed ->" +bean.getPoolName());
}
}
}

// 获得连接,根据连接池名字 获得连接
public Connection getConnection(String poolName){
Connection conn = null;
if(pools.size()>0 && pools.containsKey(poolName)){
conn = getPool(poolName).getConnection();
}else{
System.out.println("Error:Can't find this connecion pool ->"+poolName);
}
return conn;
}

// 关闭，回收连接
public void close(String poolName,Connection conn){
IConnectionPool pool = getPool(poolName);
try {
if(pool != null){
pool.releaseConn(conn);
}
} catch (SQLException e) {
System.out.println("连接池已经销毁");
e.printStackTrace();
}
}

// 清空连接池
public void destroy(String poolName){
IConnectionPool pool = getPool(poolName);
if(pool != null){
pool.destroy();
}
}

// 获得连接池
public IConnectionPool getPool(String poolName){
IConnectionPool pool = null;
if(pools.size() > 0){
pool = pools.get(poolName);
}
return pool;
}
}


package pool;

import java.util.ArrayList;
import java.util.List;
/**
* 初始化，模拟加载所有的配置文件
* @author Ran
*
*/
public class DBInitInfo {
public static List<DBbean> beans = null;
static{
beans = new ArrayList<DBbean>();
// 这里数据 可以从xml 等配置文件进行获取
// 为了测试，这里我直接写死
DBbean beanOracle = new DBbean();
beanOracle.setDriverName("oracle.jdbc.driver.OracleDriver");
beanOracle.setUrl("jdbc:oracle:thin:@7MEXGLUY95W1Y56:1521:orcl");
beanOracle.setUserName("mmsoa");
beanOracle.setPassword("password1234");

beanOracle.setMinConnections(5);
beanOracle.setMaxConnections(100);

beanOracle.setPoolName("testPool");
beans.add(beanOracle);
}
}


package pool;

import java.sql.Connection;
/**
* 模拟线程启动，去获得连接
* @author Ran
*
*/
public class ThreadConnection implements Runnable{
private IConnectionPool pool;
@Override
public void run() {
pool = ConnectionPoolManager.getInstance().getPool("testPool");
}

public Connection getConnection(){
Connection conn = null;
if(pool != null && pool.isActive()){
conn = pool.getConnection();
}
return conn;
}

public Connection getCurrentConnection(){
Connection conn = null;
if(pool != null && pool.isActive()){
conn = pool.getCurrentConnecton();
}
return conn;
}
}


package pool;



public class Client {
public static void main(String[] args) throws InterruptedException {
// 初始化连接池
Thread t = init();
t.start();
t.join();

ThreadConnection a = new ThreadConnection();
ThreadConnection b = new ThreadConnection();
ThreadConnection c = new ThreadConnection();
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);
Thread t3 = new Thread(c);


// 设置优先级，先让初始化执行，模拟 线程池 先启动
// 这里仅仅表面控制了，因为即使t 线程先启动，也不能保证pool 初始化完成，为了简单模拟，这里先这样写了
t1.setPriority(10);
t2.setPriority(10);
t3.setPriority(10);
t1.start();
t2.start();
t3.start();

System.out.println("线程A-> "+a.getConnection());
System.out.println("线程B-> "+b.getConnection());
System.out.println("线程C-> "+c.getConnection());
}

// 初始化
public static Thread init() {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
IConnectionPool pool = initPool();
while(pool == null || !pool.isActive()){
pool = initPool();
}
}
});
return t;
}

public static IConnectionPool initPool(){
return ConnectionPoolManager.getInstance().getPool("testPool");
}

}