import java.util.ArrayList;
import java.util.Iterator;
import java.util.Timer;
import java.util.TimerTask;
import com.xxx.config.*;
/**
* 连接池连接工厂实现类。<br>
* 配置说明:<br>
* DBMaxConnectionCount:连接池最大连接数<br>
* DBMinConnectionCount:连接池最小连接数<br>
* DBInitConnectionCount:连接池初始连接数<br>
* DBUseCount:数据库连接对象使用次数,默认-1;<br>
* DBTimeout:数据库连接对象空闲时间,默认-1;<br>
* DBUseTime:数据库连接对象最大使用时间,默认-1;<br>
* DBTimerInterval:数据库定时器整理连接池的间隔时间,默认-1;<br>
* 如果DBTimerInterval配置为-1,则不启动连接池定时器。
* @author
*/
public class CPoolConnectionFactory extends SimpleConnectionFactory {
int connectionPoolSize = 1;
int connectionPoolMin = 1;
int connectionPoolMax = 30;
int connectionPoolFree = -1;
int connectionUseCount = -1;
long connectionWaitTimeout = -1;
long connectionTimeout = -1;
long connectionUseTime = -1;
int timerInterval = -1;
protected ArrayList connectionObjs;
protected Timer timer;
protected CPoolConnectionFactory() {
}
/**
* 销毁连接池
*/
public void destroy() {
synchronized (connectionObjs) {
Iterator it = connectionObjs.iterator();
while (it.hasNext()) {
ConnectionObject co = (ConnectionObject) it.next();
co.close();
}
this.connectionObjs.clear();
}
}
/**
* 从连接池得到连接对象
* @return ConnectionObject对象
*/
public ConnectionObject getConnection() {
ConnectionObject co = this.getConnectionInternal(false);
return co;
}
/**
* 新建连接对象
* @return 一个新的ConnectionObject对象
*/
public ConnectionObject newConnection() {
ConnectionObject co = this.getConnectionInternal(true);
return co;
}
/**
* 释放连接对象到连接池
* @param co 将被释放的ConnectionObject对象
*/
public void freeConnection(ConnectionObject co) {
if (co == null) return;
synchronized (connectionObjs) {
co.useCount++;
if (connectionUseCount > 0 && co.useCount > connectionUseCount) {
co.close();
this.connectionObjs.remove(co);
co = null;
} else {
co.endTransaction();
co.closeStatement();
co.isusing = false;
co.lastAccess = System.currentTimeMillis();
}
}
}
/**
* 关闭连接对象
* @param co 将被关闭的ConnectionObject对象
*/
public void closeConnection(ConnectionObject co) {
if (co == null) return;
synchronized (connectionObjs) {
co.close();
this.connectionObjs.remove(co);
co = null;
}
}
/**
* 初始化
* @param conf 数据库配置
*/
public void init(Configs conf){
super.init(conf);
try {
connectionPoolMin = Integer.parseInt(conf.getConfig(ConfigKeys.dbMinConnKey, "1"));
}catch(Exception ex){}
if (connectionPoolMin < 0)
connectionPoolMin = 1;
try {
connectionPoolSize = Integer.parseInt(conf.getConfig(ConfigKeys.dbInitConnKey, "1"));
}catch(Exception ex){}
if (connectionPoolSize < connectionPoolMin)
connectionPoolSize = connectionPoolMin;
try {
connectionPoolMax = Integer.parseInt(conf.getConfig(ConfigKeys.dbMaxConnKey, "30"));
}catch(Exception ex){}
if (connectionPoolMax < 0)
connectionPoolMax = 100;
if (connectionPoolMax < connectionPoolMin)
connectionPoolMax = connectionPoolMin + 3;
try {
connectionUseCount = Integer.parseInt(conf.getConfig(ConfigKeys.dbUseCountKey, "-1"));
}catch(Exception ex){}
try {
connectionTimeout = Long.parseLong(conf.getConfig(ConfigKeys.dbTimeoutKey, "-1")) * 60 * 1000;
}catch(Exception ex){}
try {
connectionWaitTimeout = Long.parseLong(conf.getConfig(ConfigKeys.dbWaitTimeoutKey, "-1")) * 1000;
}catch(Exception ex){}
try {
connectionUseTime = Long.parseLong(conf.getConfig(ConfigKeys.dbUseTimeKey, "-1")) * 60 * 1000;
}catch(Exception ex){}
try {
timerInterval = Integer.parseInt(conf.getConfig(ConfigKeys.dbTimerIntervalKey, "-1")) * 60 * 1000;
}catch(Exception ex){}
if (timerInterval > 0) {
timer = new Timer();
timer.schedule(new TimerTask() {
public void run() {
TimerEvent();
}
}, timerInterval, timerInterval);
}
connectionObjs = new ArrayList(connectionPoolMax);
for (int i = 0; i < connectionPoolSize; i++) {
ConnectionObject co = super.newConnection();
this.connectionObjs.add(co);
}
}
protected ConnectionObject getConnectionInternal(boolean isNew) {
long sys = System.currentTimeMillis();
while (true) {
ConnectionObject ret = null;
synchronized (connectionObjs) {
if (connectionObjs.size() > 0
&& (isNew == false || this.connectionObjs.size() >= connectionPoolMax)) {
ArrayList removes = new ArrayList();
Iterator it = connectionObjs.iterator();
while (it.hasNext()) {
ConnectionObject co = (ConnectionObject) it.next();
if (!co.isusing) {
if (isNew) {
co.close();
this.connectionObjs.remove(co);
break;
}
if ((connectionTimeout < 0 || System.currentTimeMillis() - co.createTime < connectionTimeout) && !co.isClosed()) {
ret = co;
break;
}
co.close();
removes.add(co);
}
}
if (removes.size() > 0)
this.connectionObjs.removeAll(removes);
}
if (ret == null && this.connectionObjs.size() < connectionPoolMax) {
ret = super.newConnection();
this.connectionObjs.add(ret);
}
//System.out.println("get connection ret=====================" + ret);
if (ret != null) {
ret.isusing = true;
ret.lastAccess = System.currentTimeMillis();
//System.out.println("get connection size=====================" + this.connectionObjs.size());
return ret;
}
}
if (this.connectionWaitTimeout > 0 && System.currentTimeMillis() - sys > this.connectionWaitTimeout)
throw new DBException("已达到最大的等待时间,没取到可用的连接!");
try {
Thread.sleep(500);
}catch(Exception ex){}
}
}
protected void TimerEvent() {
synchronized (connectionObjs) {
if (connectionObjs.size() > 0) {
ArrayList removes = new ArrayList();
Iterator it = connectionObjs.iterator();
int cc = 0;
while (it.hasNext()) {
ConnectionObject co = (ConnectionObject) it.next();
try {
if (!co.conn.isClosed()) {
if (co.isusing) {
if (connectionUseTime < 0 || System.currentTimeMillis() - co.lastAccess < connectionUseTime)
continue;
} else {
if ((connectionTimeout < 0 || System.currentTimeMillis() - co.createTime < connectionTimeout)
&& (connectionUseCount < 0 || co.useCount <= connectionUseCount)
&& !co.isClosed()) {
if (this.connectionPoolFree < 0 || cc < this.connectionPoolFree) {
cc++;
continue;
}
}
}
}
}catch(Exception ex){
ex.printStackTrace();
}
co.close();
removes.add(co);
}
if (removes.size() > 0)
this.connectionObjs.removeAll(removes);
}
if (connectionObjs.size() < connectionPoolMin) {
for (int i = this.connectionObjs.size(); i < connectionPoolMin; i++) {
ConnectionObject co = super.newConnection();
this.connectionObjs.add(co);
}
}
//System.out.println("connection size***********************" + this.connectionObjs.size());
}
}
}
java 数据库连接方式(四)
最新推荐文章于 2024-04-16 20:43:50 发布