原文出处:http://blog.csdn.net/grland/article/details/2008717
Java应用程序访问数据库的基本原理
在Java语言中，JDBC（Java DataBase Connection）是应用程序与数据库沟通的桥梁,
即Java语言通过JDBC技术访问数据库。JDBC是一种“开放”的方案，它为数据库应用开发人员﹑数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。JDBC提供两种API，分别是面向开发人员的API和面向底层的JDBC驱动程序API，底层主要通过直接的JDBC驱动和JDBC-ODBC桥驱动实现与数据库的连接。
一般来说，Java应用程序访问数据库的过程（如图1所示）是：
①装载数据库驱动程序；
②通过JDBC建立数据库连接；
③访问数据库，执行SQL语句；
④断开数据库连接。
图1 Java数据库访问机制
JDBC作为一种数据库访问技术，具有简单易用的优点。但使用这种模式进行Web应用
程序开发，存在很多问题：首先，每一次Web请求都要建立一次数据库连接。建立连接是一个费时的活动，每次都得花费0.05s～1s的时间，而且系统还要分配内存资源。这个时间对于一次或几次数据库操作，或许感觉不出系统有多大的开销。可是对于现在的Web应用，尤其是大型电子商务网站，同时有几百人甚至几千人在线是很正常的事。在这种情况下，频繁的进行数据库连接操作势必占用很多的系统资源，网站的响应速度必定下降，严重的甚至会造成服务器的崩溃。不是危言耸听，这就是制约某些电子商务网站发展的技术瓶颈问题。其次，对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将不得不重启数据库。还有，这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。
数据库连接池（connection pool）的工作原理
1、基本概念及原理
由上面的分析可以看出，问题的根源就在于对数据库连接资源的低效管理。我们知道，
对于共享资源，有一个很著名的设计模式：资源池（Resource Pool）。该模式正是为了解决资源的频繁分配﹑释放所造成的问题。为解决上述问题，可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量﹑使用情况，为系统开发﹑测试及性能调整提供依据。连接池的基本工作原理见下图2。
图2 连接池的基本工作原理
2、服务器自带的连接池
JDBC的API中没有提供连接池的方法。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制，但是必须有其第三方的专用类方法支持连接池的用法。
连接池关键问题分析
1、并发问题
为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题。这个问题相对比较好解决，因为Java语言自身提供了对并发管理的支持，使用synchronized关键字即可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字，如：
public synchronized Connection getConnection（）
2、多数据库服务器和多用户
对于大型的企业级应用，常常需要同时连接不同的数据库（如连接Oracle和Sybase）。如何连接不同的数据库呢？我们采用的策略是：设计一个符合单例模式的连接池管理类，在连接池管理类的唯一实例被创建时读取一个资源文件，其中资源文件中存放着多个数据库的url地址（<poolName.url>）﹑用户名（<poolName.user>）﹑密码（<poolName.password>）等信息。如tx.url=172.21.15.123：5000/tx_it，tx.user=yang，tx.password=yang321。根据资源文件提供的信息，创建多个连接池类的实例，每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字，通过不同的名字来管理不同的连接池。
对于同一个数据库有多个用户使用不同的名称和密码访问的情况，也可以通过资源文件处理，即在资源文件中设置多个具有相同url地址，但具有不同用户名和密码的数据库连接信息。
3、事务处理
我们知道，事务具有原子性，此时要求对数据库的操作符合“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全做，要么全不做。
在Java语言中，Connection类本身提供了对事务的支持，可以通过设置Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来实现。但要高效的进行Connection复用，就必须提供相应的事务支持机制。可采用每一个事务独占一个连接来实现，这种方法可以大大降低事务管理的复杂性。
4、连接池的分配与释放
连接池的分配与释放，对系统的性能有很大的影响。合理的分配与释放，可以提高连接的复用度，从而降低建立新连接的开销，同时还可以加快用户的访问速度。
对于连接的管理可使用空闲池。即把已经创建但尚未分配出去的连接按创建时间存放到一个空闲池中。每当用户请求一个连接时，系统首先检查空闲池内有没有空闲连接。如果有就把建立时间最长（通过容器的顺序存放实现）的那个连接分配给他（实际是先做连接是否有效的判断，如果可用就分配给用户，如不可用就把这个连接从空闲池删掉，重新检测空闲池是否还有连接）；如果没有则检查当前所开连接池是否达到连接池所允许的最大连接数（maxConn）,如果没有达到，就新建一个连接，如果已经达到，就等待一定的时间（timeout）。如果在等待的时间内有连接被释放出来就可以把这个连接分配给等待的用户，如果等待时间超过预定时间timeout,则返回空值（null）。系统对已经分配出去正在使用的连接只做计数，当使用完后再返还给空闲池。对于空闲连接的状态，可开辟专门的线程定时检测，这样会花费一定的系统开销，但可以保证较快的响应速度。也可采取不开辟专门线程，只是在分配前检测的方法。
5、连接池的配置与维护
连接池中到底应该放置多少连接，才能使系统的性能最佳？系统可采取设置最小连接数（minConn）和最大连接数（maxConn）来控制连接池中的连接。最小连接数是系统启动时连接池所创建的连接数。如果创建过多，则系统启动就慢，但创建后系统的响应速度会很快；如果创建过少，则系统启动的很快，响应起来却慢。这样，可以在开发时，设置较小的最小连接数，开发起来会快，而在系统实际使用时设置较大的，因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目，具体设置多少，要看系统的访问量，可通过反复测试，找到最佳点。
如何确保连接池中的最小连接数呢？有动态和静态两种策略。动态即每隔一定时间就对连接池进行检测，如果发现连接数量小于最小连接数，则补充相应数量的新连接,以保证连接池的正常运转。静态是发现空闲连接不够时再去检查。
连接池的实现
1、连接池模型
本文讨论的连接池包括一个连接池类（DBConnectionPool）和一个连接池管理类（DBConnetionPoolManager）。连接池类是对某一数据库所有连接的“缓冲池”，主要实现以下功能：①从连接池获取或创建可用连接；②使用完毕之后，把连接返还给连接池；③在系统关闭前，断开所有连接并释放连接占用的系统资源；④还能够处理无效连接（原来登记为可用的连接，由于某种原因不再可用，如超时，通讯问题），并能够限制连接池中的连接总数不低于某个预定值和不超过某个预定值。
连接池管理类是连接池类的外覆类（wrapper）,符合单例模式，即系统中只能有一个连接池管理类的实例。其主要用于对多个连接池对象的管理，具有以下功能：①装载并注册特定数据库的JDBC驱动程序；②根据属性文件给定的信息，创建连接池对象；③为方便管理多个连接池对象，为每一个连接池对象取一个名字，实现连接池名字与其实例之间的映射；④跟踪客户使用连接情况，以便需要是关闭连接释放资源。连接池管理类的引入主要是为了方便对多个连接池的使用和管理，如系统需要连接不同的数据库，或连接相同的数据库但由于安全性问题，需要不同的用户使用不同的名称和密码。
2、连接池实现
//DbConnPool.java数据库连接池具体实现类
package com.pcedu.shangyt.pool;
import java.util.*;
import java.sql.*;
public class DbConnPool {
private String dbUserName;
private String dbPassWord;
private String dbConnUrl;
private int maxConn;
private int checkedOut;//当前连接数
private ArrayList<Connection> freeConn;
/*
* 初始化连接池
*/
public DbConnPool(String dbUserName, String dbPassWord, String dbConnUrl, int maxConn) {
super();
// TODO Auto-generated constructor stub
this.dbUserName = dbUserName;
this.dbPassWord = dbPassWord;
this.dbConnUrl = dbConnUrl;
this.maxConn = maxConn;
this.freeConn=new ArrayList();
}
/*
*
* 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接
* 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
* 然后递归调用自己以尝试新的可用连接.
*/
public synchronized Connection getDbConn()
{
Connection conn=null;
if(freeConn.size()>0)
{
conn=freeConn.get(0);
freeConn.remove(0);
try {
if(conn.isClosed())
{
conn=getDbConn();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else if(maxConn==0||checkedOut<maxConn)
{
conn=newDbConn();
}
if(conn!=null){
checkedOut++;
}
return(conn);
}
/*
* 从连接池获取可用连接.可以指定客户程序能够等待的最长时间
*/
public synchronized Connection getDbConn(long timeout)
{
long starttime=System.currentTimeMillis();
Connection conn;
while((conn=getDbConn())==null)
{
try {
wait(timeout);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(System.currentTimeMillis()-starttime>=timeout)
{
return null;
}
}
return conn;
}
public synchronized Connection newDbConn()
{
Connection conn=null;
try{
if(this.dbUserName==null)
{
conn=DriverManager.getConnection(this.dbConnUrl);
}
else
{
conn=DriverManager.getConnection(this.dbConnUrl,this.dbUserName,this.dbPassWord);
}
}catch(SQLException ex){
ex.printStackTrace();
}
return conn;
}
/**
* 将不再使用的连接返回给连接池
*
* @param con 客户程序释放的连接
*/
public synchronized void freeDBConnection(Connection conn){
freeConn.add(conn);
checkedOut--;
notifyAll(); //重新启动wait（）所在的函数
}
/*
* 关闭所有的连接
*/
public synchronized void release(){
Iterator<Connection> iter=freeConn.iterator();
Connection conn;
while(iter.hasNext()){
try{
conn=iter.next();
conn.close();
}catch(SQLException ex){
ex.printStackTrace(); }
}
while(iter.hasNext())
{
freeConn.remove(iter.next());
}
}
}
//外观模式+单例模式的封装做为连接池类的子接口便于操作
package com.pcedu.shangyt.pool;
import java.sql.*;
import java.util.*;
import java.io.*;
/*
* 使用Fa?ade模式+单例模式实现数据库连接池技术
*
*/
public class DbConnFacade {
private static DbConnFacade instance=null;
private DbConnPool pool;
private int client;
private Properties dbProps;
ArrayList drivers;
public DbConnFacade()
{
}
public void init()
{drivers=new ArrayList();
InputStream is=this.getClass().getResourceAsStream("db.properties");
try{
dbProps=new Properties();
dbProps.load(is);
}catch(Exception ex){
System.out.println("Miss Resource File "+ex.getMessage());
}
loadDriver();
createPool();
}
public void loadDriver(){
String driverClasses=dbProps.getProperty("dbDriver");
StringTokenizer st =new StringTokenizer(driverClasses);
while(st.hasMoreElements()){
String driverClassName=st.nextToken().trim();
try{
Driver driver=(Driver)Class.forName(driverClassName).newInstance();
DriverManager.registerDriver(driver);
drivers.add(driver);
}catch(Exception ex){
ex.printStackTrace();
}
}
}
public void createPool(){
String userName=dbProps.getProperty("dbUserName");
String password=dbProps.getProperty("dbPassword");
String url=dbProps.getProperty("connectionURL");
int maxConn;
try{
maxConn=Integer.valueOf(dbProps.getProperty("maxConnection","0")).intValue();
}catch(NumberFormatException ex){
maxConn=0;
}
pool=new DbConnPool(userName,password,url,maxConn);
} //parse the file, load username,password,url and maxconnection in
public synchronized int getClientCount(){
return(client);
}
//facade外观模式
public Connection getDBConn(){
if(pool != null){
return(pool.getDbConn());
}
return(null);
}
public Connection getDbConn(long timeout){
if(pool != null){
return(pool.getDbConn(timeout));
}
return(null);
}//act as facade
public synchronized void freeDBConnection(Connection conn){
if(pool != null){
pool.freeDBConnection(conn);
}
}//act as facade
public void release(){
if(this.client != 0){
return;
}
if(pool != null){
pool.release();
Iterator iter=drivers.iterator();
while(iter.hasNext()){
Driver driver=(Driver)iter.next();
try{
DriverManager.deregisterDriver(driver);
}catch(Exception ex){
System.out.println("Can not deregister driver "+driver.getClass().getName());
}
}
}
}
}