Java数据库连接池,jdbc数据库连接池总括

转发过来的,方今在做贰个小网址,计划选拔这种措施。

  1. 引言

 

  近日,随着Internet/Intranet建网技巧的火速发展和在世界范围内的便捷广泛,计算机

 

  应用程序已从观念的桌面应用转到Web应用。基于B/S(Browser/Server)架构的3层开拓格局逐步替代C/S(Client/Server)架构的开垦形式,成为开支公司级应用和电子商务普及运用的技能。在Web应用开垦的最先,首要使用的本事是CGI﹑ASP﹑PHP等。之后,Sun公司推出了基于Java语言的Servlet+Jsp+JavaBean本事。比较守旧的开拓技艺,它富有跨平台﹑安全﹑有效﹑可移植等特点,那使其更利于使用和付出。

Java
jdbc数据库连接池总结!

  Java应用程序访谈数据库的基本原理

  1. 引言

  在Java语言中,JDBC(Java DataBase
Connection)是应用程序与数据库交换的大桥,

  近期,随着Internet/Intranet建网本事的连忙发展和在世界范围内的快捷推广,Computer

  即Java语言通过JDBC技艺访谈数据库。JDBC是一种“开放”的方案,它为数据库应用开拓人士﹑数据库前台工具开垦人士提供了一种标准的应用程序设计接口,使开拓人士可以用纯Java语言编写完整的数据库应用程序。JDBC提供三种API,分别是面向开荒人士的API和面向底层的JDBC驱动程序API,底层重要通过直接的JDBC驱动和JDBC-ODBC桥驱动达成与数据库的连年。

  应用程序已从守旧的桌面应用转到Web应用。基于B/S(Browser/Server)架构的3层开辟方式日渐代替C/S(Client/Server)架构的开采形式,成为开支公司级应用和电子商务遍布选用的技术。在Web应用开荒的早期,主要使用的技艺是CGIASPPHP等。之后,Sun公司生产了依据Java语言的Servlet+Jsp+JavaBean技能。比较守旧的开垦技艺,它具有跨平台﹑安全﹑有效﹑可移植等特征,那使其更利于使用和支出。

  平日的话,Java应用程序访谈数据库的进程(如图1所示)是:

  Java应用程序访谈数据库的基本原理

  ①装载数据库驱动程序;

  在Java语言中,JDBC(Java DataBase
Connection)是应用程序与数据库交流的桥梁,

  ②经过JDBC营造数据库连接;

  即Java语言通过JDBC技能访谈数据库。JDBC是一种“开放”的方案,它为数据库应用开拓职员﹑数据库前台工具开辟人士提供了一种规范的应用程序设计接口,使开拓职员能够用纯Java语言编写完整的数据库应用程序。JDBC提供三种API,分别是面向开垦人员的API和面向底层的JDBC驱动程序API,底层主要通过间接的JDBC驱动和JDBC-ODBC桥驱动达成与数据库的连接。

  ③做客数据库,实践SQL语句;

  日常的话,Java应用程序访谈数据库的经过(如图1所示)是:

  ④断开数据库连接。

  ①装载数据库驱动程序;

  JDBC作为一种数据库访问本事,具备简易易用的长处。但采纳这种形式实行Web应用

  ②经过JDBC创设数据库连接;

  程序支付,存在好些个难点:首先,每一回Web央浼都要树立三回数据库连接。创立连接是一个困难的位移,每一次都得开销0.05s~1s的时刻,并且系统还要分配内部存款和储蓄器能源。那几个时刻对于一遍或四遍数据库操作,也许以为不出系统有多大的开支。但是对于后日的Web应用,特别是大型电子商务网址,同期有几百人竟是几千人在线是很健康的事。在这种情状下,频仍的进行数据库连接操作必然占用相当多的系统能源,网址的响应速度必定下落,严重的以至会导致服务器的倒台。不是危言耸听,那就是制约某个电子商务网址发展的手艺瓶颈难题。其次,对于每一遍数据库连接,使用完后都得断开。不然,要是程序出现十分而无法关闭,将会促成数据库系统中的内部存款和储蓄器泄漏,最终将只好重启数据库。还应该有,这种支付无法说了算被成立的连接对象数,系统财富会被毫无顾及的分配出去,如连续过多,也说不定变成内部存款和储蓄器泄漏,服务器崩溃。

  ③访问数据库,实行SQL语句;

 

  ④断开数据库连接。

  数据库连接池(connection pool)的办事原理

图片 1
图1 Java数据库访谈机制

  1、基本概念及原理
由地点的分析能够看见,难题的根源就在于对数据库连接能源的不算管理。我们精通,

  JDBC作为一种数据库访谈本领,具备简易易用的亮点。但使用这种格局打开Web应用

  对于分享财富,有贰个很著名的设计情势:财富池(Resource
Pool)。该情势正是为了缓慢解决财富的一再分配﹑释放所产生的主题素材。为消除上述难点,能够运用数据库连接池才能。数据库连接池的为主思量正是为数据库连接构造建设一个“缓冲池”。预先在缓冲池中放入一定数额的一而再,当必要建构数据库连接时,只需从“缓冲池”中抽取二个,使用达成之后再放回去。大家能够透过设定连接池最辛辛那提接数来防护系统数不完的与数据库连接。更为首要的是我们能够通过连接池的管理机制监视数据库的连接的数目﹑使用状态,为系统开荒﹑测量试验及品质调节提供基于。

  程序支付,存在不菲难题:首先,每叁次Web央浼都要建构二回数据库连接。创设连接是三个辛苦的运动,每一次都得开支0.05s~1s的时日,并且系统还要分配内部存款和储蓄器资源。那几个时辰对于一回或两遍数据库操作,也许认为不出系统有多大的开支。可是对于今日的Web应用,特别是大型电子商务网站,同期有几百人竟然几千人在线是很健康的事。在这里种景况下,频仍的开展数据库连接操作必然占用非常多的系统能源,网址的响应速度必定下降,严重的照旧会变成服务器的咽气。不是心有余悸,那正是制约某个电子商务网址发展的手艺瓶颈难点。其次,对于每三遍数据库连接,使用完后都得断开。否则,要是程序出现非常而不可能关闭,将会导致数据库系统中的内部存款和储蓄器泄漏,最终将不得不重启数据库。还应该有,这种支付不能够操纵被创立的连天对象数,系统财富会被毫无顾及的分配出去,如一连过多,也大概引致内部存款和储蓄器泄漏,服务器崩溃。

  2、服务器自带的连接池

 

  JDBC的API中未有提供连接池的主意。一些巨型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制,可是必须有其第三方的专项使用类措施援助连接池的用法。

  数据库连接池(connection pool)的行事规律

  连接池关键难点解析

  1、基本概念及原理
