java servlet作为首选的服务器端数据处理技术，正在迅速取代cgi脚本。servlet超越cgi的优势之一在于，不仅多个请求
可以共享公用资源，而且还可以在不同用户请求之间保留持续数据。本文介绍一种充分发挥该特色的实用技术，即数据库连
接池。
一、实现连接池的意义
动态web站点往往用数据库存储的信息生成web页面，每一个页面请求导致一次数据库访问。连接
数据库不仅要开销一定的通讯和内存资源，还必须完成用户验证、安全上下文配置这类任务，因而往往成为最为耗时的操
作。当然，实际的连接时间开销千变万化，但1到2秒延迟并非不常见。如果某个基于数据库的web应用只需建立一次初始连
接，不同页面请求能够共享同一连接，就能获得显著的性能改善。
servlet是一个java类。servlet引擎（它可能是web服务软件的一部分，也可能是一个独立的附加模块）在系统启动或servlet
第一次被请求时将该类装入java虚拟机并创建它的一个实例。不同用户请求由同一servlet实例的多个独立线程处理。那些要
求在不同请求之间持续有效的数据既可以用servlet的实例变量来保存，也可以保存在独立的辅助对象中。
用jdbc访问数据库首先要创建与数据库之间的连接，获得一个连接对象（connection），由连接对象提供执行sql语句的方法。
本文介绍的数据库连接池包括一个管理类dbconnectionmanager，负责提供与多个连接池对象（dbconnectionpool类）之间
的接口。每一个连接池对象管理一组jdbc连接对象，每一个连接对象可以被任意数量的servlet共享。
类dbconnectionpool提供以下功能：
1) 从连接池获取（或创建）可用连接。
2) 把连接返回给连接池。
3) 在系统关闭时释放所有资源，关闭所有连接。
此外， dbconnectionpool类还能够处理无效连接（原来登记为可用的连接，由于某种原因不再可用，如超时，通讯问题）
，并能够限制连接池中的连接总数不超过某个预定值。
管理类dbconnectionmanager用于管理多个连接池对象，它提供以下功能：
1) 装载和注册jdbc驱动程序。
2) 根据在属性文件中定义的属性创建连接池对象。
3) 实现连接池名字与其实例之间的映射。
4) 跟踪客户程序对连接池的引用，保证在最后一个客户程序结束时安全地关闭所有连接池。
本文余下部分将详细说明这两个类，最后给出一个示例演示servlet使用连接池的一般过程。
二、具体实现
dbconnectionmanager.java程序清单如下：
001 import java.io.*;
002 import java.sql.*;
003 import java.util.*;
004 import java.util.date;
005
006 /**
007 * 管理类dbconnectionmanager支持对一个或多个由属性文件定义的数据库连接
008 * 池的访问.客户程序可以调用getinstance()方法访问本类的唯一实例.
009 */
010 public class dbconnectionmanager {
011 static private dbconnectionmanager instance; // 唯一实例
012 static private int clients;
013
014 private vector drivers = new vector();
015 private printwriter log;
016 private hashtable pools = new hashtable();
017
018 /**
019 * 返回唯一实例.如果是第一次调用此方法,则创建实例
020 *
021 * @return dbconnectionmanager 唯一实例
022 */
023 static synchronized public dbconnectionmanager getinstance() {
024 if (instance == null) {
025 instance = new dbconnectionmanager();
026 }
027 clients++;
028 return instance;
029 }
030
031 /**
032 * 建构函数私有以防止其它对象创建本类实例
033 */
034 private dbconnectionmanager() {
035 init();
036 }
037
038 /**
039 * 将连接对象返回给由名字指定的连接池
040 *
041 * @param name 在属性文件中定义的连接池名字
042 * @param con 连接对象
043 */
044 public void freeconnection(string name, connection con) {
045 dbconnectionpool pool = (dbconnectionpool) pools.get(name);
046 if (pool != null) {
047 pool.freeconnection(con);
048 }
049 }
050
051 /**
052 * 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数
053 * 限制,则创建并返回新连接
054 *
055 * @param name 在属性文件中定义的连接池名字
056 * @return connection 可用连接或null
057 */
058 public connection getconnection(string name) {
059 dbconnectionpool pool = (dbconnectionpool) pools.get(name);
060 if (pool != null) {
061 return pool.getconnection();
062 }
063 return null;
064 }
065
066 /**
067 * 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
068 * 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
069 *
070 * @param name 连接池名字
071 * @param time 以毫秒计的等待时间
072 * @return connection 可用连接或null
073 */
074 public connection getconnection(string name, long time) {
075 dbconnectionpool pool = (dbconnectionpool) pools.get(name);
076 if (pool != null) {
077 return pool.getconnection(time);
078 }
079 return null;
080 }
081
082 /**
083 * 关闭所有连接,撤销驱动程序的注册
084 */
085 public synchronized void release() {
086 // 等待直到最后一个客户程序调用
087 if (--clients != 0) {
088 return;
089 }
090
091 enumeration allpools = pools.elements();
092 while (allpools.hasmoreelements()) {
093 dbconnectionpool pool = (dbconnectionpool) allpools.nextelement();
094 pool.release();
095 }
096 enumeration alldrivers = drivers.elements();
097 while (alldrivers.hasmoreelements()) {
098 driver driver = (driver) alldrivers.nextelement();
099 try {
100 drivermanager.deregisterdriver(driver);
101 log("撤销jdbc驱动程序 " + driver.getclass().getname()+"的注册");
102 }
103 catch (sqlexception e) {
104 log(e, "无法撤销下列jdbc驱动程序的注册: " + driver.getclass().getname());
105 }
106 }
107 }
108
109 /**
110 * 根据指定属性创建连接池实例.
111 *
112 * @param props 连接池属性
113 */
114 private void createpools(properties props) {
115 enumeration propnames = props.propertynames();
116 while (propnames.hasmoreelements()) {
117 string name = (string) propnames.nextelement();
118 if (name.endswith(".url")) {
119 string poolname = name.substring(0, name.lastindexof("."));
120 string url = props.getproperty(poolname + ".url");
121 if (url == null) {
122 log("没有为连接池" + poolname + "指定url");
123 continue;
124 }
125 string user = props.getproperty(poolname + ".user");
126 string password = props.getproperty(poolname + ".password");
127 string maxconn = props.getproperty(poolname + ".maxconn", "0");
128 int max;
129 try {
130 max = integer.valueof(maxconn).intvalue();
131 }
132 catch (numberformatexception e) {
133 log("错误的最大连接数限制: " + maxconn + " .连接池: " + poolname);
134 max = 0;
135 }
136 dbconnectionpool pool =
137 new dbconnectionpool(poolname, url, user, password, max);
138 pools.put(poolname, pool);
139 log("成功创建连接池" + poolname);
140 }
141 }
142 }
143
144 /**
145 * 读取属性完成初始化
146 */
147 private void init() {
148 inputstream is = getclass().getresourceasstream("/db.properties");
149 properties dbprops = new properties();
150 try {
151 dbprops.load(is);
152 }
153 catch (exception e) {
154 system.err.println("不能读取属性文件. " +
155 "请确保db.properties在classpath指定的路径中");
156 return;
157 }
158 string logfile = dbprops.getproperty("logfile", "dbconnectionmanager.log");
159 try {
160 log = new printwriter(new filewriter(logfile, true), true);
161 }
162 catch (ioexception e) {
163 system.err.println("无法打开日志文件: " + logfile);
164 log = new printwriter(system.err);
165 }
166 loaddrivers(dbprops);
167 createpools(dbprops);
168 }
169
170 /**
171 * 装载和注册所有jdbc驱动程序
172 *
173 * @param props 属性
174 */
175 private void loaddrivers(properties props) {
176 string driverclasses = props.getproperty("drivers");
177 stringtokenizer st = new stringtokenizer(driverclasses);
178 while (st.hasmoreelements()) {
179 string driverclassname = st.nexttoken().trim();
180 try {
181 driver driver = (driver)
182 class.forname(driverclassname).newinstance();
183 drivermanager.registerdriver(driver);
184 drivers.addelement(driver);
185 log("成功注册jdbc驱动程序" + driverclassname);
186 }
187 catch (exception e) {
188 log("无法注册jdbc驱动程序: " +
189 driverclassname + ", 错误: " + e);
190 }
191 }
192 }
193
194 /**
195 * 将文本信息写入日志文件
196 */
197 private void log(string msg) {
198 log.println(new date() + ": " + msg);
199 }
200
201 /**
202 * 将文本信息与异常写入日志文件
203 */
204 private void log(throwable e, string msg) {
205 log.println(new date() + ": " + msg);
206 e.printstacktrace(log);
207 }
208
209 /**
210 * 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最
211 * 大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性.
212 */
213 class dbconnectionpool {
214 private int checkedout;
215 private vector freeconnections = new vector();
216 private int maxconn;
217 private string name;
218 private string password;
219 private string url;
220 private string user;
221
222 /**
223 * 创建新的连接池
224 *
225 * @param name 连接池名字
226 * @param url 数据库的jdbc url
227 * @param user 数据库帐号,或 null
228 * @param password 密码,或 null
229 * @param maxconn 此连接池允许建立的最大连接数
230 */
231 public dbconnectionpool(string name, string url, string user, string password,
232 int maxconn) {
233 this.name = name;
234 this.url = url;
235 this.user = user;
236 this.password = password;
237 this.maxconn = maxconn;
238 }
239
240 /**
241 * 将不再使用的连接返回给连接池
242 *
243 * @param con 客户程序释放的连接
244 */
245 public synchronized void freeconnection(connection con) {
246 // 将指定连接加入到向量末尾
247 freeconnections.addelement(con);
248 checkedout--;
249 notifyall();
250 }
251
252 /**
253 * 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接
254 * 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
255 * 然后递归调用自己以尝试新的可用连接.
256 */
257 public synchronized connection getconnection() {
258 connection con = null;
259 if (freeconnections.size() > 0) {
260 // 获取向量中第一个可用连接
261 con = (connection) freeconnections.firstelement();
262 freeconnections.removeelementat(0);
263 try {
264 if (con.isclosed()) {
265 log("从连接池" + name+"删除一个无效连接");
266 // 递归调用自己,尝试再次获取可用连接
267 con = getconnection();
268 }
269 }
270 catch (sqlexception e) {
271 log("从连接池" + name+"删除一个无效连接");
272 // 递归调用自己,尝试再次获取可用连接
273 con = getconnection();
274 }
275 }
276 else if (maxconn == 0 || checkedout < maxconn) {
277 con = newconnection();
278 }
279 if (con != null) {
280 checkedout++;
281 }
282 return con;
283 }
284
285 /**
286 * 从连接池获取可用连接.可以指定客户程序能够等待的最长时间
287 * 参见前一个getconnection()方法.
288 *
289 * @param timeout 以毫秒计的等待时间限制
290 */
291 public synchronized connection getconnection(long timeout) {
292 long starttime = new date().gettime();
293 connection con;
294 while ((con = getconnection()) == null) {
295 try {
296 wait(timeout);
297 }
298 catch (interruptedexception e) {}
299 if ((new date().gettime() - starttime) >= timeout) {
300 // wait()返回的原因是超时
301 return null;
302 }
303 }
304 return con;
305 }
306
307 /**
308 * 关闭所有连接
309 */
310 public synchronized void release() {
311 enumeration allconnections = freeconnections.elements();
312 while (allconnections.hasmoreelements()) {
313 connection con = (connection) allconnections.nextelement();
314 try {
315 con.close();
316 log("关闭连接池" + name+"中的一个连接");
317 }
318 catch (sqlexception e) {
319 log(e, "无法关闭连接池" + name+"中的连接");
320 }
321 }
322 freeconnections.removeallelements();
323 }
324
325 /**
326 * 创建新的连接
327 */
328 private connection newconnection() {
329 connection con = null;
330 try {
331 if (user == null) {
332 con = drivermanager.getconnection(url);
333 }
334 else {
335 con = drivermanager.getconnection(url, user, password);
336 }
337 log("连接池" + name+"创建一个新的连接");
338 }
339 catch (sqlexception e) {
340 log(e, "无法创建下列url的连接: " + url);
341 return null;
342 }
343 return con;
344 }
345 }
346 }
菜鸟学堂：
