一劳永逸的数据库编码解决方案

转自IBM中国
作者：刘东


问题提出

现在几乎所有的应用系统都无法避免使用数据库系统。在JAVA世界里访问数据库是一件非常轻松的事情，JDBC为JAVA应用程序访问数据库提供了一个统一的接口，通过使用JDBC接口开发者无需关心系统最终采用哪种数据库，因为JDBC仅仅是定义了访问几个JAVA的接口类，具体的实现是由数据库厂商提供的，这种做法其实与其他数据库连接方式例如ODBC是类似的。但是在实际的应用过程中，开发者发现离JDBC设计的初衷还是有一定距离，就比如说在存储字符串时的编码问题，我想很多开发者都会遇见这个问题，倒不是因为说解决它有什么技术方面的难度，而是它的的确确非常繁琐。我们必须在每次写入或者读出字符串的时候进行编码和反编码处理；或者说我们可以写一个方法可以进行编码处理的，但又必须在每次数据库操作的时候调用，虽然调用很简单，可是我非得这样吗？要是忘了编码那又要DEBUG了。当然你可能觉得这并没有什么，或者你可能很勤快，喜欢写大量重复的代码，可是你难道没有觉得这种繁琐的工作正在浪费你过于宝贵的青春吗？停止你的键盘输入，让我们来解决这个问题吧！

解决思路

在传统的应用程序中数据库操作部分我们可以想象成两层，如图所示：一个是数据库的"连接池"，另外一个业务数据操作层。在这里数据库的连接池是广义的，你可以把JDBC中的DriverManager也当成是连接池，具体的意思就是我们可以通过这层来获取到指定数据库的连接而不去关心它是怎么获取的。如果这个时候数据库系统（有如Informix，SQL Server）要求对字符串进行转码才能存储（例如最常见的GBK->;ISO8859_1转码），那我们就必须在业务数据操作层来进行，这样有多少业务数据操作我们就要做多少编码转码的工作，太麻烦了，代码中充斥中大量重复的内容。本文提出的解决方案就是利用对获取到的数据库连接实例进行二次封装，也就是在数据库连接池与业务数据操作层之间加入了连接封装层，当然了，我们也完全可以直接将连接封装集成到数据库连接池内部。关于连接池的实现请参照我的另外一篇文章《使用JAVA动态代理实现数据库连接池》（本文后跟联）

---

 echoguo 回复于：2003-11-23 13:36:50

我们知道进行编码和转码工作都是集中在JDBC的两个接口PreparedStatement和ResultSet上进行的，主要涉及PreparedStatement的setString方法以及ResultSet的getString方法。前面我们讲过需要加入一个连接封装层来对数据库连接实例进行二次封装，但是怎么通过这个封装来改变PreparedStatement和ResultSet这两个接口的行为呢？这个问题其实也很简单，因为PreparedStatement接口必须通过Connection接口来获取实例，而ResultSet接口又必须从Statement或者PreparedStatement接口来获取实例，有了这样的级联关系，问题也就迎刃而解了。还是利用我在文章《使用JAVA动态代理实现数据库连接池》中使用的动态接口代理技术。首先我们设计Connection接口的代理类_Connection，这个代理类接管了Connection接口中所有可能获取到Statement或者PreparedStatement接口实例的方法，例如：prepareStatement和createStatement。改变这两个方法使之返回的是经过接管后的Statement或者PreparedStatement实例。通过对于Statement接口也有相应的代理类_Statement，这个代理类接管用于获取ResultSet接口实例的所有方法，包括对setString方法的接管以决定是否对字符串进行编码处理。对于接口ResultSet的接管类_ResultSet就相应的比较简单，它只需要处理getString方法即可。

关键代码

前面我们大概介绍了这个解决方案的思路，下面我们给出关键的实现代码包括Connection的代理类，Statement的代理类，ResultSet的代理类。这些代码是在原来关于数据库连接池实现的基础上进行扩充使之增加对自动编码处理的功能。有需要源码打包的可以通过电子邮件跟我联系。

_Connection.java

