J2EE开发技术点5：Tomcat jdbc pool

前言

数据库连接是一种昂贵的资源，当有多个用户访问网页的时候，对程序的性能与稳定性都有要求。数据库连接池就是为了解决这个问题的，数据库连接池负责创建、管理并释放连接。连接池中的连接可以被多个程序使用，这样就降低了创建数据库连接的开销。数据库连接池的原理也很简单，就是首先在内存存放一定数量的数据库连接，当请求的时候就从连接池中获取一个连接，该请求用完数据库连接后就会释放，于是这个连接就可以被其他程序请求。可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等。

自己实现一个数据库连接池

目前主流的数据库连接池有dbcp、c3p0和proxool。其实现原理与上面都差不多，为了更好理解数据库连接池，我们手写一个连接池：

package cp;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class ConnectoinPool {

//存放Connection对象的集合
private List<Connection> cons = null;
private String driver = null;
private String url = null;
private String user = null;
private String password = null;
//连接池中连接的索引
private int index = 0;
//数据库连接池中默认大小
private int size = 5;

public ConnectoinPool(){
try {
init();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

public ConnectoinPool(int size) {
this.size = size;
try {
init();
} catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

//初始化
private void init() throws SQLException, ClassNotFoundException, IOException{
this.cons = new ArrayList<Connection>();
parseProperties();
Class.forName(driver);
for(int i=0;i<size;i++){
Connection con = DriverManager.getConnection(url,user,password);
cons.add(con);
}
}

//读取properties文件的信息
private void parseProperties() throws IOException {
Properties p = new Properties();
InputStream in = getClass().getResourceAsStream("/db.properties");
p.load(in);
if(p.containsKey("driver")){
driver = p.getProperty("driver");
}
if(p.containsKey("url")){
url = p.getProperty("url");
}
if(p.containsKey("user")){
user = p.getProperty("user");
}
if(p.containsKey("password")){
password = p.getProperty("password");
}
}

//获取连接
public Connection getConnection(){
Connection con = cons.remove(size-1-index++);
return con;
}

//释放连接
public void release(Connection con) throws SQLException{
cons.add(con);
index--;
con.close();
}

}

创建db.properties配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost/test?useUnicode=true&charset=utf8
user=root
password=1234

然后编写主程序测试各功能是否正常：

package cp;

import java.sql.Connection;
import java.sql.SQLException;
public class TestCp {
public static void main(String[] args) throws SQLException {
// 创建一个数据库连接池
ConnectoinPool cp = new ConnectoinPool();
// 获取一个连接
Connection con1 = cp.getConnection();
System.out.println(con1);
//释放这个连接
cp.release(con1);
// 获取一个连接
Connection con2 = cp.getConnection();
System.out.println(con2);
// 获取一个连接
Connection con3 = cp.getConnection();
System.out.println(con3);
// 获取一个连接
Connection con4 = cp.getConnection();
System.out.println(con4);
// 获取一个连接
Connection con5 = cp.getConnection();
System.out.println(con5);
// 获取一个连接
Connection con6 = cp.getConnection();
System.out.println(con6);
}
}

可以发现，默认连接池有5个连接对象，在释放第一个连接后，连接池仍然有5个连接，所以在程序中创建第6个连接的时候没有报错。

当然这个程序问题很多，比如不能高访问量的情况，而且是单线程的。实际情况应该是，当用户请求一个连接的时候应该创建一个线程处理，这个线程决定该连接何时释放给连接池。通过上面的简单程序，知道了连接池管理数据库连接的原理。下面我们再看看第三方的数据库连接池的使用。

Tomcat7 jdbc pool

要知道在Tomcat7以前的版本中，使用的都是dbcp连接池，但是这个连接池bug太多，Hibernate官方宣布已经不再支持dbcp连接池dbcp连接池的主要问题：

dbcp 是单线程的，为了保证线程安全会锁整个连接池

jdk1.6编译有问题

结构太复杂

而jdbc pool在克服以上缺点的情况下，还增加了许多优良特性，详情请看这里

其中涉及的异步方式获取连接暂时还不懂，先来学习一下如何在独立的应用中获取连接。首先需要导入Tomcat7官方给的两个jar包：

tomcat-juli.jar（Tomcat的日志模块，在bin目录下）

tomcat-jdbc.jar（jdbc pool连接池，在lib目录下）

package cp;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import org.apache.tomcat.jdbc.pool.DataSource;
import org.apache.tomcat.jdbc.pool.PoolProperties;

public class TomcatJdbcPool {

private String driver = null;
private String url = null;
private String user = null;
private String password = null;
private DataSource datasource = null;

public TomcatJdbcPool() {
this.datasource = new DataSource();
try {
parseProperties();
initPoolProperties();
} catch (IOException e) {
e.printStackTrace();
}
}

// 读取properties文件的信息
private void parseProperties() throws IOException {
Properties p = new Properties();
InputStream in = getClass().getResourceAsStream("/db.properties");
p.load(in);
if (p.containsKey("driver")) {
driver = p.getProperty("driver");
}
if (p.containsKey("url")) {
url = p.getProperty("url");
}
if (p.containsKey("user")) {
user = p.getProperty("user");
}
if (p.containsKey("password")) {
password = p.getProperty("password");
}
}

private void initPoolProperties() {
PoolProperties p = new PoolProperties();
p.setUrl(url); // url
p.setDriverClassName(driver); // 驱动
p.setUsername(user); // 用户名
p.setPassword(password); // 密码
p.setJmxEnabled(true); // 通过JMX注册连接池
p.setTestWhileIdle(false); // 被空闲对象使用的时候连接是否有效
p.setTestOnBorrow(true); // 在被对象拿走之前连接是否有效
p.setValidationQuery("SELECT 1"); // 测试是否为有效连接
p.setTestOnReturn(false); // 连接返回连接池之前是否有效
p.setTimeBetweenEvictionRunsMillis(30000); // 验证线程与清除线程之间的毫秒数
p.setMaxActive(100); // 最大的活动的连接数
p.setInitialSize(10); // 初始化连接池大小
p.setMaxWait(10000); // 连接池等待连接返回的最长时间
p.setRemoveAbandonedTimeout(60); // 设置废弃连接被移除之前的毫秒数
p.setMinIdle(10); // 最小空闲连接数
p.setLogAbandoned(true); // 标记废弃连接的堆栈跟踪
p.setRemoveAbandoned(true); // 超时后是否可以移除连接
p.setJdbcInterceptors("org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;"
+ "org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer");
// jdbc拦截器
datasource.setPoolProperties(p); // 设置p到数据源中
}

public Connection getTomcatJdbcPoolConnection() {
Connection con = null;
try {
con = datasource.getConnection(); // 通过数据源获取连接
Statement st = con.createStatement();
ResultSet rs = st.executeQuery("select * from user");
int cnt = 1;
while (rs.next()) {
System.out.println((cnt++) + ". Host:" + rs.getString("Host")
+ " User:" + rs.getString("User") + " Password:"
+ rs.getString("Password"));
}
rs.close();
st.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (con != null)
try {
con.close();
} catch (Exception ignore) {
}
}
return con;
}
}

运行结果如下：



jdbc pool 小结

使用这个数据库连接池主要就是设置相关属性，再通过数据源就可以获取连接对象了。由于进行了封装处理，所以不需要自己释放连接。这里通过properties资源文件设置数据库相关的连接属性，这样做的目的不需要修改源代码，提高程序的健壮性。