/**

 * 自定义连接池, 管理连接

 * 代码实现：

1.  MyPool.java  连接池类，   

2.  指定全局参数：  初始化数目、最大连接数、当前连接、   连接池集合

3.  构造函数：循环创建3个连接

4.  写一个创建连接的方法

5.  获取连接

------>  判断： 池中有连接， 直接拿

 ------>                池中没有连接，

------>                 判断，是否达到最大连接数； 达到，抛出异常；没有达到最大连接数，

创建新的连接

6. 释放连接

 ------->  连接放回集合中(..)

 *

 */

public class MyPool {

private int init_count = 3; // 初始化连接数目

private int max_count = 6; // 最大连接数

private int current_count = 0;  // 记录当前使用连接数

// 连接池 （存放所有的初始化连接）

private LinkedList<Connection> pool = new LinkedList<Connection>();

//1.  构造函数中，初始化连接放入连接池

public MyPool() {

// 初始化连接

for (int i=0; i<init_count; i++){

// 记录当前连接数目

current_count++;

// 创建原始的连接对象

Connection con = createConnection();

// 把连接加入连接池

pool.addLast(con);

}

}

//2. 创建一个新的连接的方法

private Connection createConnection(){

try {

Class.forName("com.mysql.jdbc.Driver");

// 原始的目标对象

final Connection con = DriverManager.getConnection("jdbc:mysql:///jdbc_demo", "root", "root");

/**********对con对象代理**************/

// 对con创建其代理对象

Connection proxy = (Connection) Proxy.newProxyInstance(

con.getClass().getClassLoader(),    // 类加载器

//con.getClass().getInterfaces(),   // 当目标对象是一个具体的类的时候

new Class[]{Connection.class},      // 目标对象实现的接口

new InvocationHandler() { // 当调用con对象方法的时候， 自动触发事务处理器

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

// 方法返回值

Object result = null;

// 当前执行的方法的方法名

String methodName = method.getName();

// 判断当执行了close方法的时候，把连接放入连接池

if ("close".equals(methodName)) {

System.out.println("begin:当前执行close方法开始！");

// 连接放入连接池

pool.addLast(con);

System.out.println("end: 当前连接已经放入连接池了！");

} else {

// 调用目标对象方法

result = method.invoke(con, args);

}

return result;

}

}

);

return proxy;// 就是上面定义的 final Connection

} catch (Exception e) {

throw new RuntimeException(e);

}

}

//3. 获取连接

public Connection getConnection(){

// 3.1 判断连接池中是否有连接, 如果有连接，就直接从连接池取出

if (pool.size() > 0){

return pool.removeFirst();

}

// 3.2 连接池中没有连接： 判断，如果没有达到最大连接数，创建；

if (current_count < max_count) {

// 记录当前使用的连接数

current_count++;

// 创建连接

return createConnection();

}

// 3.3 如果当前已经达到最大连接数，抛出异常

throw new RuntimeException("当前连接已经达到最大连接数目 ！");

}

//4. 释放连接

public void realeaseConnection(Connection con) {

// 4.1 判断： 池的数目如果小于初始化连接，就放入池中

if (pool.size() < init_count){

pool.addLast(con);

} else {

try {

// 4.2 关闭

current_count--;

con.close();

} catch (SQLException e) {

throw new RuntimeException(e);

}

}

}

public static void main(String[] args) throws SQLException {

MyPool pool = new MyPool();

System.out.println("当前连接: " + pool.current_count);  // 3

// 使用连接

pool.getConnection();

pool.getConnection();

Connection con4 = pool.getConnection();

Connection con3 = pool.getConnection();

Connection con2 = pool.getConnection();

Connection con1 = pool.getConnection();

// 释放连接, 连接放回连接池

// pool.realeaseConnection(con1);

/*

 * 希望：当关闭连接的时候，要把连接放入连接池！【当调用Connection接口的close方法时候，希望触发pool.addLast(con);操作】

 * 把连接放入连接池

 * 解决1：实现Connection接口，重写close方法

 * 解决2：动态代理

 */

con1.close();

// 再获取

pool.getConnection();

System.out.println("连接池：" + pool.pool.size());      // 0

System.out.println("当前连接: " + pool.current_count);  // 3

}

}

public class App_DBCP {

// 1. 硬编码方式实现连接池

@Test

public void testDbcp() throws Exception {

// DBCP连接池核心类

BasicDataSource dataSouce = new BasicDataSource();

// 连接池参数配置：初始化连接数、最大连接数 / 连接字符串、驱动、用户、密码

dataSouce.setUrl("jdbc:mysql:///jdbc_demo"); //数据库连接字符串

dataSouce.setDriverClassName("com.mysql.jdbc.Driver");  //数据库驱动

dataSouce.setUsername("root"); //数据库连接用户

dataSouce.setPassword("root"); //数据库连接密码

dataSouce.setInitialSize(3);  // 初始化连接

dataSouce.setMaxActive(6);   // 最大连接

dataSouce.setMaxIdle(3000);   // 最大空闲时间

// 获取连接

Connection con = dataSouce.getConnection();

con.prepareStatement("delete from admin where id=3").executeUpdate();

// 关闭

con.close();

}

@Test

// 2. 【推荐】配置方式实现连接池  ,  便于维护

public void testProp() throws Exception {

// 加载prop配置文件

Properties prop = new Properties();

// 获取文件流

InputStream inStream = App_DBCP.class.getResourceAsStream("db.properties");

// 加载属性配置文件

prop.load(inStream);

// 根据prop配置，直接创建数据源对象

DataSource dataSouce = BasicDataSourceFactory.createDataSource(prop);

// 获取连接

Connection con = dataSouce.getConnection();

con.prepareStatement("delete from admin where id=4").executeUpdate();

// 关闭

con.close();

}

}

