dbcp配置

本文详细介绍了 Apache DBCP 的基本参数配置及应用示例,包括如何在 Spring 和 Hibernate 中整合使用,同时提供了核心参数的解释与优化配置方案。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

http://sjsky.iteye.com/blog/1105674


    blog迁移至:http://www.micmiu.com

本文主要介绍apache-dbcp基本参数配置和应用示例,dbcp目前最新版是1.4需要在jdk1.6的环境下运行,如果要在jdk1.4、1.5环境下运行,需要下载前一版本1.3,具体详细可以查看它的官网。
本文结构目录分两大部分:

  • 一、基础参数说明
  • 二、dbcp在spring、hibernate等应用中的配置示例
以后会陆续给出有关c3p0、proxool等相关参数介绍和应用配置实例。

c3p0的配置介绍已经发表参见:http://sjsky.iteye.com/blog/1107197

proxool的配置介绍已经发表参见:http://sjsky.iteye.com/blog/1108808

[ 一 ]、参数介绍
[ 1 ]、基础参数说明
  • defaultAutoCommit: 对于事务是否 autoCommit, 默认值为 true
  • defaultReadOnly:对于数据库是否只能读取, 默认值为 false
  • initialSize:连接池启动时创建的初始化连接数量(默认值为0)
  • driverClassName:连接数据库所用的 JDBC Driver Class,
  • url: 连接数据库的 URL
  • username:登陆数据库所用的帐号
  • password: 登陆数据库所用的密码
  • maxActive: 连接池中可同时连接的最大的连接数,为0则表示没有限制,默认为8
  • maxIdle: 连接池中最大的空闲的连接数(默认为8,设 0 为没有限制),超过的空闲连接将被释放,如果设置为负数表示不限制(maxIdle不能设置太小,因为假如在高负载的情况下,连接的打开时间比关闭的时间快,会引起连接池中idle的个数 上升超过maxIdle,而造成频繁的连接销毁和创建)
  • minIdle:连接池中最小的空闲的连接数(默认为0,一般可调整5),低于这个数量会被创建新的连接(该参数越接近maxIdle,性能越好,因为连接的创建和销毁,都是需要消耗资源的;但是不能太大,因为在机器很空闲的时候,也会创建低于minidle个数的连接)
  • maxWait: 超过时间会丟出错误信息 最大等待时间(单位为 ms),当没有可用连接时,连接池等待连接释放的最大时间,超过该时间限制会抛出异常,如果设置-1表示无限等待(默认为-1,一般可调整为60000ms,避免因线程池不够用,而导致请求被无限制挂起)
  • validationQuery: 验证连接是否成功, SQL SELECT 指令至少要返回一行
  • removeAbandoned:超过removeAbandonedTimeout时间后,是否进行没用连接的回收(默认为false)
  • removeAbandonedTimeout: 超过时间限制,回收五用的连接(默认为 300秒),removeAbandoned 必须为 true
  • logAbandoned: 是否记录中断事件, 默认为 false
一般优化的配置示例:
Xml代码   收藏代码
  1. <bean id="dbcpDataSource"  
  2.         class="org.apache.commons.dbcp.BasicDataSource"  
  3.         destroy-method="close">  
  4.         <property name="driverClassName"  
  5.             value="${jdbc.driverClassName}" />  
  6.         <property name="url" value="${jdbc.url}" />  
  7.         <property name="username" value="${jdbc.username}" />  
  8.         <property name="password" value="${jdbc.password}" />  
  9.         <property name="maxActive" value="20" />  
  10.         <property name="initialSize" value="1" />  
  11.         <property name="maxWait" value="60000" />  
  12.         <property name="maxIdle" value="15" />  
  13.         <property name="minIdle" value="5" />  
  14.         <property name="removeAbandoned" value="true" />  
  15.         <property name="removeAbandonedTimeout" value="180" />  
  16.         <property name="connectionProperties">  
  17.             <value>clientEncoding=utf-8</value>  
  18.         </property>  
  19.     </bean>  