/* 

 * Created on 2003-10-23 by Liudong 

 */

package lius.pool;

import java.sql.*;

import java.lang.reflect.*;



/*

 * 

 * 数据库连接的代理类 

 * @author Liudong 

 */

 class _Connection implements InvocationHandler{

	private Connection conn = null;

	private boolean coding = false;

	//指定是否进行字符串转码操作

	_Connection(Connection conn, boolean coding){

		this.conn = conn;

		this.coding = coding;

		initConnectionParam(this.conn);

	

	}

	

	/**	 

	 * Returns the conn.	 

	 * @return Connection	 

	 */

	 

	public Connection getConnection() {

		Class[] interfaces = conn.getClass().getInterfaces();

		if(interfaces==null||interfaces.length==0){

			interfaces = new Class[1];

			interfaces[0] = Connection.class;

		

		}

	

		Connection conn2 = (Connection)Proxy.newProxyInstance(	conn.getClass().getClassLoader(), interfaces,this);

		return conn2;

	

	}

	

	/**	 

	 * @see java.lang.reflect.InvocationHandler#invoke	 

	 */

	public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {	

		String method = m.getName();

		//调用相应的操作

		Object obj = null;

		try{

			obj = m.invoke(conn, args);

			//接管用于获取语句句柄实例的方法

			if((CS.equals(method)||PS.equals(method))&&coding) 

				return new _Statement((Statement)obj,true).getStatement();

		

		} catch(InvocationTargetException e) {

			throw e.getTargetException();

		}

		return obj;

	}

	

	private final static String PS = "prepareStatement";

	private final static String CS = "createStatement";

}

---

 echoguo 回复于：2003-11-23 13:38:03

_Statement.java

/* 

 * Created on 2003-10-23 by Liudong 

 */

 

package lius.pool;

import java.sql.*;

import java.lang.reflect.*;



/** 

 * 数据库语句对象实例的代理类 

 * @author Liudong 

 */

class _Statement implements InvocationHandler{	

	private Statement statement ; //保存所接管对象的实例	

	private boolean decode = false; //指定是否进行字符串转码	



	public _Statement(Statement stmt,boolean decode) {	

		this.statement = stmt;

		this.decode = decode;

	}

	

	/**	 

	 * 获取一个接管后的对象实例	 

	 * @return	 

	 */

	public Statement getStatement() {

		Class[] interfaces = statement.getClass().getInterfaces();

		if(interfaces==null||interfaces.length==0){	

			interfaces = new Class[1];

			interfaces[0] = Statement.class;

		}	

		Statement stmt = (Statement)Proxy.newProxyInstance(			

			statement.getClass().getClassLoader(),	

			interfaces,this);

		return stmt;

	

	}

	

	/**	 

	 * 方法接管	 

	 */

	public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {

		String method = m.getName(); //接管setString方法	

		if(decode && SETSTRING.equals(method)) {

			try{

				String param = (String)args[1];

				if(param!=null)

					param = new String(param.getBytes(),"8859_1");

				return m.invoke(statement,new Object[]{args[0],param});

			} catch(InvocationTargetException e){

				throw e.getTargetException();

 							

			}		

		}

		

		//接管executeQuery方法

		

		if(decode && EXECUTEQUERY.equals(method)){

			try{

				ResultSet rs = (ResultSet)m.invoke(statement,args);

				return new _ResultSet(rs,decode).getResultSet();

			

			}catch(InvocationTargetException e){

				throw e.getTargetException();

 			}		

		}

		

		try{

			return m.invoke(statement, args);

		} catch(InvocationTargetException e) {

			throw e.getTargetException();

 		}	

	}

	//两个要接管的方法名

	

	private final static String SETSTRING = "setString";

	private final static String EXECUTEQUERY = "executeQuery";

}

_ResultSet.java

/* 

 * Created on 2003-10-23 by Liudong 

 */

 

package lius.pool;

import java.sql.ResultSet;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;



