首先从 http://proxool.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.iteye.com/admin/show/117225。 

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

JDBC连接方法： 

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

proxool.xml 代码 

xml 代码 

   1. <!--sp-->xml version="1.0" encoding="UTF-8"?>    

   2.   

   3. <!-- the proxool configuration can be embedded within your own application's. Anything outside the "proxool" tag is ignored. -->    

   4.   

   5. <something-else-entirely>  

   6.     <proxool>  

   7.         <!--连接池的别名-->  

   8.         <alias>DBPoolalias>  

   9.         <!--proxool只能管理由自己产生的连接-->  

  10.         <driver-url>jdbc:oracle:thin:@192.168.0.40:1521:drcomdriver-url>  

  11.         <!--JDBC驱动程序-->  

  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.         <!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁-->  

  18.         <house-keeping-sleep-time>90000house-keeping-sleep-time>  

  19.         <!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->    

  20.         <maximum-new-connections>150maximum-new-connections>  

  21.         <!-- 最少保持的空闲连接数-->    

  22.         <prototype-count>3prototype-count>  

  23.         <!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->    

  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. <!--sp-->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的数据源。