BlogJava-shishaomeng-文章分类-DB connection poolhttp://www.blogjava.net/shishaomeng/category/39216.html让一切触手可及！zh-cnFri, 24 Apr 2009 22:52:13 GMTFri, 24 Apr 2009 22:52:13 GMT60proxool 简单使用http://www.blogjava.net/shishaomeng/articles/267288.html时邵猛时邵猛Fri, 24 Apr 2009 02:13:00 GMThttp://www.blogjava.net/shishaomeng/articles/267288.htmlhttp://www.blogjava.net/shishaomeng/comments/267288.htmlhttp://www.blogjava.net/shishaomeng/articles/267288.html#Feedback0http://www.blogjava.net/shishaomeng/comments/commentRss/267288.htmlhttp://www.blogjava.net/shishaomeng/services/trackbacks/267288.htmlproxool.sourceforge.net/ 下载
proxool-0.9.0RC2.zip

解压后，把proxool-0.9.0RC2.jar放到工程的lib文件夹里面。
proxool是一个非常强大的连接池工具包，我觉得相比dbcp、c3p0这两个连接池包都要好用，我用loadrunner测试过，这三个连接池的从性能上排名如下：proxool>c3p0>dbcp，特别是dbcp在大并发的情况下总是出现各种异常。详细关于dbcp的介绍请参考dbcp用户指南，dbcp实现参考tvjody.javaeye.com/admin/show/117225。

下面是实现proxool的几种方式：

JDBC连接方法：

首先建一个proxool的配置文件proxool.xml

proxool.xml 代码
xml 代码
  1. xml version="1.0" encoding="UTF-8"?>    
  2.   
  3.     
  4.   
  5. <something-else-entirely>  
  6.     <proxool>  
  7.           
  8.         <alias>DBPoolalias>  
  9.           
  10.         <driver-url>jdbc:oracle:thin:@192.168.0.40:1521:drcomdriver-url>  
  11.           
  12.         <driver-class>oracle.jdbc.driver.OracleDriverdriver-class>  
  13.         <driver-properties>  
  14.             <property name="user" value="drcom"/>  
  15.             <property name="password" value="drcom"/>  
  16.         driver-properties>  
  17.           
  18.         <house-keeping-sleep-time>90000house-keeping-sleep-time>  
  19.             
  20.         <maximum-new-connections>150maximum-new-connections>  
  21.             
  22.         <prototype-count>3prototype-count>  
  23.             
  24.         <maximum-connection-count>100maximum-connection-count>  
  25.           
  26.         <minimum-connection-count>3minimum-connection-count>  
  27.     proxool>  
  28. something-else-entirely>  

 

再在web.xml中进行配置，其中的ServletConfigurator是装载WEB-INF目录下的proxool.xml,并设置为Tomcat启动时就加载。Admin这个Servlet是proxool提供的察看连接池的信息的工具，


web.xml 代码

xml 代码
  1. xml version="1.0" encoding="UTF-8"?>  
  2. <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee    
  5.     http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
  6.     <servlet>  
  7.         <servlet-name>ServletConfiguratorservlet-name>  
  8.         <servlet-class>  
  9.             org.logicalcobwebs.proxool.configuration.ServletConfigurator   
  10.         servlet-class>  
  11.         <init-param>  
  12.             <param-name>xmlFileparam-name>  
  13.             <param-value>WEB-INF/proxool.xmlparam-value>  
  14.         init-param>  
  15.         <load-on-startup>1load-on-startup>  
  16.     servlet>  
  17.     <servlet>  
  18.         <servlet-name>Adminservlet-name>  
  19.         <servlet-class>  
  20.             org.logicalcobwebs.proxool.admin.servlet.AdminServlet   
  21.         servlet-class>  
  22.     servlet>  
  23.     <servlet-mapping>  
  24.         <servlet-name>Adminservlet-name>  
  25.         <url-pattern>/adminurl-pattern>  
  26.     servlet-mapping>  
  27.     <servlet>  
  28.         <servlet-name>TestServletservlet-name>  
  29.         <servlet-class>  
  30.             selfservice.TestServlet   
  31.         servlet-class>  
  32.     servlet>  
  33.     <servlet-mapping>  
  34.         <servlet-name>TestServletservlet-name>  
  35.         <url-pattern>/TestServleturl-pattern>  
  36.     servlet-mapping>  
  37. web-app>  


