FengShen_Xia
- 浏览: 279406 次
- 性别:
- 来自: 东方水城
-
文章分类
最新评论
-
18335864773：
pageoffice 插件 可以实现 office文档的在线操 ...
Java调用com组件操作word -
coosummer：
推荐使用在线免费bug管理系统- bug 禅思：http:// ...
Bug管理工具 -
program_coco：
柠檬bug管理系统，一个在线的bug管理系统。www.lemo ...
Bug管理工具 -
影非弦：
这个in.read(data);//data是一个byte[] ...
Java串口通信总结 -
影非弦：
这个不详细啊，我弄了一天了，都没弄出来，总是出错，读信息的时候 ...
Java串口通信总结
import java.sql.*;
import java.lang.reflect.*;
import org.omg.CORBA.portable.InvokeHandler;
import freemarker.template.utility.ObjectConstructor;
/**
* 定义数据库连接的代理类
*
* @author mark
*
*/
public class ConnectionProxy implements InvocationHandler {
// 定义连接
private Connection conn = null;
// 定义监控连接创建的语句
private Statement statRef = null;
private PreparedStatement preStatRef = null;
// 是否支持事务标志
private boolean supportTransaction = false;
// 数据库的忙状态
private boolean isFree = false;
// 最后一次访问时间
long lastAccessTime = 0;
// 定义要接管的函数的名字
String CREATESTATE = "createStatement";
String CLOSE = "close";
String PREPARESTATEMENT = "prepareStatement";
String COMMIT = "commit";
String ROLLBACK = "rollbakc";
/**
* 构造函数，采用私有，防止被直接创建
*
* @param param
* 连接参数
*/
private ConnectionProxy(ConnectionParam param) {
// 记录日志
try {
// 创建连接
Class.forName("oracle.jdbc.driver.OracleDriver");
conn = DriverManager.getConnection("jdbc:oracle:thin: @10.8.1.234:1521:WF4PPDB","PP42", "PP42");
DatabaseMetaData dm = null;
dm = conn.getMetaData();
// 判断是否支持事务
supportTransaction = dm.supportsTransactions();
} catch (Exception ex) {
ex.printStackTrace();
}
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object obj = null;
// 判断是否调用了close的方法，如果调用close方法则把连接置为无用状态
if (CLOSE.equals(method.getName())) {
// 设置不使用标志
setFree(false);
if (statRef != null)
statRef.close();
if (preStatRef != null)
preStatRef.close();
return null;
}
// 判断是使用了createStatement语句
if (CREATESTATE.equals(method.getName())) {
try {
obj = method.invoke(conn, args);
statRef = (Statement) obj;
return obj;
} catch (ClassCastException ex) {
ex.printStackTrace();
}
}
// 判断是使用了prepareStatement语句
if (PREPARESTATEMENT.equals(method.getName())) {
obj = method.invoke(conn, args);
preStatRef = (PreparedStatement) obj;
return obj;
}
// 如果不支持事务，就不执行该事物的代码
if ((COMMIT.equals(method.getName()) || ROLLBACK.equals(method
.getName()))
&& (!isSupportTransaction())) {
return null;
}
obj = method.invoke(conn, args);
// 设置最后一次访问时间，以便及时清除超时的连接
lastAccessTime = System.currentTimeMillis();
return obj;
}
/**
* 创建连接的工厂，只能让工厂调用
*
* @param factory
* 要调用工厂，并且一定被正确初始化
* @param param
* 连接参数
* @return 连接
*/
public static ConnectionProxy getConnection(ConnectionFactory factory,
ConnectionParam param) {
// 判断是否正确初始化的工厂
if (factory.isCreate()) {
ConnectionProxy _conn = new ConnectionProxy(param);
return _conn;
} else {
return null;
}
}
public Connection getFreeConnection() {
// 返回数据库连接conn的接管类，以便截住close方法
Connection cn = (Connection) Proxy.newProxyInstance(conn.getClass()
.getClassLoader(), conn.getClass().getInterfaces(), this);
return cn;
}
/**
* 该方法真正的关闭了数据库的连接
*
* @throws SQLException
*/
public void close() throws SQLException {
// 由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接
conn.close();
}
public void setFree(boolean isFree) {
this.isFree = isFree;
}
public boolean isFree() {
return isFree;
}
/**
* 判断是否支持事务
*
* @return boolean
*/
public boolean isSupportTransaction() {
return supportTransaction;
}
}
import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;
public class ConnectionFactory {
private static ConnectionFactory m_instance = null;
// 在使用的连接池
private LinkedHashSet ConnectionPool = null;
// 空闲连接池
private LinkedHashSet FreeConnectionPool = null;
// 最大连接数
private int MaxConnectionCount = 10;
// 最小连接数S
private int MinConnectionCount = 2;
// 当前连接数
private int current_conn_count = 0;
// 连接参数
private ConnectionParam connparam = null;
// 是否创建工厂的标志
private boolean isflag = false;
// 是否支持事务
private boolean supportTransaction = false;
// 定义管理策略
private int ManageType = 0;
/**
* 构造器
*/
private ConnectionFactory() {
ConnectionPool = new LinkedHashSet();
FreeConnectionPool = new LinkedHashSet();
}
/**
* 使用指定的参数创建一个连接池
*
* @throws SQLException
*/
public ConnectionFactory(ConnectionParam param, FactoryParam fparam)
throws SQLException {
if ((param == null) || (fparam == null))
throw new SQLException("ConnectionParam和FactoryParam不能为空");
if (m_instance == null) {
synchronized (ConnectionFactory.class) {
if (m_instance == null) {
// 参数定制
m_instance = new ConnectionFactory();
connparam = param;
m_instance.MaxConnectionCount = fparam
.getMaxConnectionCount();
m_instance.MinConnectionCount = fparam
.getMinConnectionCount();
m_instance.ManageType = fparam.getManageType();
m_instance.isflag = true;
// 初始化，创建MinConnectionCount个连接
System.out.println("connection factory 创建！");
try {
for (int i = 0; i < m_instance.MinConnectionCount; i++) {
ConnectionProxy conn = ConnectionProxy
.getConnection(m_instance,m_instance.connparam);
if (conn == null)
continue;
System.out.println("connection创建");
m_instance.FreeConnectionPool.add(conn);
// 加入空闲连接池
m_instance.current_conn_count++;
// 标志是否支持事务
m_instance.supportTransaction = conn
.isSupportTransaction();
}
} catch (Exception ex) {
ex.printStackTrace();
}
// 根据策略判断是否需要查询
if (m_instance.ManageType != 0) {
Thread t = new Thread(new FactoryManageThread(
m_instance));
t.start();
}
}
}
}
}
/**
* 标志工厂是否已经创建
*
* @return boolean
*/
public boolean isCreate() {
return m_instance.isflag;
}
/**
* 从连接池中取一个空闲的连接
*
* @return Connection
* @throws SQLException
*/
public synchronized Connection getFreeConnection() throws SQLException {
Connection cn = null;
// 获取空闲连接
Iterator ir = m_instance.FreeConnectionPool.iterator();
while (ir.hasNext()) {
ConnectionProxy conn = (ConnectionProxy) ir.next();
// 找到未用的连接
if (!conn.isFree()) {
cn = conn.getFreeConnection();
conn.setFree(true);
// 移出空闲区
m_instance.FreeConnectionPool.remove(conn);
// 加入连接池
m_instance.ConnectionPool.add(conn);
break;
}
}
// 检查空闲池是否为空
if (m_instance.FreeConnectionPool.isEmpty()) {
// 再检查是否能够分配
if (m_instance.current_conn_count < m_instance.MaxConnectionCount) {
// 新建连接到空闲连接池
int newCount = 0;
// 取得要建立的数目
if (m_instance.MaxConnectionCount
- m_instance.current_conn_count >= m_instance.MinConnectionCount) {
newCount = m_instance.MinConnectionCount;
} else {
newCount = m_instance.MaxConnectionCount
- m_instance.current_conn_count;
}
// 创建连接
for (int i = 0; i < newCount; i++) {
ConnectionProxy _conn = ConnectionProxy.getConnection(
m_instance, connparam);
m_instance.FreeConnectionPool.add(_conn);
m_instance.current_conn_count++;
}
} else {
// 如果不能新建，检查是否有已经归还的连接
ir = m_instance.ConnectionPool.iterator();
while (ir.hasNext()) {
ConnectionProxy _conn = (ConnectionProxy) ir.next();
if (!_conn.isFree()) {
cn = _conn.getFreeConnection();
_conn.setFree(false);
m_instance.ConnectionPool.remove(_conn);
m_instance.FreeConnectionPool.add(_conn);
break;
}
}
}
}
// 再次检查是否能分配连接
if (cn == null) {
ir = m_instance.FreeConnectionPool.iterator();
while (ir.hasNext()) {
ConnectionProxy _conn = (ConnectionProxy) ir.next();
if (!_conn.isFree()) {
cn = _conn.getFreeConnection();
_conn.setFree(true);
m_instance.FreeConnectionPool.remove(_conn);
m_instance.ConnectionPool.add(_conn);
break;
}
}
if (cn == null)
// 如果不能则说明无连接可用
throw new SQLException("没有可用的数据库连接");
}
System.out.println("Get Connection");
return cn;
}
/**
* 关闭该连接池中的所有数据库连接
*
* @throws SQLException
*/
public synchronized void close() throws SQLException {
this.isflag = false;
SQLException sqlError = null;
// 关闭空闲池
Iterator ir = m_instance.FreeConnectionPool.iterator();
while (ir.hasNext()) {
try {
((ConnectionProxy) ir.next()).close();
System.out.println("Close connection:Free");
m_instance.current_conn_count--;
} catch (Exception ex) {
if (ex instanceof SQLException) {
sqlError = (SQLException) ex;
}
}
}
// 关闭在使用的连接池
ir = m_instance.ConnectionPool.iterator();
while (ir.hasNext()) {
try {
((ConnectionProxy) ir.next()).close();
System.out.println("Close connection:Using");
} catch (Exception ex) {
if (ex instanceof SQLException) {
sqlError = (SQLException) ex;
}
}
}
if (sqlError != null)
throw sqlError;
}
/**
* 返回是否支持事务
*
* @return boolean
*/
public boolean isSupportTransaction() {
return m_instance.supportTransaction;
}
/**
* 连接池调度管理
*
*/
public void schedule() {
Connection cn = null;
// 再检查是否能够分配
Iterator ir = null;
// 检查是否有已经归还的连接
ir = m_instance.ConnectionPool.iterator();
while (ir.hasNext()) {
ConnectionProxy _conn = (ConnectionProxy) ir.next();
if (!_conn.isFree()) {
cn = _conn.getFreeConnection();
_conn.setFree(false);
m_instance.ConnectionPool.remove(_conn);
m_instance.FreeConnectionPool.add(_conn);
break;
}
}
if (m_instance.current_conn_count < m_instance.MaxConnectionCount) {
// 新建连接到空闲连接池
int newCount = 0;
// 取得要建立的数目
if (m_instance.MaxConnectionCount - m_instance.current_conn_count >= m_instance.MinConnectionCount) {
newCount = m_instance.MinConnectionCount;
} else {
newCount = m_instance.MaxConnectionCount
- m_instance.current_conn_count;
}
// 创建连接
for (int i = 0; i < newCount; i++) {
ConnectionProxy _conn = ConnectionProxy.getConnection(
m_instance, connparam);
m_instance.FreeConnectionPool.add(_conn);
m_instance.current_conn_count++;
}
}
}
}
import java.io.Serializable;
import com.mark.human.model.*;
/**
* 实现数据库连接的参数类
*
* @author mark
*
*/
public class ConnectionParam implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private String driver; // 数据库驱动程序
private String url; // 数据连接的URL
private String user; // 数据库用户名
private String password; // 数据库密码
public String getDriver() {
return driver;
}
public void setDriver(String driver) {
this.driver = driver;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public ConnectionParam(String driver, String url, String user,
String password) {
this.driver = driver;
this.url = url;
this.user = user;
this.password = password;
}
/**
* @see java.lang.Object#clone()
*/
public Object clone() {
ConnectionParam param = new ConnectionParam(driver, url, user, password);
return param;
}
/**
* @see java.lang.Object#equals(java.lang.Object)
*/
public boolean equals(Object obj) {
if (obj instanceof ConnectionParam) {
ConnectionParam param = (ConnectionParam) obj;
return ((driver.compareToIgnoreCase(param.getDriver()) == 0)
&& (url.compareToIgnoreCase(param.getUrl()) == 0)
&& (user.compareToIgnoreCase(param.getUser()) == 0) && (password
.compareToIgnoreCase(param.getPassword()) == 0));
}
return false;
}
}
/**
* 连接池调度线程
*
* @author mark
*
*/
public class FactoryManageThread implements Runnable {
ConnectionFactory cf = null;
long delay = 1000;
public FactoryManageThread(ConnectionFactory obj) {
cf = obj;
}
/*
* (non-Javadoc)
*
* @see java.lang.Runnable#run()
*/
public void run() {
while (true) {
try {
Thread.sleep(delay);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("run.....run.....");
// 判断是否已经关闭了工厂，那就退出监听
if (cf.isCreate())
cf.schedule();
else
System.exit(1);
}
}
}
/**
* 连接池工厂参数
*
* @author mark
*
*/
public class FactoryParam {
// 最大连接数
private int MaxConnectionCount = 4;
// 最小连接数
private int MinConnectionCount = 2;
// 回收策略
private int ManageType = 0;
public FactoryParam() {
}
/**
* 构造连接池工厂参数的对象
*
* @param max
* 最大连接数
* @param min
* 最小连接数
* @param type
* 管理策略
*/
public FactoryParam(int max, int min, int type) {
this.MaxConnectionCount = max;
this.MinConnectionCount = min;
this.ManageType = type;
}
public int getManageType() {
return ManageType;
}
public void setManageType(int manageType) {
ManageType = manageType;
}
public int getMaxConnectionCount() {
return MaxConnectionCount;
}
public void setMaxConnectionCount(int maxConnectionCount) {
MaxConnectionCount = maxConnectionCount;
}
public int getMinConnectionCount() {
return MinConnectionCount;
}
public void setMinConnectionCount(int minConnectionCount) {
MinConnectionCount = minConnectionCount;
}
}
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class testPool {
public void test1() {
String user = "ppuser";
String password = "ppuser";
String url = "jdbc:oracle:thin:@192.168.0.1:1521:PPDATA";
String driver = "oracle.jdbc.driver.OracleDriver";
ConnectionParam param = new ConnectionParam(driver, url, user, password);
ConnectionFactory cf = null;
// new ConnectionFactory(param,new FactoryParam());
try {
cf = new ConnectionFactory(param, new FactoryParam());
Connection conn1 = cf.getFreeConnection();
Connection conn2 = cf.getFreeConnection();
Connection conn3 = cf.getFreeConnection();
Statement stmt = conn1.createStatement();
ResultSet rs = stmt.executeQuery("select * from ADMINISTRATION");
if (rs.next()) {
System.out.println("conn1 y");
} else {
System.out.println("conn1 n");
}
stmt.close();
conn1.close();
Connection conn4 = cf.getFreeConnection();
Connection conn5 = cf.getFreeConnection();
stmt = conn5.createStatement();
rs = stmt.executeQuery("select * from ADMINISTRATION");
if (rs.next()) {
System.out.println("conn5 y");
} else {
System.out.println("conn5 n");
}
conn2.close();
conn3.close();
conn4.close();
conn5.close();
} catch (Exception ex) {
ex.printStackTrace();
} finally {
try {
cf.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
/**
* @param args
*/
public static void main(String[] args) {
String user = "ppuser";
String password = "ppuser";
String url = "jdbc:oracle:thin:@192.168.0.1:1521:PPDATA";
String driver = "oracle.jdbc.driver.OracleDriver";
ConnectionParam param = new ConnectionParam(driver, url, user, password);
System.out.println("-------" + param.getDriver());
ConnectionFactory cf = null;
try {
cf = new ConnectionFactory(param, new FactoryParam());
Connection conn1 = null;
long time = System.currentTimeMillis();
for (int i = 0; i < 10; i++) {
conn1 = cf.getFreeConnection();
Statement stmt = conn1.createStatement();
ResultSet rs = stmt.executeQuery("select * from actioncode");
if (rs.next()) {
System.out.println("conn1 y");
} else {
System.out.println("conn1 n");
}
conn1.close();
}
System.out.println("pool:" + (System.currentTimeMillis() - time));
time = System.currentTimeMillis();
Class.forName(param.getDriver()).newInstance();
for (int i = 0; i < 10; i++) {
conn1 = DriverManager.getConnection(param.getUrl(), param
.getUser(), param.getPassword());
Statement stmt = conn1.createStatement();
ResultSet rs = stmt.executeQuery("select * from actioncode");
if (rs.next()) {
System.out.println("conn1 y");
System.out.println(rs.getString(1));
System.out.println(rs.getString(2));
} else {
System.out.println("conn1 n");
}
conn1.close();
}
System.out
.println("no pool:" + (System.currentTimeMillis() - time));
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
cf.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
分享到：
发表评论
相关推荐
jdbc连接池代码详解
Tongweb5是一款基于Java的Web应用服务器，它支持配置JDBC连接池来管理数据库连接。本文将详细介绍如何在Tongweb5中配置JDBC连接池，以及Web应用如何通过JNDI（Java Naming and Directory Interface）查找并使用这些...
在Java开发中，数据库操作是不可或缺的一部分，而JDBC连接池是提高数据库访问效率、优化系统资源使用的重要技术。本文将深入探讨JDBC连接池的概念、工作原理，并以"通用basedao"模板为例，讲解如何在实际项目中应用...
本实例提供了完美的Java JDBC连接池配置，适用于Oracle、MySQL和SQL Server等主流数据库，允许开发者轻松地在不同数据库之间切换方言。 首先，让我们了解什么是JDBC连接池。JDBC（Java Database Connectivity）是...
Java JDBC连接池是一种高效管理数据库连接的技术，它允许应用程序重复使用已经建立的数据库连接，从而减少频繁创建和关闭连接带来的开销。在大型系统中，尤其是高并发环境下，使用连接池能够显著提升性能并降低资源...
描述中提到的"jdbc连接池设计"，意味着这个压缩包可能包含了一个简单的JDBC连接池实现或者相关的示例代码。其中，`jdom.jar`是一个Java文档对象模型库，主要用于解析XML文档。在数据库连接池的场景中，`jdom.jar`...
这个压缩包可能包含了一些示例代码、配置文件以及详细的使用说明，旨在帮助开发者理解并实践如何在Java项目中正确设置和使用JDBC连接池。 首先，我们需要了解JDBC连接池的基本原理。连接池维护了一组预建立的数据库...
**JDBC连接池BoneCP_Demo详解** 在Java开发中，数据库操作是不可或缺的一部分，而JDBC（Java Database Connectivity）是Java与数据库交互的标准接口。然而，直接使用JDBC进行数据库连接管理可能会导致资源浪费，...
一款小型JDBC连接池组件，具有性能高，代码轻，稳定好的特点。 一款小型JDBC连接池组件，具有性能高，代码轻，稳定好的特点。 一款小型JDBC连接池组件，具有性能高，代码轻，稳定好的特点。 一款小型JDBC连接...
标题"jdbc连接池技术代码"指的是实现或使用JDBC连接池的具体Java代码。下面将详细介绍JDBC连接池的工作原理、常见实现以及如何通过代码实现连接池管理器。 1. **JDBC连接池工作原理**： - 初始化：在应用程序启动...
在实际应用中，为了代码的健壮性和可维护性，通常会使用连接池（如C3P0、HikariCP）来管理数据库连接，以及使用DAO（Data Access Object）模式来封装数据库操作，提升代码的复用性。此外，还可以考虑使用ORM（Object...
HikariCP是一款高效、高性能的Java JDBC连接池，它被设计为替代传统连接池如C3P0和DBCP，以提供更快、更稳定的数据访问性能。在HikariCP v3.4.5这个版本中，我们可以深入探讨其在数据库连接管理、性能优化以及配置...
2. C3P0：这是一个开源的JDBC连接池，提供了比DBCP更高级的功能，如连接测试、空闲连接检测、自动扩展等。C3P0通过组合多个数据源来实现连接池，可以更好地控制并发和资源管理。 这些jar包的收集意味着开发者可以...
在实现自定义的JDBC连接池时，开发者需要考虑上述各个方面的细节，同时也要关注代码的可读性、可扩展性和维护性。此外，现有的开源连接池库，如C3P0、HikariCP、Druid等，已经提供了成熟的功能和优秀的性能，对于...
这些标签概括了本文档的主要内容和目标受众，旨在提供关于JDBC连接、连接池资源声明的详细指南和实例代码，帮助开发者更好地理解和实现JDBC连接池的配置。 ### 部分内容解读： 提供的部分内容展示了如何在Tomcat...
1. **选择连接池实现**：首先，我们需要选择一个合适的数据库连接池实现，如Apache的DBCP、C3P0、HikariCP或Tomcat JDBC连接池等。这些连接池库提供了管理和维护数据库连接的功能。 2. **配置连接池**：在应用的...
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。C3P0的主要特点包括： 1. **自动管理数据库连接**：C3P0会自动创建、配置和管理数据库连接，避免了频繁创建和销毁连接...
Java JDBC 连接池是Java数据库连接...以上就是关于Java JDBC连接池的基础知识，包括它的概念、主要实现、使用方法、关键参数、优点以及示例代码。理解并正确使用连接池是构建高效、稳定的Java数据库应用的重要一环。
**jdbc连接池c3p0工具包** 在Java开发中，数据库操作是常见的任务，而JDBC（Java Database Connectivity）是Java与数据库交互的标准接口。然而，直接使用JDBC进行数据库连接可能会导致性能问题，因为每次连接和断开...
线程安全的JDBC连接池就是为此目的设计的一种优化手段。在这个简单的实现中，我们利用了`ConcurrentLinkedQueue`数据结构来确保多线程环境下的安全性和效率。 首先，让我们了解什么是JDBC连接池。JDBC连接池（Java ...