Hibernate的连接池配置

以连接MySQl为例

在hibernate.cfg.xml中加入

<!-- JDBC驱动程序 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.url">jdbc:mysql://localhost:3306/struts</property>
<!-- 数据库用户名 -->
<property name="connection.username">root</property>
<!-- 数据库密码 -->
<property name="connection.password">987654</property>

或者

<!-- JNDI连接 -->
<property name="connection.datasource">java:comp/env/jdbc/mysql</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

1 数据库连接池为 C3P0

只需在hibernate.cfg.xml中加入
<property name="c3p0.min_size">5</property>
<property name="c3p0.max_size">30</property>
<property name="c3p0.time_out">1800</property>
<property name="c3p0.max_statement">50</property>

还有在classespath中加入c3p0-0.8.4.5.jar

2 数据库连接池为 dbcp

在hibernate.cfg.xml中加入

<property name="dbcp.maxActive">100</property>
<property name="dbcp.whenExhaustedAction">1</property>
<property name="dbcp.maxWait">60000</property>
<property name="dbcp.maxIdle">10</property>

<property name="dbcp.ps.maxActive">100</property>
<property name="dbcp.ps.whenExhaustedAction">1</property>
<property name="dbcp.ps.maxWait">60000</property>
<property name="dbcp.ps.maxIdle">10</property>

还有在classespath中加入commons-pool-1.2.jar 和commons-dbcp-1.2.1.jar.

注: 把下面的类编译后添加或替换掉原来org.hibernate.connection 包里的版本

DBCPConnectionProvider

/*
* Copyright 2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.hibernate.connection;

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

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.cfg.Environment;

/**
* <p>A connection provider that uses an Apache commons DBCP connection pool.</p>
*
* <p>To use this connection provider set:<br>
* <code>hibernate.connection.provider_class org.hibernate.connection.DBCPConnectionProvider</code></p>
*
* <pre>Supported Hibernate properties:
*   hibernate.connection.driver_class
*   hibernate.connection.url
*   hibernate.connection.username
*   hibernate.connection.password
*   hibernate.connection.isolation
*   hibernate.connection.autocommit
*   hibernate.connection.pool_size
*   hibernate.connection (JDBC driver properties)</pre>
* <br>
* All DBCP properties are also supported by using the hibernate.dbcp prefix.
* A complete list can be found on the DBCP configuration page:
* <a href="http://jakarta.apache.org/commons/dbcp/configuration.html">http://jakarta.apache.org/commons/dbcp/configuration.html</a>.
* <br>
* <pre>Example:
*   hibernate.connection.provider_class org.hibernate.connection.DBCPConnectionProvider
*   hibernate.connection.driver_class org.hsqldb.jdbcDriver
*   hibernate.connection.username sa
*   hibernate.connection.password
*   hibernate.connection.url jdbc:hsqldb:test
*   hibernate.connection.pool_size 20
*   hibernate.dbcp.initialSize 10
*   hibernate.dbcp.maxWait 3000
*   hibernate.dbcp.validationQuery select 1 from dual</pre>
*
* <p>More information about configuring/using DBCP can be found on the
* <a href="http://jakarta.apache.org/commons/dbcp/">DBCP website</a>.
* There you will also find the DBCP wiki, mailing lists, issue tracking
* and other support facilities</p>
*
* @see org.hibernate.connection.ConnectionProvider
* @author Dirk Verbeeck
*/
public class DBCPConnectionProvider implements ConnectionProvider {

private static final Log log = LogFactory.getLog(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.keySet().iterator(); iter.hasNext();) {
String key = (String) iter.next();
String value = driverProps.getProperty(key);
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.keySet().iterator() ; iter.hasNext() ;) {
String key = String.valueOf(iter.next());
if (key.startsWith(PREFIX)) {
String property = key.substring(PREFIX.length());
String value = props.getProperty(key);
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()) {
log.debug("Creating a DBCP BasicDataSource with the following DBCP factory properties:");
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.fatal(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() + ")");
}
}
}

last edited 2005-01-27 18:17:21 by DirkVerbeeck

3 数据库连接池为 proxool

在hibernate.cfg.xml中加入

<property name="proxool.pool_alias">pool1</property>
<property name="proxool.xml">ProxoolConf.xml</property>
<property name="connection.provider_class">net.sf.hibernate.connection.ProxoolConnectionProvider</property>

然后，在和hibernate.cfg.xml同一个目录下，加一个ProxoolConf.xml文件，内容为

<?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>pool1</alias>
<!--proxool只能管理由自己产生的连接-->
<driver-url>jdbc:mysql://localhost:3306/struts?useUnicode=true&characterEncoding=GBK</driver-url>
<driver-class>org.gjt.mm.mysql.Driver</driver-class>
<driver-properties>
<property name="user" value="root"/>
<property name="password" value="8888"/>
</driver-properties>
<!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁-->
<house-keeping-sleep-time>90000</house-keeping-sleep-time>
<!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->
<maximum-new-connections>20</maximum-new-connections>
<!-- 最少保持的空闲连接数-->
<prototype-count>5</prototype-count>
<!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->
<maximum-connection-count>100</maximum-connection-count>
<!-- 最小连接数-->
<minimum-connection-count>10</minimum-connection-count>
</proxool>
</something-else-entirely>

并在classespath中加入proxool-0.8.3.jar

本文大部分内容来自互联网,只为这一问题的完美解决