JAVA数据库连接池

JAVA数据库连接池

数据库连接池的主要操作如下：
　　（1）建立数据库连接池对象（服务器启动）。
　　（2）按照事先指定的参数创建初始数量的数据库连接（即：空闲连接数）。
　　（3）对于一个数据库访问请求，直接从连接池中得到一个连接。如果数据库连接池对象中没有空闲的连接，且连接数没有达到最大（即：最大活跃连接数），创建一个新的数据库连接。
　　（4）存取数据库。
　　（5）关闭数据库，释放所有数据库连接（此时的关闭数据库连接，并非真正关闭，而是将其放入空闲队列中。如实际空闲连接数大于初始空闲连接数则释放连接）。
　　（6）释放数据库连接池对象（服务器停止、维护期间，释放数据库连接池对象，并释放所有连接）。

 

基本概念及原理

n      数据库连接池是为了解决数据库对象的共享出错问题。

n      实际就是建立一个缓冲池。

n      原理

预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从连接池中取出一个，使用完毕之后再放回去。

n      JDBC的API中没有提供连接池的方法。

l       连接池关键问题分析

n       使用线程同步来解决并发问题

n       使用一个单例模式的连接池管理类来解决连接多个不同数据库。具体方法：

u    在连接池管理类的唯一实例被创建时读取一个资源文件，其中资源文件中存放着多个数据库的url地址()、用户名()、密码()等信息。如tx.url=172.21.15.123：5000/tx_it，tx.user=yang，tx.password=yang321。

u    根据资源文件提供的信息，创建多个连接池类的实例，每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字，通过不同的名字来管理不同的连接池。

n       使用资源文件来解决同一个数据库有多个用户使用不同的名称和密码访问的情况。具体方法：

u    资源文件中设置多个具有相同url地址，但具有不同用户名和密码的数据库连接信息。

n       可采用每一个事务独占一个连接来实现事务处理, 这种方法可以大大降低事务管理的复杂性。具体方法:

u    Connection类可以通过设置Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来实现。

n       使用空闲池来解决连接池的分配与释放处理。具体办法:

u    把已经创建但尚未分配出去的连接按创建时间存放到一个空闲池中。

u    每当用户请求一个连接时，系统首先检查空闲池内有没有空闲连接：

l       如果有就把建立时间最长(通过容器的顺序存放实现)的那个连接分配给他(实际是先做连接是否有效的判断，如果可用就分配给用户，如不可用就把这个连接从空闲池删掉，重新检测空闲池是否还有连接)。

l       如果没有则检查当前所建连接池是否达到连接池所允许的最大连接数(maxConn),如果没有达到，就新建一个连接，如果已经达到，就等待一定的时间(timeout)。如果在等待的时间内有连接被释放出来就可以把这个连接分配给等待的用户，如果等待时间超过预定时间timeout,则返回空值(null)。

u    系统对已经分配出去正在使用的连接只做计数，当使用完后再返还给空闲池。

n       连接池的配置与维护

u    连接池中到底应该放置多少连接，才能使系统的性能最佳?

l       设置连接最小数(系统启动时连接池所创建的连接数)、最大数(使用连接池时所允许连接最大连接数目)

u    如何确保连接池中的最小连接数呢?

l       动态策略:每隔一定时间就对连接池进行检测，如果发现连接数量小于最小连接数，则补充相应数量的新连接,以保证连接池的正常运转。

l       静态策略:发现空闲连接不够时再去检查。

l       连接池的实现

n       连接池模型

u    DBConnectionPoolManager(
连接池管理外覆类(wrapper),符合单例模式)

l        

 

 

u    DBConnectionPool(连接池内部类)

l       从连接池获取或创建可用连接;

public Connection getConnection()

l       使用完毕之后，把连接返还给连接池;

public synchronized void freeConnection(Connectioncon)

l       在系统关闭前，断开所有连接并释放连接占用的系统资源;

public synchronized void release()

l       还能够处理无效连接(原来登记为可用的连接，由于某种原因不再可用，如超时，通讯问题)，并能够限制连接池中的连接总数不低于某个预定值和不超过某个预定值。

private int checkedOut;//已被分配出去的连接数

private int minConn;//连接池里连接的最小数量

private int maxConn;//连接池里允许存在的最大连接数

private String name; //为这个连接池取个名字，方便管理

 

 

 

 

应用示例：

importjava.io.*;  

importjava.sql.*;

importjava.util.*;

import java.util.Date;

 

//建立DBConnectionManager

public class DBConnectionManager {

   staticprivate DBConnectionManagerinstance;

   staticprivate intclients;

   privateVector drivers =new Vector();

   privatePrintWriter log;

   privateHashtable pools =new Hashtable();

 

   //返回唯一的实列

   staticsynchronized public DBConnectionManager getInstance() {

      if(instance ==null) {

        instance= new DBConnectionManager();

      }

      clients++;

      returninstance;

   }

 

   //构造函数！

   privateDBConnectionManager() {

      init();

   }// 结束构造函数

   //释放一个连接

 

   publicvoid freeConnection(String name, Connection con) {

      DBConnectionPoolpool = (DBConnectionPool) pools.get(name);

      if(pool != null) {

        pool.freeConnection(con);

      }

   }

 

   //结束释放一个连接

   //取得一个连接

   publicConnection getConnection(String name) {

      DBConnectionPoolpool = (DBConnectionPool) pools.get(name);

      if(pool != null) {

        returnpool.getConnection();

      }

      returnnull;

   }

 

   publicConnection getConnection(String name,long time) {

      DBConnectionPoolpool = (DBConnectionPool) pools.get(name);

      if(pool != null) {

        returnpool.getConnection(time);

      }

      returnnull;

   }// 结束getconnection