以上配置完成后，第三步就可以创建一个连接池的类了

java 代码
  1. package selfservice;       
  2.       
  3. import java.sql.Connection;       
  4. import java.sql.DriverManager;       
  5. import java.sql.ResultSet;       
  6. import java.sql.SQLException;       
  7. import java.sql.Statement;       
  8.       
  9. import org.logicalcobwebs.proxool.ProxoolException;       
  10. import org.logicalcobwebs.proxool.ProxoolFacade;       
  11. import org.logicalcobwebs.proxool.admin.SnapshotIF;       
  12.       
  13.       
  14. public class PoolManager {       
  15.            
  16.     private static int activeCount = 0;       
  17.            
  18.            
  19.     public PoolManager(){       
  20.                
  21.     }          
  22.     /**     
  23.      * 获取连接     
  24.      * getConnection     
  25.      * @param name     
  26.      * @return     
  27.      */      
  28.     public Connection getConnection() {       
  29.         try{       
  30.             Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");//proxool驱动类       
  31.             Connection conn = DriverManager.getConnection("proxool.DBPool");    
  32.            //此处的DBPool是在proxool.xml中配置的连接池别名      
  33.             showSnapshotInfo();       
  34.                    
  35.             return conn;       
  36.         }catch(Exception ex){       
  37.             ex.printStackTrace();       
  38.         }       
  39.         return null;       
  40.     }       
  41.     /**     
  42.      * 此方法可以得到连接池的信息     
  43.      * showSnapshotInfo     
  44.      */      
  45.     private void showSnapshotInfo(){       
  46.         try{       
  47.             SnapshotIF snapshot = ProxoolFacade.getSnapshot("DBPool", true);       
  48.             int curActiveCount=snapshot.getActiveConnectionCount();//获得活动连接数       
  49.             int availableCount=snapshot.getAvailableConnectionCount();//获得可得到的连接数       
  50.             int maxCount=snapshot.getMaximumConnectionCount() ;//获得总连接数       
  51.             if(curActiveCount!=activeCount)//当活动连接数变化时输出的信息       
  52.             {       
  53.              System.out.println("活动连接数:"+curActiveCount+"(active)  可得到的连接数:"+availableCount+"(available)  总连接数:"+maxCount+"(max)");                    
  54.              activeCount=curActiveCount;       
  55.             }       
  56.         }catch(ProxoolException e){       
  57.             e.printStackTrace();       
  58.         }       
  59.     }       
  60.     /**     
  61.      * 获取连接     
  62.      * getConnection     
  63.      * @param name     
  64.      * @return     
  65.      */      
  66.     public Connection getConnection(String name){       
  67.         return getConnection();       
  68.     }       
  69.     /**     
  70.      * 释放连接     
  71.      * freeConnection     
  72.      * @param conn     
  73.      */      
  74.     public void freeConnection(Connection conn){       
  75.         if(conn!=null){       
  76.             try {       
  77.                 conn.close();       
  78.             } catch (SQLException e) {                     
  79.                 e.printStackTrace();       
  80.             }       
  81.         }       
  82.     }       
  83.     /**     
  84.      * 释放连接     
  85.      * freeConnection     
  86.      * @param name     
  87.      * @param con     
  88.      */      
  89.     public void freeConnection (String name,Connection con){       
  90.         freeConnection(con);       
  91.     }       
  92.            
  93.     public void getQuery() {               
  94.         try {       
  95.             Connection conn = getConnection();       
  96.             if(conn != null){       
  97.                 Statement statement = conn.createStatement();       
  98.                 ResultSet rs = statement.executeQuery("select * from tblgxinterface");       
  99.                 int c = rs.getMetaData().getColumnCount();       
  100.                 while(rs.next()){                          
  101.                     System.out.println();       
  102.                     for(int i=1;i<=c;i++){       
  103.                         System.out.print(rs.getObject(i));       
  104.                     }       
  105.                 }       
  106.                 rs.close();       
  107.             }       
  108.             freeConnection(conn);       
  109.         } catch (SQLException e) {                 
  110.             e.printStackTrace();       
  111.         }       
  112.       
  113.     }       
  114.       
  115. }      

 