[ 2 ]、validate配置参数说明
  • minEvictableIdleTimeMillis:大于0 ,进行连接空闲时间判断,或为0,对空闲的连接不进行验证;默认30分钟
  • timeBetweenEvictionRunsMillis:失效检查线程运行时间间隔,如果小于等于0,不会启动检查线程,默认-1
  • testOnBorrow:在进行borrowObject进行处理时,对拿到的connection进行validateObject校验,默认为false
  • testOnReturn:就是在进行returnObject对返回的connection进行validateObject校验,默认为false
  • testWhileIdle:GenericObjectPool中针对pool管理,起了一个Evict的TimerTask定时线程进行控制(可通过设置参数timeBetweenEvictionRunsMillis>0),定时对线程池中的链接进行validateObject校验,对无效的链接进行关闭后,会调用ensureMinIdle,适当建立链接保证最小的minIdle连接数,默认为false
  • numTestsPerEvictionRun:每次检查链接的数量,建议设置和maxActive一样大,这样每次可以有效检查所有的链接.
  • validateQuery:验证检查执行的sql
  • validateQueryTimeout:在执行检查时超时设置,通过statement 设置,statement.setQueryTimeout(validationQueryTimeout)
配置示例:
Xml代码   收藏代码
  1. <property name="testWhileIdle" value="true" />  
  2. <property name="testOnBorrow" value="false" />  
  3. <property name="testOnReturn" value="false" />  
  4. <property name="validationQuery">  
  5.     <value>select sysdate from dual</value>  
  6. </property>  
  7. <property name="validationQueryTimeout" value="1" />  
  8. <property name="timeBetweenEvictionRunsMillis" value="30000" />  
  9. <property name="numTestsPerEvictionRun" value="20" />  

[ 二 ]、dbcp在spring、hibernate等应用中的配置示例
dbcp.jdbc.properties
Java代码   收藏代码
  1. jdbc.driverClassName=com.mysql.jdbc.Driver  
  2. jdbc.url=jdbc:mysql://localhost/iecms  
  3. jdbc.username=root  
  4. jdbc.password=  