   //关闭所有连接

 

   publicsynchronized void release() {

      {

        if(--clients != 0)

           return;

      }

      EnumerationallPools = pools.elements();

      while(allPools.hasMoreElements()) {

        DBConnectionPoolpool = (DBConnectionPool) allPools.nextElement();

        pool.release();

      }

      EnumerationallDrivers = drivers.elements();

      while(allDrivers.hasMoreElements()) {

        Driverdriver = (Driver) allDrivers.nextElement();

        try{

           DriverManager.deregisterDriver(driver);

           log("撤消JDBC驱动程序" + driver.getClass().getName());

        }catch (SQLException e) {

           log(e,"无法撤消JDBC驱动程序的注册" + driver.getClass().getName());

        }

      }

   }

 

   privatevoid createPools(Properties props) {

      EnumerationpropNames = props.propertyNames();

      while(propNames.hasMoreElements()) {

        Stringname = (String) propNames.nextElement();

        if(name.endsWith(".url")) {

           StringpoolName = name.substring(0, name.lastIndexOf("."));

           Stringurl = props.getProperty(poolName + ".url");

           if(url ==null) {

              log("没有连接池" +poolName + "指定的URL");

              continue;

           }

           Stringuser = props.getProperty(poolName + ".user");

           Stringpassword = props.getProperty(poolName + ".password");

           Stringmaxconn = props.getProperty(poolName + ".maxconn", "0");

           intmax;

           try{

              max= Integer.valueOf(maxconn).intValue();

           }catch (NumberFormatException e) {

              log("错误的最大连接数：" +maxconn + ".连接池" + poolName);

              max= 0;

           }

           DBConnectionPoolpool = new DBConnectionPool(poolName, url,

                 user,password, max);

           pools.put(poolName,pool);

           log("成功创建连接池" +poolName);

        }

      }

   }

 

   privatevoid init() {

      InputStreamis = getClass().getResourceAsStream("/db.properties");

      PropertiesdbProps = new Properties();

      try{

        dbProps.load(is);

      }catch (Exception e) {

        System.err.println("不能读取属性文件。请确保db.properties在你的CLASSPATH中");

        return;

      }

      StringlogFile = dbProps.getProperty("logfile",

           "DBConnectionManager.log");

      try{

        log= new PrintWriter(new FileWriter(logFile,true),true);

      }catch (IOException e) {

        System.err.println("无法打开日志文件：" +logFile);

        log= new PrintWriter(System.err);

      }

      loadDriver(dbProps);

      createPools(dbProps);

   }

 

   privatevoid loadDriver(Properties props) {

      StringdriverClasses = props.getProperty("drivers");

      StringTokenizerst = new StringTokenizer(driverClasses);

      while(st.hasMoreElements()) {

        StringdriverClassName = st.nextToken().trim();

        try{

           Driverdriver = (Driver) Class.forName(driverClassName)

                 .newInstance();

           DriverManager.registerDriver(driver);

           drivers.addElement(driver);

           log("成功注册驱动程序" +driverClassName);

        } catch (Exception e) {

           log("无法注册驱动程序:" +driverClassName + ",错误" + e);

        }

      }

   }

 

   private void log(String msg) {

      log.println(new Date() +":" + msg);

   }

 

   privatevoid log(Throwable e, String msg) {

      log.println(newDate() + ":" + msg);

      e.printStackTrace(log);

   }

 

   //建立DBConnectionPool内部类

   classDBConnectionPool {

      privateint checkOut;

      privateVector freeConnections =new Vector();

      privateint maxconn;

      privateString name;

      privateString password;

      privateString URL;

      privateString user;

 

      publicDBConnectionPool(String name, String URL, String user,

           Stringpassword, int maxconn) {

        this.name= name;

        this.URL= URL;

        this.password= password;

        this.user= user;

        this.maxconn= maxconn;

      }

 

      publicsynchronized void freeConnection(Connection con) {

        freeConnections.addElement(con);

        checkOut--;

        notifyAll();

      }

 

      publicsynchronized Connection getConnection() {

        Connectioncon = null;

        if(freeConnections.size() > 0) {

           con= (Connection) freeConnections.firstElement();

           freeConnections.removeElementAt(0);

           try{

              if(con.isClosed()) {

                 log("从连接池" + name +"删除一个连接");

                 con= getConnection();

              }

           }catch (SQLException e) {

              log("从连接池" + name +"删除一个连接");

              con= getConnection();

           }

        }else if (maxconn == 0 || checkOut < maxconn) {

           con= newConnection();

        }

        if(con != null) {

           checkOut++;

        }

        returncon;

      }

 

      publicsynchronized Connection getConnection(long timeout) {

        longstartTime =new Date().getTime();

        Connectioncon;

        while((con = getConnection()) ==null) {

           try{

              wait(timeout);

           }catch (InterruptedException e) {

           }

           if((new Date().getTime() - startTime) >= timeout) {

              returnnull;

           }

        }

        returncon;

      }

 

      publicvoid release() {

        EnumerationallConnections = freeConnections.elements();

        while(allConnections.hasMoreElements()) {

           Connectioncon = (Connection) allConnections.nextElement();

           try{

              con.close();

              log("关闭连接池" + name+ "中的连接");

           }catch (SQLException e) {

              log(e,"无法关闭连接池" + name + "中的连接");

           }

        }

        freeConnections.removeAllElements();

      }

 

      privateConnection newConnection() {

        Connectioncon = null;

        try{

           con= DriverManager.getConnection(URL, user, password);

           log("连接池" + name +"创建一个新的连接");

        }catch (SQLException e) {

           log(e,"无法创建下列URL的连接" + URL);

           returnnull;

        }

        returncon;

      }

   }

}