如何在Hibernate中配置DBCP连接池

于 2020-05-25 00:51:28 发布
阅读量676 收藏
点赞数
文章标签： java php 数据库

注意
由于旧的DBCP代码中的错误，Hibernate不再维护基于DBCP的连接提供程序，请阅读此Hibernate线程 。

现在， Apache DBCP恢复了活跃的开发，并且修复了许多错误，并且现在更稳定了。 甚至Hibernate也没有附带C3P0和Proxool之类的连接提供程序，但是您仍然可以轻松地对其进行配置。

在本教程中，我们向您展示如何将Apache DBCP连接池与Hibernate框架集成。

1.获取DBCP jar

要将DBCP与Hibernate集成，您需要commons-dbcp.jar和commons-pool-1.5.4.jar 。

档案：pom.xml 

<project ...>

	<repositories>
		<repository>
			<id>JBoss repository</id>
			<url>http://repository.jboss.org/nexus/content/groups/public/</url>
		</repository>
	</repositories>

	<dependencies>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>3.6.3.Final</version>
		</dependency>

		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>

	</dependencies>
</project>

2. DBCPConnectionProvider

要将DBCP与Hibernate集成，您需要创建一个“ DBCPConnectionProvider ”类，请参考本文 。

文件：DBCPConnectionProvider.java 

