Java 的JDBC 数据库连接池实现�Ҏ��

Lansing — Fri, 04 Aug 2006 07:56:00 GMT

Java 的JDBC 数据库连接池实现�Ҏ��

关键�? Java, JDBC, Connection Pool, Database, 数据库连接池, sourcecode

虽然 J2EE �E�序员一般都有现成的应用服务器所带的JDBC 数据库连接池�Q�不�q�对于开发一般的 Java Application �?Applet 或�?JSP、velocity �Ӟ��我们可用的JDBC 数据库连接池�q�不多，�q�且一般性能都不好�?Java �E�序员都很�M�?Windows ADO �Q�只需�?new Connection ��可以直接从数据库连接池中返�?Connection。�ƈ�?ADO Connection 是线�E�安全的�Q�多个线�E�可以共用一�?Connection�Q?所�?ASP �E�序一般都�?getConnection 攑֜� Global.asa 文�g中，�?IIS 启动时徏立数据库�q�接。ADO �?Connection �?Result 都有很好的缓�Ԍ��q�且很容易��用�?br />
其实我们可以自己写一个JDBC 数据库连接池。写 JDBC connection pool 的注意事��Ҏ��Q?br />
1. 有一个简单的函数从连接池中得��C��?Connection�?
2. close 函数必须��?connection 攑֛� 数据库连接池�?
3. 当数据库�q�接池中没有�I�闲�?connection�Q?数据库连接池必须能够自动增加 connection 个数�?
4. 当数据库�q�接池中�?connection 个数在某一个特别的旉��变得很大�Q�但是以后很长时间只用其中一��部分，应该可以自动��多余的 connection 关闭掉�?
5. 如果可能�Q�应该提供debug 信息报告没有关闭�?new Connection �?

如果�?new Connection ��可以直接从数据库连接池中返�?Connection�Q?可以�q�样�? Mediator pattern ) (以下代码中��用了中文全角�I�格)�Q?br />

public class EasyConnection implements java.sql.Connection{
　　private Connection m_delegate = null;

　　public EasyConnection(){
　　　　m_delegate = getConnectionFromPool();
　　}

　　public void close(){
　　　　putConnectionBackToPool(m_delegate);
　　}

　　public PreparedStatement prepareStatement(String sql) throws SQLException{
　　　　m_delegate.prepareStatement(sql);
　　}

　　//...... other method

}

看来�q�不难。不�q�不��q�种写法�Q�因为应该尽量避免��?Java Interface, 关于 Java Interface 的缺�Ҏ��另外再写文章讨论。大家关注的�?Connection Pool 的实现方法。下面给��Z��U�实现方法�?

import java.sql.*;
import java.lang.reflect.*;
import java.util.*;
import java.io.*;