配置方式实现DBCP连接池，  配置文件中的key与BaseDataSouce中的属性一样：

db.properties

url=jdbc:mysql:///jdbc_demo

driverClassName=com.mysql.jdbc.Driver

username=root

password=root

initialSize=3

maxActive=6

maxIdle=3000

public class App {

@Test

//1. 硬编码方式，使用C3P0连接池管理连接

public void testCode() throws Exception {

// 创建连接池核心工具类

ComboPooledDataSource dataSource = new ComboPooledDataSource();

// 设置连接参数：url、驱动、用户密码、初始连接数、最大连接数

dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc_demo");

dataSource.setDriverClass("com.mysql.jdbc.Driver");

dataSource.setUser("root");

dataSource.setPassword("root");

dataSource.setInitialPoolSize(3);

dataSource.setMaxPoolSize(6);

dataSource.setMaxIdleTime(1000);

// ---> 从连接池对象中，获取连接对象

Connection con = dataSource.getConnection();

// 执行更新

con.prepareStatement("delete from admin where id=7").executeUpdate();

// 关闭

con.close();

}

@Test

//2. XML配置方式，使用C3P0连接池管理连接

public void testXML() throws Exception {

// 创建c3p0连接池核心工具类

// 自动加载src下c3p0的配置文件【c3p0-config.xml】

ComboPooledDataSource dataSource = new ComboPooledDataSource();// 使用默认的配置

// 获取连接

Connection con = dataSource.getConnection();

// 执行更新

con.prepareStatement("delete from admin where id=5").executeUpdate();

// 关闭

con.close();

}

}

public class JdbcUtil {

private static ComboPooledDataSource dataSource = null;

/**

 * 静态代码块准备需要的一些数据

 */

static

{

dataSource = new ComboPooledDataSource();

}

/**

 * 建立数据库链接的操作

 */

public static Connection getConnection()

{

try {

return dataSource.getConnection();

} catch (SQLException e) {

throw new RuntimeException(e);

}

}

/**

 * 关闭数据库链接

 * @param conn

 * @param stmt

 * @param rs

 */

public static void closeAll(Connection conn, Statement stmt, ResultSet rs)

{

if(rs!=null)

{

try {

rs.close();

rs = null;

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

}

if(stmt!=null)

{

try {

stmt.close();

stmt = null;

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

}

if(conn!=null)

{

try {

conn.close();

conn = null;

} catch (Exception e) {

e.printStackTrace();

throw new RuntimeException(e);

}

}

}

}

public class PageBean <T> {

private int currentPage = 1; //当前显示的页面 默认显示第一页

private int pageCount = 4; //查询返回的条数 默认 每页4条数据

private int totalCount; //总记录数

private int totalPage; //总页数

private List<T> pageData; //分页查询到的数据

public int getCurrentPage() {

return currentPage;

}

public void setCurrentPage(int currentPage) {

this.currentPage = currentPage;

}

public int getPageCount() {

return pageCount;

}

public void setPageCount(int pageCount) {

this.pageCount = pageCount;

}

public int getTotalCount() {

return totalCount;

}

public void setTotalCount(int totalCount) {

this.totalCount = totalCount;

}

public int getTotalPage() {

if(totalCount % pageCount == 0)

{

totalPage = totalCount / pageCount;

}

else

{

totalPage = totalCount / pageCount + 1;

}

return totalPage;

}

public void setTotalPage(int totalPage) {

this.totalPage = totalPage;

}

public List<T> getPageData() {

return pageData;

}

public void setPageData(List<T> pageData) {

this.pageData = pageData;

}

}

public class JdbcUtil {

private static ComboPooledDataSource dataSource = null;

// 初始化

static {

// 一旦创建 建辉默认的加载 c3p0文件

dataSource = new ComboPooledDataSource();

}

// 创建DbUtils核心工具类对象

public static QueryRunner getQueryRunner()

{

// 创建 QueryRunner的时候 可以传入一个参数 datasource 这样在 执行 qr.executeUpdate()的

//时候 尅不传入链接，这样最终也不需要 手动的 conn.close()

return new QueryRunner(dataSource);// 看到没有这里都不需要getConnection的操作，所以我们后面也不需要自己师范conn,stmt,rs等资源

}

// 当然有可能有某些函数中还需要使用connection所以可以写一个getConnection

// 获取连接 一遍那些需要使用 数据库链接的地方使用

public static Connection getConnection()

{

try {

return dataSource.getConnection();// 从连接池中 拿出一个链接来

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

throw new RuntimeException(e);

}

}

}