package com.mkyong.util;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.hibernate.HibernateException;
import org.hibernate.cfg.Environment;
import org.hibernate.connection.ConnectionProvider;
import org.hibernate.connection.ConnectionProviderFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DBCPConnectionProvider implements ConnectionProvider {

	private static final Logger log = LoggerFactory
			.getLogger(DBCPConnectionProvider.class);
	private static final String PREFIX = "hibernate.dbcp.";
	private BasicDataSource ds;

	// Old Environment property for backward-compatibility (property removed in
	// Hibernate3)
	private static final String DBCP_PS_MAXACTIVE = "hibernate.dbcp.ps.maxActive";

	// Property doesn't exists in Hibernate2
	private static final String AUTOCOMMIT = "hibernate.connection.autocommit";

	public void configure(Properties props) throws HibernateException {
		try {
			log.debug("Configure DBCPConnectionProvider");

			// DBCP properties used to create the BasicDataSource
			Properties dbcpProperties = new Properties();

			// DriverClass & url
			String jdbcDriverClass = props.getProperty(Environment.DRIVER);
			String jdbcUrl = props.getProperty(Environment.URL);
			dbcpProperties.put("driverClassName", jdbcDriverClass);
			dbcpProperties.put("url", jdbcUrl);

			// Username / password
			String username = props.getProperty(Environment.USER);
			String password = props.getProperty(Environment.PASS);
			dbcpProperties.put("username", username);
			dbcpProperties.put("password", password);

			// Isolation level
			String isolationLevel = props.getProperty(Environment.ISOLATION);
			if ((isolationLevel != null)
					&& (isolationLevel.trim().length() > 0)) {
				dbcpProperties.put("defaultTransactionIsolation",
						isolationLevel);
			}

			// Turn off autocommit (unless autocommit property is set)
			String autocommit = props.getProperty(AUTOCOMMIT);
			if ((autocommit != null) && (autocommit.trim().length() > 0)) {
				dbcpProperties.put("defaultAutoCommit", autocommit);
			} else {
				dbcpProperties.put("defaultAutoCommit",
						String.valueOf(Boolean.FALSE));
			}

			// Pool size
			String poolSize = props.getProperty(Environment.POOL_SIZE);
			if ((poolSize != null) && (poolSize.trim().length() > 0)
					&& (Integer.parseInt(poolSize) > 0)) {
				dbcpProperties.put("maxActive", poolSize);
			}

			// Copy all "driver" properties into "connectionProperties"
			Properties driverProps = ConnectionProviderFactory
					.getConnectionProperties(props);
			if (driverProps.size() > 0) {
				StringBuffer connectionProperties = new StringBuffer();
				for (Iterator iter = driverProps.entrySet().iterator(); iter
						.hasNext();) {
					Map.Entry entry = (Map.Entry) iter.next();
					String key = (String) entry.getKey();
					String value = (String) entry.getValue();
					connectionProperties.append(key).append('=').append(value);
					if (iter.hasNext()) {
						connectionProperties.append(';');
					}
				}
				dbcpProperties.put("connectionProperties",
						connectionProperties.toString());
			}

			// Copy all DBCP properties removing the prefix
			for (Iterator iter = props.entrySet().iterator(); iter.hasNext();) {
				Map.Entry entry = (Map.Entry) iter.next();
				String key = (String) entry.getKey();
				if (key.startsWith(PREFIX)) {
					String property = key.substring(PREFIX.length());
					String value = (String) entry.getValue();
					dbcpProperties.put(property, value);
				}
			}

			// Backward-compatibility
			if (props.getProperty(DBCP_PS_MAXACTIVE) != null) {
				dbcpProperties.put("poolPreparedStatements",
						String.valueOf(Boolean.TRUE));
				dbcpProperties.put("maxOpenPreparedStatements",
						props.getProperty(DBCP_PS_MAXACTIVE));
			}

			// Some debug info
			if (log.isDebugEnabled()) {
				StringWriter sw = new StringWriter();
				dbcpProperties.list(new PrintWriter(sw, true));
				log.debug(sw.toString());
			}

			// Let the factory create the pool
			ds = (BasicDataSource) BasicDataSourceFactory
					.createDataSource(dbcpProperties);

			// The BasicDataSource has lazy initialization
			// borrowing a connection will start the DataSource
			// and make sure it is configured correctly.
			Connection conn = ds.getConnection();
			conn.close();

			// Log pool statistics before continuing.
			logStatistics();
		} catch (Exception e) {
			String message = "Could not create a DBCP pool";
			log.error(message, e);
			if (ds != null) {
				try {
					ds.close();
				} catch (Exception e2) {
					// ignore
				}
				ds = null;
			}
			throw new HibernateException(message, e);
		}
		log.debug("Configure DBCPConnectionProvider complete");
	}

	public Connection getConnection() throws SQLException {
		Connection conn = null;
		try {
			conn = ds.getConnection();
		} finally {
			logStatistics();
		}
		return conn;
	}

	public void closeConnection(Connection conn) throws SQLException {
		try {
			conn.close();
		} finally {
			logStatistics();
		}
	}

	public void close() throws HibernateException {
		log.debug("Close DBCPConnectionProvider");
		logStatistics();
		try {
			if (ds != null) {
				ds.close();
				ds = null;
			} else {
				log.warn("Cannot close DBCP pool (not initialized)");
			}
		} catch (Exception e) {
			throw new HibernateException("Could not close DBCP pool", e);
		}
		log.debug("Close DBCPConnectionProvider complete");
	}

	protected void logStatistics() {
		if (log.isInfoEnabled()) {
			log.info("active: " + ds.getNumActive() + " (max: "
					+ ds.getMaxActive() + ")   " + "idle: " + ds.getNumIdle()
					+ "(max: " + ds.getMaxIdle() + ")");
		}
	}

	public boolean supportsAggressiveRelease() {
		return false;
	}
}

3.在hibernate.cfg.xml中配置DBCP

现在，链接“ DBCPConnectionProvider ”并在“ hibernate.cfg.xml ”中定义DBCP属性，例如：

