使用dbcp做为数据库连接池

/** *//**
 * 负责管理数据库连接。池化操作在这里进行。建议采用Apache Commons来实现。
 * 
 * 
 * 
 */
public class BaseDAO implements IBaseDAO ...{
    
    private static Logger log = Logger.getLogger(BaseDAO.class);

    protected static IConfiguration baseLineConfigure;

    private static Class driverClass = null;

    private static GenericObjectPool connectionPool = null;

    protected Connection conn = null;

    protected IDialect dialect = DialectFactory.getDialect();

    /**//*
     * (non-Javadoc)
     * 
     * @see com.ultrapower.baseline.dao.IBaseDAO#getConnection()
     */
    /** *//**
     * 初使化配置信息
     */
    private static void initConfigure() ...{
        baseLineConfigure = XmlConfiguration.getInstance();
    }

    /** *//**
     * 初始化数据源
     */
    private static synchronized void initDataSource() ...{
        if (baseLineConfigure == null) ...{
            initConfigure();
        }
        try ...{
            driverClass = Class.forName(baseLineConfigure.getDriver());
        }
        catch (ClassNotFoundException e) ...{
            e.printStackTrace();
        }
    }

    /** *//**
     * 连接池启动
     * 
     * @throws Exception
     */
    public static void startPool() ...{
        initDataSource();
        if (connectionPool != null) ...{
            ShutdownPool();
        }
        try ...{
            connectionPool = new GenericObjectPool(null);
            connectionPool.setMaxActive(10);
            byte value = 2;
            connectionPool.setWhenExhaustedAction(value);
            ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(baseLineConfigure.getUrl(),
                    baseLineConfigure.getUserName(), baseLineConfigure.getPassWord());
            PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,
                    connectionPool, null, null, false, true);
            Class.forName("org.apache.commons.dbcp.PoolingDriver");
            PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
            driver.registerPool("dbpool", connectionPool);
            if (log.isInfoEnabled()) ...{
                log.info("装配连接池OK");
            }
        }
        catch (Exception e) ...{
            e.printStackTrace();
        }
    }

    /** *//**
     * 释放连接池
     */
    public static void ShutdownPool() ...{
        try ...{
            PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
            driver.closePool("dbpool");
        }
        catch (SQLException e) ...{
            e.printStackTrace();
        }
    }

    public synchronized Connection getConnection() ...{
        // Connection conn = null;
        if (connectionPool == null)
            startPool();
        try ...{
            conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:dbpool");
        }
        catch (SQLException e) ...{
            e.printStackTrace();
        }
        // conn.
        return conn;
    }

    // public void closeConnection() {
    // try {
    // if (conn != null && !conn.isClosed()) {
    // conn.close();
    // }
    // }
    // catch (SQLException e) {
    // e.printStackTrace();
    // }
    //    }

    /** *//**
     * 执行带参数的查询SQL
     * 
     * @param sql
     * @param params
     * @return
     */
    protected ResultSet executeQuery(String sql, List params) ...{
        // TODO Auto-generated method stub
        Connection con = this.getConnection();
        try ...{
//            CallableStatement pa =    con.prepareCall(sql, ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);
            PreparedStatement pa = con.prepareStatement(sql);
            dialect.parserSQL(pa, params);
            ResultSet rs = pa.executeQuery();
//            pa.close();
            return rs;
        }
        catch (SQLException e) ...{
            log.error(e.getMessage(), e);
            throw new BaseLineException("", "", e);
        }
        finally ...{
            // this.closeConnection();
        }
    }

    /** *//**
     * 执行不带参数的SQL
     * 
     * @param sql
     * @return
     */
    protected boolean execute(String sql) ...{
        // TODO Auto-generated method stub
        return this.execute(sql, null);
    }

    /** *//**
     * 执行带参数的SQL
     * 
     * @param sql
     * @param params
     * @return
     */
    protected boolean execute(String sql, List<Object> params) ...{
        // TODO Auto-generated method stub
        Connection con = this.getConnection();
        try ...{
            // con.setAutoCommit(false);
            PreparedStatement pa = con.prepareStatement(sql);
            dialect.parserSQL(pa, params);
            pa.execute();
            pa.close();
            con.close();
            return true;
        }
        catch (SQLException e) ...{
            log.error(e.getMessage(), e);
            try ...{
                con.rollback();
                con.close();
            }
            catch (SQLException e1) ...{
                log.error(e1.getMessage(), e1);
                return false;
            }
            return false;
        }
    }

    /** *//**
     * 执行不带参数的查询SQL
     * 
     * @param sql
     * @return
     */
    protected ResultSet executeQuery(String sql) ...{
        // TODO Auto-generated method stub
        return this.executeQuery(sql, null);
    }

    /** *//**
     * 返回查询不带参数的第一条数据
     * 
     * @param sql
     * @return
     */
    protected Object executeSingleQuery(String sql) ...{
        // TODO Auto-generated method stub
        return this.executeSingleQuery(sql, null);
    }

    /** *//**
     * 返回查询带参数的第一条数据
     * 
     * @param sql
     * @param params
     * @return
     */
    protected Object executeSingleQuery(String sql, List<Object> params) ...{
        // TODO Auto-generated method stub
        try ...{
            ResultSet rs = this.executeQuery(sql, params);
            if (rs != null && rs.next()) ...{
                return rs.getObject(1);
            }
        }
        catch (SQLException e) ...{
            log.error(e.getMessage(), e);
        }
        return null;
    }

    /** *//**
     * 返回一个简单实现类
     * 
     * @return
     */
    public static BaseDAO getSimpleInstance() ...{
        BaseDAO dao = new DefatulBaseDAO();
        return dao;
    }

    /** *//**
     * 简单实现类
     * 
     * 
     */
    static class DefatulBaseDAO extends BaseDAO ...{
        public DefatulBaseDAO() ...{
        }
    }

}