由地点的深入分析能够见见,难题的起点就在于对数据库三番两次能源的不行管理。大家通晓,

  1、并发难点

  对于分享能源,有三个很著名的设计情势:财富池(Resource
Pool)。该格局就是为了化解能源的累累分配﹑释放所形成的问题。为化解上述难点,能够行使数据库连接池本领。数据库连接池的基本观念正是为数据库连接创立叁个“缓冲池”。预先在缓冲池中放入一定数额的总是,当必要创设数据库连接时,只需从“缓冲池”中抽出三个,使用完成之后再放回去。我们能够透过设定连接池最菲尼克斯接数来幸免系统数不胜数的与数据库连接。更为主要的是大家能够经过连接池的处理机制监视数据库的连年的多寡﹑使用情形,为系统开拓﹑测量试验及品质调度提供基于。连接池的着力职业规律见下图2。

  为了使连接管理服务具备最大的通用性,必需考虑二十四线程意况,即出现难题。这么些问题相对比较好化解,因为Java语言本人提供了对出现管理的支撑,使用synchronized关键字就能够确认保障线程是一块的。使用方式为直接在类方式前面加上synchronized关键字,如:

图片 2
图2 连接池的着力职业原理

public synchronized Connection getConnection()

  2、服务器自带的连接池

  2、好些个据库服务器和多顾客

  JDBC的API中平素不提供连接池的措施。一些重型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制,可是必得有其第三方的专项使用类措施协理连接池的用法。

  对于大型的小卖部级应用,平时供给同期连接分化的数据库(如连接Oracle和Sybase)。怎样连接不一样的数据库呢?大家运用的国策是:设计三个顺应单例情势的连接池管理类,在连接池管理类的独一实例被创设时读取贰个财富文件,在那之中财富文件中贮存着七个数据库的url地址(<poolName.url>)﹑顾客名(<poolName.user>)﹑密码(<poolName.password>)等新闻。如tx.url=192.168.1.123:四千/tx_it,tx.user=cyl,tx.password=123456。根据财富文件提供的音信,成立多少个两次三番池类的实例,每多个实例都以一个一定数据库的连接池。连接池处理类实例为各种连接池实例取三个名字,通过分歧的名字来处理区别的连接池。

  连接池关键难题分析

  对于同多少个数据库有四个客户选拔不一样的称呼和密码访谈的景况,也得以由此能源文件处理,即在能源文件中安装多少个具备一样url地址,但具有分裂客户名和密码的数据库连接新闻。

  1、并发难点

  3、事务管理

  为了使连接管理服务具备最大的通用性,必得思量二十八线程情状,即出现难点。那么些难点相对相比较好消除,因为Java言语自身提供了对出现管理的扶助,使用synchronized关键字就可以确认保障线程是三只的。使用方法为直接在类措施前边加上synchronized关键字,如:

  大家领略,事务有着原子性,此时要求对数据库的操作符合“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全做,要么全不做。
在Java语言中,Connection类本人提供了对事情的支撑,能够通过安装Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来贯彻。但要高效的打开Connection复用,就无法不提供相应的业务扶助机制。可选拔每多少个职业独占三个连连来完毕,这种办法能够大大收缩事务管理的琐碎。

public synchronized Connection getConnection()

  4、连接池的分配与自由

  2、好多据库服务器和多顾客

  连接池的分配与自由,对系统的天性有不小的影响。合理的分红与自由,能够拉长连接的复开销,进而减少建立新连接的付出,同失常候还足以加快客户的访谈速度。

  对于大型的集团级应用,平常需求同期连接不一样的数据库(如三番两次OracleSybase)。怎么样连接不一样的数据库呢?大家采纳的计划是:设计八个切合单例形式的连接池管理类,在连接池管理类的独步天下实例被创立时读取五个能源文件,当中财富文件中贮存着多少个数据库的url地址(<poolName.url>)﹑顾客名(<poolName.user>)﹑密码(<poolName.password>)等信息。如tx.url=192.168.1.123:陆仟/tx_it,tx.user=cyl,tx.password=123456。依据财富文件提供的音信,成立多个三番五次池类的实例,每三个实例都以贰个特定数据库的连接池。连接池管理类实例为各个连接池实例取一个名字,通过差异的名字来保管分歧的连接池。

  对于三番五次的管制可使用空闲池。即把曾经创办但尚未分配出去的连天按创造时间存放到五个空闲池中。每当顾客乞请三个总是时,系统率先检查空闲池内有未有空余连接。假诺有就把建立时间最长(通过容器的依次贮存达成)的至极连接分配给她(实际是先做连接是或不是可行的推断,借使可用就分配给客户,如不可用就把这些三回九转从空闲池删掉,重新检查实验空闲池是或不是还恐怕有连接);若无则检查当前所开连接池是不是到达连接池所允许的最艾哈迈达巴德接数(maxConn),若无高达,就新建二个接连,假若已经实现,就等候一定的小运(timeout)。假使在等候的年月内有再而三被释放出来就足以把这一个连续分配给等待的顾客,就算等待时间当先预约时间timeout,则赶回空值(null)。系统对已经分配出去正在接纳的接连只做计数,当使用完后再返还给空闲池。对于空闲连接的意况,可开采特地的线程按时检查评定,那样会费用一定的系统开垦,但能够保障十分的快的响应速度。也可采取不开辟特意线程,只是在分配前检查评定的措施。

  对于同八个数据库有三个顾客接纳差异的称谓和密码访谈的情况,也能够由此能源文件管理,即在能源文件中设置多少个拥有同等url地址,但持有不一样客户名和密码的数据库连接音信。

  5、连接池的布局与保安

  3、事务管理

  连接池中毕竟应该放置多少连接,能力使系统的质量最好?系统可使用安装最小连接数(minConn)和最明斯克接数(maxConn)来支配连接池中的连接。最小连接数是系统运维时连接池所开创的连接数。要是创立过多,则系统运转就慢,但创立后系统的响应速度会相当的慢;如果创立过少,则系统运营的短平快,响应起来却慢。那样,可以在开拓时,设置十分小的一丝一毫连接数,开辟起来会快,而在系统实际运用时设置比较大的,因为如此对拜见客商来讲速度会快些。最地拉那接数是连接池中允许连接的最大数目,具体设置有个别,要看系统的访谈量,可透过一再测试,找到最棒点。

  大家了然,事务有着原子性,此时供给对数据库的操作相符“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全做,要么全不做。
Java语言中,Connection类本身提供了对作业的支撑,可以经过安装Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来促成。但要高效的拓宽Connection复用,就必需提供相应的事务支持机制。可应用每二个事务独占三个总是来贯彻,这种措施能够大大裁减事务管理的复杂性。

  怎么样保障连接池中的最小连接数呢?有动态和静态两种政策。动态即每间距一定期间就对连接池进行检查测验,假设开掘三番五次数量低于最小连接数,则补充相应数据的新连接,以确定保证连接池的常规运营。静态是发现没事连接远远不够时再去反省。
