一个基本成熟的数据库连接池(part 2)<修正后>

/**
* 数据连接类Connection的自封装，屏蔽了close方法和createStatement，prepareStatement 方法以返回自己的接管类
* @author zxg
*/
package com.dbaccess.dbpool;
import java.sql.*;
import java.util.Date;
import java.lang.reflect.*;
public class ConnectionObject implements InvocationHandler{
private final static String CLOSE_METHOD_NAME = "close";
private final static String CREATSTATMENT_METHOD_NAME = "createStatement";
private final static String PREPARESTATEMENT_METHOD_NAME = "prepareStatement";
private Connection conn_proxy=null;
private PreparedStatementObject pso=null;
private StatementObject stmo=null;
public Connection conn = null;
public String poolName=null;
//数据库的忙状态
private boolean inUse = false;
//用户最后一次访问该连接方法的时间
private long lastAccessTime = new Date().getTime();
public ConnectionObject(Connection conn, boolean inUse){
this.conn = conn;
this.inUse = inUse;
}
/**
* Returns the conn.
* @return Connection
*/
//返回数据库连接conn的接管类，以便截住Connection 的各个方法
public Connection getConnection(boolean bNewConn) {
if (bNewConn)
{
ClassLoader classloader=conn.getClass().getClassLoader();
Class[] interfaces = conn.getClass().getInterfaces();
if(interfaces==null||interfaces.length==0){
interfaces = new Class[1];
interfaces[0] = Connection.class;
}
conn_proxy=null;
try{
conn_proxy= (Connection)Proxy.newProxyInstance(classloader,interfaces,this);
}catch(NullPointerException e){
log(e,"ConnectionObject getConnection()--error");
}
if(conn_proxy!=null)
log("ConnectionObject getConnection()--success");
}
return conn_proxy;
}
/**
* 该方法真正的关闭了数据库的连接
* @throws SQLException
*/
synchronized void close() throws SQLException{
//由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接
conn.close();
conn=null;
}
/**
* Returns the inUse.
* @return boolean
*/
public boolean isInUse() {
return inUse;
}
public boolean isClosed() {
boolean bClosed=false;
try{
bClosed=conn.isClosed();
}catch(SQLException e){
log(e,"ConnectionObject--isClosed");
bClosed=false;
}
return bClosed;
}
/**
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object)
*/
public Object invoke(Object proxy, Method m, Object[] args)
throws Throwable
{
Object obj = null;
log("ConnectionObject--invoke:Method: \""+m.getName()+"\"");
//判断是否调用了close的方法，如果调用close方法则把连接置为无用状态
if(CLOSE_METHOD_NAME.equals(m.getName())){
setInUse(false);
}else if(CREATSTATMENT_METHOD_NAME.equals(m.getName())){
//如果调用了 createStatment 的方法，封装 Statement 类接受管理
try{
Statement stm=(Statement) m.invoke(conn, args);
stmo=new StatementObject(stm);
stmo.setConnectionObject(this);
obj=stmo.getStatement();
}catch(Exception e){
obj = m.invoke(conn, args);
log(e,"ConnectionObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else if(PREPARESTATEMENT_METHOD_NAME.equals(m.getName())){
//如果调用了 createStatment 的方法，封装 PreparedStatement 类接受管理
try{
PreparedStatement ps=(PreparedStatement) m.invoke(conn, args);
pso=new PreparedStatementObject(ps);
pso.setConnectionObject(this);
obj=pso.getPreparedStatement();
}catch(Exception e){
obj = m.invoke(conn, args);
log(e,"ConnectionObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else
obj = m.invoke(conn, args);
//设置最后一次访问时间，以便及时清除超时的连接
lastAccessTime = new Date().getTime();
return obj;
}
/**
* Returns the lastAccessTime.
* @return long
*/
public long getLastAccessTime() {
return lastAccessTime;
}
/**
* set the lastAccessTime.
* @param latimelong
*/
public void setLastAccessTime(long latime) {
lastAccessTime=latime;
}
/**
* Sets the inUse.
* @param inUse The inUse to set
*/
public void setInUse(boolean inUse) {
this.inUse = inUse;
}
public synchronized void release() {
try{
close();
}catch(SQLException e){
log(e,"ConnectionObject--release 调用 close 失败");
}
}
/**
* 将文本信息写入日志文件
*/
private void log(String msg) {
msg="POOLMSG:Name:["+poolName+"];Msg:"+msg;
ConnectionManager.log(msg);
}
/**
* 将文本信息与异常写入日志文件
*/
private void log(Throwable e, String msg) {
msg="POOLERR:Name:["+poolName+"];Msg:"+msg;
ConnectionManager.log(e,msg);
}
public void setPoolName(String pn){
poolName=pn;
}
public String getPoolName(){
return poolName;
}
}
/**
* Statement的自封装，屏蔽了getResultSet，executeQuery，getGeneratedKeys方法返回自己的接管类
* 目的适记录SQl的动作和设置相应连接最后活动时间。
* @author Liudong
*/
package com.dbaccess.dbpool;
import java.sql.*;
import java.util.Date;
import java.lang.reflect.*;
public class StatementObject implements InvocationHandler{
private Statement stm=null;
private Statement stm_proxy=null;
private ConnectionObject connoj=null;
private final static String GETRESULTSET_METHOD_NAME = "getResultSet";
private final static String EXECUTEQUERY_METHOD_NAME = "executeQuery";
private final static String GETGENERATEDKEYS_METHOD_NAME = "getGeneratedKeys";
private ResultSetObject rso=null;
public StatementObject(Statement stm){
this.stm=stm;
}
public Statement getStatement(){
ClassLoader classloader=stm.getClass().getClassLoader();
Class[] interfaces = stm.getClass().getInterfaces();
if(interfaces==null||interfaces.length==0){
interfaces = new Class[1];
interfaces[0] = Statement.class;
}
if (stm_proxy!=null) stm_proxy=null;
try{
stm_proxy= (Statement)Proxy.newProxyInstance(classloader,interfaces,this);
}catch(NullPointerException e){
log(e,"StatementObject getStatement()--error");
}
if(stm_proxy!=null)
log("StatementObject getStatement()--success");
return stm_proxy;
}
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
{
Object obj = null;
log("StatementObject--invoke:Method: \""+m.getName()+"\"");
//判断是否调用了getResultSet or executeQuery or getGeneratedKeys
//是就截获
if(GETRESULTSET_METHOD_NAME.equals(m.getName())
|| EXECUTEQUERY_METHOD_NAME.equals(m.getName())
|| GETGENERATEDKEYS_METHOD_NAME.equals(m.getName())){
try{
ResultSet rs=(ResultSet)m.invoke(stm, args);
rso=new ResultSetObject(rs);
rso.setConnectionObject(connoj);
obj=rso.getResultSet();
}catch(Exception e){
obj = m.invoke(stm, args);
log(e,"StatementObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else{
obj = m.invoke(stm, args);
}
//设置最后一次访问时间，以便及时清除超时的连接
setLastAccessTime( new Date().getTime());
return obj;
}
/**
* 将文本信息写入日志文件
*/
private void log(String msg) {
msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(msg);
}
/**
* 将文本信息与异常写入日志文件
*/
private void log(Throwable e, String msg) {
msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(e,msg);
}
//设置最后一次访问时间
private void setLastAccessTime(long ltime){
connoj.setLastAccessTime(ltime);
}
public void setConnectionObject(ConnectionObject cnoj){
connoj=cnoj;
}
}
/**
* PreparedStatement 的自封装，屏蔽了executeQuery方法返回自己的接管类
* 目的适记录SQl的动作和设置相应连接最后活动时间。
* @author Liudong
*/
package com.dbaccess.dbpool;
import java.sql.*;
import java.util.Date;
import java.lang.reflect.*;
public class PreparedStatementObject implements InvocationHandler{
private PreparedStatement ps=null;
private PreparedStatement ps_proxy =null;
private ConnectionObject connoj=null;
private final static String EXECUTEQUERY_METHOD_NAME = "executeQuery";
private ResultSetObject rso=null;
PreparedStatementObject(PreparedStatement ps){
this.ps=ps;
}
public PreparedStatement getPreparedStatement(){
ClassLoader classloader=ps.getClass().getClassLoader();
Class[] interfaces = ps.getClass().getInterfaces();
if(interfaces==null||interfaces.length==0){
interfaces = new Class[1];
interfaces[0] = PreparedStatement.class;
}
if (ps_proxy!=null) ps_proxy=null;
try{
ps_proxy= (PreparedStatement) Proxy.newProxyInstance(classloader,interfaces,this);
}catch(NullPointerException e){
log(e,"PreparedStatementObject getPreparedStatement()--error");
}
if(ps_proxy!=null)
log("PreparedStatementObject getPreparedStatement()--success");
return ps_proxy;
}
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
{
Object obj = null;
log("PreparedStatementObject--invoke:Method: \""+m.getName()+"\"");
//是否调用了executeQuery 如果是则接管
if(EXECUTEQUERY_METHOD_NAME.equals(m.getName())){
try{
ResultSet rs=(ResultSet)m.invoke(ps, args);
rso=new ResultSetObject(rs);
rso.setConnectionObject(connoj);
obj=rso.getResultSet();
}catch(Exception e){
obj = m.invoke(ps, args);
log(e,"PreparedStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else{
obj = m.invoke(ps, args);
}
obj = m.invoke(ps, args);
//设置最后一次访问时间，以便及时清除超时的连接
setLastAccessTime( new Date().getTime());
return obj;
}
/**
* 将文本信息写入日志文件
*/
private void log(String msg) {
msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(msg);
}
/**
* 将文本信息与异常写入日志文件
*/
private void log(Throwable e, String msg) {
msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(e,msg);
}
//设置最后一次访问时间
private void setLastAccessTime(long ltime){
connoj.setLastAccessTime(ltime);
}
public void setConnectionObject(ConnectionObject cnoj){
connoj=cnoj;
}
}
/**
*ResultSet 的自封装，屏蔽了getStatement,getMetaData,getString 方法返回自己的接管类
* 目的适记录SQl的动作和设置相应连接最后活动时间。
* @author Liudong
*/
package com.dbaccess.dbpool;
import java.sql.*;
import java.util.Date;
import java.lang.reflect.*;
public class ResultSetObject implements InvocationHandler{
private ResultSet rs=null;
private ResultSet rs_proxy =null;
private ConnectionObject connoj=null;
private final static String GETSTATEMENT_METHOD_NAME = "getStatement";
private final static String GETMETADATA_METHOD_NAME = "getMetaData";
private StatementObject stmo=null;
private ResultSetMetaDataObject rsdmo=null;
public ResultSetObject(ResultSet rs){
this.rs=rs;
}
public ResultSet getResultSet(){
ClassLoader classloader=rs.getClass().getClassLoader();
Class[] interfaces = rs.getClass().getInterfaces();
if(interfaces==null||interfaces.length==0){
interfaces = new Class[1];
interfaces[0] = ResultSet.class;
}
if(rs_proxy!=null) rs_proxy =null;
try{
rs_proxy =(ResultSet)Proxy.newProxyInstance(classloader,interfaces,this);
}catch(NullPointerException e){
log(e,"ResultSetObject getResultSet()--error");
}
if(rs_proxy!=null)
log("ResultSet getResultSet()--success");
return rs_proxy;
}
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
{
Object obj = null;
log("ResultSetObject--invoke:Method: \""+m.getName()+"\"");
//是否执行getStatement，返回Statement 的接管类
if(GETSTATEMENT_METHOD_NAME.equals(m.getName())){
try{
Statement stm=(Statement)m.invoke(rs,args);
if (stmo!=null) stmo=null;
stmo=new StatementObject(stm);
stmo.setConnectionObject(connoj);
obj=stmo.getStatement();
}catch(Exception e){
obj=m.invoke(rs,args);
log(e,"ResultSetObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else if(GETMETADATA_METHOD_NAME.equals(m.getName())){
try{
ResultSetMetaData rsdm=(ResultSetMetaData)m.invoke(rs, args);
if (rsdmo!=null) rsdmo=null;
rsdmo=new ResultSetMetaDataObject(rsdm);
rsdmo.setConnectionObject(connoj);
obj = rsdmo.getMetaData();
}catch(Exception e){
obj=m.invoke(rs,args);
log(e,"ResultSetObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else if(m.getName().equals("getString")){
try{
Class paramTypes[]=m.getParameterTypes();
Class paramType = paramTypes[0];
String paramName=paramType.getName();
//debug
// log(paramName);
if(paramName.indexOf("string")!=-1 ||
paramName.indexOf("String")!=-1){
String parm=(String)args[0];
//debug
// log(parm);
String character=getCharacter(connoj.getPoolName());
obj=new String(rs.getBytes(parm),character);
}else{
Object oi=args[0];
String si=oi.toString();
//debug
// log(si);
int i=Integer.parseInt(si);
String character=getCharacter(connoj.getPoolName());
obj=new String(rs.getBytes(i),character);
}
}catch(Exception e){
obj=m.invoke(rs,args);
log(e,"ResultSetObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else
obj=m.invoke(rs,args);
//设置最后一次访问时间，以便及时清除超时的连接
setLastAccessTime( new Date().getTime());
return obj;
}
/**
* 将文本信息写入日志文件
*/
private void log(String msg) {
msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(msg);
}
/**
* 将文本信息与异常写入日志文件
*/
private void log(Throwable e, String msg) {
msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(e,msg);
}
private String getCharacter(String poolName) {
return ConnectionManager.getCharacter(poolName);
}
//设置最后一次访问时间
private void setLastAccessTime(long ltime){
connoj.setLastAccessTime(ltime);
}
//关联所使用得连接。
public void setConnectionObject(ConnectionObject cnoj){
connoj=cnoj;
}
}
/**
* ResultSetMetaData 的自封装，屏蔽了executeQuery方法返回自己的接管类
* 目的适记录SQl的动作和设置相应连接最后活动时间。
* @author Liudong
*/
package com.dbaccess.dbpool;
import java.sql.*;
import java.util.Date;
import java.lang.reflect.*;
public class ResultSetMetaDataObject implements InvocationHandler{
private ResultSetMetaData rsmd=null;
private ResultSetMetaData rsmd_proxy =null;
//
private ConnectionObject connoj=null;
public ResultSetMetaDataObject(ResultSetMetaData rsmd){
this.rsmd=rsmd;
}
public ResultSetMetaData getMetaData(){
ClassLoader classloader=rsmd.getClass().getClassLoader();
Class[] interfaces = rsmd.getClass().getInterfaces();
if(interfaces==null||interfaces.length==0){
interfaces = new Class[1];
interfaces[0] = ResultSetMetaData.class;
}
if (rsmd_proxy!=null) rsmd_proxy=null;
try{
rsmd_proxy= (ResultSetMetaData) Proxy.newProxyInstance(classloader,interfaces,this);
}catch(NullPointerException e){
log(e,"ResultSetMetaDataObject getPreparedStatement()--error");
}
if(rsmd_proxy!=null)
log("ResultSetMetaDataObject getPreparedStatement()--success");
return rsmd_proxy;
}
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
{
Object obj = null;
log("ResultSetMetaDataObject--invoke:Method: \""+m.getName()+"\"");
obj = m.invoke(rsmd, args);
//设置最后一次访问时间，以便及时清除超时的连接
setLastAccessTime( new Date().getTime());
return obj;
}
/**
* 将文本信息写入日志文件
*/
private void log(String msg) {
msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(msg);
}
/**
* 将文本信息与异常写入日志文件
*/
private void log(Throwable e, String msg) {
msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(e,msg);
}
//设置最后一次访问时间
private void setLastAccessTime(long ltime){
connoj.setLastAccessTime(ltime);
}
public void setConnectionObject(ConnectionObject cnoj){
connoj=cnoj;
}
}
/**
* CallableStatement 的自封装，屏蔽了executeQuery getGeneratedKeys getMetaData 方法返回自己的接管类
* 目的是记录SQl的动作和设置相应连接最后活动时间。
* @author Liudong
*/
package com.dbaccess.dbpool;
import java.sql.*;
import java.util.Date;
import java.lang.reflect.*;
public class CallableStatementObject implements InvocationHandler{
private CallableStatement cs=null;
private CallableStatement cs_proxy =null;
private ConnectionObject connoj=null;
private final static String EXECUTEQUERY_METHOD_NAME = "executeQuery";
private final static String GETRESULTSET_METHOD_NAME = "getResultSet";
private final static String GETGENERATEDKEYS_METHOD_NAME = "getGeneratedKeys";
private final static String GETMETADATA_METHOD_NAME = "getMetaData";
private ResultSetObject rso=null;
private ResultSetMetaDataObject rsmdo=null;
CallableStatementObject(CallableStatement cs){
this.cs=cs;
}
public CallableStatement getCallableStatement(){
ClassLoader classloader=cs.getClass().getClassLoader();
Class[] interfaces = cs.getClass().getInterfaces();
if(interfaces==null||interfaces.length==0){
interfaces = new Class[1];
interfaces[0] = CallableStatement.class;
}
try{
cs_proxy= (CallableStatement) Proxy.newProxyInstance(classloader,interfaces,this);
}catch(NullPointerException e){
log(e,"CallableStatementObject getCallableStatement()--error");
}
if(cs_proxy!=null)
log("CallableStatementObject getCallableStatement()--success");
return cs_proxy;
}
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
{
Object obj = null;
log("CallableStatementObject--invoke:Method: \""+m.getName()+"\"");
//是否调用了executeQuery || getGeneratedKeys 如果是则接管
if(EXECUTEQUERY_METHOD_NAME.equals(m.getName()) ||
GETGENERATEDKEYS_METHOD_NAME.equals(m.getName())||
GETRESULTSET_METHOD_NAME.equals(m.getName())){
try{
ResultSet rs=(ResultSet)m.invoke(cs, args);
rso=new ResultSetObject(rs);
rso.setConnectionObject(connoj);
obj=rso.getResultSet();
}catch(Exception e){
obj=m.invoke(cs, args);
log(e,"CallableStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else if(GETMETADATA_METHOD_NAME.equals(m.getName())){
try{
ResultSetMetaData rsmd=(ResultSetMetaData)m.invoke(cs, args);
rsmdo=new ResultSetMetaDataObject(rsmd);
rsmdo.setConnectionObject(connoj);
obj=rsmdo.getMetaData();
}catch(Exception e){
obj=m.invoke(cs, args);
log(e,"CallableStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
}
}else if(m.getName().equals("getString")){
try{
Class paramTypes[]=m.getParameterTypes();
Class paramType = paramTypes[0];
String paramName=paramType.getName();
//debug
// log(paramName);
if(paramName.indexOf("string")!=-1 ||
paramName.indexOf("String")!=-1){
String parm=(String)args[0];
//debug
// log(parm);
String character=getCharacter(connoj.getPoolName());
obj=new String(cs.getBytes(parm),character);
}else{
Object oi=args[0];
String si=oi.toString();
//debug
// log(si);
int i=Integer.parseInt(si);
String character=getCharacter(connoj.getPoolName());
obj=new String(cs.getBytes(i),character);
}
}catch(Exception e){
log(e,"CallableStatementObject--invoke:Method: \""+m.getName()+"\"--失败");
obj=m.invoke(cs,args);
}
}else
obj = m.invoke(cs, args);
//设置最后一次访问时间，以便及时清除超时的连接
setLastAccessTime( new Date().getTime());
return obj;
}
/**
* 将文本信息写入日志文件
*/
private void log(String msg) {
msg="POOLMSG:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(msg);
}
/**
* 将文本信息与异常写入日志文件
*/
private void log(Throwable e, String msg) {
msg="POOLERR:Name:["+connoj.getPoolName()+"];Msg:"+msg;
ConnectionManager.log(e,msg);
}
//设置最后一次访问时间
private void setLastAccessTime(long ltime){
connoj.setLastAccessTime(ltime);
}
public void setConnectionObject(ConnectionObject cnoj){
connoj=cnoj;
}
private String getCharacter(String poolName) {
return ConnectionManager.getCharacter(poolName);
}
}

//===================这部分是数据库连接和造作类的封装================