使用dbcp做为数据库连接池- -
                                       

在数据库应用中，数据库连接过程需要较长的时间。
而且，频繁的连接数据库会增加数据库系统的压力。
所以，最好在项目中使用数据库连接池来减少数据库连接的数量提高数据库访问效率。

DBCP是Apache的一个开源项目：
commons.dbcp
http://jakarta.apache.org/commons/dbcp/index.html

DBCP依赖Apache的另外2个开源项目
commons.collections
和
commons.pool

下载这些包并将这些包的路径添加到classpath中就可以使用dbcp做为项目中的数据库连接池使用了。

下面是一段示例代码，简单说说dbcp的使用方法：

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.PoolingDriver;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;

public class DaoUtil ...{
    
    /** *//**
     * 数据库连接池
     * @see http://jakarta.apache.org/commons/dbcp/index.html
     */
    private static PoolingDriver driver = null;
    
   
    /** *//**
     * 设置一个数据库连接池
     * 
     * @param name 连接池的名称
     * @param url 数据源
     * @throws SQLException
     */
    private static void setUpPool(String poolname, String url,String username,String password) throws SQLException...{
        if ((driver == null) || driver.getPoolNames().length < 2) ...{
            try ...{
                /** *//**
                 * 首先创建一个对象池来保存数据库连接
                 * 
                 * 使用 commons.pool 的 GenericObjectPool对象
                 */
                ObjectPool connectionPool = new GenericObjectPool(null);
                
                connectionPool.setMaxActive(10);
                      byte value = 2;
                      connectionPool.setWhenExhaustedAction(value);
                /** *//**
                 * 创建一个 DriverManagerConnectionFactory对象
                 * 连接池将用它来获取一个连接
                 */
                ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(url, username,password);
                
                /** *//**
                 * 创建一个PoolableConnectionFactory 对象。
                 */
                PoolableConnectionFactory poolableConnectionFactory = 
                    new PoolableConnectionFactory(connectionFactory,connectionPool,null,null,false,true);
                
                /** *//**
                 * 注册PoolingDriver。
                 */
                Class.forName("org.apache.commons.dbcp.PoolingDriver");
                
                driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
                
                driver.registerPool(poolname,  connectionPool);
                
            }
            catch (ClassNotFoundException e) ...{
                throw new RuntimeException(e);
            }
        }
    }
    
    /** *//**
     * 关闭所有数据库连接池
     *
     */
    public static void shutDownPool() ...{
        
        try ...{          
            PoolingDriver driver = (PoolingDriver)DriverManager.getDriver("jdbc:apache:commons:dbcp:");
            for (int i = 0; i < poolNames.length; i++) ...{
                driver.closePool("pool");
            }
        }
        catch (SQLException sqle) ...{
            throw new RuntimeException(sqle);
        }
    }