[ 1 ]、最基本的应用
Java代码   收藏代码
  1. package michael.jdbc.dbcp;  
  2.   
  3. import javax.sql.DataSource;  
  4. import java.sql.Connection;  
  5. import java.sql.Statement;  
  6. import java.sql.ResultSet;  
  7. import java.sql.SQLException;  
  8. import java.util.Properties;  
  9.   
  10. import org.apache.commons.dbcp.BasicDataSource;  
  11.   
  12. /** 
  13.  * @see http://sjsky.iteye.com 
  14.  * @author michael sjsky007@gmail.com 
  15.  */  
  16. public class DbcpDataSourceExample {  
  17.   
  18.     /** 
  19.      * @param args 
  20.      */  
  21.     public static void main(String[] args) {  
  22.   
  23.         String testSql = "select * from TB_MYTEST";  
  24.         String cfgFileName = "dbcp.jdbc.properties";  
  25.   
  26.         System.out.println("Setting up data source.");  
  27.         DataSource dataSource = setupDataSource(cfgFileName);  
  28.         System.out.println("dataSource Done.");  
  29.   
  30.         printDataSourceStats(dataSource);  
  31.   
  32.         Connection conn = null;  
  33.         Statement stmt = null;  
  34.         ResultSet rset = null;  
  35.   
  36.         try {  
  37.             System.out.println("Creating connection start.");  
  38.             conn = dataSource.getConnection();  
  39.   
  40.             System.out.println("Creating statement start.");  
  41.             stmt = conn.createStatement();  
  42.   
  43.             System.out.println("Executing statement start.");  
  44.             rset = stmt.executeQuery(testSql);  
  45.   
  46.             System.out.println("executeQuery Results:");  
  47.             int numcols = rset.getMetaData().getColumnCount();  
  48.   
  49.             while (rset.next()) {  
  50.                 for (int i = 1; i <= numcols; i++) {  
  51.                     System.out.print("\t" + rset.getString(i));  
  52.                 }  
  53.                 System.out.println("");  
  54.             }  
  55.             System.out.println("Results display done.");  
  56.         } catch (SQLException e) {  
  57.             e.printStackTrace();  
  58.         } finally {  
  59.             try {  
  60.                 if (rset != null)  
  61.                     rset.close();  
  62.             } catch (Exception e) {  
  63.             }  
  64.             try {  
  65.                 if (stmt != null)  
  66.                     stmt.close();  
  67.             } catch (Exception e) {  
  68.             }  
  69.             try {  
  70.                 if (conn != null)  
  71.                     conn.close();  
  72.                 shutdownDataSource(dataSource);  
  73.             } catch (Exception e) {  
  74.             }  
  75.   
  76.         }  
  77.     }  
  78.   
  79.     /** 
  80.      * @param cfgFileName 
  81.      * @return DataSource 
  82.      */  
  83.     public static DataSource setupDataSource(String cfgFileName) {  
  84.         BasicDataSource ds = new BasicDataSource();  
  85.         try {  
  86.             Properties cfgpp = new Properties();  
  87.             cfgpp.load(DbcpDataSourceExample.class  
  88.                     .getResourceAsStream(cfgFileName));  
  89.             ds.setDriverClassName(cfgpp.getProperty("jdbc.driverClassName"));  
  90.             ds.setUrl(cfgpp.getProperty("jdbc.url"));  
  91.             ds.setUsername(cfgpp.getProperty("jdbc.username"));  
  92.             ds.setPassword(cfgpp.getProperty("jdbc.password"));  
  93.         } catch (Exception e) {  
  94.             e.printStackTrace();  
  95.             return null;  
  96.         }  
  97.   
  98.         return ds;  
  99.     }  
  100.   
  101.     /** 
  102.      * @param ds 
  103.      */  
  104.     public static void printDataSourceStats(DataSource ds) {  
  105.         BasicDataSource bds = (BasicDataSource) ds;  
  106.         System.out.println("NumActive: " + bds.getNumActive());  
  107.         System.out.println("NumIdle: " + bds.getNumIdle());  
  108.     }  
  109.   
  110.     /** 
  111.      * @param ds 
  112.      * @throws SQLException 
  113.      */  
  114.     public static void shutdownDataSource(DataSource ds) throws SQLException {  
  115.         BasicDataSource bds = (BasicDataSource) ds;  
  116.         bds.close();  
  117.     }  
  118. }  

运行结果:
引用
Setting up data source.
dataSource Done.
NumActive: 0
NumIdle: 0
Creating connection start.
Creating statement start.
Executing statement start.
executeQuery Results:
1 batch add 0 2011-06-16 14:29:08.0
2 batch add 1 2011-06-16 14:29:08.0
3 batch add 2 2011-06-16 14:29:08.0
4 batch add 3 2011-06-16 14:29:08.0
5 batch add 4 2011-06-16 14:29:08.0
Results display done.

[ 2 ]、结合spring的应用测试
Xml代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
  3. <beans>  
  4.     <bean id="propertyConfigurer"  
  5.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  6.         <property name="locations">  
  7.             <list>  
  8.                 <value>  
  9.                     classpath:michael/jdbc/dbcp/dbcp.jdbc.properties  
  10.                 </value>  
  11.             </list>  
  12.         </property>  
  13.     </bean>  
  14.   
  15.     <bean id="dbcpDataSource"  
  16.         class="org.apache.commons.dbcp.BasicDataSource"  
  17.         destroy-method="close">  
  18.         <property name="driverClassName"  
  19.             value="${jdbc.driverClassName}" />  
  20.         <property name="url" value="${jdbc.url}" />  
  21.         <property name="username" value="${jdbc.username}" />  
  22.         <property name="password" value="${jdbc.password}" />  
  23.         <property name="maxActive" value="20" />  
  24.         <property name="initialSize" value="1" />  
  25.         <property name="maxWait" value="60000" />  
  26.         <property name="maxIdle" value="15" />  
  27.         <property name="minIdle" value="5" />  
  28.         <property name="removeAbandoned" value="true" />  
  29.         <property name="removeAbandonedTimeout" value="180" />  
  30.         <property name="connectionProperties">  
  31.             <value>clientEncoding=utf-8</value>  
  32.         </property>  
  33.     </bean>  
  34.   
  35. </beans>  

