Java数据库连接池

  ①装载数据库驱动程序;

}

  对于大型的店堂级应用,平日须求同时连接不一样的数据库(如延续OracleSybase)。如何连接不相同的数据库呢?我们利用的国策是:设计2个合乎单例形式的连接池管理类,在连接池管理类的唯一实例被创立时读取贰个能源文件,当中资源文件中存放着八个数据库的url地址(<poolName.url>)﹑用户名(<poolName.user>)﹑密码(<poolName.password>)等新闻。如tx.url=192.168.1.123:五千/tx_it,tx.user=cyl,tx.password=123456。依照能源文件提供的音信,创立多少个延续池类的实例,每1个实例都以三个特定数据库的连接池。连接池管理类实例为各类连接池实例取一个名字,通过不相同的名字来保管不一致的连接池。

  为了使连接管理服务具有最大的通用性,必须考虑四线程环境,即出现难点。那几个题材绝比较较好化解,因为Java言语本人提供了对出现管理的扶助,使用synchronized关键字即可确定保障线程是同步的。使用办法为直接在类措施后边加上synchronized关键字,如:

  ② 、服务器自带的连接池

public synchronized Connection getConnection()

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

 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() 
 {
     //临时还不曾达成以后会添加的
 }

Java
jdbc数据库连接池总括!

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

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

 }
 /**
  * @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;
 }

 

  连接池管理类是接二连三池类的外覆类(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;

  ②因此JDBC建立数据库连接;

  JDBC的API中绝非提供连接池的法子。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的建制,可是必须有其第1方的专用类措施帮衬连接池的用法。

  本文切磋的连接池包罗一个接二连三池类(DBConnectionPool)和3个连接池管理类(DBConnetionPoolManager)和多个陈设文件操作类(ParseDSConfig)。连接池类是对某一数据库拥有连接的“缓冲池”,首要完成以下功效:①从连接池获取或创办可用连接;②利用完结之后,把连接返还给连接池;③在系统关闭前,断开全部连接并释放连接占用的系统能源;④还是能够处理无效连接(原来登记为可用的三番五次,由于某种原因不再可用,如超时,通讯难点),并能够范围连接池中的连接总数十分的大于有些预订值和不当先有些预订值。(5)当多数据库时,且数据库是动态扩展的话,将会加到配置文件中。

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

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”);
 }

}


  一 、基本概念及原理
由地点的剖析能够看看,难点的来自就在于对数据库连日资源的无效管理。大家明白,

  1. 引言

  五 、连接池的布置与珍贵

 

  ④ 、连接池的分红与自由

  大家清楚,事务有着原子性,此时要求对数据库的操作符合“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全做,要么全不做。
Java言语中,Connection类本人提供了对业务的辅助,能够因而设置Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来促成。但要高效的进行Connection复用,就必须提供对应的政工扶助机制。可应用每1个工作独占3个接连来贯彻,这种措施能够大大下降事务管理的纷纷。

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

转发过来的,最近在做八个小网站,准备利用那种艺术。

  数据库连接池(connection pool)的劳作规律

  程序开发,存在重重题材:首先,每二次Web请求都要树立1遍数据库连接。建立连接是1个一步一摇的位移,每趟都得开销0.05s~1s的年月,而且系统还要分配内部存款和储蓄器财富。这么些时刻对于1次或一遍数据库操作,也许感到不出系统有多大的开发。但是对于明日的Web应用,尤其是巨型电子商务网站,同时有几百人甚至几千人在线是很正规的事。在那种气象下,频仍的拓展数据库连接操作必然占用很多的系统能源,网站的响应速度必定下落,严重的居然会招致服务器的倒台。不是惊人,这就是制约某个电子商务网站发展的技艺瓶颈难点。其次,对于每一遍数据库连接,使用完后都得断开。不然,假若程序出现格外而不能够关闭,将会促成数据库系统中的内部存款和储蓄器泄漏,最后将只可以重启数据库。还有,那种支付不可能说了算被创制的接连对象数,系统能源会被毫无顾及的分红出去,如接二连三过多,也大概引致内部存款和储蓄器泄漏,服务器崩溃。

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

  即Java语言经过JDBC技术访问数据库。JDBC是一种“开放”的方案,它为数据库应用开发职员﹑数据库前台工具开发职员提供了一种标准的应用程序设计接口,使开发人士可以用纯Java语言编写完整的数据库应用程序。JDBC提供二种API,分别是面向开发职员的API和面向底层的JDBC驱动程序API,底层首要透过一向的JDBC驱动和JDBC-ODBC桥驱动完成与数据库的总是。

  对于共享能源,有三个很著名的设计方式:资源池(Resource
Pool)。该方式就是为了缓解能源的多次分配﹑释放所造成的题材。为化解上述难点,能够利用数据库连接池技术。数据库连接池的骨干考虑正是为数据库连接建立三个“缓冲池”。预先在缓冲池中放入一定数量的连续,当供给树立数据库连接时,只需从“缓冲池”中取出1个,使用完成之后再放回去。大家得以因此设定连接池最加纳阿克拉接数来预防系统无尽的与数据库连接。更为主要的是大家得以经过连接池的管理机制监视数据库的接连的数量﹑使用情状,为系统开发﹑测试及品质调整提供根据。连接池的骨干工作原理见下图2。

  近来,随着Internet/Intranet建网技术的快速发展和在世界范围内的便捷普及,计算机

  ④断开数据库连接。

  二 、多数据库服务器和多用户

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

  一般的话,Java应用程序访问数据库的进度(如图1所示)是:

  连接池关键难点分析

}

}

  对于连日来的保管可应用空闲池。即把已经创办但未曾分配出去的一而再按创制时间存放到二个空闲池中。每当用户请求二个三番五次时,系统第贰检查空闲池内有没有空暇连接。假设有就把树马上间最长(通过容器的相继存放完毕)的相当连接分配给她(实际是先做连接是还是不是有效的判定,借使可用就分配给用户,如不可用就把这一个两次三番从空闲池删掉,重新检查和测试空闲池是不是还有连接);借使没有则检查当前所开连接池是或不是达到规定的标准连接池所允许的最地拉这接数(maxConn),假如没有高达,就新建二个三番五次,若是已经高达,就等候一定的日子(timeout)。如若在等候的光阴内有连接被释放出来就足以把这一个接二连三分配给等待的用户,假设等待时间超越预订时间timeout,则赶回空值(null)。系统对已经分配出去正在使用的总是只做计数,当使用完后再返还给空闲池。对于空闲连接的情形,可开发专门的线程定时检查和测试,那样会开支自然的系统开发,但足以确定保证较快的响应速度。也可采用不开发专门线程,只是在分配前检查和测试的点子。

  一 、连接池模型

  一 、并发难点

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

  怎样有限帮助连接池中的最小连接数呢?有动态和静态二种政策。动态即每隔一定时间就对连接池实行检测,倘诺发现一而再数量低于最小连接数,则补充相应数据的新连接,以确认保证连接池的符合规律运维。静态是意识没事连接不够时再去反省。
连接池的兑现

 

 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

 }

  连接池的分红与自由,对系统的习性有十分大的震慑。合理的分红与释放,能够进步连接的复成本,从而降低建立新连接的支出,同时还能加速用户的访问速度。

  对于同四个数据库有多个用户选择分裂的名号和密码访问的景观,也能够由此财富文件处理,即在能源文件中装置七个拥有同样url地址,但全体分化用户名和密码的数据库连接新闻。

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; //最加纳Ake拉接数
 /**
  * 
  */
 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;
 }

  连接池中到底应该放置多少连接,才能使系统的品质最佳?系统可使用设置最小连接数(minConn)和最洛桑接数(maxConn)来决定连接池中的连接。最小连接数是系统运营时连接池所创制的连接数。假若创设过多,则系统运行就慢,但创建后系统的响应速度会不慢;若是创造过少,则系统运行的飞速,响应起来却慢。这样,能够在支付时,设置较小的细小连接数,开发起来会快,而在系统实际运用时设置较大的,因为如此对走访客户来说速度会快些。最菲尼克斯接数是连接池中允许连接的最大数目,具体设置有个别,要看系统的访问量,可透过反复测试,找到最佳点。

  JDBC作为一种数据库访问技术,具有简易易用的亮点。但利用那种情势举行Web应用

图片 2
图2 连接池的基本工作规律

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

  叁 、事务处理


相关文章