档案：hibernate.cfg.xml 

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
  <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:MKYONG</property>
  <property name="hibernate.connection.username">mkyong</property>
  <property name="hibernate.connection.password">password</property>
  <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property>
  <property name="hibernate.default_schema">MKYONG</property>
  <property name="show_sql">true</property>
  
  <property name="hibernate.connection.provider_class">
	com.mkyong.util.DBCPConnectionProvider
  </property>
  <property name="hibernate.dbcp.initialSize">8</property>
  <property name="hibernate.dbcp.maxActive">20</property>
  <property name="hibernate.dbcp.maxIdle">20</property>
  <property name="hibernate.dbcp.minIdle">0</property>
         
  <mapping class="com.mkyong.user.DBUser"></mapping>
</session-factory>
</hibernate-configuration>
注意
Hibernate通过“ hibernate.dbcp.properties-name ”支持DBCP属性。

有关所有DBCP属性，请参考此DBCP配置页面。

4.运行它，输出

完成，运行它，然后看到以下输出：

dbcp connection pool in hibernate

在应用程序启动阶段，将在连接池中创建8个数据库连接，以供您的Web应用程序使用。

下载它– Hibernate-DBCP-Connection-Pool-Example.zip （10KB）

参考

  1. http://wiki.apache.org/commons/DBCP/休眠
  2. https://forum.hibernate.org/viewtopic.php?f=1&t=947528&view=next
  3. http://commons.apache.org/dbcp/configuration.html
  4. http://wiki.apache.org/commons/DBCP
标签：

翻译自: https://mkyong.com/hibernate/how-to-configure-dbcp-connection-pool-in-hibernate/