连接池的贯彻

  4、连接池的分红与释放

  1、连接池模型

  连接池的分配与释放,对系统的习性有十分的大的熏陶。合理的分配与自由,能够进步连接的复耗费,进而减弱创立新连接的支出,同有时间还足以加快客户的访谈速度。

  本文钻探的连接池包蕴贰个老是池类(DBConnectionPool)和八个连接池管理类(DBConnetionPoolManager)和四个陈设文件操作类(ParseDSConfig)。连接池类是对某一数据库全体连接的“缓冲池”,主要完结以下功效:①从连接池获取或创办可用连接;②选取实现之后,把连接返还给连接池;③在系统关闭前,断开全体连接并释放连接占用的系统财富;④仍可以够够处理无效连接(原来登记为可用的连接,由于某种原因不再可用,如超时,通信难题),并能够范围连接池中的连接总的数量十分的大于有个别预订值和不超过有些预订值。(5)当比比较多据库时,且数据库是动态扩充的话,将会加到配置文件中。

  对于连日来的管理可采纳空闲池。即把曾经创办但从未分配出去的延续按创设时间贮存到三个空闲池中。每当客户伏乞三个三翻五次时,系统第一检查空闲池内有未有空闲连接。假设有就把树马上间最长(通过容器的次第存放达成)的特别连接分配给她(实际是先做连接是还是不是行得通的论断,就算可用就分配给顾客,如不可用就把这些三番五次从空闲池删掉,重新检验空闲池是不是还会有连接);若无则检查当前所开连接池是不是达到规定的标准连接池所允许的最艾哈迈达巴德接数(maxConn),若无达到,就新建二个一而再,如若已经达到规定的规范,就等候一定的年华(timeout)。假使在伺机的大运内有一连被释放出来就能够把这一个延续分配给等待的客商,假诺等待时间超过预订时间timeout,则赶回空值(null)。系统对已经分配出去正在采用的总是只做计数,当使用完后再返还给空闲池。对于空闲连接的意况,可开荒特地的线程定时检查评定,那样会开支自然的系统开荒,但足以确定保障相当的慢的响应速度。也可利用不开采特地线程,只是在分配前检验的章程。

  连接池管理类是接连池类的外覆类(wrapper),符合单例形式,即系统中只好有八个连接池管理类的实例。其注重用来对多个连接池对象的军管,具有以下功用:①装载并注册特定数据库的JDBC驱动程序;②依照属性文件给定的音讯,成立连接池对象;③为方便处理多少个连接池对象,为每一个连接池对象取三个名字,落成连接池名字与其实例之间的照耀;④追踪顾客接纳连接情况,以便需若是关闭连接释放能源。连接池管理类的引进首倘诺为了便于对多少个连接池的利用和管制,如系统要求再而三分化的数据库,或接二连三一样的数据库但由于安全性难题,须求差异的客户选拔不一致的名号和密码。
2、连接池完毕(经过本人改版,可以适用许多据库类型的运用以致一种数据库类型多少个数据库且数量
库的多少能够动态增添的应用程序)
1),DBConnectionPool.java 数据库连接池类
2),DBConnectionManager .java 数据库处理类
3),DSConfigBean .java 单个数据库连接新闻Bean
4),ParseDSConfig.java
操作多(那么些’多’包蕴区别的数据库和同一种数据库有多个数据库)
数据 配置文件xml
5),ds.config.xml 数据库配置文件xml
原代码如下:

  5、连接池的布局与维护

DBConnectionPool.java

/**
* 数据库连接池类
*/
package com.chunkyo.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Timer;

/**
* @author chenyanlin
*
*/
public class DBConnectionPool implements TimerListener {

private Connection con=null;
private int inUsed=0; //使用的连接数
private ArrayList freeConnections = new ArrayList();//容器,空闲连接
private int minConn; //最小连接数
private int maxConn; //最地拉那接
private String name; //连接池名字
private String password; //密码
private String url; //数据库连接地址
private String driver; //驱动
private String user; //用户名
public Timer timer; //定时
/**
*
*/
public DBConnectionPool() {
// TODO Auto-generated constructor stub
}
/**
* 创立连接池
* @param driver
* @param name
* @param URL
* @param user
* @param password
* @param maxConn
*/
public DBConnectionPool(String name, String driver,String URL, String
user, String password, int maxConn)
{
this.name=name;
this.driver=driver;
this.url=URL;
this.user=user;
this.password=password;
this.maxConn=maxConn;
}
/**
* 用完,释放连接
* @param con
*/
public synchronized void freeConnection(Connection con)
{
this.freeConnections.add(con);//增加到空闲连接的终极
this.inUsed–;
}
/**
* timeout 依照timeout得到接二连三
* @param timeout
* @return
*/
public synchronized Connection getConnection(long timeout)
{
Connection con=null;
if(this.freeConnections.size()>0)
{
con=(Connection)this.freeConnections.get(0);
if(con==null)con=getConnection(timeout); //继续猎取三翻五次
}
else
{
con=newConnection(); //新建连接
}
if(this.maxConn==0||this.maxConn<this.inUsed)
{
con=null;//达到最亚松森接数,权且不能够获得延续了。
}
if(con!=null)
{
this.inUsed++;
}
return con;
}
/**
*
* 从连接池里得到延续
* @return
*/
public synchronized Connection getConnection()
{
Connection con=null;
if(this.freeConnections.size()>0)
{
con=(Connection)this.freeConnections.get(0);
this.freeConnections.remove(0);//假使总是分配出去了,就从闲暇连接里删除
if(con==null)con=getConnection(); //继续获得三番两次
}
else
{
con=newConnection(); //新建连接
}
if(this.maxConn==0||this.maxConn<this.inUsed)
{
con=null;//等待 超过最亚松森接时
}
if(con!=null)
{
this.inUsed++;
System.out.println(“获得 ”+this.name+” 的连天,现成”+inUsed+”个连续在使用!”);
}
return con;
}
/**
*出狱全体连接
*
*/
public synchronized void release()
{
Iterator allConns=this.freeConnections.iterator();
while(allConns.hasNext())
{
Connection con=(Connection)allConns.next();
try
{
con.close();
}
catch(SQLException e)
{
e.printStackTrace();
}

}
this.freeConnections.clear();

}
/**
* 创建新连接
* @return
*/
private Connection newConnection()
{
try {
Class.forName(driver);
con=DriverManager.getConnection(url, user, password);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(“sorry can’t find db driver!”);
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
System.out.println(“sorry can’t create Connection!”);
}
return con;

}
/**
* 定期管理函数
*/
public synchronized void TimerEvent()
{
//权且还尚无兑现以后会增多的
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}
/**
* @return the driver
*/
public String getDriver() {
return driver;
}
/**
* @param driver the driver to set
*/
public void setDriver(String driver) {
this.driver = driver;
}
/**
* @return the maxConn
*/
public int getMaxConn() {
return maxConn;
}
/**
* @param maxConn the maxConn to set
*/
public void setMaxConn(int maxConn) {
this.maxConn = maxConn;
}
/**
* @return the minConn
*/
public int getMinConn() {
return minConn;
}
/**
* @param minConn the minConn to set
*/
public void setMinConn(int minConn) {
this.minConn = minConn;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the password
*/
public String getPassword() {
return password;
}
/**
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}
/**
* @return the url
*/
public String getUrl() {
return url;
}
/**
* @param url the url to set
*/
public void setUrl(String url) {
this.url = url;
}
/**
* @return the user
*/
public String getUser() {
return user;
}
/**
* @param user the user to set
*/
public void setUser(String user) {
this.user = user;
}

}


