JDBC 连接池代码

package com.mark.human.db;

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();
}
}

/**
* (non-Javadoc)
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
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;
}
}

===================================================================================

package com.mark.human.db;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;

/**
*
* @author mark
*
*/
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++;
}
}
}

}

================================================================================

package com.mark.human.db;

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;
}

}

============================================================================

package com.mark.human.db;

/**
* 连接池调度线程
*
* @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);
}
}
}

=================================================================================

package com.mark.human.db;

/**
* 连接池工厂参数
*
* @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;
}
}

============================================================================

package com.mark.human.db;

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();
}
}
}

}