就这样我们完成了一个连接池的功能。proxool的连接池我用loadrunner进行大并发的测试，性能还是很好的。

Hibernate中proxool连接池的方式：

首先步骤跟JDBC的连接池一样，也是新建一个proxool.xml配置文件，再在web.xml中配置，具体参考上面。
第二步在hibernate的配置文件hibernate.cfg.xml中配置proxool连接设置：

hibernate.cfg.xml代码
xml 代码
  1. <property name="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProviderproperty>  
  2.             <property name="hibernate.proxool.pool_alias">DBPoolproperty>  
  3.             <property name="hibernate.proxool.xml">proxoolconf.xmlproperty>  


Spring中proxool连接池的方式：

首先布骤与JDBC的连接池一样，先建一个proxool.xml配置文件，再在web.xml中配置，具体参考上面的。
第二步在spring配置文件applicationContext.xml中配置proxool连接设置

applicationContext.xml代码
xml 代码
  1. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" singleton="true">  
  2.         <property name="driverClassName" value="org.logicalcobwebs.proxool.ProxoolDriver"/>  
  3.         <property name="url" value="proxool.StatDBPool"/>  
  4.     bean>  
  5.     <bean id="transactionManager"    
  6.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  7.         <property name="dataSource">  
  8.             <ref local="dataSource" />  
  9.         property>  
  10.     bean>   

这样spring就能得到一个dataSource的数据源。


proxool还有很多功能，我这只是简单的应用。具体请察看proxool用户指南。



时邵猛 2009-04-24 10:13 发表评论
]]>连接池的基本工作原理http://www.blogjava.net/shishaomeng/articles/267285.html时邵猛时邵猛Fri, 24 Apr 2009 02:01:00 GMThttp://www.blogjava.net/shishaomeng/articles/267285.htmlhttp://www.blogjava.net/shishaomeng/comments/267285.htmlhttp://www.blogjava.net/shishaomeng/articles/267285.html#Feedback0http://www.blogjava.net/shishaomeng/comments/commentRss/267285.htmlhttp://www.blogjava.net/shishaomeng/services/trackbacks/267285.html　　连接池的基本工作原理

　　1、基本概念及原理

　　由上面的分析可以看出，问题的根源就在于对数据库连接资源的低效管理。我们知道，对于共享资源，有一个很著名的设计模式：资源池 (Resource Pool)。该模式正是为了解决资源的频繁分配?释放所造成的问题。为解决上述问题，可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量?使用情况，为系统开发?测试及性能调整提供依据。

　　2、服务器自带的连接池

　　JDBC的API中没有提供连接池的方法。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制，但是必须有其第三方的专用类方法支持连接池的用法。

　　连接池关键问题分析

　　1、并发问题

　　为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题。这个问题相对比较好解决，因为Java语言自身提供了对并发管理的支持，使用synchronized关键字即可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字，如：

　　public synchronized Connection getConnection()

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

　　对于大型的企业级应用，常常需要同时连接不同的数据库(如连接Oracle和Sybase)。如何连接不同的数据库呢?我们采用的策略是：设计一个符合单例模式的连接池管理类，在连接池管理类的唯一实例被创建时读取一个资源文件，其中资源文件中存放着多个数据库的url地址()?用户名()?密码()等信息。如 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、连接池实现

　　下面给出连接池类和连接池管理类的主要属性及所要实现的基本接口：