/** 

 * 数据库结果集的代理类 

 * @author Liudong 

 */

 class _ResultSet implements InvocationHandler{	

	private ResultSet rs = null;

	private boolean decode = false;

	

	public _ResultSet(ResultSet rs,boolean decode) {

		this.rs = rs;

		this.decode = decode;

	}

	

	public ResultSet getResultSet(){	

		Class[] interfaces = rs.getClass().getInterfaces();

		if(interfaces==null||interfaces.length==0){

			interfaces = new Class[1];

			interfaces[0] = ResultSet.class;		

		}

	

		ResultSet rs2 = (ResultSet)Proxy.newProxyInstance(rs.getClass().getClassLoader(),			interfaces,this);

		return rs2;

	

	}



	/**	 

	 * 结果getString方法	 

	 */

	public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {	

		String method = m.getName();

		if(decode && GETSTRING.equals(method)){

			try{

				String result = (String)m.invoke(rs,args);

				if(result!=null)					

					return new String(result.getBytes("8859_1"));

				return null;

			

			}catch(InvocationTargetException e){

				throw e.getTargetException();

 			}

			

		}	

		

		try{

			return m.invoke(rs, args);

		}catch(InvocationTargetException e){

			throw e.getTargetException();

		}

	}

	

	private final static String GETSTRING = "getString";



}

---

 echoguo 回复于：2003-11-23 13:41:30

现在我们已经把三个接口的代理类做好了，下一步就是怎么来使用这三个类。其实对于使用者来讲并不需要关心三个类，只需要了解_Connection就可以了，因为另外两个是_Connection直接调用的。为了使用_Connection我们必须传入两个参数，第一个是数据库实际的数据库连接实例，另外一个是布尔值代表是否进行转码处理。我们必须先通过实际的情况获取到数据库连接后再传入_Connection的构造函数作为参数，下面例子告诉你如何来使用_Connection这个类：

Connection conn = getConnection(); //获取数据库连接

boolean coding = false; //从配置或者其他地方读取是否进行转码的配置	

//接管数据库连接实例	

_Connection _conn = new _Connection(conn,coding);

//获得接管后的数据库连接实例，以后直接使用conn2而不是conn	

Connection conn2 = _conn.getConnection();

因为对一个应用系统来讲，数据库连接的获取必然有统一的方法，在这个方法中加入对连接的接管就可以一劳永逸的解决数据库的编码问题。

[size=18]性能比较[/size]

功能没有问题了，开发者接下来就会关心性能的问题，因为在进行一些对响应速度要求很高或者大数据量的处理情况下性能就成为一个非常突出的问题。由于JAVA中的动态接口代理采用的是反射（Reflection）机制，同时又加入我们自己的一些代码例如方法名判断，字符串转码等操作因此在性能上肯定比不上直接使用没有经过接管的数据库连接。但是这点性能上的差别是不是我们可以忍受的呢，为此我做了一个试验对二者进行了比较：

测试环境简单描述：

使用ACCESS数据库，建两张结构一样的表，计算从获取连接后到插入数据完毕后的时间差，两个程序（直连数据库和使用连接接管）都进行的字符串的转码操作。


测试结果：

插入记录数  直连数据库程序耗时 单位：ms  使用连接接管程序耗时  性能比较 
1000         2063                                     2250                         9.0% 
5000         8594                                     8359                         -2.7% 
10000       16750                                   17219                         2.8% 
15000        22187                                  23000                         3.6% 
20000       27031                                   27813                         2.9% 
 
从上面这张测试结果表中来看，二者的性能的差别非常小，尽管在两万条数据的批量插入的时候时间差别也不会多于一秒钟，这样的结果应该说还是令人满意的，毕竟为了程序良好的结构有时候牺牲一点点性能还是值得的。

本文算是我之前文章《使用JAVA动态代理实现数据库连接池》中提出的数据库连接池实现的进一步完善，同样使用动态接口代理的技术来解决数据库编码的问题。JAVA的这个高级技术可以用来解决许多实际中非常棘手的问题，就像本文提到的编码问题的处理以及数据库连接池的实现，同时在WEB开发框架的实现上也有非常大的作为。欢迎对这方面感兴趣的朋友来信共同来研究。

