本篇文章借鉴博文来源：
1、 http://blog.csdn.net/shuaihj/article/details/14223015
2、 http://blog.csdn.net/q514004204/article/details/48375143
注意：
随着上班时间的增长，发现公司里面基本不会有这段代码出现，基本都引用jar里面的东西，但是原理了解一下还是有好处的。
博文目录：
（1）、早期数据库操作实现
（2）、技术演进出来的数据库连接池
（3）、连接池还要考虑的一些问题
（4）、在实际开发中，关于连接池的解决方案
（5）、一个简单可用的连接池实现工具类
一、早期数据库操作实现
1、原理：一般来说，java应用程序访问数据库的过程是：
（1）、装在数据库驱动程序；
（2）、通过jdbc建立数据库连接；
（3）、访问数据库，执行sql语句；
（4）、断开数据库连接。
2、代码
/**
* 函数功能：查询所有用户
*/
public void findAllUsers(){
//1、装载sqlserver驱动对象
DriverManager.registerDriver(new SqlServerDriver());
//2、通过JDBC简历数据库链接
Connection conn = DriverManager.getConnection("url", "user", "password");
//3、创建状态
Statement state = conn.createStatement();
//4、查询数据库并返回结果
ResultSet resultSet = state.executeQuery("sql语句");
//5、输出查询结果
while(resultSet.next()){
System.out.println(resultSet.getString("字段值"));
}
//6、断开数据库连接
resultSet.close();
state.close();
conn.close();
}上述代码只是简单的实现以下上述文字描述过程，在实际项目中基本都不会这样写，需要考虑很多其他的问题，比如说异常。
3、分析
程序开发过程中，存在很多为题：首先，每一次web请求都要建立一次数据库连接。建立链接是一个费时的活动，每次都得话费0.05s~1s的时间，而且系统还要分配内存资源。这个时间对于一次或几次数据库操作，或许感觉不出来系统有多大的开销。可是对于现在的web应用，尤其是大型电子商务网站，同事有几百甚至几千人在线是很正常的事情。在这种情况下，频繁的进行数据库连接操作势必占用很多的系统资源，网站的相应速度必定下降，严重的情况甚至会造成服务器的崩溃。不是危言耸听，这就是制约某些电子商务网站发展的技术瓶颈问题。其次，对于每一次数据库链接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将不得不重启数据库。还有，这种开发不能控制被创建的连接对象书，系统资源会被毫无顾忌的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。
上述的用户查询案例，如果同时有1000人访问，就会不断的有数据库连接、断开操作：
通过上面的分析，我们可以看出来，“数据库连接”是一种稀缺的资源，为了保障网站的正常使用，应该对其进行妥善管理。其实我们查询完数据库后，如果不关闭连接，而是展示存放起来，当别人使用时，把这个连接给他们使用。就避免了一次建立数据库链接和断开的操作时间消耗。原理如下：
二、技术演进出来的数据库连接池
由上面的分析可以看出，问题的根源就在于数据库连接资源的低效管理。我们知道，对于共享资源，有一个很著名的设计模式：资源池（resource pool）。该模式正是为了解决资源的频繁分配、释放所造成的问题。为解决上述问题，可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量、使用情况，为系统开发、测试以及性能调优提供依据。
我们自己尝试开发一个连接池，来为上面的业务提供数据库连接服务：
（1）、编写class实现DataSource接口
（2）、在class构造器一次创建10个连接，将连接保存LinkedList中
（3）、实现getConnection从LinkList中返回一个连接
（4）、提供将连接放回连接池中方法
1、连接池代码
//链表 -- 实现栈结构
private LinkedList<Connection> dataSources = new LinkedList<Connection>();
/**
* 函数功能：初始化连接数量（构造函数）
*/
public MyDataSource(){
//一次性创建10个连接
for(int i = 0; i < 10; i++){
try {
//1、装在sqlserver驱动对象
DriverManager.registerDriver(new SqlServerDriver());
//2、通过JDBC建立数据库连接
Connection connection = DriverManager.getConnection("url", "user", "password");
//3、将连接加入连接池
dataSources.add(connection);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 函数功能：取出连接池中一个连接
*/
@Override
public Connection getConnection() throws SQLException {
Connection connection = dataSources.removeFirst();//删除第一个元素（效果即得到链表上第一个元素）
return connection;
}
/**
* 函数功能：将连接放回连接池
*/
public void releaseConnection(Connection connection){
dataSources.add(connection);
}2、使用连接池重构我们在上面已经实现的业务
/**
* 使用连接池重构刚刚已经实现的业务
*/
Public void findAllUsers(){
//1、使用连接池建立数据库连接
MyDataSource dataSource = new MyDataSource();
Connection conn =dataSource.getConnection();
//2、创建状态
Statement state =con.createStatement();
//3、查询数据库并返回结果
ResultSet result =state.executeQuery("sql语句");
//4、输出查询结果
while(result.next()){
System.out.println(result.getString("字段名"));
}
//5、断开数据库连接
result.close();
state.close();
//6、归还数据库连接给连接池
dataSource.releaseConnection(conn);
} 这就是数据库连接池的原理，它大大帮助了数据库连接的利用率，减少了内存吞吐的开销。我们在开发过程中，就不需要再去关心数据库连接的问题，自然有数据库连接池帮助我们解决问题，这回就可以放心了。但是连接池需要考虑的问题不仅仅如此，下面在看看有哪些问题还需要考虑。
三、连接池还要考虑更多的问题
1、并发问题
为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题，这个问题相对比较好解决，因为java语言自身提供了对并发管理的支持，使用synchronized关键字即可确保线程是同步的（当然java 中对并发管理的解决方法有很多，关键字synchronized是一种解决办法）。使用方法为直接在类方法前面加synchronized关键字，如：
public synchronized connection getConnection();2、多数据库服务器和多用户
对于大型的企业级应用，常常需要同时连接不同的数据库（如连接Oracle和sybase）。如何连接不同的数据库那？我们采用的策略是：设计一个符合单例模式的连接池管理类，在连接池管理类的唯一实例被创建时读取一个资源文件，其中资源文件中存放着多个数据库的url地址等信息。根据资源文件提供的信息，创建多个连接池类的实例，每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字，通过不同的名字来管理不同的连接池。
对于同一个数据库有多个用户使用不同的名称和密码访问情苦啊个，也可以通过资源文件处理，即在资源文件中设置多个具有相同url地址，但是具有不同用户名和密码的数据库连接信息。
3、事务处理
我们知道，事务具有原子性，此时要求对数据库的操作符合“all-all-nothing”原则即对于一组sql语句要么全做，要么全部做。
在java语言中，connection类本身提供了对事务的支持。可以通过设置connection的autocommit属性为false，然后显示的调用commit或rollback方法来实现。但要高效的进行connection复用，就必须提供相应的事务支持机制。可采用每一个事务独占一格连接来实现，这种方法可大大降低事务管理的复杂性。
4、连接池的分配与释放
连接池的分配与释放，对系统的性能有很大的影响。合理的分配与释放，可以提高连接的复用度，从而降低建立新连接的开销，同时还可以加快用户的访问速度。
对于连接的管理可使用空闲池。即把已经创建但尚未分配出去的连接按创建时间存放到一个空闲池中。每当用户请求一个连接时，系统首先检查空闲池内有没有空闲连接。如果有就把建立时间最长（通过容器的顺序存放实现）的那个连接分配给他（实际是先做连接是否有效的判断，如果可用就分配给用户，如不可用就把这个连接从空闲池删掉，重新检测空闲池是否还有连接）；如果没有则检查当前所开连接池是否达到连接池所允许的最大连接数（maxconn）如果没有达到，就新建一个连接，如果已经达到，就等待一定的时间（timeout）。如果在等待的时间内有连接被释放出来就可以把这个连接分配给等待的用户，如果等待时间超过预定时间timeout 则返回空值（null）。系统对已经分配出去正在使用的连接只做计数，当使用完后再返还给空闲池。对于空闲连接的状态，可开辟专门的线程定时检测，这样会花费一定的系统开销，但可以保证较快的响应速度。也可采取不开辟专门线程，只是在分配前检测的方法。
5、连接池的配置与维护
连接池中到底应该放置多少连接，才能使系统的性能最佳？系统可采取设置最小连接数（minconn）和最大连接数（maxconn）来控制连接池中的连接。最小连接数是系统启动时连接池所创建的连接数。如果创建过多，则系统启动就慢，但创建后系统的响应速度会很快；如果创建过少，则系统启动的很快，响应起来却慢。这样，可以在开发时，设置较小的最小连接数，开发起来会快，而在系统实际使用时设置较大的，因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目，具体设置多少，要看系统的访问量，可通过反复测试，找到最佳点。
如何确保连接池中的最小连接数呢？有动态和静态两种策略。动态即每隔一定时间就对连接池进行检测，如果发现连接数量小于最小连接数，则补充相应数量的新连接以保证连接池的正常运转。静态是发现空闲连接不够时再去检查。
四、实际开发中有成熟的开源连接池供我们使用
理解了连接池的原理就可以了，没有必要什么都从头写一遍，那样会花费很多时间，并且性能及稳定性也不一定满足要求。事实上，已经存在很多流行的性能优良的第三方数据库连接池jar包供我们使用。如：
1.Apache commons-dbcp 连接池
下载地址：http://commons.apache.org/proper/commons-dbcp/
2.c3p0 数据库连接池
下载地址：http://sourceforge.net/projects/c3p0/
五、一个简单的数据库连接池工具类实现
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Vector;
/**
* <Description>
* 一个效果非常不错的JAVA数据库连接池.
* 虽然现在用APACHE COMMONS DBCP可以非常方便的建立数据库连接池，
* 但是像这篇文章把数据库连接池的内部原理写的这么透彻，注视这么完整，真是非常难得.
* 让开发人员可以更深层次的理解数据库连接池，真是非常感谢这篇文章的作者。
* <br>
*/
public class ConnectionPool {
private String jdbcDriver = ""; // 数据库驱动
private String dbUrl = ""; // 数据 URL
private String dbUsername = ""; // 数据库用户名
private String dbPassword = ""; // 数据库用户密码
private String testTable = ""; // 测试连接是否可用的测试表名，默认没有测试表
private int initialConnections = 10; // 连接池的初始大小
private int incrementalConnections = 5; // 连接池自动增加的大小
private int maxConnections = 50; // 连接池最大的大小
private Vector<PooledConnection> connections = null; // 存放连接池中数据库连接的向量 , 初始时为 null
public ConnectionPool(String jdbcDriver, String dbUrl, String dbUsername,String dbPassword) {
this.jdbcDriver = jdbcDriver;
this.dbUrl = dbUrl;
this.dbUsername = dbUsername;
this.dbPassword = dbPassword;
}
public int getInitialConnections() {
return this.initialConnections;
}
public void setInitialConnections(int initialConnections) {
this.initialConnections = initialConnections;
}
public int getIncrementalConnections() {
return this.incrementalConnections;
}
public void setIncrementalConnections(int incrementalConnections) {
this.incrementalConnections = incrementalConnections;
}
public int getMaxConnections() {
return this.maxConnections;
}
public void setMaxConnections(int maxConnections) {
this.maxConnections = maxConnections;
}
public String getTestTable() {
return this.testTable;
}
public void setTestTable(String testTable) {
this.testTable = testTable;
}
public synchronized void createPool() throws Exception {
// 确保连接池没有创建
// 假如连接池己经创建了，保存连接的向量 connections 不会为空
if (connections != null) {
return; // 假如己经创建，则返回
}
// 实例化 JDBC Driver 中指定的驱动类实例
Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序
// 创建保存连接的向量 , 初始时有 0 个元素
connections = new Vector<PooledConnection>();
// 根据 initialConnections 中设置的值，创建连接。
createConnections(this.initialConnections);
System.out.println(" 数据库连接池创建成功！ ");
}
private void createConnections(int numConnections) throws SQLException {
// 循环创建指定数目的数据库连接
for (int x = 0; x < numConnections; x++) {
// 是否连接池中的数据库连接的数量己经达到最大？最大值由类成员 maxConnections
// 指出，假如 maxConnections 为 0 或负数，表示连接数量没有限制。
// 假如连接数己经达到最大，即退出。
if (this.maxConnections > 0 && this.connections.size() >= this.maxConnections) {
break;
}
//add a new PooledConnection object to connections vector
// 增加一个连接到连接池中（向量 connections 中）
try {
connections.addElement(new PooledConnection(newConnection()));
} catch (SQLException e) {
System.out.println(" 创建数据库连接失败！ " + e.getMessage());
throw new SQLException();
}
System.out.println(" 数据库连接己创建 ......");
}
}
private Connection newConnection() throws SQLException {
// 创建一个数据库连接
Connection conn = DriverManager.getConnection(dbUrl, dbUsername, dbPassword);
// 假如这是第一次创建数据库连接，即检查数据库，获得此数据库答应支持的最大客户连接数目
// connections.size() == 0 表示目前没有连接己被创建
if (connections.size() == 0) {
DatabaseMetaData metaData = conn.getMetaData();
int driverMaxConnections = metaData.getMaxConnections();
// 数据库返回的 driverMaxConnections 若为 0 ，
// 表示此数据库没有最大连接限制，或数据库的最大连接限制不知道
// driverMaxConnections 为返回的一个整数，表示此数据库答应客户连接的数目
// 假如连接池中设置的最大连接数量大于数据库答应的连接数目 , 则置连接池的最大
// 连接数目为数据库答应的最大数目
if (driverMaxConnections > 0 && this.maxConnections > driverMaxConnections) {
this.maxConnections = driverMaxConnections;
}
}
return conn; // 返回创建的新的数据库连接
}
public synchronized Connection getConnection() throws SQLException {
// 确保连接池己被创建
if (connections == null) {
return null; // 连接池还没创建，则返回 null
}
Connection conn = getFreeConnection(); // 获得一个可用的数据库连接
// 假如目前没有可以使用的连接，即所有的连接都在使用中
while (conn == null) {
// 等一会再试
wait(250);
conn = getFreeConnection(); // 重新再试，直到获得可用的连接，假如
// getFreeConnection() 返回的为 null
// 则表明创建一批连接后也不可获得可用连接
}
return conn; // 返回获得的可用的连接
}
private Connection getFreeConnection() throws SQLException {
// 从连接池中获得一个可用的数据库连接
Connection conn = findFreeConnection();
if (conn == null) {
// 假如目前连接池中没有可用的连接
// 创建一些连接
createConnections(incrementalConnections);
// 重新从池中查找是否有可用连接
conn = findFreeConnection();
if (conn == null) {
// 假如创建连接后仍获得不到可用的连接，则返回 null
return null;
}
}
return conn;
}
private Connection findFreeConnection() throws SQLException {
Connection conn = null;
PooledConnection pConn = null;
// 获得连接池向量中所有的对象
Enumeration<PooledConnection> enumerate = connections.elements();
// 遍历所有的对象，看是否有可用的连接
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
if (!pConn.isBusy()) {
// 假如此对象不忙，则获得它的数据库连接并把它设为忙
conn = pConn.getConnection();
pConn.setBusy(true);
// 测试此连接是否可用
if (!testConnection(conn)) {
// 假如此连接不可再用了，则创建一个新的连接，
// 并替换此不可用的连接对象，假如创建失败，返回 null
try {
conn = newConnection();
} catch (SQLException e) {
System.out.println(" 创建数据库连接失败！ " + e.getMessage());
return null;
}
pConn.setConnection(conn);
}
break; // 己经找到一个可用的连接，退出
}
}
return conn; // 返回找到到的可用连接
}
private boolean testConnection(Connection conn) {
try {
// 判定测试表是否存在
if (testTable.equals("")) {
// 假如测试表为空，试着使用此连接的 setAutoCommit() 方法
// 来判定连接否可用（此方法只在部分数据库可用，假如不可用 ,
// 抛出异常）。注重：使用测试表的方法更可靠
conn.setAutoCommit(true);
} else { // 有测试表的时候使用测试表测试
//check if this connection is valid
Statement stmt = conn.createStatement();
stmt.execute("select count(*) from " + testTable);
}
} catch (SQLException e) {
// 上面抛出异常，此连接己不可用，关闭它，并返回 false;
closeConnection(conn);
return false;
}
// 连接可用，返回 true
return true;
}
public void returnConnection(Connection conn) {
// 确保连接池存在，假如连接没有创建（不存在），直接返回
if (connections == null) {
System.out.println(" 连接池不存在，无法返回此连接到连接池中 !");
return;
}
PooledConnection pConn = null;
Enumeration<PooledConnection> enumerate = connections.elements();
// 遍历连接池中的所有连接，找到这个要返回的连接对象
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
// 先找到连接池中的要返回的连接对象
if (conn == pConn.getConnection()) {
// 找到了 , 设置此连接为空闲状态
pConn.setBusy(false);
break;
}
}
}
public synchronized void refreshConnections() throws SQLException {
// 确保连接池己创新存在
if (connections == null) {
System.out.println(" 连接池不存在，无法刷新 !");
return;
}
PooledConnection pConn = null;
Enumeration<PooledConnection> enumerate = connections.elements();
while (enumerate.hasMoreElements()) {
// 获得一个连接对象
pConn = (PooledConnection) enumerate.nextElement();
// 假如对象忙则等 5 秒 ,5 秒后直接刷新
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
// 关闭此连接，用一个新的连接代替它。
closeConnection(pConn.getConnection());
pConn.setConnection(newConnection());
pConn.setBusy(false);
}
}
public synchronized void closeConnectionPool() throws SQLException {
// 确保连接池存在，假如不存在，返回
if (connections == null) {
System.out.println(" 连接池不存在，无法关闭 !");
return;
}
PooledConnection pConn = null;
Enumeration<PooledConnection> enumerate = connections.elements();
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
// 假如忙，等 5 秒
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
//5 秒后直接关闭它
closeConnection(pConn.getConnection());
// 从连接池向量中删除它
connections.removeElement(pConn);
}
// 置连接池为空
connections = null;
}
private void closeConnection(Connection conn) {
try {
conn.close();
} catch (SQLException e) {
System.out.println(" 关闭数据库连接出错： " + e.getMessage());
}
}
private void wait(int mSeconds) {
try {
Thread.sleep(mSeconds);
} catch (InterruptedException e) {
}
}
class PooledConnection {
Connection connection = null; // 数据库连接
boolean busy = false; // 此连接是否正在使用的标志，默认没有正在使用
// 构造函数，根据一个 Connection 构告一个 PooledConnection 对象
public PooledConnection(Connection connection) {
this.connection = connection;
}
// 返回此对象中的连接
public Connection getConnection() {
return connection;
}
// 设置此对象的，连接
public void setConnection(Connection connection) {
this.connection = connection;
}
// 获得对象连接是否忙
public boolean isBusy() {
return busy;
}
// 设置对象的连接正在忙
public void setBusy(boolean busy) {
this.busy = busy;
}
}
public static void main(String[] args) {
String driverClass = "oracle.jdbc.driver.OracleDriver";
String driverUrl = "*";
String username = "*";
String password = "*";
ConnectionPool connPool = new ConnectionPool(driverClass,driverUrl,username,password);
try {
connPool.createPool();
} catch (Exception ex) {
ex.printStackTrace();
}
try {
Connection conn = connPool.getConnection();
System.out.println(conn);
} catch (SQLException ex1) {
ex1.printStackTrace();
}
}
} 
扫一扫
2877
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
