JDBC 数据库连接池详解和示例

• • 学习目标
  • 数据库连接池
  • • 数据库连接池原理
    • • 第一步
      • 第二步
      • 第三步
      • 第四步
      • 第五步
  • DBCP
  • • DBCP参数
    • 方法1
    • 方法2
  • C3P0
  • • 方法1
    • 方法2
  • DbUtils
  • • QueryRunner核心类
    • ResultSetHandler结果集处理类
    • 案例
    • 查询
    • 其他方法
• 作业
• • 模拟数据库连接池
  • DBCP 连接池
  • C3P0连接池

1. 了解数据库连接池的原理
2. 了解C3P0数据库连接池
3. 了解DBCP数据库连接池
4. 掌握Druid数据库连接池

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用现有的N个（自定义）数据库连接，不用每次都再重新建立一个新的连接，以提高对数据库操作的性能。

常用开源的数据库连接池

• C3P0：是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate [2] 一起发布，包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象。
• Proxool：是一个Java SQDriver驱动程序，提供了对选择的其它类型的驱动程序的连接池封装。可以非常简单的移植到现存的代码中，完全可配置，快速、成熟、健壮。可以透明地为现存的JDBC驱动程序增加连接池功能。
• Jakarta DBCP：DBCP是一个依赖Jakartacommons-pool对象池机制的数据库连接池。DBCP可以直接的在应用程序中使用。
  -DBPool：是一个高效、易配置的数据库连接池。它除了支持连接池应有的功能之外，还包括了一个对象池，使用户能够开发一个满足自己需求的数据库连接池。
• SmartPool：是一个连接池组件，它模仿应用服务器对象池的特性。SmartPool能够解决一些临界问题如连接泄漏（connection leaks）、连接阻塞、打开的JDBC对象（如Statements、PreparedStatements）等。
• Druid连接池是阿里巴巴开源的数据库连接池项目。Druid连接池为监控而生，内置强大的监控功能，监控特性不影响性能。功能强大，能防SQL注入，内置Loging能诊断Hack应用行为。

简单来说，数据库连接池就是在一开始先创建N多个数据库连接connection对象，存储在一个集合内，每次使用一个就从集合内取出一个，用完之后又添加到集合内，一直反复使用。

创建带有是否使用标记的Connection对象。自定义一个带有是否使用标记的Connection对象。

package com.pool;
import java.sql.Connection;
public class PooledConnection {
    // 数据库连接
    private Connection conn;
    // 用于标识当前数据库连接的状态 true:执行 false:空闲
    private boolean busy;
    public PooledConnection(Connection conn) {
        this.conn = conn;
    }
    public Connection getConn() {
        return conn;
    }
    public void setConn(Connection conn) {
        this.conn = conn;
    }
    public boolean isBusy() {
        return busy;
    }
    public void setBusy(boolean busy) {
        this.busy = busy;
    }
}

创建数据库线程池对象

数据库线程池对象包含默认连接数、最大连接数、每次新增个数、超时时间和连接对象集合。

package com.star;

import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.*;


public class Poo{
    // 初始化连接数
    private static int initSize = 2;
    // 池中最大连接数
    private static int maxSize = 10;
    // 每次创建的连接数
    private static int stepSize = 2;
    // 超时时间
    private static int timeout = 2000;
    // 用来保存创建的数据库连接
    private static List poo= Collections.synchronizedList(new ArrayList<>());
    //单例对象
    private static Pooinstance;

    
    private Pool() {
        resizePool(initSize);
    }

    
    private Pool() {
        resizePool(initSize);
    }

    
    public static synchronized PoogetInstance() {
        if (instance == null) {
            instance = new Pool();
        }
        return instance;
    }

    
    private void resizePool(int size) {
        int current = pool.size();
        if (current + size > maxSize) {
            size = maxSize - current;

        }
        for (int i = 0; i < size; i++) {
            pool.add(new PoolCollection(createConnection()));
        }

    }
}

获取连接