  连接池中到底应该放置多少连接,才具使系统的习性最好?系统可利用安装最小连接数(minConn)和最瓜达拉哈拉接数(maxConn)来支配连接池中的连接。最小连接数是系统运维时连接池所开创的连接数。假使创设过多,则系统运行就慢,但创设后系统的响应速度会十分的快;假若创设过少,则系统运行的短平快,响应起来却慢。那样,能够在支付时,设置相当的小的矮小连接数,开采起来会快,而在系统实际使用时设置非常的大的,因为这么对寻访顾客的话速度会快些。最达累斯萨Lamb接数是连接池中允许连接的最大额,具体设置有个别,要看系统的访谈量,可经过一再测验,找到最棒点。

DBConnectionManager .java

/**
* 数据库连接池管理类
*/
package com.chunkyo.db;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;
import java.util.Vector;

import com.chunkyo.db.ParseDSConfig;
import com.chunkyo.db.DSConfigBean;
import com.chunkyo.db.DBConnectionPool;

/**
* @author chenyanlin
*
*/
public class DBConnectionManager {

static private DBConnectionManager
instance;//独一数据库连接池管理实例类
static private int clients; //客户连接数
private Vector drivers = new Vector();//驱动新闻
private Hashtable pools=new Hashtable();//连接池

/**
* 实例化管理类
*/
public DBConnectionManager() {
// TODO Auto-generated constructor stub
this.init();
}
/**
* 得到独一实例管理类
* @return
*/
static synchronized public DBConnectionManager getInstance()
{
if(instance==null)
{
instance=new DBConnectionManager();
}
return instance;

}
/**
* 释放连接
* @param name
* @param con
*/
public void freeConnection(String name, Connection con)
{
DBConnectionPool
pool=(DBConnectionPool)pools.get(name);//根据重大名字获得连接池
if(pool!=null)
pool.freeConnection(con);//释放连接
}
/**
* 获得一个连接依据连接池的名字name
* @param name
* @return
*/
public Connection getConnection(String name)
{
DBConnectionPool pool=null;
Connection con=null;
pool=(DBConnectionPool)pools.get(name);//从名字中得到连接池
con=pool.getConnection();//从选定的连接池中取得接二连三
if(con!=null)
System.out.println(“获得再三再四。。。”);
return con;
}
/**
* 获得多少个连接,依照连接池的名字和等待时间
* @param name
* @param time
* @return
*/
public Connection getConnection(String name, long timeout)
{
DBConnectionPool pool=null;
Connection con=null;
pool=(DBConnectionPool)pools.get(name);//从名字中拿到连接池
con=pool.getConnection(timeout);//从选定的连接池中获得一而再
System.out.println(“获得延续。。。”);
return con;
}
/**
* 释放具备连接
*/
public synchronized void release()
{
Enumeration allpools=pools.elements();
while(allpools.hasMoreElements())
{
DBConnectionPool pool=(DBConnectionPool)allpools.nextElement();
if(pool!=null)pool.release();
}
pools.clear();
}

/**
* 成立连接池
* @param props
*/
private void createPools(DSConfigBean dsb)
{
DBConnectionPool dbpool=new DBConnectionPool();
dbpool.setName(dsb.getName());
dbpool.setDriver(dsb.getDriver());
dbpool.setUrl(dsb.getUrl());
dbpool.setUser(dsb.getUsername());
dbpool.setPassword(dsb.getPassword());
dbpool.setMaxConn(dsb.getMaxconn());
System.out.println(“ioio:”+dsb.getMaxconn());
pools.put(dsb.getName(), dbpool);
}
/**
* 起头化连接池的参数
*/
private void init()
{
//加载驱动程序
this.loadDrivers();
//成立连接池
Iterator alldriver=drivers.iterator();
while(alldriver.hasNext())
{
this.createPools((DSConfigBean)alldriver.next());
System.out.println(“成立连接池。。。”);

}
System.out.println(“创制连接池完结。。。”);
}

/**
* 加载驱动程序
* @param props
*/
private void loadDrivers()
{
ParseDSConfig pd=new ParseDSConfig();
//读取数据库配置文件
drivers=pd.readConfigInfo(“ds.config.xml”);
System.out.println(“加载驱动程序。。。”);
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

  如何保管连接池中的最小连接数呢?有动态和静态二种政策。动态即每间距一定期间就对连接池进行检查评定,假使开掘接二连三数量低于最小连接数,则补充相应数额的新连接,以确认保障连接池的例行运作。静态是开掘没事连接相当不足时再去反省。
连接池的落实

}

  1、连接池模型

DSConfigBean.java

/**
* 配置文件Bean类
*/
package com.chunkyo.db;

/**
* @author chenyanlin
*
*/
public class DSConfigBean {

private String type =””; //数据库类型
private String name =””; //连接池名字
private String driver =””; //数据库驱动
private String url =””; //数据库url
private String username =””; //用户名
private String password =””; //密码
private int maxconn =0; //最罗安达接数
/**
*
*/
public DSConfigBean() {
// TODO Auto-generated constructor stub
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

/**
* @return the driver
*/
public String getDriver() {
return driver;
}

/**
* @param driver the driver to set
*/
public void setDriver(String driver) {
this.driver = driver;
}

/**
* @return the maxconn
*/
public int getMaxconn() {
return maxconn;
}

/**
* @param maxconn the maxconn to set
*/
public void setMaxconn(int maxconn) {
this.maxconn = maxconn;
}

/**
* @return the name
*/
public String getName() {
return name;
}

/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}

/**
* @return the password
*/
public String getPassword() {
return password;
}

/**
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}

/**
* @return the type
*/
public String getType() {
return type;
}

/**
* @param type the type to set
*/
public void setType(String type) {
this.type = type;
}

/**
* @return the url
*/
public String getUrl() {
return url;
}

/**
* @param url the url to set
*/
public void setUrl(String url) {
this.url = url;
}

/**
* @return the username
*/
public String getUsername() {
return username;
}

/**
* @param username the username to set
*/
public void setUsername(String username) {
this.username = username;
}

