connectionpool .java

Title:数据库连接池 Description: 通用的数据库连接池 通用的数据库连接池 可以设置： 加载的驱动 连接的URL 数据库的用户名 数据库的名字 最大连接数 默认创建数量 Copyrig

package cn.freekl.util;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
import java.io.Serializable;
import java.sql.*;

/**
 * <p>
 * Title:数据库连接池
 * </p>
 * <p>
 * Description: 通用的数据库连接池
 * 
 * <pre>
 *       		通用的数据库连接池
 *       		可以设置：
 *       			加载的驱动
 *       			连接的URL
 *       			数据库的用户名
 *       			数据库的名字
 *       			最大连接数
 *       			默认创建数量
 *       		
 * </pre>
 * 
 * Copyright: Copyright (c) 2008
 * </p>
 * <p>
 * Company: www.gdc8888.com
 * </p>
 * 
 * @author zjchxj
 * @version 1.0
 */

public class ConnectionPool {

	// 连接池的管理器,首先初始化，仅仅有一个对象，管理连接池
	private static ConnectionPool connPool;

	// 没有用过的连接池，用vector实现同步
	private static Vector<Connection> noUseConnectionPool = new Vector<Connection>();

	// 正在用的连接池
	private static HashMap<Connection, Connection> nowUseConnectionPool = new HashMap<Connection, Connection>();

	// 连接驱动
	private static String dbDriver = "sun.jdbc.odbc.JdbcOdbcDriver";

	// 连接URL
	private static String dbUrl = "jdbc:odbc:testpool";

	// 数据库用户名
	private static String userName = "";

	// 数据库密码
	private static String userPassword = "";

	// 最大连接池数量
	private static int MAX_POOL = 100;

	// 默认创建数量
	private static int DEFAULT_POOL = 2;

	// 是否已经初始化过
	private static boolean isInit = false;

	// 是否自动提交事务
	private static boolean isAutoCommit = false;

	// 默认的构造方法
	private ConnectionPool() {
		try {
			ConnectionPool.initConnection();
		} catch (Exception e) {
			System.out.println("初始化连接出错");
			e.printStackTrace();
		}

	}

	/**
	 * 初始化连接
	 * 
	 * @throws Exception
	 */
	public static void initConnection() throws Exception {
		System.out.println("初始化连接池开始..........");
		try {
			Class.forName(dbDriver);
		} catch (Exception e) {
			System.out.println("加载连接驱动出错？");
			e.printStackTrace();
		}

		synchronized (noUseConnectionPool) {
			for (int i = 0; i < DEFAULT_POOL; i++) {
				Connection conn = createConnection(dbDriver, dbUrl, userName,
						userPassword);
				noUseConnectionPool.add(conn);
			}
		}
		isInit = true;
		System.out.println("初始化连接池完成..........");

	}

	/**
	 * 设置数据库连接的配置
	 * 
	 * @param String
	 *            driver 连接数据库的驱动
	 * @param String
	 *            url 连接数据库的URL
	 * @param String
	 *            name 数据库的用户名
	 * @param String
	 *            password 数据为的密码
	 * @param String
	 *            max 连接池最大的连接数
	 * @param String
	 *            defalut 默认创建的连接数
	 */
	public static void setDBConfig(String driver, String url, String name,
			String password, int max, int defalut, boolean isCommit) {
		dbDriver = driver;
		dbUrl = url;
		userName = name;
		userPassword = password;
		MAX_POOL = max;
		DEFAULT_POOL = defalut;
		isAutoCommit = isCommit;
	}

	/**
	 * 通过连接池获得真正的链接
	 * 
	 * @return 连接
	 * @throws java.sql.SQLException
	 */
	public static synchronized Connection getConnection()
			throws java.sql.SQLException {

		if (!isInit) {
			connPool = new ConnectionPool();// 使用默认的初始化
		}

		if (nowUseConnectionPool.size()-noUseConnectionPool.size() >= MAX_POOL) {
			throw new SQLException("连接数已经达到最大数");
		}

		Connection conn = null;

		if (noUseConnectionPool.size() > 0) { // 里面是否有连接
			conn = (Connection) noUseConnectionPool.firstElement();//取第一个出来
			noUseConnectionPool.remove(conn);//从noUseConnectionPool删除刚取出来的连接
		}

		// 如果数据库连接池没有链接了，自己创建一个
		if (conn == null) {
			
			conn = createConnection(dbDriver, dbUrl, userName, userPassword);
		} else if (conn.isClosed()) {
			nowUseConnectionPool.remove(conn);// 正在使用的连接删除已经关闭的连接
			conn = createConnection(dbDriver, dbUrl, userName, userPassword);// 重新建立一个连接
		}
		conn.setAutoCommit(isAutoCommit);// 是否自动提交事务
		nowUseConnectionPool.put(conn, conn);// 在正在使用的连接池添一个连接下来
		return conn;
	}
	
	
	/**
	 * 显示数据库连接池的一些相关信息
	 */
	public static void showPoolInfo(){
		System.out.println("*****************************************");
		System.out.println("数据库连接驱动:"+dbDriver);
		System.out.println("数据库连接URL:"+dbUrl);
		System.out.println("数据库用户名:"+userName);
		System.out.println("数据库密码:"+userPassword);
		System.out.println("连接池最大连接数:"+MAX_POOL);
		System.out.println("默认创建连接数:"+DEFAULT_POOL);
		System.out.println("是否自动提交事务："+(isAutoCommit?"是":"否"));
		
		System.out.println("正在使用的连接数:"+nowUseConnectionPool.size());
		System.out.println("空闲的连接数："+noUseConnectionPool.size());		
		System.out.println("*****************************************");
	}