cyan20115
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring中数据源和数据库连接池配置的几种方法
liyangbing315的专栏
10-26 3万+
<! v/:* {behavior:url(#default#VML);}o/:* {behavior:url(#default#VML);}w/:* {behavior:url(#default#VML);}.shape {behavior:url(#default#VML);}-->Spring 中数据源和数据库连接池配置的几种方法 一、           数
hibernate DBCP 资料
05-22
DBCP 资料，配置的解释，属性，以及一些BUG，在项目中都出现过 比如：web程序启动后会注册JDBC驱动，关闭不了，tomcat7.（版本在什么之上会自动检测，强行关闭导致报错）
hibernate配置文件hibernate.cfg.xml的详细解释
weixin_30345577的博客
06-28 172
<!--标准的XML文件的起始行，version='1.0'表明XML的版本，encoding='gb2312'表明XML文件的编码方式--> <?xml version='1.0' encoding='gb2312'?><!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即...
Hibernate的三种连接池设置C3P0、dbcp和Proxool
潘玄的兄
11-21 5911
property name="connection.driver_class">org.gjt.mm.mysql.Driverproperty>property name="connection.url">jdbc:mysql://localhost:3306/struts?useUnicode=true&characterEncoding=GBKproperty>property na
hibernate中dbcp.BasicDataSource连接池配备属性
夏末
12-19 1385
org.apache.commons.dbcp.BasicDataSource连接池配备属性  池配置属性 指定的内容 initialSize 池启动时创建的连接数量 maxActive 同一时间可以从池分配的最多连接数量。设置为0时表示无限制。 maxIdle 池里不会被释放的最多空闲连接数量。设置为0时表示无限制。 maxOpenP
Hibernate 连接池的三种配置方式：dbcp , c3p0
liaoyuanzi的专栏
10-09 1012
原文地址：连接池的三种配置方式：dbcp , c3p0 , proxool" style="text-decoration:none; color:rgb(62,115,160)">Hibernate 连接池的三种配置方式：dbcp , c3p0 , proxool作者：Oo__Sunday__oO ===== 使用 proxool ======= Xml代码 hiber
java配置dbcp数据库连接池架包
07-12
3. **连接池实例化**：在Java代码中，你需要读取这个配置文件并创建DBCP连接池的实例。可以使用`BasicDataSource`类来实现： ```java import org.apache.commons.dbcp.BasicDataSource; public class ...
DBCP连接池
11-24
在SSH（Spring、Struts和Hibernate）这样的经典企业级开发框架中，DBCP连接池是一个常用的数据库管理工具。 1. **数据库连接池概念**：数据库连接池是在应用服务器启动时创建的，它会预先建立一定数量的数据库连接...
扩展Hibernate使用自定义数据库连接池的方法
09-02
在Java开发中，Hibernate是一个非常流行的持久化框架，它简化了数据库操作，使得开发者能够更加专注于业务逻辑而...确保正确实现接口的方法，并根据需要调整配置，以便在Hibernate框架中充分利用自定义的数据库连接池。
hibernate配置连接池整理
03-31
**二、DBCP连接池** Apache的DBCP是另一个常用的连接池实现，它基于Jakarta Pool。配置方式与C3P0类似，但在`hibernate.cfg.xml`中替换为： ```xml <property name="hibernate.connection.datasource">org.apache....
dbcp 连接池 jar包
03-15
在配置DBCP连接池时，开发者需要设置一些关键参数，例如： 1. **maxActive**：最大活动连接数，决定了连接池能够同时处理的最大并发请求。 2. **maxIdle**：最大空闲连接数，超过这个数量的空闲连接将会被池自动...
Hibernate & DBCP
PieStar的专栏
04-03 182
转载 http://wiki.apache.org/commons/DBCP/Hibernate 2010-01-27 Version 5 2005-01-27 Version1 About Hibernate &amp; DBCP Hibernate 2 includes a limited DBCP ConnectionProvider . ...
Hibernate 连接池的三种配置方式
gd2008的专栏
10-15 732
本文主要内容：  Hibernate 连接池的三种配置方式：dbcp , c3p0 , proxool  URL的多种指定方式  连接池监控  上班第二天，看到公司的Hibernate配置文件在写法上，跟我以前的不一样，就去研究了哈，得出的结果如下。  在hibernate3.0中，已经不再支持dbcp了，hibernate的作者在hibernate.org中，
转贴 :hibernate 配置 dbcp
limbo1982的博客
12-21 225
Hibernate属性文件的配置参数 #连接池的最大活动个数 hibernate.dbcp.maxActive 100 #当连接池中的连接已经被耗尽的时候，DBCP将怎样处理( 0 = 失败, 1 = 等待, 2= 增长) hibernate.dbcp.whenExhaustedAction 1 #最大等待时间 hibernate.dbcp.maxWait 120000 ...
让Hibernate支持DBCP数据源
zzbnalbp
12-10 432
老版本的 Hibernate 不支持 DBCP 连接池，不过没关系，有了这个类就可以轻松搞定。 配置：hibernate.connection.provider_class com.dlog4j.dbaccess.DBCPConnectionProvider 标签： DBCP 数据源 连接池 DataSource ConnectionProvider Hibernate [1]
Hibernate的三种连接池设置C3P0、Proxool和DBCP
xzc0202
01-30 89
Xml代码 &lt;!-- JDBC驱动程序 --&gt;   &lt;property name="connection.driver_class"&gt;com.mysql.jdbc.Driver&lt;/property&gt; &lt;property name="connection.url"&gt;jdbc:mysql://localhost:3306/st...
利用spring+hibernate配置dbcp连接池配置的异常解析
12-07 1885
利用spring+hibernate配置dbcp连接池配置过程出现的异常解析 首先导入spring，hibernate的jar包 hibernate-distribution-3.3.2.GA-dist spring-framework-2.5.6.SEC01-with-dependencies 建立applicationContext.xml，配置web.xml启动 =========
hibernate框架和dbcp或其他连接池的使用
纯冰蓝色的BLOG
03-17 1282
以下三种连接都是以连接MySQl为例。 org.gjt.mm.mysql.Driver jdbc:mysql://localhost:3306/struts?useUnicode=true&characterEncoding=GBK root 8888 上 面的一段配置，在c3p0和dbcp中，都是必需的，因为hibernate会根据上述的配置来生成connections，再交给c3p0或d

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值