Java数据库连接池实现

首先写一个读取本地数据库驱动，数据库用户名、数据库密码、连接数的类。

 

 

package cn.cate.utils;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class PoolProperties {

	private Properties properties;
	private String driver;
	private String url;
	private String user;
	private String password;
	private int maxConn;
	private int minConn;
	
	public PoolProperties(){
		properties = new Properties();
		String path = getClass().getProtectionDomain().getCodeSource().getLocation().toString();
		path = path.substring(6, path.length());
		if (path.indexOf("WEB-INF") > 0) {
		      path = path.substring(0, path.indexOf("/WEB-INF") + 9) + "lib/";
		}else{
		      path = "d:";
		}
		try {
			this.properties.load(new FileReader(path + "db.pro"));
		}catch (FileNotFoundException e) {
		    e.printStackTrace();
		}catch (IOException e) {
		    e.printStackTrace();
		}
		this.setDriver(properties.getProperty("driver"));
		this.setUrl(properties.getProperty("url"));
		this.setUser(properties.getProperty("user"));
		this.setPassword(properties.getProperty("password"));
		this.setMaxConn(Integer.parseInt(properties.getProperty("maxConn")));
		this.setMinConn(Integer.parseInt(properties.getProperty("minConn")));
	}
	
	
	public Properties getProperties() {
		return properties;
	}

	public void setProperties(Properties properties) {
		this.properties = properties;
	}

	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 getUser() {
		return user;
	}

	public void setUser(String user) {
		this.user = user;
	}

	public String getPassword() {
		return password;
	}

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

	public int getMaxConn() {
		return maxConn;
	}

	public void setMaxConn(int maxConn) {
		this.maxConn = maxConn;
	}

	public int getMinConn() {
		return minConn;
	}

	public void setMinConn(int minConn) {
		this.minConn = minConn;
	}
	
	
}

 

 

db.pro的内容如下：

 

driver=com.mysql.jdbc.Driver         maxConn=10            minConn=1           url=jdbc:mysql://127.0.0.1:3306/cate           user=root           password=11111  

 

然后定义一个数据库连接池：DBConnectionPool

 

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
 * 此内部类定义了一个连接池，它能够根据要求创建连接，直到预定的最大连接数为止。
 * 在返回连接给客户程序之前，它能够验证连接的有效性。
 */
public class DBConnectionPool {

	/*
	 * 连接池
	 */
	private List<Connection> freeConnections = new ArrayList<Connection>();
	private Connection conn = null;
	private int connect = 0;     //使用的连接数
	private int maxConn;      //最大连接数
	private String driver;    //数据库驱动
	private String url;     //数据库连接地址
	private String user;     //用户名
	private String password;      //用户名
	
	public DBConnectionPool(String driver,String URL,String user,String password,int maxConn){
		this.driver = driver;
		this.url = URL;
		this.user = user;
		this.password = password;
		this.maxConn = maxConn;
		poolInfo();
	}
	
	/*
	 * 显示准备创建连接池的信息
	 */
	private void poolInfo(){
		Connection conn = this.newConnection();
		freeConnections.add(conn);
		for(int i = 0;i < this.maxConn - 1;i++){
			Connection freeConn = conn;
			freeConnections.add(freeConn);
		}
	}
	
	/*
	 * 用完，释放一个连接
	 */
	public synchronized void freeConnection(Connection conn){
		this.freeConnections.add(conn);
		this.connect--;
	}
	
	/*
	 * 从连接池中获取一个可用连接，当无法从连接池中获取可用连接时，新创建一个连接
	 */
	public synchronized Connection getConnection(){
		if(this.freeConnections.size() > 0){
			/*
			 * 当在连接池中取出一个连接后，删除此连接
			 */
			conn = this.freeConnections.get(0);
			this.freeConnections.remove(0);
		}
		/*
		 * 当取出的连接为null时，递归调用自己，直到获得一个可用连接为止
		 */
		if(conn == null){
			conn = getConnection();
		}else{
			conn = newConnection();
		}
		if(this.maxConn == 0 || this.maxConn < this.connect){
			/*
			 * 等待超过最大连接时
			 */
			conn = null;
		}
		if(conn != null){
			this.connect++;
		}
		return conn;
	}
	
	/*
	 * 释放全部连接
	 */
	public synchronized void release(){
		Iterator<Connection> allConns = this.freeConnections.iterator();
		while(allConns.hasNext()){
			Connection conn = (Connection)allConns.next();
			try{
				if(null != conn){
					conn.close();
				}
				conn = null;
			}catch(SQLException e){
				e.printStackTrace();
			}
		}
		this.freeConnections.clear();
	}
	
	/*
	 * 创建一个数据库连接对象
	 */
	private Connection newConnection(){
		try{
			Class.forName(driver);
		}catch(ClassNotFoundException e2){
			e2.printStackTrace();
		}
		try{
			conn = DriverManager.getConnection(url,user,password);
		}catch(SQLException e3){
			e3.printStackTrace();
			System.exit(0);
		}
		return conn;
	}
}

 

 

最后提供一个连接池的管理类：

 

import java.sql.Connection;
import java.util.Enumeration;
import java.util.Hashtable;

import cn.cate.utils.PoolProperties;

/*
 * 连接池的管理类，负责读取配置连接池的文件，并创建连接池
 * 从连接池中获取，释放连接
 */
public class DBConnectionManager {

	/*
	 * 唯一数据库连接池管理实例类
	 * 使用单例模式创建
	 */
	private static DBConnectionManager instance;
	
	/*
	 * 连接池的集合
	 */
	private Hashtable<String,DBConnectionPool> pools = new Hashtable<String,DBConnectionPool>();
	private static String poolName = "MYSQL_MZBA";      //连接池名字
	
	public static synchronized DBConnectionManager getInstance(){
		if(instance == null){
			instance = new DBConnectionManager();
		}
		return instance;
	}
	
	/*
	 * 只允许内部实例化管理类
	 */
	private DBConnectionManager(){
		this.init();
	}
	
	/*
	 * 加载驱动程序
	 */
	private void init(){
		PoolProperties poolProperties = new PoolProperties();
		DBConnectionPool pool = new DBConnectionPool(poolProperties.getDriver(), poolProperties.getUrl(), 
				poolProperties.getUser(), poolProperties.getPassword(), poolProperties.getMaxConn());
		pools.put(poolName, pool);
	}
	
	/*
	 * 根据连接池的名字得到一个连接
	 */
	public Connection getConnection(){
		DBConnectionPool pool = null;
		Connection conn = null;
		pool = pools.get(poolName);
		try{
			conn = pool.getConnection();
		}catch(Exception e){
			e.printStackTrace();
		}
		return conn;
	}
	/*
	 * 释放一个连接
	 */
	public synchronized void freeConnection(Connection conn){
		DBConnectionPool pool = pools.get(poolName);
		if(pool != null){
			pool.freeConnection(conn);
		}
	}
	/*
	 * 释放所有连接
	 */
	public synchronized void release(){
		Enumeration<DBConnectionPool> allpools = pools.elements();
		while(allpools.hasMoreElements()){
			DBConnectionPool pool = allpools.nextElement();
			if(pool != null){
				pool.release();
			}
		}
		pools.clear();
	}

}