学习笔记之 自定义连接池实现代码

package cn.itcast.a_mypool;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;

/**
 * 自定义连接池
 * 
 * @author Administrator
 * 
 */
public class PoolDemo {
	// 数据库连接信息
	private String driverName = "com.mysql.jdbc.Driver";
	private String url = "jdbc:mysql:///day17";
	private String user = "root";
	private String password = "root";

	// 当前连接数
	private int current_count = 0;
	// 初始化连接
	private int init_count = 3;
	// 最大连接数
	private int max_count = 6;

	// 保存连接的集合 （连接池）
	private LinkedList<Connection> pool = new LinkedList<Connection>();

	public PoolDemo() {
		// 初始化3个连接
		for (int i = 0; i < init_count; i++) {
			// 创建连接，放入集合(连接池)
			pool.addLast(this.createConnection());
			// 当前连接 +1
			this.current_count++;
		}
	}

	// 1. 创建连接
	private Connection createConnection() {
		// 保存代理对象
		Connection proxy = null;
		try {
			// 加载驱动
			Class.forName(driverName);
			// con相关于目标对象， 要求要创建目标对象的代理对象
			final Connection con = DriverManager.getConnection(url, user,
					password);
			// 创建代理对象
			proxy = (Connection) Proxy.newProxyInstance(this.getClass()
					.getClassLoader(), // 类加载器
					new Class[] { Connection.class }, // 代理对象的接口
					// 每当执行代理对象接口中的方法的时候，(反射)自动调用处理器中的invoke方法， 传入参数信息
					new InvocationHandler() {
						// 方法返回值
						Object returnValue = null;

						// 第一个参数： 代理对象
						// 第二个参数： 调用目标方法(接口中方法)的方法类型
						// 第三个参数： 参数值
						public Object invoke(Object proxy, Method method,
								Object[] args) throws Throwable {

							// 目标：检测close方法的调用，当执行close方法的时候，往连接池中添加连接

							// 获取当前执行接口中方法的方法名称
							String methodName = method.getName();
							// 检测close方法执行
							if ("close".equals(methodName)) {
								pool.add(con); // 当调用close方法时候，把连接放入连接池
								System.out
										.println("检测到close方法执行，当前连接已经放入连接中了！");
							} else {
								// 其他方法执行执行
								returnValue = method.invoke(proxy, args);
							}

							return returnValue;
						}
					});

		} catch (Exception e) {
			throw new RuntimeException();
		}

		return proxy;
	}

	// 2. 获取连接
	public Connection getConnection() {
		// 思路：从连接池中获取连接；如果连接池中已经没有连接了， 当前连接数 < 最大, 创建新的连接
		// 如果连接池中已经没有连接了，当前连接 >=最大， 不创建新的连接，抛出异常

		synchronized (driverName) {
			// 1. 如果连接池中有连接，获取连接
			if (pool.size() > 0) {
				return pool.removeFirst();
			}
			// 2. 连接池中没有连接
			// 2.1 如果当前连接没有达到最大连接，创建连接, 当前连接+1
			if (this.current_count < this.max_count) {
				this.current_count++;
				return this.createConnection();
			}
		}
		// 2.2 连接已经达到最大连接数
		throw new RuntimeException("连接已经达到最大连接数，获取连接失败！");
	}

	// 3. 关闭连接
	public void closeConnection(Connection con) {
		// 先判断连接池中连接数是否达到最大连接数， 如果没有把连接放入连接池中， 否则关闭

		if (pool.size() < this.max_count) {
			this.pool.add(con);// 把连接放入连接池
		} else {
			try {
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) throws SQLException {
		PoolDemo demo = new PoolDemo();
		System.out.println("当前连接：" + demo.init_count);
		System.out.println("最大连接：" + demo.max_count);
		System.out.println("连接池连接数：" + demo.pool.size());
		System.out.println("---------------------");

		demo.getConnection();
		demo.getConnection();
		demo.getConnection();

		demo.getConnection();
		demo.getConnection();
		Connection con = demo.getConnection();

		// 回收连接
		// demo.closeConnection(con);
		con.close();// 关闭连接时候，没有吧连接放入连接池， 没有执行：this.pool.add(con);

		demo.getConnection();

		System.out.println("当前连接：" + demo.current_count);
		System.out.println("连接池连接数：" + demo.pool.size());

	}

}