proxool

作为开源的连接池Proxool 有以下优点：

透明性   可以明的添加接连池而不影响你原来的项目的JDBC代码；

开放性 你可以方便的与其它的开源产品进行整合。如hibernate  中自带的这个Proxool ；

标准性 它是在J2SE下开出来的。你可以放心的开发；

易用性  非常容易 的进行配置。

proxool 是一个非常强大的连接池工具包，我觉得相比dbcp、c3p0这两个连接池包都要好用，我用loadrunner测试过，这三个连接池的从性能上排名如 下：proxool>c3p0>dbcp，特别是dbcp在大并发的情况下总是出现各种异常。

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

JDBC连接方法：

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

proxool.xml 代码

XML/HTML代码

<?xml version="1.0" encoding="UTF-8"?>

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

<something-else-entirely>
    <proxool>
        <!--连接池的别名-->
        <alias>DBPool</alias>
        <!--proxool只能管理由自己产生的连接-->
        <driver-url>jdbc:oracle:thin:@192.168.0.40:1521:drcom</driver-url>
        <!--JDBC驱动程序-->
        <driver-class>oracle.jdbc.driver.OracleDriver</driver-class>
        <driver-properties>
            <property name="user" value="drcom"/>
            <property name="password" value="drcom"/>
        </driver-properties>
        <!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁-->
        <house-keeping-sleep-time>90000</house-keeping-sleep-time>
        <!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->
        <maximum-new-connections>150</maximum-new-connections>
        <!-- 最少保持的空闲连接数-->
        <prototype-count>3</prototype-count>
        <!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->
        <maximum-connection-count>100</maximum-connection-count>
        <!-- 最小连接数-->
        <minimum-connection-count>3</minimum-connection-count>
    </proxool>
</something-else-entirely>

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

web.xml 代码

XML/HTML代码

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <servlet>
        <servlet-name>ServletConfigurator</servlet-name>
        <servlet-class>
            org.logicalcobwebs.proxool.configuration.ServletConfigurator
        </servlet-class>
        <init-param>
            <param-name>xml</Fileparam-name>
            <param-value>WEB-INF/proxool.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>Admin</servlet-name>
        <servlet-class>
            org.logicalcobwebs.proxool.admin.servlet.AdminServlet
        </servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Adminservlet-name>
        <url-pattern>/adminurl-pattern>
    </servlet-mapping>
    <servlet>
        <servlet-name>TestServlet</servlet-name>
        <servlet-class>
            selfservice.TestServlet
        </servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>TestServlet</servlet-name>
        <url-pattern>/TestServlet</url-pattern>
    </servlet-mapping>
</web-app>

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

ActionScript/Java代码

java 代码

package selfservice;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.ProxoolFacade;
import org.logicalcobwebs.proxool.admin.SnapshotIF;


public class PoolManager {

    private static int activeCount = 0;


    public PoolManager(){

    }
    /**
     * 获取连接
     * getConnection
     * @param name
     * @return
     */
    public Connection getConnection() {
        try{
            Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");//proxool驱动类
            Connection conn = DriverManager.getConnection("proxool.DBPool");
           //此处的DBPool是在proxool.xml中配置的连接池别名
            showSnapshotInfo();

            return conn;
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return null;
    }
    /**
     * 此方法可以得到连接池的信息
     * showSnapshotInfo
     */
    private void showSnapshotInfo(){
        try{
            SnapshotIF snapshot = ProxoolFacade.getSnapshot("DBPool", true);
            int curActiveCount=snapshot.getActiveConnectionCount();//获得活动连接数
            int availableCount=snapshot.getAvailableConnectionCount();//获得可得到的连接数
            int maxCount=snapshot.getMaximumConnectionCount() ;//获得总连接数
            if(curActiveCount!=activeCount)//当活动连接数变化时输出的信息
            {
             System.out.println("活动连接数:"+curActiveCount+"(active)  可得到的连接数:"+availableCount+"(available)  总连接数:"+maxCount+" (max)");
             activeCount=curActiveCount;
            }
        }catch(ProxoolException e){
            e.printStackTrace();
        }
    }
    /**
     * 获取连接
     * getConnection
     * @param name
     * @return
     */
    public Connection getConnection(String name){
        return getConnection();
    }
    /**
     * 释放连接
     * freeConnection
     * @param conn
     */
    public void freeConnection(Connection conn){
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 释放连接
     * freeConnection
     * @param name
     * @param con
     */
    public void freeConnection (String name,Connection con){
        freeConnection(con);
    }

    public void getQuery() {
        try {
            Connection conn = getConnection();
            if(conn != null){
                Statement statement = conn.createStatement();
                ResultSet rs = statement.executeQuery("select * from tblgxinterface");
                int c = rs.getMetaData().getColumnCount();
                while(rs.next()){
                    System.out.println();
                    for(int i=1;i<=c;i++){
                        System.out.print(rs.getObject(i));
                    }
                }
                rs.close();
            }
            freeConnection(conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

}

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

Hibernate中proxool连接池的方式：

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

第二步在hibernate的配置文件hibernate.cfg.xml中配置proxool连接设置：


hibernate.cfg.xml代码

XML/HTML代码

<property name="hibernate.connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</property>
            <property name="hibernate.proxool.pool_alias">DBPool</property>
            <property name="hibernate.proxool.xml">proxool.xml</property>

Spring中proxool连接池的方式：

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

第二步在spring配置文件applicationContext.xml中配置proxool连接设置

applicationContext.xml代码

XML/HTML代码

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" singleton="true">
        <property name="driverClassName" value="org.logicalcobwebs.proxool.ProxoolDriver"/>
        <property name="url" value="proxool.StatDBPool"/>
    </bean>
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref local="dataSource" />
        </property>
    </bean>

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

proxool还有很多功能，我这只是简单的应用。

具体请察看proxool用户指南。

来自JavaWorld的资料：http://www.javaworld.com.tw/confluence/display/opensrc/Proxool

如果您复制代码的时候，也包含了行号，可用 UltraEdit-32处理一下，非常方便。