---

 echoguo 回复于：2003-11-23 13:42:45

使用JAVA中的动态代理实现数据库连接池


数据库连接池在编写应用服务是经常需要用到的模块，太过频繁的连接数据库对服务性能来讲是一个瓶颈，使用缓冲池技术可以来消除这个瓶颈。我们可以在互联网上找到很多关于数据库连接池的源程序，但是都发现这样一个共同的问题：这些连接池的实现方法都不同程度地增加了与使用者之间的耦合度。很多的连接池都要求用户通过其规定的方法获取数据库的连接，这一点我们可以理解，毕竟目前所有的应用服务器取数据库连接的方式都是这种方式实现的。但是另外一个共同的问题是，它们同时不允许使用者显式的调用Connection.close()方法，而需要用其规定的一个方法来关闭连接。这种做法有两个缺点：

第一：改变了用户使用习惯，增加了用户的使用难度。

首先我们来看看一个正常的数据库操作过程：

int executeSQL(String sql) throws SQLException

{

	Connection conn = getConnection();	//通过某种方式获取数据库连接

	PreparedStatement ps = null;

	int res = 0;

	try{

		ps = conn.prepareStatement(sql);

		res = ps.executeUpdate();

}finally{

try{

ps.close();

}catch(Exception e){}

try{

	conn.close();//

}catch(Exception e){}

}

return res;

}

---

 echoguo 回复于：2003-11-23 13:43:32

使用者在用完数据库连接后通常是直接调用连接的方法close来释放数据库资源，如果用我们前面提到的连接池的实现方法，那语句conn.close()将被某些特定的语句所替代。

第二：使连接池无法对之中的所有连接进行独占控制。由于连接池不允许用户直接调用连接的close方法，一旦使用者在使用的过程中由于习惯问题直接关闭了数据库连接，那么连接池将无法正常维护所有连接的状态，考虑连接池和应用由不同开发人员实现时这种问题更容易出现。

综合上面提到的两个问题，我们来讨论一下如何解决这两个要命的问题。

首先我们先设身处地的考虑一下用户是想怎么样来使用这个数据库连接池的。用户可以通过特定的方法来获取数据库的连接，同时这个连接的类型应该是标准的java.sql.Connection。用户在获取到这个数据库连接后可以对这个连接进行任意的操作，包括关闭连接等。

通过对用户使用的描述，怎样可以接管Connection.close方法就成了我们这篇文章的主题。

为了接管数据库连接的close方法，我们应该有一种类似于钩子的机制。例如在Windows编程中我们可以利用Hook API来实现对某个Windows API的接管。在JAVA中同样也有这样一个机制。JAVA提供了一个Proxy类和一个InvocationHandler，这两个类都在java.lang.reflect包中。我们先来看看SUN公司提供的文档是怎么描述这两个类的。

public interface InvocationHandler



InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 



Each proxy instance has an associated invocation handler. 

When a method is invoked on a proxy instance, 

the method invocation is encoded and dispatched to the invoke method of its invocation handler.

SUN的API文档中关于Proxy的描述很多，这里就不罗列出来。通过文档对接口InvocationHandler的描述我们可以看到当调用一个Proxy实例的方法时会触发Invocationhanlder的invoke方法。从JAVA的文档中我们也同时了解到这种动态代理机制只能接管接口的方法，而对一般的类无效，考虑到java.sql.Connection本身也是一个接口由此就找到了解决如何接管close方法的出路。

---

 echoguo 回复于：2003-11-23 13:44:35

首先，我们先定义一个数据库连接池参数的类，定义了数据库的JDBC驱动程序类名，连接的URL以及用户名口令等等一些信息，该类是用于初始化连接池的参数，具体定义如下：

public class ConnectionParam implements Serializable

{

	private String driver;				//数据库驱动程序

	private String url;					//数据连接的URL

	private String user;					//数据库用户名

	private String password;				//数据库密码

	private int minConnection = 0;		//初始化连接数

	private int maxConnection = 50;		//最大连接数

