代理模式之静态代理---数据库连接池对象实现原理

众所周知，数据库在建立链接的时候是很耗费时间的，如果每次操作数据库都要重新建立一下链接，这样对系统的性能就会造成影响。

所谓数据库连接池就是在服务器启动时已经建立好一定数量的数据库链接对象，用的时候只需要在池里面拿就行了，而关闭的时候就是把拿出来的链接对象重新放入池中。

其实说白了就是在服务器启动的时候就已经建立好一系列的数据库链接对象，并把这些对象放入一个容器里。

1.首先实现自己的数据源：

package com.zzg.jdbc.datasource;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;

public class MyDataSource {
	private String url;
	private String user;
	private String password;
	// 默认初始化链接数
        int initCount = 5;
	// 默认最大链接数
        int maxCount = 10;

	// 当前链接数
	private int currentCount = 0;

	/*
	 * 这里选择LinkedList而非ArrayList是因为获取链接对象 或释放链接对象是要反复的从容器中添加或删除节点，
	 * 而LinkedList是以链表的方式存储数据的， 所以在容器写操作上LinkedList在效率上要高于ArrayList
	 */
	LinkedList<Connection> connectionsPool = new LinkedList<Connection>();

	public MyDataSource(String url, String user, String password) {
		this.url = url;
		this.user = user;
		this.password = password;
		initPool();
	}

	public MyDataSource(String url, String user, String password,
			int initCount, int maxCount) {
		this.url = url;
		this.user = user;
		this.password = password;
		this.initCount = initCount;
		this.maxCount = maxCount;
		initPool();
	}

	/**
	 * 初始化的时候创建10个链接，并放入池中
	 */
	private void initPool() {
		System.out.println("initCount=" + this.initCount);
		try {
			for (int i = 0; i < this.initCount; i++) {
				this.connectionsPool.addLast(this.createConnection());
				this.currentCount++;
			}
		} catch (SQLException e) {
			throw new ExceptionInInitializerError(e);
		}
	}

	/**
	 * 从连接池中获取链接
	 * 
	 * @return
	 * @throws SQLException
	 */
	public Connection getConnection() throws SQLException {
		// 保证并发情况下拿到的不是同一个数据库链接对象
		synchronized (connectionsPool) {
			// 当数据库链接池中有链接时
			if (this.connectionsPool.size() > 0) {
				this.currentCount--;
				return this.connectionsPool.removeFirst();
			}
			// 当当前链接对象小于最大链接对象时创建链接对象
			if (this.currentCount < this.maxCount) {
				System.out.println("ddddddddddddddddd");
				this.currentCount++;
				return this.createConnection();
			}
			throw new SQLException("已没有链接可用");
		}

	}

	/**
	 * 释放链接，把链接重新放入池中
	 * 
	 * @param conn
	 * @throws SQLException
	 */
	public void free(Connection conn) throws SQLException {
	        this.currentCount++;
		this.connectionsPool.addLast(conn);
	}

	/**
	 * 创建链接
	 * 
	 * @return
	 * @throws SQLException
	 */
	private Connection createConnection() throws SQLException {
		return DriverManager.getConnection(url, user, password);
	}
}

2.建立获取数据库链接对象的帮助类

package com.zzg.jdbc.util;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import com.zzg.jdbc.datasource.MyDataSource;

public final class JdbcUtils {
	private static MyDataSource myDataSource = null;
	private static String url = "jdbc:mysql://localhost:3306/test";
	private static String user = "root";
	private static String password = "123456";

	private JdbcUtils() {
	}

