用連線池提高Servlet訪問資料庫的效率 (轉)[@more@]

作者：好兵

作為首選的端資料處理技術，正在迅速取代CGI指令碼。Servlet超越CGI的優勢之一在於，不僅多個請求可以共享公用資源，而且還可以在不同請求之間保留持續資料。本文介紹一種充分發揮該特色的實用技術，即連線池。


一、實現連線池的意義

動態站點往往用資料庫的資訊生成Web頁面，每一個頁面請求導致一次資料庫訪問。連線資料庫不僅要開銷一定的通訊和資源，還必須完成使用者驗證、上下文這類任務，因而往往成為最為耗時的操作。當然，實際的連線時間開銷千變萬化，但1到2秒延遲並非不常見。如果某個基於資料庫的Web應用只需建立一次初始連線，不同頁面請求能夠共享同一連線，就能獲得顯著的改善。
Servlet是一個Java類。Servlet引擎（它可能是Web服務的一部分，也可能是一個獨立的附加模組）在啟動或Servlet第一次被請求時將該類裝入Java虛擬機器並建立它的一個例項。不同使用者請求由同一Servlet例項的多個獨立執行緒處理。那些要求在不同請求之間持續有效的資料既可以用Servlet的例項變數來儲存，也可以儲存在獨立的輔助中。
用JC訪問資料庫首先要建立與資料庫之間的連線，獲得一個連線物件（Connection），由連線物件提供語句的方法。本文介紹的資料庫連線池包括一個管理類DBConnectionManager，負責提供與多個連線池物件（DBConnectionPool類）之間的介面。每一個連線池物件管理一組連線物件，每一個連線物件可以被任意數量的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 s = 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 pass = 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().getReAsStream("/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 }


三、類DBConnectionPool說明

該類在209至345行實現，它表示指向某個資料庫的連線池。資料庫由JDBC URL標識。一個JDBC URL由三部分組成：標識（總是jdbc），驅動程式標識（如 odbc、idb、等），資料庫標識（其格式依賴於驅動程式）。例如，jdbc:odbc:demo，即是一個指向demo資料庫的JDBC URL，而且訪問該資料庫要使用JDBC-ODBC驅動程式。每個連線池都有一個供客戶程式使用的名字以及可選的使用者帳號、密碼、最大連線數限制。如果Web應用程式所支援的某些資料庫操作可以被所有使用者執行，而其它一些操作應由特別許可的使用者執行，則可以為兩類操作分別定義連線池，兩個連線池使用相同的JDBC URL，但使用不同的帳號和密碼。
類DBConnectionPool的建構函式需要上述所有資料作為其引數。如222至238行所示，這些資料被儲存為它的例項變數：
如252至283行、285至305行所示， 客戶程式可以使用DBConnectionPool類提供的兩個方法獲取可用連線。兩者的共同之處在於：如連線池中存在可用連線，則直接返回，否則建立新的連線並返回。如果沒有可用連線且已有連線總數等於最大限制數，第一個方法將直接返回null，而第二個方法將等待直到有可用連線為止。
所有的可用連線物件均登記在名為freeConnections的向量（Vector）中。如果向量中有多於一個的連線，getConnection()總是選取第一個。同時，由於新的可用連線總是從尾部加入向量，從而使得資料庫連線由於長時間閒置而被關閉的風險減低到最小程度。
第一個getConnection()在返回可用連線給客戶程式之前，呼叫了isClosed()方法驗證連線仍舊有效。如果該連線被關閉或觸發異常，getConnection()遞迴地呼叫自己以嘗試獲取另外的可用連線。如果在向量freeConnections中不存在任何可用連線，getConnection()方法檢查是否已經指定最大連線數限制。如已經指定，則檢查當前連線數是否已經到達極限。此處maxConn為0表示沒有限制。如果沒有指定最大連線數限制或當前連線數小於該值，該方法嘗試建立新的連線。如建立成功，則增加已使用連線的計數並返回，否則返回空值。
如325至345行所示，建立新連線由newConnection()方法實現。建立過程與是否已經指定資料庫帳號、密碼有關。
JDBC的DriverManager類提供多個getConnection()方法，這些方法要用到JDBC URL與其它一些引數，如使用者帳號和密碼等。DriverManager將使用指定的JDBC URL確定適合於目標資料庫的驅動程式及建立連線。
在285至305行實現的第二個getConnection()方法需要一個以毫秒為單位的時間引數，該參數列示客戶程式能夠等待的最長時間。建立連線的具體操作仍舊由第一個getConnection()方法實現。
該方法執行時先將startTime初始化為當前時間。在while迴圈中嘗試獲得一個連線。如果失敗，則以給定的時間值為引數呼叫wait()。wait()的返回可能是由於其它執行緒呼叫notify()或notifyAll()，也可能是由於預定時間已到。為找出wait()返回的真正原因，程式用當前時間減開始時間（startTime），如差值大於預定時間則返回空值，否則再次呼叫getConnection()。
把空閒的連線登記到連線池由240至250行的freeConnection()方法實現，它的引數為返回給連線池的連線物件。該物件被加入到freeConnections向量的末尾，然後減少已使用連線計數。呼叫notifyAll()是為了通知其它正在等待可用連線的執行緒。
許多Servlet引擎為實現安全關閉提供多種方法。資料庫連線池需要知道該事件以保證所有連線能夠正常關閉。DBConnectionManager類負協調整個關閉過程，但關閉連線池中所有連線的任務則由DBConnectionPool類負責。在307至323行實現的release()方法供DBConnectionManager呼叫。該方法遍歷freeConnections向量並關閉所有連線，然後從向量中刪除這些連線。


四、類DBConnectionManager 說明

該類只能建立一個例項，其它物件能夠呼叫其靜態方法（也稱為類方法）獲得該唯一例項的引用。如031至036行所示，DBConnectionManager類的建構函式是私有的，這是為了避免其它物件建立該類的例項。
DBConnectionManager類的客戶程式可以呼叫getInstance()方法獲得對該類唯一例項的引用。如018至029行所示，類的唯一例項在getInstance()方法第一次被呼叫期間建立，此後其引用就一直儲存在靜態變數instance中。每次呼叫getInstance()都增加一個DBConnectionManager的客戶程式計數。即，該計數代表引用DBConnectionManager唯一例項的客戶程式總數，它將被用於控制連線池的關閉操作。
該類例項的初始化工作由146至168行之間的私有方法init()完成。其中 getResourceAsStream()方法用於定位並開啟外部檔案。外部檔案的定位方法依賴於類裝載器的實現。標準的本地類裝載器查詢操作總是開始於類檔案所在路徑，也能夠搜尋CLASSPATH中宣告的路徑。db.properties是一個屬性檔案，它包含定義連線池的鍵-值對。可供定義的公用屬性如下：

drivers 以空格分隔的JDBC驅動程式類列表
logfile 日誌檔案的絕對路徑

其它的屬性和特定連線池相關，其屬性名字前應加上連線池名字：

.url 資料庫的 JDBC URL
.maxconn 允許建立的最大連線數，0表示沒有限制
.user 用於該連線池的資料庫帳號
.password 相應的密碼

其中url屬性是必需的，而其它屬性則是可選的。資料庫帳號和密碼必須合法。用於平臺的db.properties檔案示例如下：

drivers=sun.jdbc.odbc.JdbcOdbcDriver jdbc.idbDriver
logfile=D:usersrcjavaDBConnectionManagerlog.txt

idb.url=jdbc:idb:c:localjavawebserver1.1dbdb.prp
idb.maxconn=2

access.url=jdbc:odbc:demo
access.user=demo
access.password=demopw

注意在Windows路徑中的反斜槓必須輸入2個，這是由於屬性檔案中的反斜槓同時也是一個跳脫字元。
init()方法在建立屬性物件並讀取db.properties檔案之後，就開始檢查logfile屬性。如果屬性檔案中沒有指定日誌檔案，則預設為當前目錄下的DBConnectionManager.log檔案。如日誌檔案無法使用，則向System.err輸出日誌記錄。
裝載和註冊所有在drivers屬性中指定的JDBC驅動程式由170至192行之間的loadDrivers()方法實現。該方法先用StringTokenizer將drivers屬性值分割為對應於驅動程式名稱的字串，然後依次裝載這些類並建立其例項，最後在 DriverManager中註冊該例項並把它加入到一個私有的向量drivers。向量drivers將用於關閉服務時從DriverManager取消所有JDBC 驅動程式的註冊。
init()方法的最後一個任務是呼叫私有方法createPools()建立連線池物件。如109至142行所示，createPools()方法先建立所有屬性名字的列舉物件（即Enumeration物件，該物件可以想象為一個元素系列，逐次呼叫其nextElement()方法將順序返回各元素），然後在其中搜尋名字以“.url”結尾的屬性。對於每一個符合條件的屬性，先提取其連線池名字部分，進而讀取所有屬於該連線池的屬性，最後建立連線池物件並把它儲存在例項變數pools中。雜湊表（Hashtable類 ）pools實現連線池名字到連線池物件之間的對映，此處以連線池名字為鍵，連線池物件為值。
為便於客戶程式從指定連線池獲得可用連線或將連線返回給連線池，類DBConnectionManager提供了方法getConnection()和freeConnection()。所有這些方法都要求在引數中指定連線池名字，具體的連線獲取或返回操作則呼叫對應的連線池物件完成。它們的實現分別在051至064行、066至080行、038至049行。
如082至107行所示，為實現連線池的安全關閉，DBConnectionManager提供了方法release()。在上面我們已經提到，所有DBConnectionManager的客戶程式都應該呼叫靜態方法getInstance()以獲得該管理器的引用，此呼叫將增加客戶程式計數。客戶程式在關閉時呼叫release()可以遞減該計數。當最後一個客戶程式呼叫release()，遞減後的引用計數為0，就可以呼叫各個連線池的release()方法關閉所有連線了。管理類release()方法最後的任務是撤銷所有JDBC驅動程式的註冊。


五、Servlet使用連線池示例

Servlet 所定義的Servlet生命週期類如：

1) 建立並初始化Servlet（init()方法）。
2) 響應客戶程式的服務請求（service()方法）。
3) Servlet終止執行，釋放所有資源（destroy()方法）。