	private long timeoutValue = 600000;//连接的最大空闲时间

	private long waitTime = 30000;		//取连接的时候如果没有可用连接最大的等待时间

其次是连接池的工厂类ConnectionFactory，通过该类来将一个连接池对象与一个名称对应起来，使用者通过该名称就可以获取指定的连接池对象，具体代码如下：

/**

 * 连接池类厂，该类常用来保存多个数据源名称合数据库连接池对应的哈希

 * @author liusoft

 */

public class ConnectionFactory

{

	//该哈希表用来保存数据源名和连接池对象的关系表

	static Hashtable connectionPools = null;

	static{

		connectionPools = new Hashtable(2,0.75F);

	} 

	/**

	 * 从连接池工厂中获取指定名称对应的连接池对象

	 * @param dataSource	连接池对象对应的名称

	 * @return DataSource	返回名称对应的连接池对象

	 * @throws NameNotFoundException	无法找到指定的连接池

	 */

	public static DataSource lookup(String dataSource) 

		throws NameNotFoundException

	{

		Object ds = null;

		ds = connectionPools.get(dataSource);

		if(ds == null || !(ds instanceof DataSource))

			throw new NameNotFoundException(dataSource);

		return (DataSource)ds;

	}



	/**

	 * 将指定的名字和数据库连接配置绑定在一起并初始化数据库连接池

	 * @param name		对应连接池的名称

	 * @param param	连接池的配置参数，具体请见类ConnectionParam

	 * @return DataSource	如果绑定成功后返回连接池对象

	 * @throws NameAlreadyBoundException	一定名字name已经绑定则抛出该异常

	 * @throws ClassNotFoundException		无法找到连接池的配置中的驱动程序类

	 * @throws IllegalAccessException		连接池配置中的驱动程序类有误

	 * @throws InstantiationException		无法实例化驱动程序类

	 * @throws SQLException				无法正常连接指定的数据库

	 */

	public static DataSource bind(String name, ConnectionParam param)

		throws NameAlreadyBoundException,ClassNotFoundException,

				IllegalAccessException,InstantiationException,SQLException

	{

		DataSourceImpl source = null;

		try{

			lookup(name);

			throw new NameAlreadyBoundException(name);

		}catch(NameNotFoundException e){

			source = new DataSourceImpl(param);

			source.initConnection();

			connectionPools.put(name, source);

		}

		return source;

	}

	/**

	 * 重新绑定数据库连接池

	 * @param name		对应连接池的名称

	 * @param param	连接池的配置参数，具体请见类ConnectionParam

	 * @return DataSource	如果绑定成功后返回连接池对象

	 * @throws NameAlreadyBoundException	一定名字name已经绑定则抛出该异常

	 * @throws ClassNotFoundException		无法找到连接池的配置中的驱动程序类

	 * @throws IllegalAccessException		连接池配置中的驱动程序类有误

	 * @throws InstantiationException		无法实例化驱动程序类

	 * @throws SQLException				无法正常连接指定的数据库

	 */

	public static DataSource rebind(String name, ConnectionParam param)

		throws NameAlreadyBoundException,ClassNotFoundException,

				IllegalAccessException,InstantiationException,SQLException

	{

		try{

			unbind(name);

		}catch(Exception e){}

		return bind(name, param);

	}

	/**

	 * 删除一个数据库连接池对象

	 * @param name

	 * @throws NameNotFoundException

	 */

	public static void unbind(String name) throws NameNotFoundException

	{

		DataSource dataSource = lookup(name);

		if(dataSource instanceof DataSourceImpl){

			DataSourceImpl dsi = (DataSourceImpl)dataSource;

			try{

				dsi.stop();

				dsi.close();

			}catch(Exception e){

			}finally{

				dsi = null;

			}

		}

		connectionPools.remove(name);

	}

	

}

---

 echoguo 回复于：2003-11-23 13:45:44

ConnectionFactory主要提供了用户将将连接池绑定到一个具体的名称上以及取消绑定的操作。使用者只需要关心这两个类即可使用数据库连接池的功能。下面我们给出一段如何使用连接池的代码：