	static {
		try {
			Class.forName("com.mysql.jdbc.Driver");
			myDataSource = new MyDataSource(url, user, password);
			//myDataSource = new MyDataSource(url, user, password,2,10);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}

	/**
	 * 获取数据库链接对象（从连接池中获取）
	 * @return
	 * @throws SQLException
	 */
	public static Connection getConnection() throws SQLException {
		// return DriverManager.getConnection(url, user, password);
		return myDataSource.getConnection();
	}

	/**
	 * 释放链接对象（这里释放Connection是调用数据源的free方法）
	 * @param rs
	 * @param st
	 * @param conn
	 */
	public static void free(ResultSet rs, Statement st, Connection conn) {
		try {
			if (rs != null)
				rs.close();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				if (st != null)
					st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			} finally {
				if (conn != null)
					try {
						// conn.close();
						myDataSource.free(conn);
					} catch (Exception e) {
						e.printStackTrace();
					}
			}
		}
	}
}

3.测试：

package com.zzg.jdbc.test;

import java.sql.Connection;
import java.sql.SQLException;

import com.zzg.jdbc.util.JdbcUtils;

public class Base {
	public static void main(String[] args) throws SQLException {
		for (int i = 0; i < 10; i++) {
			Connection conn = JdbcUtils.getConnection();
			System.out.println(conn);
			JdbcUtils.free(null, null, conn);
		}
	}

}

到目前为止，我们还没有说到代理模式，上面在数据库链接对象释放的时候要调用数据源的free方法（把要关闭的链接重新放入连接池中），这样如果在写代码的时候不小心还是用Connection的close关闭的话，就会造成连接池失效的问题。

有没有一种方法能够使用Collection的close方法并且起到与数据源的free方法一致的效果。

提供以下几种方式：
1.可以去修改mysql的驱动
2.继承mysql的Collection类，并重写它的close方法。
3.使用代理模式

前两种方式都非常不灵活，如果要是换数据库了，我们还要重新的去修改驱动或继承你要使用的数据库的Collection类，并重新它的close方法。

因此我们可以使用代理模式，代理模式分为静态代理和动态代理，这里我先介绍一下静态代理。

1.因此首先我们要建立一个代理类，这个代理类就是代理真实驱动的Connection类的，这个类构造的时候需要传入驱动的Connection对象和连接词对象，并且让这个类实现Connection接口。因此我们要实现Connection接口所有的方法，这里我们只关注close方法，其他方法可以调用传入驱动的Connection对象的方法。

代理类MyConnection的主要代码

package com.zzg.jdbc.datasource;

import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.util.Map;
import java.util.Properties;

/**
 * close()方法调用数据源对象myds的free方法，其他方法可以调用数据库驱动的Connection对象的方法
 * 
 * @author toshiba
 * 
 */
public class MyConnection implements Connection {

	private Connection realConn;

	private MyDataSource myds;

	/**
	 * 
	 * @param realConn
	 *            数据库驱动的Connection对象
	 * @param myds
	 *            数据库连接池对象
	 */
	public MyConnection(Connection realConn, MyDataSource myds) {
		this.realConn = realConn;
		this.myds = myds;
	}

	@Override
	public void clearWarnings() throws SQLException {
		//调用传入的数据库驱动的Connection对象的方法
		this.realConn.clearWarnings();
	}

	@Override
	public void close() throws SQLException {
		this.myds.currentCount++;
		if (this.myds.currentCount < this.myds.maxCount) {
			this.myds.connectionsPool.addLast(this);
		} else {
			System.out.println("hhhhhhhhhhh");
			this.realConn.close();
			this.myds.currentCount--;
		}
	}

	@Override
	public void commit() throws SQLException {
		this.realConn.commit();
	}
.......

因此我们就需要修改数据源类MyDataSource类的创建数据库链接对象的方法createConnection方法

	/**
	 * 创建链接（使用代理类MyConnection的Connection）
	 * 
	 * @return
	 * @throws SQLException
	 */
	private Connection createConnection() throws SQLException {
		// return DriverManager.getConnection(url, user, password);
		Connection realConn = DriverManager.getConnection(url, user, password);
		MyConnection myConn = new MyConnection(realConn, this);
		return myConn;
	}

到这里为止我们就可以使用Connection的close方法去关闭链接对象，并且能够起到与数据源的free方法释放链接对象一致的效果。