
ӳࣺ

package ConnectPool;

import java.sql.*;
import java.lang.reflect.*;
import java.nio.ShortBuffer;
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.deregisterDriver(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) {
   this.connection = (Connection) Proxy.newProxyInstance(con.getClass()
     .getClassLoader(), con.getClass().getInterfaces(), 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;
}
}

ӳز

package ConnectPool;

import java.sql.Connection;

public class testconnectionpool {
public static void main(String[] args) {

   simpleconnetionpool
     .seturl(//Լݿ);
   simpleconnetionpool.setuser(//Լû);
   simpleconnetionpool.setpassword(//Լݿ);

   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();

}
}