	String name = "pool";

	String driver = " sun.jdbc.odbc.JdbcOdbcDriver ";

	String url = "jdbc:odbc:datasource";

	ConnectionParam param = new ConnectionParam(driver,url,null,null);

	param.setMinConnection(1);

	param.setMaxConnection(5);

	param.setTimeoutValue(20000);

	ConnectionFactory.bind(name, param);

	System.out.println("bind datasource ok.");

	//以上代码是用来登记一个连接池对象，该操作可以在程序初始化只做一次即可

	//以下开始就是使用者真正需要写的代码

	DataSource ds = ConnectionFactory.lookup(name);

	try{

		for(int i=0;i<10;i++){

			Connection conn = ds.getConnection();

			try{

				testSQL(conn, sql);

			}finally{

				try{

					conn.close();

				}catch(Exception e){}

			}

		}

	}catch(Exception e){

		e.printStackTrace();

	}finally{

		ConnectionFactory.unbind(name);

		System.out.println("unbind datasource ok.");

		System.exit(0);

	}

从使用者的示例代码就可以看出，我们已经解决了常规连接池产生的两个问题。但是我们最最关心的是如何解决接管close方法的办法。接管工作主要在ConnectionFactory中的两句代码：

source = new DataSourceImpl(param);

source.initConnection();

---

 echoguo 回复于：2003-11-23 13:47:01

DataSourceImpl是一个实现了接口javax.sql.DataSource的类，该类维护着一个连接池的对象。由于该类是一个受保护的类，因此它暴露给使用者的方法只有接口DataSource中定义的方法，其他的所有方法对使用者来说都是不可视的。我们先来关心用户可访问的一个方法getConnection

/**

 * @see javax.sql.DataSource#getConnection(String,String)

 */

	public Connection getConnection(String user, String password) throws SQLException 

	{

		//首先从连接池中找出空闲的对象

		Connection conn = getFreeConnection(0);

		if(conn == null){

			//判断是否超过最大连接数,如果超过最大连接数

			//则等待一定时间查看是否有空闲连接,否则抛出异常告诉用户无可用连接

			if(getConnectionCount() >;= connParam.getMaxConnection())

				conn = getFreeConnection(connParam.getWaitTime());

			else{//没有超过连接数，重新获取一个数据库的连接

				connParam.setUser(user);

				connParam.setPassword(password);

				Connection conn2 = DriverManager.getConnection(connParam.getUrl(), 

				user, password);

				//代理将要返回的连接对象

				_Connection _conn = new _Connection(conn2,true);

				synchronized(conns){

					conns.add(_conn);

				}

				conn = _conn.getConnection();

			}

		}

		return conn;

	}

	/**

	 * 从连接池中取一个空闲的连接

	 * @param nTimeout	如果该参数值为0则没有连接时只是返回一个null

	 * 否则的话等待nTimeout毫秒看是否还有空闲连接，如果没有抛出异常

	 * @return Connection

	 * @throws SQLException

	 */

	protected synchronized Connection getFreeConnection(long nTimeout) 

		throws SQLException

	{

		Connection conn = null;

		Iterator iter = conns.iterator();

		while(iter.hasNext()){

			_Connection _conn = (_Connection)iter.next();

			if(!_conn.isInUse()){

				conn = _conn.getConnection();

				_conn.setInUse(true);				

				break;

			}

		}

		if(conn == null && nTimeout >; 0){

			//等待nTimeout毫秒以便看是否有空闲连接

			try{

				Thread.sleep(nTimeout);

			}catch(Exception e){}

			conn = getFreeConnection(0);

			if(conn == null)

				throw new SQLException("没有可用的数据库连接");

		}

		return conn;

	}

DataSourceImpl类中实现getConnection方法的跟正常的数据库连接池的逻辑是一致的，首先判断是否有空闲的连接，如果没有的话判断连接数是否已经超过最大连接数等等的一些逻辑。但是有一点不同的是通过DriverManager得到的数据库连接并不是及时返回的，而是通过一个叫_Connection的类中介一下，然后调用_Connection.getConnection返回的。如果我们没有通过一个中介也就是JAVA中的Proxy来接管要返回的接口对象，那么我们就没有办法截住Connection.close方法。

终于到了核心所在，我们先来看看_Connection是如何实现的，然后再介绍是客户端调用Connection.close方法时走的是怎样一个流程，为什么并没有真正的关闭连接。

/**

 * 数据连接的自封装，屏蔽了close方法

 * @author Liudong

 */

class _Connection implements InvocationHandler

{

