proxool資料連線池

首先從 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的資料來源。