  本文探究的连接池富含四个老是池类(DBConnectionPool)和一个连接池管理类(DBConnetionPoolManager)和二个铺排文件操作类(ParseDSConfig)。连接池类是对某一数据库有着连接的“缓冲池”,首要达成以下效用:①从连接池获取或创立可用连接;②行使实现之后,把连接返还给连接池;③在系统关闭前,断开全数连接并释放连接占用的系统财富;④还是可以够处理无效连接(原本登记为可用的连年,由于某种原因不再可用,如超时,通信难点),并能够范围连接池中的连接总量相当大于有些预订值和不当先某些预订值。(5)当许多据库时,且数据库是动态扩充的话,将会加到配置文件中。

}

  连接池管理类是接连池类的外覆类(wrapper),切合单例方式,即系统中只可以有三个连接池管理类的实例。其根本用以对三个连接池对象的军管,具备以下职能:①装载并登记特定数据库的JDBC驱动程序;②基于属性文件给定的新闻,创造连接池对象;③为方便管理七个连接池对象,为每四个连接池对象取一个名字,达成连接池名字与其实例之间的映照;④追踪顾客利用连接意况,以便需假设关门连接释放能源。连接池管理类的引入主如果为了有助于对多个连接池的使用和保管,如系统需求再三再四区别的数据库,或一连一样的数据库但出于安全性难点,须要不一致的顾客使用分化的称号和密码。
        
2、连接池实现(经过自身改版,能够适用多数据库类型的运用以致一种数据库类型八个数据库且数额 
库的数目能够动态扩展的应用程序)
         1),DBConnectionPool.java   数据库连接池类
         2),DBConnectionManager .java   数据库管理类
         3),DSConfigBean .java                单个数据库连接消息Bean
         4),ParseDSConfig.java               
操作多(这几个’多’包含差别的数据库和一样种数据库有三个数据库)
                                                            数据
配置文件xml
         5),ds.config.xml                           数据库配置文件xml
         原代码如下: 
        DBConnectionPool.java   
        ———————————————————-
      /**
 * 数据库连接池类
 */
package com.chunkyo.db;

ParseDSConfig.java

/**
* 操作配置文件类 读 写 修改 删除等操作
*/
package com.chunkyo.db;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Vector;
import java.util.Iterator;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