public class SimpleConnetionPool {
　　private static LinkedList m_notUsedConnection = new LinkedList();
　　private static HashSet m_usedUsedConnection = new HashSet();
　　private static String m_url = "";
　　private static String m_user = "";
　　private static String m_password = "";
　　static final boolean DEBUG = true;
　　static private long m_lastClearClosedConnection = System.currentTimeMillis();
　　public static long CHECK_CLOSED_CONNECTION_TIME = 4 * 60 * 60 * 1000; //4 hours

　　static {
　　　　initDriver();
　　}

　　private SimpleConnetionPool() {
　　}

　　private static void initDriver() {
　　　　Driver driver = null;
　　　　//load mysql driver
　　　　try {
　　　　　　driver = (Driver) Class.forName("com.mysql.jdbc.Driver").newInstance();
　　　　　　installDriver(driver);
　　　　} catch (Exception e) {
　　　　}

　　　　//load postgresql driver
　　　　try {
　　　　　　driver = (Driver) Class.forName("org.postgresql.Driver").newInstance();
　　　　　　installDriver(driver);
　　　　} catch (Exception e) {
　　　　}
　　}

　　public static void installDriver(Driver driver) {
　　　　try {
　　　　　　DriverManager.registerDriver(driver);
　　　　} catch (Exception e) {
　　　　　　e.printStackTrace();
　　　　}
　　}


　　public static synchronized Connection getConnection() {
　　　　clearClosedConnection();
　　　　while (m_notUsedConnection.size() > 0) {
　　　　　　try {
　　　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();
　　　　　　　　if (wrapper.connection.isClosed()) {
　　　　　　　　　　continue;
　　　　　　　　}
　　　　　　　　m_usedUsedConnection.add(wrapper);
　　　　　　　　if (DEBUG) {
　　　　　　　　　　wrapper.debugInfo = new Throwable("Connection initial statement");
　　　　　　　　}
　　　　　　　　return wrapper.connection;
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　　　int newCount = getIncreasingConnectionCount();
　　　　LinkedList list = new LinkedList();
　　　　ConnectionWrapper wrapper = null;
　　　　for (int i = 0; i < newCount; i++) {
　　　　　　wrapper = getNewConnection();
　　　　　　if (wrapper != null) {
　　　　　　　　list.add(wrapper);
　　　　　　}
　　　　}
　　　　if (list.size() == 0) {
　　　　　　return null;
　　　　}
　　　　wrapper = (ConnectionWrapper) list.removeFirst();
　　　　m_usedUsedConnection.add(wrapper);

　　　　m_notUsedConnection.addAll(list);
　　　　list.clear();

　　　　return wrapper.connection;
　　}

　　private static ConnectionWrapper getNewConnection() {
　　　　try {
　　　　　　Connection con = DriverManager.getConnection(m_url, m_user, m_password);
　　　　　　ConnectionWrapper wrapper = new ConnectionWrapper(con);
　　　　　　return wrapper;
　　　　} catch (Exception e) {
　　　　　　e.printStackTrace();
　　　　}
　　　　return null;
　　}

　　static synchronized void pushConnectionBackToPool(ConnectionWrapper con) {
　　　　boolean exist = m_usedUsedConnection.remove(con);
　　　　if (exist) {
　　　　　　m_notUsedConnection.addLast(con);
　　　　}
　　}

　　public static int close() {
　　　　int count = 0;

　　　　Iterator iterator = m_notUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　try {
　　　　　　　　( (ConnectionWrapper) iterator.next()).close();
　　　　　　　　count++;
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　　　m_notUsedConnection.clear();

　　　　iterator = m_usedUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　try {
　　　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
　　　　　　　　wrapper.close();
　　　　　　　　if (DEBUG) {
　　　　　　　　　　wrapper.debugInfo.printStackTrace();
　　　　　　　　}
　　　　　　　　count++;
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　　　m_usedUsedConnection.clear();

　　　　return count;
　　}

　　private static void clearClosedConnection() {
　　　　long time = System.currentTimeMillis();
　　　　//sometimes user change system time,just return
　　　　if (time < m_lastClearClosedConnection) {
　　　　　　time = m_lastClearClosedConnection;
　　　　　　return;
　　　　}
　　　　//no need check very often
　　　　if (time - m_lastClearClosedConnection < CHECK_CLOSED_CONNECTION_TIME) {
　　　　　　return;
　　　　}
　　　　m_lastClearClosedConnection = time;

　　　　//begin check
　　　　Iterator iterator = m_notUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
　　　　　　try {
　　　　　　　　if (wrapper.connection.isClosed()) {
　　　　　　　　　　iterator.remove();
　　　　　　　　}
　　　　　　} catch (Exception e) {
　　　　　　　　iterator.remove();
　　　　　　　　if (DEBUG) {
　　　　　　　　　　System.out.println("connection is closed, this connection initial StackTrace");
　　　　　　　　　　wrapper.debugInfo.printStackTrace();
　　　　　　　　}
　　　　　　}
　　　　}

　　　　//make connection pool size smaller if too big
　　　　int decrease = getDecreasingConnectionCount();
　　　　if (m_notUsedConnection.size() < decrease) {
　　　　　　return;
　　　　}

　　　　while (decrease-- > 0) {
　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();
　　　　　　try {
　　　　　　　　wrapper.connection.close();
　　　　　　} catch (Exception e) {
　　　　　　}
　　　　}
　　}

　　/**
　　 * get increasing connection count, not just add 1 connection
　　 * @return count
　　 */
　　public static int getIncreasingConnectionCount() {
　　　　int count = 1;
　　　　int current = getConnectionCount();
　　　　count = current / 4;
　　　　if (count < 1) {
　　　　　　count = 1;
　　　　}
　　　　return count;
　　}

　　/**
　　 * get decreasing connection count, not just remove 1 connection
　　 * @return count
　　 */
　　public static int getDecreasingConnectionCount() {
　　　　int count = 0;
　　　　int current = getConnectionCount();
　　　　if (current < 10) {
　　　　　　return 0;
　　　　}
　　　　return current / 3;
　　}

　　public synchronized static void printDebugMsg() {
　　　　printDebugMsg(System.out);
　　}

　　public synchronized static void printDebugMsg(PrintStream out) {
　　　　if (DEBUG == false) {
　　　　　　return;
　　　　}
　　　　StringBuffer msg = new StringBuffer();
　　　　msg.append("debug message in " + SimpleConnetionPool.class.getName());
　　　　msg.append("\r\n");
　　　　msg.append("total count is connection pool: " + getConnectionCount());
　　　　msg.append("\r\n");
　　　　msg.append("not used connection count: " + getNotUsedConnectionCount());
　　　　msg.append("\r\n");
　　　　msg.append("used connection, count: " + getUsedConnectionCount());
　　　　out.println(msg);
　　　　Iterator iterator = m_usedUsedConnection.iterator();
　　　　while (iterator.hasNext()) {
　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();
　　　　　　wrapper.debugInfo.printStackTrace(out);
　　　　}
　　　　out.println();
　　}

　　public static synchronized int getNotUsedConnectionCount() {
　　　　return m_notUsedConnection.size();
　　}

　　public static synchronized int getUsedConnectionCount() {
　　　　return m_usedUsedConnection.size();
　　}

　　public static synchronized int getConnectionCount() {
　　　　return m_notUsedConnection.size() + m_usedUsedConnection.size();
　　}

　　public static String getUrl() {
　　　　return m_url;
　　}

　　public static void setUrl(String url) {
　　　　if (url == null) {
　　　　　　return;
　　　　}
　　　　m_url = url.trim();
　　}

　　public static String getUser() {
　　　　return m_user;
　　}

　　public static void setUser(String user) {
　　　　if (user == null) {
　　　　　　return;
　　　　}
　　　　m_user = user.trim();
　　}

　　public static String getPassword() {
　　　　return m_password;
　　}

　　public static void setPassword(String password) {
　　　　if (password == null) {
　　　　　　return;
　　　　}
　　　　m_password = password.trim();
　　}

}

class ConnectionWrapper implements InvocationHandler {
　　private final static String CLOSE_METHOD_NAME = "close";
　　public Connection connection = null;
　　private Connection m_originConnection = null;
　　public long lastAccessTime = System.currentTimeMillis();
　　Throwable debugInfo = new Throwable("Connection initial statement");

　　ConnectionWrapper(Connection con) {
　　　　Class[] interfaces = {java.sql.Connection.class};
　　　　this.connection = (Connection) Proxy.newProxyInstance(
　　　　　　con.getClass().getClassLoader(),
　　　　　　interfaces, this);
　　　　m_originConnection = con;
　　}

　　void close() throws SQLException {
　　　　m_originConnection.close();
　　}

　　public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
　　　　Object obj = null;
　　　　if (CLOSE_METHOD_NAME.equals(m.getName())) {
　　　　　　SimpleConnetionPool.pushConnectionBackToPool(this);
　　　　}
　　　　else {
　　　　　　obj = m.invoke(m_originConnection, args);
　　　　}
　　　　lastAccessTime = System.currentTimeMillis();
　　　　return obj;
　　}
}

使用�Ҏ��

public class TestConnectionPool{
　　public static void main(String[] args) {
　　　　SimpleConnetionPool.setUrl(DBTools.getDatabaseUrl());
　　　　SimpleConnetionPool.setUser(DBTools.getDatabaseUserName());
　　　　SimpleConnetionPool.setPassword(DBTools.getDatabasePassword());

　　　　Connection con = SimpleConnetionPool.getConnection();
　　　　Connection con1 = SimpleConnetionPool.getConnection();
　　　　Connection con2 = SimpleConnetionPool.getConnection();

　　　　//do something with con ...

　　　　try {
　　　　　　con.close();
　　　　} catch (Exception e) {}

　　　　try {
　　　　　　con1.close();
　　　　} catch (Exception e) {}

　　　　try {
　　　　　　con2.close();
　　　　} catch (Exception e) {}

　　　　con = SimpleConnetionPool.getConnection();
　　　　con1 = SimpleConnetionPool.getConnection();
　　　　try {
　　　　　　con1.close();
　　　　} catch (Exception e) {}

　　　　con2 = SimpleConnetionPool.getConnection();
　　　　SimpleConnetionPool.printDebugMsg();

　　}
}

Lansing 2006-08-04 15:56 发表评论

免费成人在线电影,污污的网站在线看,精品福利在线

Java 的JDBC 数据库连接池实现�Ҏ��