本例演示連線池應用，上述關鍵步驟中的相關操作為：

1) 在init()，用例項變數connMgr 儲存呼叫DBConnectionManager.getInstance()所返回的引用。
2) 在service()，呼叫getConnection()，執行資料庫操作，用freeConnection()將連線返回給連線池。
3) 在destroy()，呼叫release()關閉所有連線，釋放所有資源。

示例程式清單如下：

import java.io.*;
import java.sql.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class TestServlet extends HttpServlet {
private DBConnectionManager connMgr;

public void init(ServletConfig conf) throws ServletException {
super.init(conf);
connMgr = DBConnectionManager.getInstance();
}

public void service(HttpServletRequest req, HttpServletResponse res)
throws IOException {

res.setContentType("text/html");
PrintWriter out = res.getWriter();
Connection con = connMgr.getConnection("idb");
if (con == null) {
out.println("不能獲取資料庫連線.");
return;
}
ResultSet rs = null;
ResultSetMetaData md = null;
Statement stmt = null;
try {
stmt = con.createStatement();
rs = stmt.executeQuery(" * FROM EMPLOYEE");
md = rs.getMetaData();
out.println("

職工資料

");
while (rs.next()) {
out.println("
");
for (int i = 1; i < md.getColumnCount(); i++) {
out.print(rs.getString(i) + ", ");
}
}
stmt.close();
rs.close();
}
catch (SQLException e) {
e.printStackTrace(out);
}
connMgr.freeConnection("idb", con);
}

public void destroy() {
connMgr.release();
super.destroy();
}
}