/**
* @author chenyanlin
*
*/
public class ParseDSConfig {

/**
* 构造函数
*/
public ParseDSConfig() {
// TODO Auto-generated constructor stub
}
/**
* 读取xml配置文件
* @param path
* @return
*/
public Vector readConfigInfo(String path)
{
String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
Vector dsConfig=null;
FileInputStream fi = null;
try
{
fi=new FileInputStream(rpath);//读取路线文件
dsConfig=new Vector();
SAXBuilder sb=new SAXBuilder();
Document doc=sb.build(fi);
Element root=doc.getRootElement();
List pools=root.getChildren();
Element pool=null;
Iterator allPool=pools.iterator();
while(allPool.hasNext())
{
pool=(Element)allPool.next();
DSConfigBean dscBean=new DSConfigBean();
dscBean.setType(pool.getChild(“type”).getText());
dscBean.setName(pool.getChild(“name”).getText());
System.out.println(dscBean.getName());
dscBean.setDriver(pool.getChild(“driver”).getText());
dscBean.setUrl(pool.getChild(“url”).getText());
dscBean.setUsername(pool.getChild(“username”).getText());
dscBean.setPassword(pool.getChild(“password”).getText());
dscBean.setMaxconn(Integer.parseInt(pool.getChild(“maxconn”).getText()));
dsConfig.add(dscBean);
}

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JDOMException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

finally
{
try {
fi.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

return dsConfig;
}

/**
*修改配置文件 没时间写 过段时间再贴上去 其实同样的
*/
public void modifyConfigInfo(String path,DSConfigBean dsb) throws
Exception
{
String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
FileInputStream fi=null; //读出
FileOutputStream fo=null; //写入

}
/**
*日增铺排文件
*
*/
public void addConfigInfo(String path,DSConfigBean dsb)
{
String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
FileInputStream fi=null;
FileOutputStream fo=null;
try
{
fi=new FileInputStream(rpath);//读取xml流

SAXBuilder sb=new SAXBuilder();

Document doc=sb.build(fi); //得到xml
Element root=doc.getRootElement();
List pools=root.getChildren();//得到xml子树

Element newpool=new Element(“pool”); //创设新连接池

Element pooltype=new Element(“type”); //设置连接池类型
pooltype.setText(dsb.getType());
newpool.addContent(pooltype);

Element poolname=new Element(“name”);//设置连接池名字
poolname.setText(dsb.getName());
newpool.addContent(poolname);

Element pooldriver=new Element(“driver”); //设置连接池驱动
pooldriver.addContent(dsb.getDriver());
newpool.addContent(pooldriver);

Element poolurl=new Element(“url”);//设置连接池url
poolurl.setText(dsb.getUrl());
newpool.addContent(poolurl);

Element poolusername=new Element(“username”);//设置连接池客商名
poolusername.setText(dsb.getUsername());
newpool.addContent(poolusername);

Element poolpassword=new Element(“password”);//设置连接池密码
poolpassword.setText(dsb.getPassword());
newpool.addContent(poolpassword);

Element poolmaxconn=new Element(“maxconn”);//设置连接池最第Billy斯接
poolmaxconn.setText(String.valueOf(dsb.getMaxconn()));
newpool.addContent(poolmaxconn);
pools.add(newpool);//将child添加到root
Format format = Format.getPrettyFormat();
format.setIndent(“”);
format.setEncoding(“utf-8”);
XMLOutputter outp = new XMLOutputter(format);
fo = new FileOutputStream(rpath);
outp.output(doc, fo);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JDOMException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{

}
}
/**
*剔除配置文件
*/
public void delConfigInfo(String path,String name)
{
String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
FileInputStream fi = null;
FileOutputStream fo=null;
try
{
fi=new FileInputStream(rpath);//读取路线文件
SAXBuilder sb=new SAXBuilder();
Document doc=sb.build(fi);
Element root=doc.getRootElement();
List pools=root.getChildren();
Element pool=null;
Iterator allPool=pools.iterator();
while(allPool.hasNext())
{
pool=(Element)allPool.next();
if(pool.getChild(“name”).getText().equals(name))
{
pools.remove(pool);
break;
}
}
Format format = Format.getPrettyFormat();
format.setIndent(“”);
format.setEncoding(“utf-8”);
XMLOutputter outp = new XMLOutputter(format);
fo = new FileOutputStream(rpath);
outp.output(doc, fo);

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JDOMException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

finally
{
try {
fi.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub

ParseDSConfig pd=new ParseDSConfig();
String path=”ds.config.xml”;
pd.readConfigInfo(path);
//pd.delConfigInfo(path, “tj012006”);
DSConfigBean dsb=new DSConfigBean();
dsb.setType(“oracle”);
dsb.setName(“yyy004”);
dsb.setDriver(“org.oracle.jdbc”);
dsb.setUrl(“jdbc:oracle://localhost”);
dsb.setUsername(“sa”);
dsb.setPassword(“”);
dsb.setMaxconn(1000);
pd.addConfigInfo(path, dsb);
pd.delConfigInfo(path, “yyy001”);
}

}


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Timer;

ds.config.xml 配置文件

<ds-config>
<pool>
<type>mysql</type>
<name>user</name>
<driver>com.mysql.jdbc.driver</driver>
<url>jdbc:mysql://localhost:3306/user</url>
<username>sa</username>
<password>123456</password>
<maxconn>100</maxconn>
</pool>
<pool>
<type>mysql</type>
<name>user2</name>
<driver>com.mysql.jdbc.driver</driver>
<url>jdbc:mysql://localhost:3306/user2</url>
<username>sa</username>
<password>1234</password>
<maxconn>10</maxconn>
</pool>
<pool>
<type>sql2000</type>
<name>books</name>
<driver>com.microsoft.sqlserver.driver</driver>
<url>jdbc:sqlserver://localhost:1433/books:databasename=books</url>
<username>sa</username>
<password></password>
<maxconn>100</maxconn>
</pool>
</ds-config>

  1. 连接池的选拔
    1。Connection的拿走和释放
    DBConnectionManager connectionMan=DBConnectionManager
    .getInstance();//得到独一实例
    //获得接二连三
    String name=”mysql”;//从上下文获得你要拜候的数据库的名字
    Connection con=connectionMan.getConnection(name);
    //使用
    。。。。。。。
    // 使用完成
    connectionMan.freeConnection(name,con);//释放,但未有断开连接
    2。数据库连接的动态扩张和连接池的动态扩大
    1。调用xml操作扩充类

2。重新实例华连接池管理池类

/**
 * @author chenyanlin
 *
 */
public class DBConnectionPool implements TimerListener {

 private Connection con=null;
 private int inUsed=0;    //使用的连接数
 private ArrayList freeConnections = new ArrayList();//容器,空闲连接
 private int minConn;     //最小连接数
 private int maxConn;     //最菲尼克斯接
 private String name;     //连接池名字
 private String password; //密码
 private String url;      //数据库连接地址
 private String driver;   //驱动
 private String user;     //用户名
 public Timer timer;      //定时
 /**
  * 
  */
 public DBConnectionPool() {
  // TODO Auto-generated constructor stub
 }
 /**
  * 创造连接池
  * @param driver
  * @param name
  * @param URL
  * @param user
  * @param password
  * @param maxConn
  */
 public DBConnectionPool(String name, String driver,String URL, String
user, String password, int maxConn)
 {
  this.name=name;
  this.driver=driver;
  this.url=URL;
  this.user=user;
  this.password=password;
  this.maxConn=maxConn;
 }
 /**
  * 用完,释放连接
  * @param con
  */
 public synchronized void freeConnection(Connection con) 
 {
  this.freeConnections.add(con);//增多到空闲连接的末段
  this.inUsed–;
 }
 /**
  * timeout  依据timeout获得接二连三
  * @param timeout
  * @return
  */
 public synchronized Connection getConnection(long timeout)
 {
  Connection con=null;
  if(this.freeConnections.size()>0)
  {
   con=(Connection)this.freeConnections.get(0);
   if(con==null)con=getConnection(timeout); //继续获得三番五次
  }
  else
  {
   con=newConnection(); //新建连接
  }
  if(this.maxConn==0||this.maxConn<this.inUsed)
  {
   con=null;//到达最安卡拉接数,目前不能够得到一连了。
  }
  if(con!=null)
  {
   this.inUsed++;
  }
  return con;
 }
 /**
  * 
  * 从连接池里获得延续
  * @return
  */
 public synchronized Connection getConnection()
 {
  Connection con=null;
  if(this.freeConnections.size()>0)
  {
   con=(Connection)this.freeConnections.get(0);
   this.freeConnections.remove(0);//要是连接分配出去了,就从闲暇连接里删除
   if(con==null)con=getConnection(); //继续得到三番五次
  }
  else
  {
   con=newConnection(); //新建连接
  }
  if(this.maxConn==0||this.maxConn<this.inUsed)
  {
   con=null;//等待 超越最达累斯萨Lamb接时
  }
  if(con!=null)
  {
   this.inUsed++;
   System.out.println(“获得 ”+this.name+” 的接连,现成”+inUsed+”个三番两次在接纳!”);
  }
  return con;
 }
 /**
  *获释全体连连
  *
  */
 public synchronized void release()
 {
  Iterator allConns=this.freeConnections.iterator();
  while(allConns.hasNext())
  {
   Connection con=(Connection)allConns.next();
   try
   {
    con.close();
   }
   catch(SQLException e)
   {
    e.printStackTrace();
   }
   
  }
  this.freeConnections.clear();
   
 }
 /**
  * 创设新连接
  * @return
  */
 private Connection newConnection()
 {
  try {
   Class.forName(driver);
   con=DriverManager.getConnection(url, user, password);
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   System.out.println(“sorry can’t find db driver!”);
  } catch (SQLException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
   System.out.println(“sorry can’t create Connection!”);
  }
  return con;
  
 }
 /**
  * 定期管理函数
  */
 public synchronized void TimerEvent() 
 {
     //这段日子还平昔不实现今后会增进的
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub

 }
 /**
  * @return the driver
  */
 public String getDriver() {
  return driver;
 }
 /**
  * @param driver the driver to set
  */
 public void setDriver(String driver) {
  this.driver = driver;
 }
 /**
  * @return the maxConn
  */
 public int getMaxConn() {
  return maxConn;
 }
 /**
  * @param maxConn the maxConn to set
  */
 public void setMaxConn(int maxConn) {
  this.maxConn = maxConn;
 }
 /**
  * @return the minConn
  */
 public int getMinConn() {
  return minConn;
 }
 /**
  * @param minConn the minConn to set
  */
 public void setMinConn(int minConn) {
  this.minConn = minConn;
 }
 /**
  * @return the name
  */
 public String getName() {
  return name;
 }
 /**
  * @param name the name to set
  */
 public void setName(String name) {
  this.name = name;
 }
 /**
  * @return the password
  */
 public String getPassword() {
  return password;
 }
 /**
  * @param password the password to set
  */
 public void setPassword(String password) {
  this.password = password;
 }
 /**
  * @return the url
  */
 public String getUrl() {
  return url;
 }
 /**
  * @param url the url to set
  */
 public void setUrl(String url) {
  this.url = url;
 }
 /**
  * @return the user
  */
 public String getUser() {
  return user;
 }
 /**
  * @param user the user to set
  */
 public void setUser(String user) {
  this.user = user;
 }

}


 DBConnectionManager .java

/**
 * 数据库连接池管理类
 */
package com.chunkyo.db;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;
import java.util.Vector;

import com.chunkyo.db.ParseDSConfig;
import com.chunkyo.db.DSConfigBean;
import com.chunkyo.db.DBConnectionPool;

/**
 * @author chenyanlin
 *
 */
public class DBConnectionManager {

 static private DBConnectionManager
instance;//独一数据库连接池管理实例类
 static private int clients;                 //客商连接数
 private Vector drivers  = new Vector();//驱动音讯
 private Hashtable pools=new Hashtable();//连接池
 
 /**
  * 实例化管理类
  */
 public DBConnectionManager() {
  // TODO Auto-generated constructor stub
  this.init();
 }
 /**
  * 获得独一实例管理类
  * @return
  */
 static synchronized public DBConnectionManager getInstance()
 {
  if(instance==null)
  {
   instance=new DBConnectionManager();
  }
  return instance;
  
 }
 /**
  * 释放连接
  * @param name
  * @param con
  */
 public void freeConnection(String name, Connection con)
 {
  DBConnectionPool
pool=(DBConnectionPool)pools.get(name);//根据重大名字得到连接池
  if(pool!=null)
  pool.freeConnection(con);//释放连接 
 }
 /**
  * 得到贰个老是依照连接池的名字name
  * @param name
  * @return
  */
 public Connection getConnection(String name)
 {
  DBConnectionPool pool=null;
  Connection con=null;
  pool=(DBConnectionPool)pools.get(name);//从名字中赢得连接池
  con=pool.getConnection();//从选定的连接池中拿走再三再四
  if(con!=null)
  System.out.println(“获得一连。。。”);
  return con;
 }
 /**
  * 得到叁个三番五次,依据连接池的名字和等候时间
  * @param name
  * @param time
  * @return
  */
 public Connection getConnection(String name, long timeout)
 {
  DBConnectionPool pool=null;
  Connection con=null;
  pool=(DBConnectionPool)pools.get(name);//从名字中获得连接池
  con=pool.getConnection(timeout);//从选定的连接池中获取一连
  System.out.println(“获得再而三。。。”);
  return con;
 }
 /**
  * 释放具备连接
  */
 public synchronized void release()
 {
  Enumeration allpools=pools.elements();
  while(allpools.hasMoreElements())
  {
   DBConnectionPool pool=(DBConnectionPool)allpools.nextElement();
   if(pool!=null)pool.release();
  }
  pools.clear();
 }

 /**
  * 创制连接池
  * @param props
  */
 private void createPools(DSConfigBean dsb)
 {
  DBConnectionPool dbpool=new DBConnectionPool();
  dbpool.setName(dsb.getName());
  dbpool.setDriver(dsb.getDriver());
  dbpool.setUrl(dsb.getUrl());
  dbpool.setUser(dsb.getUsername());
  dbpool.setPassword(dsb.getPassword());
  dbpool.setMaxConn(dsb.getMaxconn());
  System.out.println(“ioio:”+dsb.getMaxconn());
  pools.put(dsb.getName(), dbpool);
 }
 /**
  * 开端化连接池的参数
  */
 private void init()
 {
  //加载驱动程序
  this.loadDrivers();
  //创设连接池
  Iterator alldriver=drivers.iterator();
  while(alldriver.hasNext())
  {
   this.createPools((DSConfigBean)alldriver.next());
   System.out.println(“成立连接池。。。”);
   
  }
  System.out.println(“创造连接池达成。。。”);
 }

 /**
  * 加载驱动程序
  * @param props
  */
 private void loadDrivers()
 {
  ParseDSConfig pd=new ParseDSConfig();
 //读取数据库配置文件
  drivers=pd.readConfigInfo(“ds.config.xml”);
  System.out.println(“加载驱动程序。。。”);
 }
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub

 }

}

DSConfigBean.java

/**
 * 配置文件Bean类
 */
package com.chunkyo.db;

/**
 * @author chenyanlin
 *
 */
public class DSConfigBean {

 private String type     =””; //数据库类型
 private String name     =””; //连接池名字
 private String driver   =””; //数据库驱动
 private String url      =””; //数据库url
 private String username =””; //用户名
 private String password =””; //密码
 private int maxconn  =0; //最奥斯汀接数
 /**
  * 
  */
 public DSConfigBean() {
  // TODO Auto-generated constructor stub
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub

 }

 /**
  * @return the driver
  */
 public String getDriver() {
  return driver;
 }

 /**
  * @param driver the driver to set
  */
 public void setDriver(String driver) {
  this.driver = driver;
 }

 /**
  * @return the maxconn
  */
 public int getMaxconn() {
  return maxconn;
 }

 /**
  * @param maxconn the maxconn to set
  */
 public void setMaxconn(int maxconn) {
  this.maxconn = maxconn;
 }

 /**
  * @return the name
  */
 public String getName() {
  return name;
 }

 /**
  * @param name the name to set
  */
 public void setName(String name) {
  this.name = name;
 }

 /**
  * @return the password
  */
 public String getPassword() {
  return password;
 }

 /**
  * @param password the password to set
  */
 public void setPassword(String password) {
  this.password = password;
 }

 /**
  * @return the type
  */
 public String getType() {
  return type;
 }

 /**
  * @param type the type to set
  */
 public void setType(String type) {
  this.type = type;
 }

 /**
  * @return the url
  */
 public String getUrl() {
  return url;
 }

 /**
  * @param url the url to set
  */
 public void setUrl(String url) {
  this.url = url;
 }

 /**
  * @return the username
  */
 public String getUsername() {
  return username;
 }

 /**
  * @param username the username to set
  */
 public void setUsername(String username) {
  this.username = username;
 }

}

ParseDSConfig.java

/**
 * 操作配置文件类 读  写 修改 删除等操作 
 */
package com.chunkyo.db;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Vector;
import java.util.Iterator;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

/**
 * @author chenyanlin
 *
 */
public class ParseDSConfig {

 /**
  * 构造函数
  */
 public ParseDSConfig() {
  // TODO Auto-generated constructor stub
 }
 /**
  * 读取xml配置文件
  * @param path
  * @return
  */
 public Vector readConfigInfo(String path)
 {
  String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
  Vector dsConfig=null;
  FileInputStream fi = null;
  try
  {
   fi=new FileInputStream(rpath);//读取路线文件
   dsConfig=new Vector();
   SAXBuilder sb=new SAXBuilder();
   Document doc=sb.build(fi);
   Element root=doc.getRootElement();
   List pools=root.getChildren();
   Element pool=null;
   Iterator allPool=pools.iterator();
   while(allPool.hasNext())
   {
    pool=(Element)allPool.next();
    DSConfigBean dscBean=new DSConfigBean();
    dscBean.setType(pool.getChild(“type”).getText());
    dscBean.setName(pool.getChild(“name”).getText());
    System.out.println(dscBean.getName());
    dscBean.setDriver(pool.getChild(“driver”).getText());
    dscBean.setUrl(pool.getChild(“url”).getText());
    dscBean.setUsername(pool.getChild(“username”).getText());
    dscBean.setPassword(pool.getChild(“password”).getText());
    dscBean.setMaxconn(Integer.parseInt(pool.getChild(“maxconn”).getText()));
    dsConfig.add(dscBean);
   }
   
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
  finally
  {
   try {
    fi.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  
  return dsConfig;
 }

/**
 *修改配置文件 没时间写 过段时间再贴上去 其实同样的 
 */
 public void modifyConfigInfo(String path,DSConfigBean dsb) throws
Exception
 {
  String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
  FileInputStream fi=null; //读出
  FileOutputStream fo=null; //写入
  
 }
/**
 *追加陈设文件
 *
 */
 public void addConfigInfo(String path,DSConfigBean dsb) 
 {
  String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
  FileInputStream fi=null;
  FileOutputStream fo=null;
  try
  {
   fi=new FileInputStream(rpath);//读取xml流
   
   SAXBuilder sb=new SAXBuilder();
   
   Document doc=sb.build(fi); //得到xml
   Element root=doc.getRootElement();
   List pools=root.getChildren();//得到xml子树
   
   Element newpool=new Element(“pool”); //创制新连接池
   
   Element pooltype=new Element(“type”); //设置连接池类型
   pooltype.setText(dsb.getType());
   newpool.addContent(pooltype);
   
   Element poolname=new Element(“name”);//设置连接池名字
   poolname.setText(dsb.getName());
   newpool.addContent(poolname);
   
   Element pooldriver=new Element(“driver”); //设置连接池驱动
   pooldriver.addContent(dsb.getDriver());
   newpool.addContent(pooldriver);
   
   Element poolurl=new Element(“url”);//设置连接池url
   poolurl.setText(dsb.getUrl());
   newpool.addContent(poolurl);
   
   Element poolusername=new Element(“username”);//设置连接池客商名
   poolusername.setText(dsb.getUsername());
   newpool.addContent(poolusername);
   
   Element poolpassword=new Element(“password”);//设置连接池密码
   poolpassword.setText(dsb.getPassword());
   newpool.addContent(poolpassword);
   
   Element poolmaxconn=new Element(“maxconn”);//设置连接池最加纳Ake拉接
   poolmaxconn.setText(String.valueOf(dsb.getMaxconn()));
   newpool.addContent(poolmaxconn);
   pools.add(newpool);//将child添加到root
   Format format = Format.getPrettyFormat();
      format.setIndent(“”);
      format.setEncoding(“utf-8”);
      XMLOutputter outp = new XMLOutputter(format);
      fo = new FileOutputStream(rpath);
      outp.output(doc, fo);
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  finally
  {
   
  }
 }
 /**
  *删去配置文件
  */
 public void delConfigInfo(String path,String name)
 {
  String
rpath=this.getClass().getResource(“”).getPath().substring(1)+path;
  FileInputStream fi = null;
  FileOutputStream fo=null;
  try
  {
   fi=new FileInputStream(rpath);//读取路线文件
   SAXBuilder sb=new SAXBuilder();
   Document doc=sb.build(fi);
   Element root=doc.getRootElement();
   List pools=root.getChildren();
   Element pool=null;
   Iterator allPool=pools.iterator();
   while(allPool.hasNext())
   {
    pool=(Element)allPool.next();
    if(pool.getChild(“name”).getText().equals(name))
    {
     pools.remove(pool);
     break;
    }
   }
   Format format = Format.getPrettyFormat();
      format.setIndent(“”);
      format.setEncoding(“utf-8”);
      XMLOutputter outp = new XMLOutputter(format);
      fo = new FileOutputStream(rpath);
      outp.output(doc, fo);

   
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
  finally
  {
   try {
    fi.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
 /**
  * @param args
  * @throws Exception 
  */
 public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub

  ParseDSConfig pd=new ParseDSConfig();
  String path=”ds.config.xml”;
  pd.readConfigInfo(path);
  //pd.delConfigInfo(path, “tj012006”);
  DSConfigBean dsb=new DSConfigBean();
  dsb.setType(“oracle”);
  dsb.setName(“yyy004”);
  dsb.setDriver(“org.oracle.jdbc”);
  dsb.setUrl(“jdbc:oracle://localhost”);
  dsb.setUsername(“sa”);
  dsb.setPassword(“”);
  dsb.setMaxconn(1000);
  pd.addConfigInfo(path, dsb);
  pd.delConfigInfo(path, “yyy001”);
 }

}


ds.config.xml   配置文件

<ds-config>
<pool>
<type>mysql</type>
<name>user</name>
<driver>com.mysql.jdbc.driver</driver>
<url>jdbc:mysql://localhost:3306/user</url>
<username>sa</username>
<password>123456</password>
<maxconn>100</maxconn>
</pool>
<pool>
<type>mysql</type>
<name>user2</name>
<driver>com.mysql.jdbc.driver</driver>
<url>jdbc:mysql://localhost:3306/user2</url>
<username>sa</username>
<password>1234</password>
<maxconn>10</maxconn>
</pool>
<pool>
<type>sql2000</type>
<name>books</name>
<driver>com.microsoft.sqlserver.driver</driver>
<url>jdbc:sqlserver://localhost:1433/books:databasename=books</url>
<username>sa</username>
<password></password>
<maxconn>100</maxconn>
</pool>
</ds-config>

  1. 连接池的选择
      1。Connection的获取和刑释
      DBConnectionManager  
    connectionMan=DBConnectionManager .getInstance();//获得独一实例
       //获得三番五次
       String name=”mysql”;//从上下文得到你要访谈的数据库的名字
       Connection  con=connectionMan.getConnection(name);
      //使用
      。。。。。。。
      // 使用完成
     connectionMan.freeConnection(name,con);//释放,但绝非断开连接
     2。数据库连接的动态增添和连接池的动态扩展
          1。调用xml操作扩大类

      2。重新实例华连接池管理池类

 

初藳地址:http://www.blogjava.net/chunkyo/archive/2007/01/16/94266.html