http://www.oschina.net/question/12_4528#tags_nav
数据库连接池在编写应用服务是经常需要用到的模块,太过频繁的连接数据库对服务性能来讲是一个瓶颈,使用缓冲池技术可以来消除这个瓶颈。我们可以在 互联网上找到很多关于数据库连接池的源程序,但是都发现这样一个共同的问题:这些连接池的实现方法都不同程度地增加了与使用者之间的耦合度。很多的连接池 都要求用户通过其规定的方法获取数据库的连接,这一点我们可以理解,毕竟目前所有的应用服务器取数据库连接的方式都是这种方式实现的。但是另外一个共同的 问题是,它们同时不允许使用者显式的调用Connection.close()方法,而需要用其规定的一个方法来关闭连接。这种做法有两个缺点:
第一:改变了用户使用习惯,增加了用户的使用难度。
首先我们来看看一个正常的数据库操作过程:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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;
}
|
使用者在用完数据库连接后通常是直接调用连接的方法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方法的出 路。
首先,我们先定义一个数据库连接池参数的类,定义了数据库的JDBC驱动程序类名,连接的URL以及用户名口令等等一些信息,该类是用 于初始化连接池的参数,具体定义如下:
1
2
3
4
5
6
7
8
9
10
|
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,通过该类来将一个连接池对象与一个名称对应起来,使用者通过该名称就可以获 取指定的连接池对象,具体代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
/**
* 连接池类厂,该类常用来保存多个数据源名称合数据库连接池对应的哈希
* @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);
}
}
|
ConnectionFactory主要提供了用户将将连接池绑定到一个具体的名称上以及取消绑定的操作。使用者只需要关心这两个类即 可使用数据库连接池的功能。下面我们给出一段如何使用连接池的代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
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中的两句代码:
1
2
|
source =
new
DataSourceImpl(param);
source.initConnection();
|
DataSourceImpl是一个实现了接口javax.sql.DataSource的类,该类维护着一个连接池的对象。由于该类 是一个受保护的类,因此它暴露给使用者的方法只有接口DataSource中定义的方法,其他的所有方法对使用者来说都是不可视的。我们先来关心用户可访 问的一个方法getConnection
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
/**
* @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方法时 走的是怎样一个流程,为什么并没有真正的关闭连接。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
/**
* 数据连接的自封装,屏蔽了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;
}
}
|
一旦使用者调用所得到连接的close方法,由于用户的连接对象是经过接管后的对象,因此JAVA虚拟机会首先调用 _Connection.invoke方法,在该方法中首先判断是否为close方法,如果不是则将代码转给真正的没有被接管的连接对象conn。否则的 话只是简单的将该连接的状态设置为可用。到此您可能就明白了整个接管的过程,但是同时也有一个疑问:这样的话是不是这些已建立的连接就始终没有办法真正关 闭?答案是可以的。我们来看看ConnectionFactory.unbind方法,该方法首先找到名字对应的连接池对象,然后关闭该连接池中的所有连 接并删除掉连接池。在DataSourceImpl类中定义了一个close方法用来关闭所有的连接,详细代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/**
* 关闭该连接池中的所有数据库连接
* @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方法真正的释放了数据库资源。