	private final static String CLOSE_METHOD_NAME = "close";

	private Connection conn = null;

	//数据库的忙状态

	private boolean inUse = false;

	//用户最后一次访问该连接方法的时间

	private long lastAccessTime = System.currentTimeMillis();

	

	_Connection(Connection conn, boolean inUse){

		this.conn = conn;

		this.inUse = inUse;

	}

	/**

	 * Returns the conn.

	 * @return Connection

	 */

	public Connection getConnection() {

		//返回数据库连接conn的接管类，以便截住close方法

		Connection conn2 = (Connection)Proxy.newProxyInstance(

			conn.getClass().getClassLoader(),

			conn.getClass().getInterfaces(),this);

		return conn2;

	}

	/**

	 * 该方法真正的关闭了数据库的连接

	 * @throws SQLException

	 */

	void close() throws SQLException{

		//由于类属性conn是没有被接管的连接，因此一旦调用close方法后就直接关闭连接

		conn.close();

	}

	/**

	 * Returns the inUse.

	 * @return boolean

	 */

	public boolean isInUse() {

		return inUse;

	}



	/**

	 * @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;

		//判断是否调用了close的方法，如果调用close方法则把连接置为无用状态

		if(CLOSE_METHOD_NAME.equals(m.getName()))

			setInUse(false);		

		else

			obj = m.invoke(conn, args);	

		//设置最后一次访问时间，以便及时清除超时的连接

		lastAccessTime = System.currentTimeMillis();

		return obj;

	}

		

	/**

	 * Returns the lastAccessTime.

	 * @return long

	 */

	public long getLastAccessTime() {

		return lastAccessTime;

	}



	/**

	 * Sets the inUse.

	 * @param inUse The inUse to set

	 */

	public void setInUse(boolean inUse) {

		this.inUse = inUse;

	}

}

---

 echoguo 回复于：2003-11-23 13:48:17

一旦使用者调用所得到连接的close方法，由于用户的连接对象是经过接管后的对象，因此JAVA虚拟机会首先调用_Connection.invoke方法，在该方法中首先判断是否为close方法，如果不是则将代码转给真正的没有被接管的连接对象conn。否则的话只是简单的将该连接的状态设置为可用。到此您可能就明白了整个接管的过程，但是同时也有一个疑问：这样的话是不是这些已建立的连接就始终没有办法真正关闭？答案是可以的。我们来看看ConnectionFactory.unbind方法，该方法首先找到名字对应的连接池对象，然后关闭该连接池中的所有连接并删除掉连接池。在DataSourceImpl类中定义了一个close方法用来关闭所有的连接，详细代码如下：

	/**

	 * 关闭该连接池中的所有数据库连接

	 * @return int 返回被关闭连接的个数

	 * @throws SQLException

	 */

	public int close() throws SQLException

	{

		int cc = 0;

		SQLException excp = null;

		Iterator iter = conns.iterator();

		while(iter.hasNext()){

			try{

				((_Connection)iter.next()).close();

				cc ++;

			}catch(Exception e){

				if(e instanceof SQLException)

					excp = (SQLException)e;

			}

		}

		if(excp != null)

			throw excp;

		return cc;

	}

该方法一一调用连接池中每个对象的close方法，这个close方法对应的是_Connection中对close的实现，在_Connection定义中关闭数据库连接的时候是直接调用没有经过接管的对象的关闭方法，因此该close方法真正的释放了数据库资源。

以上文字只是描述了接口方法的接管，具体一个实用的连接池模块还需要对空闲连接的监控并及时释放连接。