Java代码   收藏代码
  1. package michael.jdbc.dbcp;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.ResultSet;  
  5. import java.sql.SQLException;  
  6. import java.sql.Statement;  
  7.   
  8. import javax.sql.DataSource;  
  9.   
  10. import org.apache.commons.dbcp.BasicDataSource;  
  11. import org.springframework.context.ApplicationContext;  
  12. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  13.   
  14. /** 
  15.  * @see http://sjsky.iteye.com 
  16.  * @author michael sjsky007@gmail.com 
  17.  */  
  18. public class DbcpSpringExample {  
  19.   
  20.     /** 
  21.      * @param args 
  22.      */  
  23.     public static void main(String[] args) {  
  24.         System.out.println("spring xml init start ");  
  25.         ApplicationContext appCt = new ClassPathXmlApplicationContext(  
  26.                 "michael/jdbc/dbcp/dbcp.ds.spring.xml");  
  27.   
  28.         System.out.println("spring bean create DataSource");  
  29.         DataSource dataSource = (BasicDataSource) appCt  
  30.                 .getBean("dbcpDataSource");  
  31.   
  32.         String testSql = "select * from TB_MYTEST";  
  33.   
  34.         Connection conn = null;  
  35.         Statement stmt = null;  
  36.         ResultSet rset = null;  
  37.   
  38.         try {  
  39.             System.out.println("Creating connection start.");  
  40.             conn = dataSource.getConnection();  
  41.   
  42.             System.out.println("Creating statement start.");  
  43.             stmt = conn.createStatement();  
  44.   
  45.             System.out.println("Executing statement start.");  
  46.             rset = stmt.executeQuery(testSql);  
  47.   
  48.             System.out.println("executeQuery Results:");  
  49.             int numcols = rset.getMetaData().getColumnCount();  
  50.   
  51.             while (rset.next()) {  
  52.                 for (int i = 1; i <= numcols; i++) {  
  53.                     System.out.print("\t" + rset.getString(i));  
  54.                 }  
  55.                 System.out.println("");  
  56.             }  
  57.             System.out.println("Results display done.");  
  58.         } catch (SQLException e) {  
  59.             e.printStackTrace();  
  60.         } finally {  
  61.             try {  
  62.                 if (rset != null)  
  63.                     rset.close();  
  64.             } catch (Exception e) {  
  65.             }  
  66.             try {  
  67.                 if (stmt != null)  
  68.                     stmt.close();  
  69.             } catch (Exception e) {  
  70.             }  
  71.             try {  
  72.                 if (conn != null)  
  73.                     conn.close();  
  74.             } catch (Exception e) {  
  75.             }  
  76.   
  77.         }  
  78.   
  79.     }  
  80.   
  81. }  

运行结果:
引用
spring xml init start
spring bean create DataSource
Creating connection start.
Creating statement start.
Executing statement start.
executeQuery Results:
1 batch add 0 2011-06-16 14:29:08.0
2 batch add 1 2011-06-16 14:29:08.0
3 batch add 2 2011-06-16 14:29:08.0
4 batch add 3 2011-06-16 14:29:08.0
5 batch add 4 2011-06-16 14:29:08.0
Results display done.


