JDBC连接池设计--Mysql

JDBC连接数据库，并非是一件轻松的差事。数据库连接不仅仅在应用服务器和数据库服务器之间建立Socket Connection，还需要交换若干次数据用来验证等，以及系统资源和进程，日志的处理，所以数据库连接池在设计应用中是不可忽视的！缓解系统很大的压力！

思考：在创建好Connection之后，我们会习惯性地在用完后connection后，调用它的close()方法，有什么好的设计方法使其在调用close()方法和数据库连接池挂钩，即判断当前连接是否达到最大值？如果是，直接关闭，反之-将其加入数据库连接池中，待后续再用！

1.数据库连接池类DBConnection

public class DBPool {
	//容器--装Connection
	private static Vector<Connection> vector;
	//设置的 连接池----最大连接数
	private final int POOL_MAX_Size = 20;
	//获取一个Connection实例
	public synchronized Connection getConnection() throws Exception{
		Connection con;
		if(vector == null){
			vector = new Vector<Connection>();
		}
		if(vector.isEmpty()){
			con = createConnection();
		}else{
			int index = vector.size()-1;
			//从连接池-- 获取一个Connection
			con = vector.get(index);
			//连接池--移除 被使用的Connection
			vector.remove(index);
		}
		return con;
	}
	//处理一个Connection用完后的逻辑
	public synchronized void releaseConnection(Connection con) throws Exception{
		//连接池容器--是否满了
		if(vector.size() == POOL_MAX_Size){
			try {
				//直接关闭连接
				con.close();
			} catch (SQLException e) {
				throw new Exception("When closing a Connection throws exception");
			}
		}else{
			//没有满，将该Connection放入连接池，后续再用
			vector.add(con);
		}
	}
	
	//创建一个Connection连接
	private static Connection createConnection() throws Exception{
		Connection con;
		try{
			Class.forName("com.mysql.jdbc.Driver");
			con = DriverManager.getConnection("jdbc:mysql://192.168.125.107:3306/naladb?autoReconnect=true&useUnicode=true&characterEncoding=UTF8","naladb","nalanala");
		} catch(ClassNotFoundException ex){
			throw new Exception("ClassNotFoundException when loading jdbc driver");
		} catch(SQLException ex){
			throw new Exception("SQLException  when loading jdbc driver");
		}
		return con;
	}
}

=====在此，数据库连接池 基本写好了(当然是简单的，没有考虑连接时间处理等，但是这是 核心思想)，那么在用完Connection后，我们可以选择调用DBPolol的 releaseConnection(Connection con)来处理，但是 上面" 思考"，提到我们 习惯性是调用Connection的close()方法，这样看上去很 简洁， 规范(PreparedStatement，ResultSet也是调用close()来关闭连接)

肿麽办？就应该想到一些设计模式，有装饰，动态代理等，在这采用动态代理来完美处理这一问题！

动态代理----->三个前提：

1.接口：Connection  就是一个接口啊，有了。

2.接口的实现类：也有啊，上面的createConnection()不就得到一个实现了connection接口的类的实例么！ok

3.InvocationHandler接口的实现类：自己新创建一个类来实现该接口不就好了？也行

public class ConnectionHandler implements InvocationHandler {
	//Connection的实例
	private Connection con;
	//数据库连接池----(一般一个数据库使用一个连接池)
	private DBPool dbpool;
	
	public ConnectionHandler(DBPool dbPool){
		this.dbpool = dbPool;
	}
	//绑定当前的Connection实例
	public  Connection bind(Connection con){
		this.con = con;
		//创建Connection的代理对象
		Connection proxyCon =  (Connection) Proxy.newProxyInstance(con.getClass().getClassLoader(), con.getClass().getInterfaces(), this);
		return proxyCon;
	}
	/**
	 * 动态代理的类---class sun.proxy.$Proxy0  实现了：Connection接口，也继承了实现该接口的类，所以它有真实对象con 所有的方法！
	 */
	@Override
	public Object invoke(Object object, Method method, Object[] args)
			throws Throwable {
		Object obj = null;
		//如果 执行的是：close()方法
		if("close".equals(method.getName())){
			//调用数据库连接池的releaseConnection(Connection con)方法
			this.dbpool.releaseConnection(con);
		}else{
			//否则,调用自己的方法----这里反射机制，调用真实的Connection的实例con，而不是Proxy0代理对象
			obj = method.invoke(con, args);
		}
		return obj;
	}

}

当然也要修改连接池DBPool中的getConnection()方法里面内容-----》仅仅修改了这两句话

     //创建Connection的代理机制
     ConnectionHandler connectionHandler = new ConnectionHandler(this);
   //返回con代理对象
     return connectionHandler.bind(con);

public synchronized Connection getConnection() throws Exception{
		Connection con;
		if(vector == null){
			vector = new Vector<Connection>();
		}
		if(vector.isEmpty()){
			con = createConnection();
		}else{
			int index = vector.size()-1;
			//从连接池-- 获取一个Connection
			con = vector.get(index);
			//连接池--移除 被使用的Connection
			vector.remove(index);
		}
		//创建Connection的代理机制
		ConnectionHandler connectionHandler = new ConnectionHandler(this);
		//返回con代理对象
		return connectionHandler.bind(con);
	}

测试类：------

public class JDBCPoolJunit {
	public static void main(String[] args) throws Exception {
		DBPool dbPool = new DBPool();
		Connection conProxy = dbPool.getConnection();
		System.out.println("================================");
		System.out.println(conProxy);
		System.out.println(conProxy.getClass());
		System.out.println("===============================");
		conProxy.close();
		long timeStart = new Date().getTime();
		PreparedStatement statement = conProxy.prepareStatement("select t.id from trade t,user u where t.buyer_id=u.id and t.date_created>'2013-01-01 00:00:00' and u.username like '%qq%'");
		ResultSet re = statement.executeQuery();
		long timeEnd = new Date().getTime();
		System.out.println((timeEnd-timeStart)/1000.0+"秒");
	}
}

结果：

================================
com.mysql.jdbc.Connection@a3d4cf ---->代理对象  如果我们打印System(con)结果也是：com.mysql.jdbc.Connection@a3d4cf，但

是它的类：class com.mysql.jdbc.Connection

class sun.proxy.$Proxy0------>代理类
===============================
2.991秒

根据结果知道：调用close()方法后，该连接并没有关闭，还可以进行sql语句查询，这就是动态代理的好处！  我们要 认识  代理类和被代理类的关系和区别！