view plaincopy to clipboardprint?
  1. 　　public class DBConnectionPool implements TimerListener{   
  2. 　　private int checkedOut;//已被分配出去的连接数   
  3. 　　private ArrayList freeConnections=new ArrayList();   
  4. 　　//容器，空闲池，根据//创建时间顺序存放已创建但尚未分配出去的连接   
  5. 　　private int minConn;//连接池里连接的最小数量   
  6. 　　private int maxConn;//连接池里允许存在的最大连接数   
  7. 　　private String name;//为这个连接池取个名字，方便管理   
  8. 　　private String password;//连接数据库时需要的密码   
  9. 　　private String url;//所要创建连接的数据库的地址   
  10. 　　private String user;//连接数据库时需要的用户名   
  11. 　　public Timer timer;//定时器   
  12. 　　public DBConnectionPool(String name,String URL,String user,   
  13. 　　String password,int maxConn)//公开的构造函数   
  14. 　　public synchronized void freeConnection(Connection con)   
  15. 　　//使用完毕之后，把连接返还给空闲池   
  16. 　　public synchronized Connection getConnection(long timeout)   
  17. 　　//得到一个连接，timeout是等待时间   
  18. 　　public synchronized void release()   
  19. 　　//断开所有连接，释放占用的系统资源   
  20. 　　private Connection newConnection()   
  21. 　　//新建一个数据库连接   
  22. 　　public synchronized void TimerEvent()   
  23. 　　//定时器事件处理函数   
  24. 　　}   
  25. 　　public class DBConnectionManager {   
  26. 　　static private DBConnectionManager instance;   
  27. 　　//连接池管理类的唯一实例   
  28. 　　static private int clients;//客户数量   
  29. 　　private ArrayList drivers=new ArrayList();   
  30. 　　//容器，存放数据库驱动程序   
  31. 　　private HashMap pools = new HashMap();   
  32. 　　//以name/value的形式存取连接池对象的名字及连接池对象   
  33. 　　static synchronized public DBConnectionManager getInstance()   
  34. 　　/**如果唯一的实例instance已经创建，直接返回这个实例;否则，调用私有构造函数，  
  35. 　　创建连接池管理类的唯一实例*/  
  36. 　　private DBConnectionManager()   
  37. 　　//私有构造函数,在其中调用初始化函数init()   
  38. 　　public void freeConnection(String name,Connection con)   
  39. 　　//释放一个连接，name是一个连接池对象的名字   
  40. 　　public Connection getConnection(String name)   
  41. 　　//从名字为name的连接池对象中得到一个连接   
  42. 　　public Connection getConnection(String name,long time)   
  43. 　　//从名字为name的连接池对象中取得一个连接，time是等待时间   
  44. 　　public synchronized void release()//释放所有资源   
  45. 　　private void createPools(Properties props)   
  46. 　　//根据属性文件提供的信息，创建一个或多个连接池   
  47. 　　private void init()//初始化连接池管理类的唯一实例，由私有构造函数调用   
  48. 　　private void loadDrivers(Properties props)//装载数据库驱动程序   
  49. 　　}  

　　3、连接池使用

　　上面所实现的连接池在程序开发时如何应用到系统中呢?下面以Servlet为例说明连接池的使用。

　　Servlet的生命周期是：在开始建立servlet时，调用其初始化(init)方法。之后每个用户请求都导致一个调用前面建立的实例的service方法的线程。最后，当服务器决定卸载一个servlet时，它首先调用该servlet的destroy方法。

　　根据servlet的特点，我们可以在初始化函数中生成连接池管理类的唯一实例(其中包括创建一个或多个连接池)。如：

view plaincopy to clipboardprint?
  1. 　　public void init() throws ServletException   
  2. 　　{   
  3. 　　connMgr=DBConnectionManager.getInstance();   
  4. 　　}   
  5. 　　然后就可以在service方法中通过连接池名称使用连接池，执行数据库操作。最后在destroy方法中释放占用的系统资源，如：   
  6. 　　public void destroy(){   
  7. 　　connMgr.release();   
  8. 　　super.destroy();   
  9. 　　}  

　　结束语

　　在使用JDBC进行与数据库有关的应用开发中，数据库连接的管理是一个难点。很多时候，连接的混乱管理所造成的系统资源开销过大成为制约大型企业级应用效率的瓶颈。对于众多用户访问的Web应用，采用数据库连接技术的系统在效率和稳定性上比采用传统的其他方式的系统要好很多。本文阐述了使用 JDBC访问数据库的技术?讨论了基于连接池技术的数据库连接管理的关键问题并给出了一个实现模型。文章所给出的是连接池管理程序的一种基本模式，为提高系统的整体性能，在此基础上还可以进行很多有意义的扩展。



时邵猛 2009-04-24 10:01 发表评论
]]>