public Connection createConnection() {
    try {
        //加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //加载配置文件
        Properties p = new Properties();
        p.load(new FileInputStream("jdbc.properties"));
        return DriverManager.getConnection(p.getProperty("url"), p.getProperty("user"), p.getProperty("password"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}


public Connection getConnection() {
    Connection connection = getAddConnection();
    while (connection == null) {
        System.out.println(Thread.currentThread().getName() + "开始等待获取连接");
        try {
            Thread.sleep(timeout);
            connection = getAddConnection();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println(Thread.currentThread().getName() + "拿到连接");
    return connection;
}


private Connection getAddConnection() {
    Connection connection = getUsableConnection();
    if (connection == null) {
        resizePool(stepSize);
        connection = getUsableConnection();
    }
    return connection;
}


private Connection getUsableConnection() {
    Connection connection = null;
    if (pool.size() > 0) {
        for (PoolCollection poolCollection : pool) {
            if (poolCollection.isUsed() == false) {
                poolCollection.setUsed(true);
                connection = poolCollection.getConnection();
                //connection有课能在上次使用过程中产生异常被中断
                try {
                    // connection.isValid如果连接未关闭且有效，则返回true
                    if (connection.isValid(2000) == false) {
                        connection = createConnection();
                    }
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
                break;
            }
        }
    }
    return connection;
}

归还

public void close(Connection connection){
    for (PoolCollection poolCollection : pool) {
        if(connection == poolCollection.getConnection()){
            poolCollection.setUsed(false);
        }
    }
}

测试

package com.star;

import java.sql.Connection;

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "获取连接");
                    Poopool1 = Pool.getInstance();
                    Connection connection = pool1.getConnection();
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    pool1.close(connection);
                    System.out.println(Thread.currentThread().getName() + "释放连接");
                }
            }.start();
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

下载DBCP地址：

下载pool地址

下载Logging地址

package com.dbcp;

import javax.sql.DataSource;

import org.apache.commons.dbcp2.BasicDataSource;

public class DBCPUtils {
	private String driver = "com.mysql.cj.jdbc.Driver";
	private String ur= "jdbc:mysql://localhost/mydbcp?serverTimezone=GMT";
	private String username = "root";
	private String password = "";
	private static BasicDataSource basicDataSource = new BasicDataSource();

	public DBCPUtils() {
		basicDataSource.setUrl(url);
		basicDataSource.setDriverClassName(driver);
		basicDataSource.setUsername(username);
		basicDataSource.setPassword(password);

		basicDataSource.setInitialSize(10);// 初始化时创建10个链接
		basicDataSource.setMaxIdle(8);// 设置最大连接数
		basicDataSource.setMaxIdle(5);// 这只最大的空闲连接数
		basicDataSource.setMinIdle(1);// 设置最小空闲连接数字
	}

	
	public static DataSource getDataSource() {
		return basicDataSource;
	}
}

测试

package com.dbcp;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class DBCPTest {
	public static void main(String[] args) {
		DBCPUtils uti= new DBCPUtils();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

配置文件dbcp.properties

#驱动名
driverClassName=com.mysql.cj.jdbc.Driver
#数据库
database=mydbcp
#url
url=jdbc:mysql://localhost/${database}?serverTimezone=Asia/Shanghai&characterEncoding=UTF-8
#用户名
username=root
#密码
password=
#初试连接数
initialSize=30
#最大活跃数
maxTotal=30
#最大idle数
maxIdle=10
#最小idle数
minIdle=5
#最长等待时间(毫秒)
maxWaitMillis=1000
#程序中的连接不使用后是否被连接池回收(该版本要使用removeAbandonedOnMaintenance和removeAbandonedOnBorrow)
#removeAbandoned=true
removeAbandonedOnMaintenance=true
removeAbandonedOnBorrow=true
#连接在所指定的秒数内未使用才会被删除(秒)(为配合测试程序才配置为1秒)
removeAbandonedTimeout=1

使用

package com.dbcp;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;

public class DBCPUtils2 {
	private static BasicDataSource basicDataSource = new BasicDataSource();

	public DBCPUtils2() {
		Properties prop = new Properties();
		try {
			prop.load(new FileInputStream("src/dbcp.properties"));
			basicDataSource = new BasicDataSourceFactory().createDataSource(prop);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	
	public static DataSource getDataSource() {
		return basicDataSource;
	}
}

测试

package com.dbcp;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class DBCPTest2 {
	public static void main(String[] args) {
		DBCPUtils2 uti= new DBCPUtils2();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

下载C3P0地址：

package com.c3p0;

import java.beans.PropertyVetoException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Utils {

	private static ComboPooledDataSource cpds = null;

	
	public C3P0Utils() {
		cpds = new ComboPooledDataSource();
		try {
			cpds.setDriverClass("com.mysql.cj.jdbc.Driver");
			cpds.setJdbcUrl("jdbc:mysql://localhost/mydbcp?serverTimezone=GMT");
			cpds.setUser("root");
			cpds.setPassword("");

			cpds.setMinPoolSize(5);
			cpds.setMaxPoolSize(20);
			cpds.setAcquireIncrement(5);
			cpds.setInitialPoolSize(5);
			cpds.setMaxStatements(50);
			cpds.setMaxIdleTime(60);
		} catch (PropertyVetoException e) {
			e.printStackTrace();
		}

	}
	
	public static ComboPooledDataSource getDataSource() {
		return cpds;
	}
}

测试

package com.c3p0;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class C3P0Test {
	public static void main(String[] args) {
		C3P0Utils uti= new C3P0Utils();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

配置文件夹，通过 c3p0-config.xml文件进行配置，文件名不能改

	
	
		root
		root
		jdbc:mysql://localhost/mydbcp? serverTimezone=Asia/Shanghai&characterEncoding=UTF-8&useSSL=false
		
		com.mysql.cj.jdbc.Driver
		30000
		30
		5
		60
		20
		5
		50
		5
	

	
	
		Xiaopengwei
		123456
		jdbc:mysql://localhost:3306/Xiaopengwei
		
		com.mysql.jdbc.Driver
		
		5
		
		20
		
		25
		
		5
	

使用

package com.c3p0;

import java.beans.PropertyVetoException;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class C3P0Utils2 {
	private static ComboPooledDataSource cpds = null;
	
	public C3P0Utils2() {
		cpds = new ComboPooledDataSource();
	}
	
	public static ComboPooledDataSource getDataSource() {
		return cpds;
	}
}

测试

package com.c3p0;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class C3P0Test2 {
	public static void main(String[] args) {
		C3P0Utils2 uti= new C3P0Utils2();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

DbUtils是在数据库连接池基础上建立起来的快速操作数据库的工具类。

后面会用到spring JdbcTemplate、Mybatis、hibernate等框架

下载地址：

DBUtils三个核心功能介绍

-QueryRunner中提供对sql语句操作的API

• ResultSetHandler接口，用于定义select操作后，怎样封装结果集
• DBUtils类，它就是一个工具类，定义了关闭资源与事务处理的方法

QueryRunner(DataSource ds)，传入连接池，并且底层自动维护连接connection

-update（String sql，Obj...params），执行更新数据

• query（String sql，ResultSetHandler rsh,Object...panrams)，执行查询

-ArrayHandler：适合取1条记录，把结果集中的第一行数据转成对象数组。

• ArrayListHandler：适合取多条记录，把结果集中的每一行数据都转成一个对象数组，再存放到List中。
• BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中（把每条记录封装成对象，适合取一条记录）
  -BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
• MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
• MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
• KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里(Map