[ 3 ]、结合hibernate的应用测试
DBCP在Hibernate2中受支持,目前在hibernate3.0,已经不再支持dbcp了,hibernate的作者在hibernate.org中,明确指出在实践中发现dbcp有 BUG,在某些种情会产生很多空连接不能释放,所以推荐使用c3p0连接,本文重点只是描述其基本使用配置,不是比较两者的优劣,故不过多展开描述。
Xml代码   收藏代码
  1. <!DOCTYPE hibernate-configuration  
  2.     PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"  
  3.     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  4.   
  5. <hibernate-configuration>  
  6.   
  7.     <session-factory>  
  8.         <!--database connection settings -->  
  9.         <property name="connection.driver_class">  
  10.             com.mysql.jdbc.Driver  
  11.         </property>  
  12.         <property name="connection.url">  
  13.             jdbc:mysql://localhost/iecms  
  14.         </property>  
  15.         <property name="connection.username">root</property>  
  16.         <property name="connection.password"></property>  
  17.   
  18.         <!-- dbcp -->  
  19.         <!-- 连接池的最大活动个数 -->  
  20.         <property name="dbcp.maxActive">100</property>  
  21.         <!-- 当连接池中的连接已经被耗尽的时候,DBCP将怎样处理( 0 = 失败, 1 = 等待, 2= 增长) -->  
  22.         <property name="dbcp.whenExhaustedAction">1</property>  
  23.         <!-- 最大等待时间(ms)  -->  
  24.         <property name="dbcp.maxWait">60000</property>  
  25.         <!-- 最大闲置的连接个数 -->  
  26.         <property name="dbcp.maxIdle">10</property>  
  27.         <!-- 下面是对 prepared statement -->  
  28.         <property name="dbcp.ps.maxActive">100</property>  
  29.         <property name="dbcp.ps.whenExhaustedAction">1</property>  
  30.         <property name="dbcp.ps.maxWait">60000</property>  
  31.         <property name="dbcp.ps.maxIdle">10</property>  
  32.   
  33.         <property name="current_session_context_class">thread</property>  
  34.         <property name="show_sql">false</property>  
  35.         <property name="dialect">  
  36.             org.hibernate.dialect.MySQL5Dialect  
  37.         </property>  
  38.   
  39.         <property name="hbm2ddl.auto">update</property>  
  40.     </session-factory>  
  41. </hibernate-configuration>  

Java代码   收藏代码
  1. package michael.jdbc.dbcp;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.hibernate.Session;  
  6. import org.hibernate.SessionFactory;  
  7. import org.hibernate.Transaction;  
  8. import org.hibernate.cfg.AnnotationConfiguration;  
  9. import org.hibernate.cfg.Configuration;  
  10.   
  11. /** 
  12.  * @see http://sjsky.iteye.com 
  13.  * @author michael sjsky007@gmail.com 
  14.  */  
  15. public class DbcpHibernateExample {  
  16.   
  17.     /** 
  18.      * @param args 
  19.      */  
  20.     public static void main(String[] args) {  
  21.         SessionFactory sessionFactory = null;  
  22.         try {  
  23.             System.out.println(" hibernate config start");  
  24.             Configuration config = new AnnotationConfiguration()  
  25.                     .configure("michael/jdbc/dbcp/hibernate.cfg.xml");  
  26.   
  27.             System.out.println(" create sessionFactory ");  
  28.             sessionFactory = config.buildSessionFactory();  
  29.   
  30.             System.out.println(" create session ");  
  31.             Session session = sessionFactory.getCurrentSession();  
  32.             String testSql = "select * from TB_MYTEST";  
  33.   
  34.             System.out.println(" beginTransaction ");  
  35.             Transaction ta = session.beginTransaction();  
  36.             org.hibernate.Query query = session.createSQLQuery(testSql);  
  37.             List<Object[]> list = query.list();  
  38.             System.out.println(" createSQLQuery list: ");  
  39.             for (Object[] objArr : list) {  
  40.                 for (Object obj : objArr) {  
  41.                     System.out.print("\t" + obj);  
  42.                 }  
  43.                 System.out.println("");  
  44.             }  
  45.             System.out.println(" beginTransaction commit ");  
  46.             ta.commit();  
  47.   
  48.         } catch (Exception e) {  
  49.             e.printStackTrace();  
  50.         } finally {  
  51.             if (null != sessionFactory) {  
  52.                 sessionFactory.close();  
  53.             }  
  54.   
  55.         }  
  56.   
  57.     }  
  58. }  

运行结果:
引用
hibernate config start
create sessionFactory
create session
beginTransaction
createSQLQuery list:
1 batch add 0 2011-06-16 14:29:08.0
2 batch add 1 2011-06-16 14:29:08.0
3 batch add 2 2011-06-16 14:29:08.0
4 batch add 3 2011-06-16 14:29:08.0
5 batch add 4 2011-06-16 14:29:08.0
beginTransaction commit

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值