	/**
	 * 释放连接
	 * 
	 * @param Connection
	 *            conn 要关闭的连接
	 * @param Boolean
	 *            isCommit 是否需要提交事务
	 */
	public static void releaseConnection(Connection conn, boolean isCommit) {
		System.out.println("释放连接");
		try {

			if (isCommit)
				conn.commit();
			else
				conn.rollback();

			nowUseConnectionPool.remove(conn);
			if (noUseConnectionPool.size() + nowUseConnectionPool.size() < MAX_POOL) {
				synchronized (noUseConnectionPool) {
					noUseConnectionPool.add(conn);
				}
			} else {
				conn.close();
			}
		} catch (Exception e) {
			System.out.println("释放资源出错");
			e.printStackTrace();
		}
		System.out.println("正在使用的连接数=" + nowUseConnectionPool.size());
	}

	/**
	 * 释放全部正在使用的连接
	 * 
	 * @param boolean
	 *            isCommit 是否提交事务
	 */
	public static void releaseAllConnection(boolean isCommit) {
		for (Iterator it = nowUseConnectionPool.values().iterator(); it
				.hasNext();) {
			Object obj = it.next();
			Connection conn = (Connection) obj;
			it.remove();// 必须加这句。不然很可能会报错
			// java.util.ConcurrentModificationException
			releaseConnection(conn, isCommit);

		}

	}

	public static void main(String[] args) throws Exception {
		ConnectionPool.setDBConfig("sun.jdbc.odbc.JdbcOdbcDriver",
				"jdbc:odbc:testpool", "", "", 10, 2, true);

		ThreadTest t1 = new ThreadTest("1");
		ThreadTest t2 = new ThreadTest("2");
		ThreadTest t3 = new ThreadTest("3");
		ThreadTest t4 = new ThreadTest("4");
		ThreadTest t5 = new ThreadTest("5");
		ThreadTest t6 = new ThreadTest("6");
		ThreadTest t7 = new ThreadTest("7");
		ThreadTest t8 = new ThreadTest("8");
		ThreadTest t9 = new ThreadTest("9");
		ThreadTest t10 = new ThreadTest("10");

		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();
		t7.start();
		t8.start();
		t9.start();
		t10.start();
		showPoolInfo();
		Thread.sleep(2 * 1000);

		ConnectionPool.releaseAllConnection(true);
		showPoolInfo();

		// 测试模拟20个客户
		for (int i = 0; i < 10; i++) {
			try {
				// xxxx 一般为属性文件读取

				Connection conn = ConnectionPool.getConnection();
				System.out.println(conn);
				// ConnectionPool.releaseConnection(conn, true);
				System.out.println("正在使用的连接数=" + nowUseConnectionPool.size());

			} catch (SQLException ex1) {
				ex1.printStackTrace();
				// 处理异常
			}

		}
		showPoolInfo();
		 ConnectionPool.releaseAllConnection(true);
		 System.out.println("-----------------------------------");
		 // 测试模拟20个客户
		 for (int i = 0; i <20; i++) {
		 try {
		 // xxxx 一般为属性文件读取
		
		 Connection conn = ConnectionPool.getConnection();
		 System.out.println(conn);
		 // ConnectionPool.releaseConnection(conn, true);
		
		 } catch (SQLException ex1) {
		 ex1.printStackTrace();
		 // 处理异常
		 }
		
		 }

	}

	/**
	 * 设置连接数据库驱动
	 * 
	 * @param dbDriver
	 */
	public static void setDbDriver(String dbDriver) {
		ConnectionPool.dbDriver = dbDriver;
	}

	/**
	 * 设置连接数据库的URL
	 * 
	 * @param dbUrl
	 */
	public static void setDbUrl(String dbUrl) {
		ConnectionPool.dbUrl = dbUrl;
	}

	/**
	 * 设置默认创建好的连接数
	 * 
	 * @param default_pool
	 */
	public static void setDEFAULT_POOL(int default_pool) {
		DEFAULT_POOL = default_pool;
	}

	/**
	 * 设置是否自动提交事务
	 * 
	 * @param isAutoCommit
	 */
	public static void setAutoCommit(boolean isAutoCommit) {
		ConnectionPool.isAutoCommit = isAutoCommit;
	}

	/**
	 * 设置连接池的最大容量
	 * 
	 * @param max_pool
	 */
	public static void setMAX_POOL(int max_pool) {
		MAX_POOL = max_pool;
	}

	/**
	 * 设置数据库的用户名
	 * 
	 * @param userName
	 */
	public static void setUserName(String userName) {
		ConnectionPool.userName = userName;
	}

	/**
	 * 设置数据库的密码
	 * 
	 * @param userPassword
	 */
	public static void setUserPassword(String userPassword) {
		ConnectionPool.userPassword = userPassword;
	}

	// 如果连接池没有链接了，就需要产生一个链接
	private static Connection createConnection(String driver, String url,
			String user, String password) throws java.sql.SQLException {		
		Connection conn = DriverManager.getConnection(url, user, password);		
		return conn;
	}

}

class ThreadTest extends Thread {
	private String test;

	public ThreadTest(String test) {
		this.test = test;
	}

	public void run() {
		try {
			System.out.println(test);
			ConnectionPool.getConnection();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}