    /** *//**
     * 取得一个数据库连接对象。
     * 
     * 因为可能使用两个不同的数据库，
     * 所以依据report的值来确定使用那个数据库。
     * 
     * @param report
     * @return
     */
    public static Connection getConnection(String poolName) ...{
        Connection con = null;
        
        try ...{
            //装载mysql的jdbc驱动
            String driver = "com.mysql.jdbc.Driver";
            String url = "jdbc:mysql://server/db";    
            String username = "root";    
            String password = "123456";    
                          
            Class.forName(driver);
            setUpPool(poolName, url,username,password);
            con = DriverManager.getConnection("jdbc:apache:commons:dbcp:" + poolName);
            return con;
        }
        catch (ClassNotFoundException cnfe) ...{
            throw new RuntimeException("无法装入数据库引擎") ;
        } 
        catch (SQLException sqle) ...{
            throw new RuntimeException("无法打开数据库连接");
        }
    }
    
    /** *//**
     * 执行清理过程
     * 
     * <li>关闭数据库连接</li>
     * <li>关闭语句对象</li>
     * <li>关闭结果集</li>
     * 
     * @param con
     * @param s
     * @param rs
     */
    public static void closeAll(Connection con, Statement s, ResultSet rs) ...{
        try ...{
            if (rs != null) ...{
                rs.close();
                rs = null;
            }
            
            if (s != null) ...{
                s.close();
                s = null;
            }
            
            if (con != null) ...{
                con.close();
                con = null;
            }
        } 
        catch (SQLException sqle) ...{
            //nothing to do, forget it;
        }
    }
    
}

 

 使用jakarta commons-dbcp配置数据库连接池

Commons DBCP需要三个.jar：

    commons-collections-3.1.jar、commons-dbcp-1.2.1.jar、commons-pool-1.2.jar

public class DpcpTest ...{
    private static BasicDataSource bds = new BasicDataSource();

    private static ConnectionFactory fac = null;

    public DpcpTest() ...{
        // 初始化连接池
        bds.setDriverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); // 数据库驱动程序
        bds.setUrl("jdbc:sqlserver://localhost:1433; DatabaseName=TestHibernate"); // 数据库url
        bds.setUsername("liyong1"); // dba帐号
        bds.setPassword("123456"); // 密码
        bds.setMaxActive(200); //初始化连接数量
        bds.setMaxIdle(100); // 最大idle数
        bds.setMaxWait(1000 * 600); // 超时回收时间
        
        fac = new DataSourceConnectionFactory(bds); // 得到连接工厂
    }

    public Connection getConnection() throws Exception ...{
        //return bds.getConnection();
                                             return fac.createConnection();
    }

    public static void main(String[] args) ...{
        try ...{
            DpcpTest dpcpTest = new DpcpTest();
            Connection connection = dpcpTest.getConnection();
            for(int i=0 ;i<100;i++)...{
                Connection connection1=    dpcpTest.getConnection();
                System.out.println(i+"、连接数："+i+","+connection1.toString());
            }
        }
        catch (Exception e) ...{
            e.printStackTrace();
        }
    }
}

  conn.close(); //释放连接，回到池中  
  
    //销毁连接池  
    bds.close();  
    bds=null;  
    fac=null;

jakarta commons-dbcp
1.DBCP简介
网络程序的设计，很多都涉及到和关系型数据库的交互操作，一般的操作方式都是使用的时候创建到数据库的连
接，然后进行各种操作，这种简单的操作方式带来的问题便是数据库的频繁的打开和关闭，以及Transtion的执
行，这是一种很耗费时间和资源的操作。于是数据库缓冲池DBCP就出现了，这个包是从pool包发展出来的。
2.DBCP实现的基本流程
  1.创建enericObjectPool实例
  GenericObjectPool pool = new GenericObjectPool(null);
  2.创建PoolableConnectionFactory
  DriverManagerConnectionFactory cf =
    new DriverManagerConnectionFactory(
    "jdbc:mysql://host/db", "username", "password"); 

PoolableConnectionFactory pcf =
    new PoolableConnectionFactory(
    CF, pool, null, "SELECT * FROM mysql.db", false, true);
  3.创建和注册PoolingDriver
  new PoolingDriver().registerPool("myPool", pool);
  到此为止,数据库缓冲池就创建完毕了.
3.DataSource的实现过程
DataSource在众多的jsp容器和应用程序中都已经实现，在容器或者应用服务器启动的时候，他会读取相关的
配置文件，自动完成DataSource的创建工作，我们一般只需要在服务器的配置文件中指定就可以了，这里贴出
实现的过程，便于大家理解它内部的实现机制，便于编程参考。
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.commons.dbcp.BasicDataSource;
public class BasicDataSourceExample ...{

