数据库连接池技术：DBCP和C3P0
1.什么是数据库连接池
已知的方法是需要访问数据库的时候进行一次数据库的连接，对数据库操作完之后再释放这个连接，通常这样业务是缺点很明显的：
用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出，拓机。
所有，有了数据库连接池的概念，在程序启动的时候，就自动创建几个数据库连接，放在一个池子里（集合），需要用的时候从这个池子里面获取
连接池技术
连接池技术有两种，一种是自定义连接池，但是这样使用过于繁琐，不可能在每个项目都都重新定义一个连接池。第二种是使用一些开源组件，常用的数据库连接池组件有：DBCP组件和C3P0组件，下面分别讲解
2.自定义连接池
自定义连接池程序思路：
1.指定“初始化连接数目”（假设为3），在app启动的时候，就自行创建
2.指定“最大连接数”（假设为6）
3.指定“当前使用连接个数”（不能超出最大连接数）
代码逻辑：
1.dbPool.java连接池类
2.指定全局参数：初始化数目，最大连接数目，当前连接，连接池集合
3.构造函数：循环创建3个连接
4.写一个创建连接的方法
5.获取连接
- 判断：池中有连接，直接拿，如果池中没有连接再判断是否达到最大连接数
- 如果没有达到最大连接数，直接创建新连接，如果已经大多最大连接数，抛出异常
6.释放连接：连接放回集合中或者连接池已满，可以直接释放掉
代码实现：
实现过程中如果直接使用realeaseConnection(con1);来释放是没有问题的，但是如果使用close()来释放，就需要再对这个方法使用代理方法来监控close方法，如果close方法被调用，则触发另外的命令
如何对Connection对象，生成一个代理对象：
|--Proxy
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h );
ClassLoader loader, 当前使用的类加载器
Class<?>[] interfaces, 目标对象(Connection)实现的接口类型
InvocationHandler h 事件处理器：当执行上面接口中的方法的时候，就会自动触发事件处理器代码，把当前执行的方法(method)作为参数传入。
package db;
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;
/**
* 自定义连接池，管理连接池
* Created by cenyu on 16-12-18.
*/
public class dbPool {
//初始化变量
private int init_count = 3;//初始化连接池数目
private int max_count = 6;//初始化最大连接数
private int current_count = 0;//记录当前使用连接数
//连接池（存放所有的初始化连接）
private LinkedList<Connection> pool = new LinkedList<Connection>();
//1.构造函数中，初始化连接放入连接池
public dbPool(){
//初始化连接
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://db", "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;
} 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 {
dbPool pool = new dbPool();
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
}
}
2.DBCP连接池
开源数据库连接池
在java的web服务器上，都提供了DataSoruce的，即连接池实现的，sun公司规定，如果是自己写的连接池，要实现javax.sql.DataSource接口
目前使用最多的开源数据库连接池有：
- DBCP 数据库连接池(tomcat)
- C3P0 数据库连接池(hibernate)
实际应用时不需要编写连接数据库代码，直接从数据源获得数据库的连接。程序员变成时也应尽量使用这些技术，以提升程序的数据库访问性能
DBCP数据源
DBCP是Apache软件基金组织下的开源连接池实现，使用DBCO数据源
使用的时候需要导入两个jar文件
- commons-dbcp.jar：连接池的实现
- commons-pool.jar：连接池实现的依赖库
Tomcat的连接池正是采用该连接池来实现的，该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用
使用方法有两种，一种是硬编码，由于不好维护，所以不推荐，推荐使用第二种用配置文件法。
第二种配置方式实现需要注意点是：配置文件中的key与BaseDataSouce中的属性一致。(去掉set然后第一个字母小写)
代码示例：
package dao;
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.junit.Test;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
/**
* 测试DBCP数据源的使用方式
* Created by cenyu on 16-12-18.
*/
public class testDBCP {
//1.硬编码方式实现连接池
@Test
public void test1() throws SQLException {
//DBCP连接池核心类
BasicDataSource dataSource = new BasicDataSource();
//连接池参数配置：初始化参数，最大连接数/连接字符串，驱动，用户名，密码等
dataSource.setUrl("jdbc:mysql://localhost:3306/db");
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUsername("root");
dataSource.setPassword("root");
dataSource.setInitialSize(3);//初始化连接数量
dataSource.setMaxActive(6);//最大连接数量
dataSource.setMaxIdle(3000);//最大空闲时间，超过这个时间就会释放
//获取连接
Connection con = dataSource.getConnection();
con.prepareStatement("DELETE FROM Admin WHERE id =2").executeUpdate();
//关闭
con.close();
}
//2.【推荐使用】配置方式实现连接池，便于维护
@Test
public void test2() throws Exception {
//加载prop配置文件
Properties prop = new Properties();
//获取文件流
InputStream inputStream=testDBCP.class.getClassLoader().getResourceAsStream("db.properties");
//加载属性配置文件
prop.load(inputStream);
//根据prop配置，直接创建数据源对象
DataSource dataSource = BasicDataSourceFactory.createDataSource(prop);
//获取连接
Connection con = dataSource.getConnection();
con.prepareStatement("DELETE FROM Admin WHERE id =4").executeUpdate();
//关闭
con.close();
}
}
3.C3P0连接池
C3P0连接池组件是最常用的连接池技术，Spring框架默认是支持C3P0连接池技术的。
C3P0连接池的核心类：
CombopooledDataSource ;
使用方法：
1.下载，引入jar文件：c3p0-0.9.1.2.jar
2.使用连接池，创建连接
- a.硬编码方法
- b.配置方式(xml配置)
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.ConcurrentNavigableMap;
/**
* 使用C3P0连接池技术的两种方法
* Created by cenyu on 16-12-18.
*/
public class testC3P0 {
//1.硬编码方式，使用c3p0连接池管理连接
@Test
public void testCode() throws Exception {
//创建连接池核心工具类
ComboPooledDataSource dataSource=new ComboPooledDataSource();
//设置连接参数：url、驱动、用户密码、初始连接数、最大连接数
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db");
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setUser("root");
dataSource.setPassword("root");
dataSource.setInitialPoolSize(3);
dataSource.setMaxPoolSize(6);
dataSource.setMaxIdleTime(1000);
//从连接池对象中，获取连接对象
Connection conn = dataSource.getConnection();
//执行跟新
conn.prepareStatement("DELETE FROM Admin WHERE id=1").executeUpdate();
//关闭
conn.close();
}
//2.xml配置方式，使用c3p0连接池管理连接
@Test
public void testXML() throws Exception{
//创建C3P0连接核心工具类
//自动加载src下c3p0的配置文件【c3p0-config.xml】
ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");//使用mysql的配置
//获取连接
Connection conn = dataSource.getConnection();
//执行连接
conn.prepareStatement("delete from Admin where id=3").executeUpdate();
//关闭
conn.close();
}
}
c3p0-config.xml配置文件修改之后放在项目src的根目录下就可以了，编译之后会把这个文件编译到WEB-INF/classes下的
常用的配置文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<!-- This is default config! -->
<default-config>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
<property name="maxStatements">200</property>
</default-config>
<!-- This is my config for mysql-->
<named-config name="mysql">
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
<property name="user">root</property>
<property name="password"></property>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
<property name="maxStatements">200</property>
</named-config>
<!-- This is my config for oracle -->
<named-config name="oracle">
<property name="driverClass">oracle.jdbc.driver.OracleDriver</property>
<property name="jdbcUrl">jdbc:oracle:thin:@localhost:1521:orcl</property>
<property name="user">scott</property>
<property name="password">liang</property>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
<property name="maxStatements">200</property>
</named-config>
</c3p0-config>