2009-3-31 | ConnectionPool - Proxy

ConnectionPool.java

package ConnectionPool;

import java.util.*;
import java.sql.*;

public class ConnectionPool {

 private static ConnectionPool cPool = null;
 
 private static String url="jdbc:mysql://localhost/jdbc?user=root&password=xxxx";

 private static final int INIT_SIZE = 2;
 
 private static final int MAX_SIZE = 4;
 
 static int createdConnectionCount = 0;
 
 static LinkedList<Connection> pool = null;
 
 private ConnectionPool(){
  
 }
 
 static{
  cPool = new ConnectionPool();
  try {
   Class.forName("com.mysql.jdbc.Driver");
   pool = new LinkedList<Connection>();
   
   for(int i = 0 ;i<INIT_SIZE;i++){
    Connection conn = DriverManager.getConnection(url);
    MyConnection warpedConn = new MyConnection(cPool,conn);
    pool.addLast(warpedConn);
   }
  } catch (ClassNotFoundException e) {
   throw new ExceptionInInitializerError("mysql驱动没有找到");
  } catch(SQLException e){
   throw new ExceptionInInitializerError("sql error");
  }
  
  System.out.println("+++++++++++++++++++++++");
  for(int i=0;i<pool.size();i++){
   
   System.out.println(pool.get(i));
  }
  System.out.println("+++++++++++++++++++++++");
  
 }
 
 public static Connection getConnection() throws Exception {
  MyConnection conn = null;
  synchronized(cPool){
   if(pool.size()>0){
//    Connection realConn = pool.removeFirst();
//    conn = new MyConnection(cPool,realConn);
    conn = (MyConnection) pool.removeFirst();
    createdConnectionCount ++;
    
   } else if(pool.size()<=0 && createdConnectionCount < MAX_SIZE){
    try {
     Connection realConn = DriverManager.getConnection(url); 
     conn = new MyConnection(cPool,realConn);   //单例对象cPool

     createdConnectionCount ++;
    } catch (Exception e) {
     throw e;
    }
   } else{
    throw new Exception("数据库负荷超载");
   }
  }    
  return conn;
 }
 
 public static void free(Connection conn) throws SQLException{
  
  synchronized(cPool){
   if(conn != null && createdConnectionCount <MAX_SIZE){
    pool.addLast((Connection)conn);
    System.out.println("free from remove: --------" + conn + "---------");
    createdConnectionCount--;
   } else if(createdConnectionCount >INIT_SIZE){
    try {
     System.out.println("free from close: --------" + conn + "---------");
     ((MyConnection) conn).getRealConnection().close();
     createdConnectionCount--;
     
    } catch (SQLException e) {
     throw e;
    }
   }
  }
 }

}

//MyConnection.java  手动写的代理类

package ConnectionPool;

import java.sql.*;
import java.util.Map;
import java.util.Properties;

public class MyConnection implements Connection{
 
 private Connection realConnection = null;
 private ConnectionPool pool = null;
 
 public MyConnection(ConnectionPool pool,Connection conn){
  this.realConnection = conn;
  this.pool = pool;
 }
 
 public void clearWarnings() throws SQLException {  //交给realConnection处理
  this.realConnection.clearWarnings();
 }

 public Connection getRealConnection(){      //交给realConnection处理
  return this.realConnection;
 }
 public void close() throws SQLException {  //本例真正感兴趣的方法
  //System.out.println("--------");
  
  pool.free(this);
  
 }

 ....

}

//MyConnectionUsePoolHandler.java  由Proxy产生的动态代理类

package ConnectionPool;

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

public class MyConnectionUsePoolHandler implements InvocationHandler{

 
 private Connection realConn =null;
 private Connection warpedConn = null;
 private ConnectionPool pool = null;
 
 public MyConnectionUsePoolHandler(ConnectionPool pool){
  this.pool = pool;
 }
 
 public Connection bind(Connection realConn){
  this.realConn = realConn;
  /**
   * loader --> 定义代理类的类加载器
   * 动态的构建一个代理类，这个代理类他实现了Connection接口  -->  new Class[]{Connection.class}，
   * 并把这个接口所应实现的所有方法都交给一个InvocationHandler的invoke()
   * 处理(本例中为this)
   *
   * 使用方法
   * public Connection createConnection(){
   *   MyConnectionUsePoolHandler proxy = new MyConnectionUsePoolHandler(pool)
   *   return proxy.bing(realConn);
   * }
   *
   */
  warpedConn = (Connection)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{Connection.class}, this);
  return warpedConn;
 }
 
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
 
  if("close".equals(method.getName())){  //如果是close方法，则执行括号内的代码
   pool.free(warpedConn);
  }  
  return method.invoke(this.realConn, args);  //如果是其它的方法，交给realConn，而realConn调用相应的方法
 }
}