    public static void main(String[] args) ...{
        // 创建BasicDataSource
        System.out.println("Setting up data source.");
        DataSource dataSource = setupDataSource(args[0]);
        System.out.println("Done.");

 //创建JDBC数据源
        Connection conn = null;
        Statement stmt = null;
        ResultSet rset = null;

        try ...{
            System.out.println("Creating connection.");
            conn = dataSource.getConnection();
            System.out.println("Creating statement.");
            stmt = conn.createStatement();
            System.out.println("Executing statement.");
            rset = stmt.executeQuery(args[1]);
            System.out.println("Results:");
            int numcols = rset.getMetaData().getColumnCount();
            while(rset.next()) ...{
                for(int i=1;i<=numcols;i++) ...{
                    System.out.print(" " + rset.getString(i));
                }
                System.out.println("");
            }
        } catch(SQLException e) ...{
            e.printStackTrace();
        } finally ...{
            try ...{ rset.close(); } catch(Exception e) ...{ }
            try ...{ stmt.close(); } catch(Exception e) ...{ }
            try ...{ conn.close(); } catch(Exception e) ...{ }
        }
    }
    //创建数据源
    public static DataSource setupDataSource(String connectURI) ...{
        BasicDataSource ds = new BasicDataSource();
        ds.setDriverClassName("oracle.jdbc.driver.OracleDriver");
        ds.setUsername("scott");
        ds.setPassword("tiger");
        ds.setUrl(connectURI);
        return ds;
    }
    //提示数据源状态
    public static void printDataSourceStats(DataSource ds) throws SQLException ...{
        BasicDataSource bds = (BasicDataSource) ds;
        System.out.println("NumActive: " + bds.getNumActive());
        System.out.println("NumIdle: " + bds.getNumIdle());
    }
    //关闭数据源
    public static void shutdownDataSource(DataSource ds) throws SQLException ...{
        BasicDataSource bds = (BasicDataSource) ds;
        bds.close();
    }
}
例子比较简单，不再多说了~
4.tomcat中DBCP的配置
这里是以Mysql作为数据库进行说明。
使用DBCP，在 server.xml 中需要设置相关的连接及 dbcp 的参数值. 
 <Context path="/MysqlTest" docBase="MysqlTest"
                    debug="5" reloadable="true" crossContext="true">
 
     <Logger className="org.apache.catalina.logger.FileLogger"
                 prefix="localhost_MysqlTest_log." suffix=".txt"
                 timestamp="true"/>
                 
    <Resource name="jdbc/TestDB"  auth="Container" type="javax.sql.DataSource"/>
    
    <ResourceParams name="jdbc/TestDB">
        <parameter>
            <name>factory</name>
            <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
        </parameter>
        <parameter>
            <name>maxActive</name>
            <value>100</value>
        </parameter>
        <parameter>
            <name>maxIdle</name>
            <value>30</value>
        </parameter>
        <parameter>
            <name>maxWait</name>
            <value>10000</value>
        </parameter>
        <parameter>
            <name>username</name>
            <value>root</value>
        </parameter>
        <parameter>
            <name>password</name>
            <value>admin</value>
        </parameter>
        <parameter>
            <name>driverClassName</name>
            <value>org.gjt.mm.mysql.Driver</value>
        </parameter>
        <parameter>
            <name>url</name>
            <value>jdbc:mysql://localhost:3306/javatest?autoReconnect=true</value>
        </parameter>
      </ResourceParams>
</Context>
我们可以看到他使用的 dbcp factory 就是 org.apache.commons.dbcp.BasicDataSourceFactory
5.参数说明
*dataSource:要连接的 datasource (通常我们不会定义在 server.xml) 
*defaultAutoCommit:对于事务是否 autoCommit, 默认值为 true 
*defaultReadOnly:对于数据库是否只能读取, 默认值为 false 
*driverClassName:连接数据库所用的 JDBC Driver Class, 
*maxActive:最大连接数据库连接数,设 0 为没有限制 
*maxIdle:最大等待连接中的数量,设 0 为没有限制 
*maxWait:最大等待秒数, 单位为 ms, 超过时间会丟出错误信息 
*password:登陆数据库所用的密码 
*url:连接数据库的 URL 
*username:登陆数据库所用的帐号 
*validationQuery:验证连接是否成功, SQL SELECT 指令至少要返回一行 
*removeAbandoned:是否自我中断, 默认是 false 
*removeAbandonedTimeout:几秒后会自我中断, removeAbandoned 必须为 true 
*logAbandoned:是否记录中断事件, 默认为 false
6.总结
DBCP一般应用在数据库的使用非常频繁的情况下使用，它可以处理大量的数据库的连接请求，不失为做大型站
点的首选数据库配置