proxool是一个使用方便的数据库连接池.
适应于一个应用需要同时连接多种或多个数据库的场合.
该连接池能够按照别名获取数据库连接.
别名的生成为 url加username,因为这两个组合能够区分不同数据库和统一数据库不同用户的连接.
连接池代码:
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
import org.logicalcobwebs.proxool.ProxoolConstants;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.ProxoolFacade;
import org.logicalcobwebs.proxool.admin.SnapshotIF;
import com.hedes.exception.cp.ConnectionPoolException;
import com.hedes.exception.cp.ConnectionPoolNotExistAliasException;
import com.hedes.exception.cp.InitConnectionPoolException;
import com.hedes.exception.cp.NullConnectionException;
import java.sql.DriverManager;
import java.util.Properties;
/**
* 基于proxool的数据库连接池
*
* @author AXIN
*/
public class ConnectionPool {
private static Logger log = Logger.getLogger(ConnectionPool.class);
private static Map idList = new HashMap();// 别名映射
private static int ids = 0;// 别名序列
private static ConnectionPool c = null;// 唯一实例
/**
* 初始化数据库连接池
*
* @throws InitConnectionPoolException
* 初始化失败异常
*/
private ConnectionPool() throws InitConnectionPoolException {
try {
Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
} catch (ClassNotFoundException e) {
throw new InitConnectionPoolException(e);
}
}
/**
* 获取数据库连接池实例
*
* @return 数据库连接池实例
* @throws InitConnectionPoolException
* 初始化失败异常
*/
public final static ConnectionPool getConnectionPool()
throws InitConnectionPoolException {
if (c == null) {
try {
c = new ConnectionPool();
} catch (InitConnectionPoolException e) {
throw e;
}
}
return c;
}
/**
* 获取别名 普通的访问方式 在别名不存在的情况下不创建数据库连接
*
* @param prop
* 连接参数
* @return
* @throws ConnectionPoolNotExistAliasException
*/
public final synchronized String getId(java.util.Properties prop)
throws ConnectionPoolNotExistAliasException {
if (prop == null) {
throw new ConnectionPoolNotExistAliasException(
"无效的入参 Properties.--" + prop);
}
String URL = prop.getProperty("URL");
String USER = prop.getProperty("USER");
if (URL == null || "".compareTo(URL.trim()) == 0) {
throw new ConnectionPoolNotExistAliasException("无效的入参 URL.--" + URL);
}
if (USER == null || "".compareTo(USER.trim()) == 0) {
throw new ConnectionPoolNotExistAliasException("无效的入参 USER.--"
+ URL);
}
String alias = (String) idList.get(URL.toLowerCase() + "-"
+ USER.toLowerCase());
if (alias == null) {
throw new ConnectionPoolNotExistAliasException("null");
}
return alias;
}
/**
* 获取别名 特殊的访问方式 在别名不存在的情况下尝试创建数据库连接
*
* @param prop
* 连接参数
* @return
* @throws ConnectionPoolNotExistAliasException
*/
public final synchronized String getIdSpecial(java.util.Properties prop)
throws ConnectionPoolNotExistAliasException {
if (prop == null) {
throw new ConnectionPoolNotExistAliasException(
"无效的入参 Properties.--" + prop);
}
String URL = prop.getProperty("URL");
String USER = prop.getProperty("USER");
if (URL == null || "".compareTo(URL.trim()) == 0) {
throw new ConnectionPoolNotExistAliasException("无效的入参 URL.--" + URL);
}
if (USER == null || "".compareTo(USER.trim()) == 0) {
throw new ConnectionPoolNotExistAliasException("无效的入参 USER.--"
+ URL);
}
String alias = (String) idList.get(URL.toLowerCase() + "-"
+ USER.toLowerCase());
if (alias == null) {
try {
this.add(prop);
} catch (ConnectionPoolException e) {
e.printStackTrace();
throw new ConnectionPoolNotExistAliasException(e.getMessage());
}
}
alias = (String) idList.get(URL.toLowerCase() + "-"
+ USER.toLowerCase());
return alias;
}
/**
* 数据库连接参数 字符串类型校验
*
* @param value
* 值
* @param key
* 关键字
* @throws ConnectionPoolException
*/
private void checkPropValueString(final String value, final String key)
throws ConnectionPoolException {
if (value == null || "".compareTo(value.trim()) == 0) {
throw new ConnectionPoolException("无效的入参 " + key + ".--" + key);
}
}
/**
* 数据库连接参数 数字类型校验
*
* @param value
* 值
* @param key
* 关键字
* @param def
* 默认值
* @return
* @throws ConnectionPoolException
*/
private String checkPropValueNumber(final String value, final String key,
final String def) throws ConnectionPoolException {
if (value == null || "".compareTo(value.trim()) == 0) {
return def;
}
try {
int temp = Integer.parseInt(value);
if (temp < 1) {
throw new ConnectionPoolException("无效的入参 " + key + ".--" + key);
}
} catch (java.lang.NumberFormatException e) {
throw new ConnectionPoolException("无效的入参 " + key + ".--" + key);
}
return value;
}
/**
* 添加一个数据库连接池
*
* @param prop
* 连接参数
* @throws ConnectionPoolException
*/
public final synchronized void add(java.util.Properties prop)
throws ConnectionPoolException {
if (prop == null) {
throw new ConnectionPoolException("无效的入参 Properties.--" + prop);
}
String DRIVER = prop.getProperty("DRIVER");
checkPropValueString(DRIVER, "DRIVER");
String URL = prop.getProperty("URL");
checkPropValueString(URL, "URL");
String USER = prop.getProperty("USER");
checkPropValueString(USER, "USER");
String PASSWORD = prop.getProperty("PASSWORD");
String MIN = prop.getProperty("MIN");
String MAX = prop.getProperty("MAX");
String INIT = prop.getProperty("INIT");
String WATITIME = prop.getProperty("WATITIME");
MIN = checkPropValueNumber(MIN, "MIN", "5");
MAX = checkPropValueNumber(MAX, "MAX", "20");
INIT = checkPropValueNumber(INIT, "INIT", "5");
WATITIME = checkPropValueNumber(WATITIME, "WATITIME", "50000");
if (Integer.parseInt(INIT) < Integer.parseInt(MIN)) {
throw new ConnectionPoolException("最小连接数必须小于初始化连接数!");
}
Properties info = new Properties();
info.setProperty(ProxoolConstants.USER_PROPERTY, USER);
info.setProperty(ProxoolConstants.PASSWORD_PROPERTY, PASSWORD);
info.setProperty(ProxoolConstants.VERBOSE_PROPERTY, Boolean.TRUE
.toString());
info.setProperty(ProxoolConstants.MINIMUM_CONNECTION_COUNT_PROPERTY,
MIN);
info.setProperty(ProxoolConstants.MAXIMUM_CONNECTION_COUNT_PROPERTY,
MAX);
info.setProperty(ProxoolConstants.PROTOTYPE_COUNT_PROPERTY, INIT);
info.setProperty(ProxoolConstants.HOUSE_KEEPING_SLEEP_TIME_PROPERTY,
WATITIME);
String alias = "HEDES-" + ids;
idList.put(URL.toLowerCase() + "-" + USER.toLowerCase(), alias);
ids = ids + 1;
String url = "proxool." + alias + ":" + DRIVER + ":" + URL;
try {
ProxoolFacade.registerConnectionPool(url, info);
} catch (ProxoolException e) {
throw new ConnectionPoolException("创建连接池错误.--" + e.getMessage());
}
}
/**
* 获取连接
*
* @param key
* 别名
* @return 一个可用的数据库连接
* @throws NullConnectionException
*/
public final Connection getConnection(String key)
throws NullConnectionException {
try {
Connection conn = DriverManager.getConnection("proxool." + key);
// wacth(key);
if (conn == null) {
throw new NullConnectionException("无法获取连接" + key + ".");
}
return conn;
} catch (SQLException e) {
throw new NullConnectionException("获取连接异常.", e);
}
}
/**
* 查看指定别名下的连接池情况
*
* @param key
* 别名
*/
public final void wacth(String key) {
SnapshotIF snapshot;
try {
snapshot = ProxoolFacade.getSnapshot(key, true);
int curActiveCount = snapshot.getActiveConnectionCount();
int availableCount = snapshot.getAvailableConnectionCount();
int maxCount = snapshot.getMaximumConnectionCount();
log.info("----------------------------------");
log.info(curActiveCount + "(当前活动连接) " + availableCount
+ "(可用连接) " + maxCount + "(最大连接)");
log.info("----------------------------------");
} catch (ProxoolException e) {
e.printStackTrace();
}
}
}
调用方式:
Properties prop = new Properties();
prop.put("URL", "");
prop.put("DRIVER", "");
prop.put("USER", "");
prop.put("PASSWORD", "");
prop.put("MIN", "5");
prop.put("MAX", "10");
prop.put("INIT", "6");
prop.put("WATITIME", "10000");
ConnectionPool cp;
try {
cp = ConnectionPool.getConnectionPool();
} catch (InitConnectionPoolException e) {
//TODO
}
try {
id = cp.getIdSpecial(prop);
} catch (ConnectionPoolNotExistAliasException e) {
//TODO
}
try {
Connection cn=cp.getConnection(id);
//TODO
} catch (NullConnectionException e) {
//TODO
}
虽然调用麻烦,但是在一定程度上能够保证安全性和稳定性.在获取到别名以后获取连接的方式就简单很多了.
注:连接在使用完毕后请记得要关闭.
分享到：
相关推荐
标题中提到的"各种数据库连接池"，包括了c3p、DBCP和Proxool，这些都是Java环境下常见的数据库连接池实现： 1. **C3P0**：这是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。...
在Java开发中，数据库连接池是一种重要的资源管理工具，它允许开发者高效地管理和复用数据库连接，从而提高系统的性能和稳定性。数据库连接池的基本原理是预先创建一定数量的数据库连接，当应用程序需要访问数据库时...
Proxool是一个轻量级的数据库连接池，它通过SSH（Spring、Struts、Hibernate）框架进行集成，可以有效地管理和优化数据库连接。下面我们将深入探讨基于SSH的Proxool连接池配置。 首先，配置环境：MyEclipse5.5，...
Proxool是一个基于代理的数据库连接池，它通过创建数据库连接的虚拟池来实现连接复用，从而提高系统的运行效率。Proxool的核心思想是将物理数据库连接转换为逻辑连接，这样可以减少创建和关闭物理连接的次数，减轻...
基于这些优势，文章建议在实际应用中优先考虑使用Proxool作为数据库连接池解决方案。 ### 综合评价 通过对Proxool和Tomcat DBCP的性能评测，我们不仅了解了两种连接池技术的基本参数设置及其对性能的影响，还深入...
DBCP是Apache Commons的一个项目，基于Jakarta-pool实现的数据库连接池。它简单易用，但相比于C3P0和Druid，DBCP的性能和稳定性稍弱。尽管如此，由于其开源和轻量级的特性，DBCP仍被广泛应用于小型项目中。 5. ...
标题中的"spring+dwr+proxool连接池"指的是一个整合了Spring框架、Direct Web Remoting (DWR)和Proxool数据库连接池技术的应用程序。这个应用可能用于创建一个能够实时交互的Web应用程序，其中Spring提供了依赖注入...
`Proxool数据库连接池配置.doc`应详细介绍了如何配置和使用Proxool，包括关键的配置参数及其作用。最后，`FCKeditor在线编译器.doc`可能会涵盖FCKeditor的安装、使用方法，以及如何集成自定义函数的教程。 总的来说...
**Proxool连接池**：Proxool是数据库连接池的一种实现，它的主要作用是管理数据库连接，减少创建和销毁连接的开销。当多个用户请求数据库连接时，Proxool会复用已存在的连接，而不是每次请求都新建一个。这大大提高...
- Proxool：开源的Java数据库连接池，提供监控功能，便于检测连接泄漏。尽管已被Hibernate官方弃用，但在过去是常用的连接池之一。 3. 主要配置说明 - 基本配置：包括数据库驱动类名、数据库URL、用户名和密码，...
Proxool是一个基于池化的JDBC代理，它维护着一个数据库连接池，当应用需要访问数据库时，可以从池中获取连接，用完后再归还，而不是每次请求都创建新的连接，从而提高系统性能，减少数据库的压力。 **配置步骤** 1...
### 数据库连接池技术概述 #### 一、连接池原理 连接池技术是现代软件开发中为了优化数据库访问效率而采用的一种重要手段。其核心思想在于连接复用，即通过预建立一定数量的数据库连接并将这些连接存储在一个池中...
虽然这个简单的数据库连接池实现能够帮助理解池化的概念和工作原理，但在实际生产环境中，通常会使用更成熟、功能更完善的连接池实现，例如C3P0、DBCP、Proxool或阿里巴巴的Druid。这些第三方库提供了更丰富的特性，...
"JAVA数据库连接池的探讨" 本文探讨了JAVA中的数据库连接池，首先提出了性能问题，然后针对该问题进行了调查，并找到 原因：是数据源配置引起的，进一歩对带连接池的数据源进行了总结。本文还提供了一个方向，并且...
基于proxool插件有3种方式实现联接池。 1） JSP 运行程序中Test.jsp即可建立连接池 2） 应用程序实现。 3） Xml实现。 很简单。（推荐） <br>内有proxool及相关说明
标题中的"Proxool.jar"指的是Proxool数据库连接池的Java库文件，它是Hibernate框架中常用的一个连接池实现。连接池在Java应用程序，特别是基于JDBC的Web应用中起着至关重要的作用，它能够有效地管理和复用数据库连接...
Proxool是一个开源的、基于Java的数据库连接池，它在2003年由iBatis（现在的MyBatis）团队开发并维护，旨在提供一个轻量级、高效的数据库连接管理解决方案。在深入研究Proxool源码之前，我们先了解一下数据库连接池...