dbpool java连接_Java数据库连接池

如何确保连接池中的最小连接数呢？有动态和静态两种策略。动态即每隔一定时间就对连接池进行检测，如果发现连接数量小于最小连接数，则补充相应数量的新连接,以保证连接池的正常运转。静态是发现空闲连接不够时再去检查。

连接池的实现

1、连接池模型

本文讨论的连接池包括一个连接池类(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;

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

{

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

{

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;

}

}

-------------------------------------------

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;

/**

* @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");//设置连接池最大连接

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   配置文件

--------------------------------------

mysql

user

com.mysql.jdbc.driver

jdbc:mysql://localhost:3306/user

sa

123456

100

mysql

user2

com.mysql.jdbc.driver

jdbc:mysql://localhost:3306/user2

sa

1234

10

sql2000

books

com.microsoft.sqlserver.driver

jdbc:sqlserver://localhost:1433/books:databasename=books

sa

100

3. 连接池的使用

1。Connection的获得和释放

DBConnectionManager   connectionMan=DBConnectionManager .getInstance();//得到唯一实例

//得到连接

String name="mysql";//从上下文得到你要访问的数据库的名字

Connection  con=connectionMan.getConnection(name);

//使用

。。。。。。。

// 使用完毕

connectionMan.freeConnection(name,con);//释放，但并未断开连接

2。数据库连接的动态增加和连接池的动态增加

1。调用xml操作增加类

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