firtre

Connection con = DriverManager.getConnection（"jdbc：odbc：wombat"，"login"，
"password"）；
Statement stmt = con.createStatement（）；
ResultSet rs = stmt.executeQuery（"SELECT a， b， c FROM Table1"）；
while （rs.next（）） {
int x = rs.getInt（"a"）；
String s = rs.getString（"b"）；
float f = rs.getFloat（"c"）；
}

　　上述代碼對基于JDBC的數(shù)據(jù)庫訪問做了經(jīng)典的總結(jié)，當(dāng)然，在本小節(jié)的后續(xù)部分會對它做詳盡的分析講解。

二、JDBC API

　　JDBC 是個"低級"接口，也就是說，它用于直接調(diào)用 SQL 命令。在這方面它的功能極佳，并比其它的數(shù)據(jù)庫連接 API 易于使用，但它同時也被設(shè)計為一種基礎(chǔ)接口，在它之上可以建立高級接口和工具。高級接口是"對用戶友好的"接口，它使用的是一種更易理解和更為方便的 API，這種API在幕后被轉(zhuǎn)換為諸如 JDBC 這樣的低級接口。

　　在關(guān)系數(shù)據(jù)庫的"對象/關(guān)系"映射中，表中的每行對應(yīng)于類的一個實例，而每列的值對應(yīng)于該實例的一個屬性。于是，程序員可直接對 Java 對象進行操作；存取數(shù)據(jù)所需的 SQL 調(diào)用將在"掩蓋下"自動生成。此外還可提供更復(fù)雜的映射，例如將多個表中的行結(jié)合進一個 Java 類中。

　　隨著人們對 JDBC 的興趣日益增漲，越來越多的開發(fā)人員一直在使用基于 JDBC 的工具，以使程序的編寫更加容易。程序員也一直在編寫力圖使最終用戶對數(shù)據(jù)庫的訪問變得更為簡單的應(yīng)用程序。例如應(yīng)用程序可提供一個選擇數(shù)據(jù)庫任務(wù)的菜單。任務(wù)被選定后，應(yīng)用程序?qū)⒔o出提示及空白供填寫執(zhí)行選定任務(wù)所需的信息。所需信息輸入應(yīng)用程序?qū)⒆詣诱{(diào)用所需的 SQL 命令。在這樣一種程序的協(xié)助下，即使用戶根本不懂 SQL 的語法，也可以執(zhí)行數(shù)據(jù)庫任務(wù)。

三、JDBC與ODBC和其它API的比較

　　目前，Microsoft 的 ODBC API 可能是使用最廣的、用于訪問關(guān)系數(shù)據(jù)庫的編程接口。它能在幾乎所有平臺上連接幾乎所有的數(shù)據(jù)庫。為什么 Java 不使用 ODBC？對這個問題的回答是：Java 可以使用 ODBC，但最好是在 JDBC 的幫助下以 JDBC-ODBC 橋的形式使用，這一點我們稍后再說?，F(xiàn)在的問題已變成："為什么需要 JDBC"？答案是顯然的：ODBC 不適合直接在 Java 中使用，因為它使用 C 語言接口。從Java 調(diào)用本地 C 代碼在安全性、實現(xiàn)、堅固性和程序的自動移植性方面都有許多缺點。從 ODBC C API 到 Java API 的字面翻譯是不可取的。例如，Java 沒有指針，而 ODBC 卻對指針用得很廣泛（包括很容易出錯的指針"void *"）。您可以將 JDBC 想象成被轉(zhuǎn)換為面向?qū)ο?/a>接口的 ODBC，而面向?qū)ο蟮慕涌趯?Java 程序員來說較易于接收。

　　目前，Microsoft 又引進了 ODBC 之外的新 API： RDO、 ADO 和OLE DB。這些設(shè)計在許多方面與 JDBC 是相同的，即它們都是面向?qū)ο蟮臄?shù)據(jù)庫接口且基于可在 ODBC 上實現(xiàn)的類。但在這些接口中，我們未看見有特別的功能使我們要轉(zhuǎn)而選擇它們來替代 ODBC，尤其是在 ODBC 驅(qū)動程序已建立起較為完善的市場的情況下。它們最多也就是在 ODBC 上加了一種裝飾而已。

四、JDBC對B/S和C/S模式的支持

　　JDBC API 既支持數(shù)據(jù)庫訪問的兩層模型（C/S），同時也支持三層模型（B/S）。在兩層模型中，Java applet或應(yīng)用程序?qū)⒅苯优c數(shù)據(jù)庫進行對話。這將需要一個JDBC驅(qū)動程序來與所訪問的特定數(shù)據(jù)庫管理系統(tǒng)進行 通訊。用戶的SQL語句被送往數(shù)據(jù)庫中，而其結(jié)果將被送回給用戶。數(shù)據(jù)庫可以位于另一臺計算機上，用戶通過網(wǎng)絡(luò)連接到上面。這就叫做客戶機/服務(wù)器配置，其中用戶的計算機為客戶機，提供數(shù)據(jù)庫的計算機為服務(wù)器。網(wǎng)絡(luò)可以是 Intranet（它可將公司職員連接起來），也可以是 Internet。

　　在三層模型中，命令先是被發(fā)送到服務(wù)的"中間層"，然后由它將SQL 語句發(fā)送給數(shù)據(jù)庫。數(shù)據(jù)庫對 SQL 語句進行處理并將結(jié)果送回到中間層，中間層再將結(jié)果送回給用戶。MIS 主管們都發(fā)現(xiàn)三層模型很吸引人，因為可用中間層來控制對公司數(shù)據(jù)的訪問和可作的的更新的種類。中間層的另一個好處是，用戶可以利用易于使用的高級API，而中間層將把它轉(zhuǎn)換為相應(yīng)的低級調(diào)用。最后，許多情況下三層結(jié)構(gòu)可提供一些性能上的好處。

　　到目前為止，中間層通常都用 C 或 C++ 這類語言來編寫，這些語言執(zhí)行速度較快。然而，隨著最優(yōu)化編譯器（它把 Java 字節(jié)代碼轉(zhuǎn)換為高效的特定于機器的代碼）的引入，用 Java 來實現(xiàn)中間層將變得越來越實際。這將是一個很大的進步，它使人們可以充分利用 Java 的諸多優(yōu)點（如堅固、多線程和安全等特征）。JDBC 對于從Java的中間層來訪問數(shù)據(jù)庫非常重要。

五、SQL 的一致性

　　結(jié)構(gòu)化查詢語言 （SQL） 是訪問關(guān)系數(shù)據(jù)庫的標(biāo)準語言。困難之處在于：雖然大多數(shù)的 DBMS （數(shù)據(jù)庫管理系統(tǒng)）對其基本功能都使用了標(biāo)準形式的 SQL，但它們卻不符合最近為更高級的功能定義的標(biāo)準 SQL 語法或語義。例如，并非所有的數(shù)據(jù)庫都支持儲存程序或外部連接，那些支持這一功能的數(shù)據(jù)庫又相互不一致。人們希望 SQL 中真正標(biāo)準的那部份能夠進行擴展以包括越來越多的功能。但同時 JDBC API 又必須支持現(xiàn)有的 SQL。

　　JDBC API 解決這個問題的一種方法是允許將任何查詢字符串一直傳到所涉及的 DBMS 驅(qū)動程序上。這意味著應(yīng)用程序可以使用任意多的 SQL 功能，但它必須冒這樣的風(fēng)險：有可能在某些 DBMS 上出錯。事實上，應(yīng)用程序查詢甚至不一定要是 SQL，或者說它可以是個為特定的 DBMS 設(shè)計的 SQL 的專用派生物（例如，文檔或圖象查詢）。

　　JDBC 處理 SQL 一致性問題的第二種方法是提供 ODBC 風(fēng)格的轉(zhuǎn)義子句，這將在后續(xù)部分中討論。轉(zhuǎn)義語法為幾個常見的 SQL 分歧提供了一種標(biāo)準的 JDBC 語法。例如，對日期文字和已儲存過程的調(diào)用都有轉(zhuǎn)義語法。

　　對于復(fù)雜的應(yīng)用程序，JDBC 用第三種方法來處理 SQL 的一致性問題它利用 DatabaseMetaData 接口來提供關(guān)于 DBMS 的描述性信息，從而使應(yīng)用程序能適應(yīng)每個 DBMS 的要求和功能。

　　由于 JDBC API 將用作開發(fā)高級數(shù)據(jù)庫訪問工具和 API 的基礎(chǔ) API，因此它還必須注意其所有上層建筑的一致性。"符合JDBC標(biāo)準TM" 代表用戶可依賴的 JDBC 功能的標(biāo)準級別。要使用這一說明，驅(qū)動程序至少必須支持 ANSI SQL-2 Entry Level（ANSI SQL-2 代表美國國家標(biāo)準局 1992 年所采用的標(biāo)準。Entry Level代表SQL功能的特定清單）。驅(qū)動程序開發(fā)人員可用 JDBC API 所帶的測試工具包來確定他們的驅(qū)動程序是否符合這些標(biāo)準。

　　"符合 JDBC 標(biāo)準TM" 表示提供者的 JDBC 實現(xiàn)已經(jīng)通過了JavaSoft 提供的一致性測試。這些一致性測試將檢查 JDBC API中定義的所有類和方法是否都存在，并盡可能地檢查程序是否具有SQL Entry Level 功能。當(dāng)然，這些測試并不完全，而且 JavaSoft 目前也無意對各提供者的實現(xiàn)進行標(biāo)級。但這種一致性定義的確可對JDBC實現(xiàn)提供一定的可信度。隨著越來越多的數(shù)據(jù)庫提供者、連接提供者、Internet 提供者和應(yīng)用程序編程員對 JDBC API 的接受，JDBC 也正迅速成為 Java 數(shù)據(jù)庫訪問的標(biāo)準。

六、JDBC 入門 -- 建立聯(lián)接

教程：JDBC 入門 作者：Maydene Fisher 翻譯：comer
　　你需要做的第一事情是你與想要使用的 DBMS 建立一個連接。這包含 2 個步驟：裝載驅(qū)動程序并建立連接。

裝載驅(qū)動程序
　　裝載驅(qū)動程序只需要非常簡單的一行代碼。例如，你想要使用 JDBC-ODBC 橋驅(qū)動程序, 可以用下列代碼裝載它：

　　　　Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

　　你的驅(qū)動程序文檔將告訴你應(yīng)該使用的類名。例如， 如果類名是 jdbc.DriverXYZ ，你將用代碼以下的代碼裝載驅(qū)動程序：

　　　　Class.forName("jdbc.DriverXYZ");

　　你不需要創(chuàng)建一個驅(qū)動程序類的實例并且用 DriverManager 登記它，因為調(diào)用 Class.forName 將自動將加載驅(qū)動程序類。如果你曾自己創(chuàng)建實例，你將創(chuàng)建一個不必要的副本，但它不會帶來什么壞處。

　　加載 Driver 類后，它們即可用來與數(shù)據(jù)庫建立連接。

建立連接
　　第二步就是用適當(dāng)?shù)尿?qū)動程序類與 DBMS 建立一個連接。下列代碼是一般的做法：

　　　　Connection con = DriverManager.getConnection(url, "myLogin", "myPassword");

　　這個步驟也非常簡單，最難的是怎么提供 url。如果你正在使用 JDBC-ODBC 橋， JDBC URL 將以 jdbc:odbc 開始：余下 URL 通常是你的數(shù)據(jù)源名字或數(shù)據(jù)庫系統(tǒng)。因此，假設(shè)你正在使用 ODBC 存取一個叫 "Fred" 的 ODBC 數(shù)據(jù)源，你的 JDBC URL 是 jdbc:odbc:Fred 。把 "myLogin" 及 "myPassword" 替換為你登陸 DBMS 的用戶名及口令。如果你登陸數(shù)據(jù)庫系統(tǒng)的用戶名為 "Fernanda" 口令為 "J8"，只需下面的 2 行代碼就可以建立一個連接：

String url = "jdbc:odbc:Fred";
Connection con = DriverManager.getConnection(url,"Fernanda", "J8");
　　如果你使用的是第三方開發(fā)了的 JDBC驅(qū)動程序，文檔將告訴你該使用什么 subprotocol， 就是在 JDBC URL 中放在 jdbc 后面的部分。例如, 如果驅(qū)動程序開發(fā)者注冊了 acme 作為 subprotocol， JDBC URL 的第一和第二部分將是 jdbc:acme。驅(qū)動程序文檔也會告訴你余下 JDBC URL 的格式。JDBC URL 最后一部分提供了定位數(shù)據(jù)庫的信息。

　　如果你裝載的驅(qū)動程序識別了提供給 DriverManager.getConnection 的 JDBC URL ，那個驅(qū)動程序?qū)⒏鶕?jù) JDBC URL 建立一個到指定 DBMS 的連接。正如名稱所示，DriverManager 類在幕后為你管理建立連接的所有細節(jié)。除非你是正在寫驅(qū)動程序，你可能無需使用此類的其它任何方法，一般程序員需要在此類中直接使用的唯一方法是 DriverManager.getConnection。

　　DriverManager.getConnection 方法返回一個打開的連接，你可以使用此連接創(chuàng)建 JDBC statements 并發(fā)送 SQL 語句到數(shù)據(jù)庫。在前面的例子里，con 對象是一個打開的連接，并且我們要在以后的例子里使用它。

JDBC 入門 -- 設(shè)置表
創(chuàng)建表
　　首先，我們在我們的示例數(shù)據(jù)庫創(chuàng)建其中一張表 COFFEES，包含在咖啡店所賣咖啡的必要的信息，包括咖啡名字，他們的價格，本星期賣了多少磅及迄今為止賣的數(shù)目。關(guān)于 COFFEES 表我們以后會詳細描述，如下：

COF_NAME SUP_ID PRICE SALES TOTAL
Colombian 101 7.99 0 0
French_Roast 49 8.99 0 0
Espresso 150 9.99 0 0
Colombian_Decaf 101 8.99 0 0
French_Roast_Decaf 49 9.99 0 0

　　存儲咖啡名的列是 COF_NAME，它的 SQL 數(shù)據(jù)類型是 VARCHAR，最大的長度為 32 個字符。因為我們所賣的每種類型咖啡都使用不同的名字，名字可用于作為唯一識別咖啡的標(biāo)識，因此可用于作主鍵。第二個列叫 SUP_ID，用于保存咖啡供應(yīng)商標(biāo)識；其 SQL 數(shù)據(jù)類型為 INTEGER。第 3 列叫 PRICE，因為它需要保存帶小數(shù)的十進制數(shù)，因此它的 SQL 類型為 FLOAT。（注意，通常錢的 SQL 類型為 DECIMAL 或 NUMERIC，但在不同 DBMSs 間存在差異，為了避免于老版本的 JDBC 的不兼容性在本教程我們采用更標(biāo)準的 FLOAT 類型）SALES 列的 SQL 類型為 INTEGER，其值為本星期所賣咖啡的磅數(shù)。最后一列，TOTAL 的 SQL 類型為 INTEGER，保存了迄今為止所賣咖啡的總磅數(shù)。

　　數(shù)據(jù)庫里的第二個表 SUPPLIERS，保存了每個供應(yīng)商的信息：

SUP_ID SUP_NAME STREET CITY STATE ZIP
101 Acme, Inc. 99 Market Street Groundsville CA 95199
49 Superior Coffee 1 Party Place Mendocino CA 95460
150 The High Ground 100 Coffee Lane Meadows CA 93966

　　COFFEES 跟 SUPPLIERS 都包含列 SUP_ID，它意味著可以用 SELECT 語句從這兩張表中取得有關(guān)信息。列 SUP_ID 是 SUPPLIERS 表的主鍵，用于唯一識別每個咖啡供應(yīng)商。在 COFFEES 表中，SUP_ID 列被稱外鍵。注意每個 SUP_ID 值在 SUPPLIERS 表里只出現(xiàn)一次；這對主鍵是必須的。在 COFFEES 表里，它作為外鍵，顯然它可以有重復(fù)的 SUP_ID 值，因為同一供應(yīng)商可以提供很多種的咖啡。在本節(jié)的最后，你將看見如何在 SELECT 語句中使用主鍵及外鍵的一個例子。

　　下面的 SQL 語句用于創(chuàng)建 COFFEES 表。列由列名跟空格跟 SQL 類型組成。列（包括列名及其 SQL 類型）跟下一個之間用逗號分隔。VARCHAR 類型創(chuàng)建定義了最大長度， 因此它需要有一個參數(shù)來表示最大長度。參數(shù)必須在類型后面的括號內(nèi)。SQL 語句如下，列 COF_NAME 的長度 被限定為不得超過 32 個字符：

CREATE TABLE COFFEES
(COF_NAME VARCHAR(32),
SUP_ID INTEGER,
PRICE FLOAT,
SALES INTEGER,
TOTAL INTEGER)

　　這些代碼不帶 DBMS 語句結(jié)束符， 因為每個 DBMS 都可能不同。例如, Oracle 使用一個分號 (;) 作為語句的結(jié)束，而 Sybase 使用 go。你所使用的驅(qū)動程序會自動提供合適的語句結(jié)束符，因此你無須把它包括在你的 JDBC 代碼中。

　　另外，我們應(yīng)該指出的的是 SQL 語句的格式。在 CREATE TABLE 語句中，關(guān)鍵字采用大寫字符，并且每個項目都另起一行。SQL 并沒有此要求；僅僅是為了更容易閱讀。SQL 標(biāo)準是不區(qū)分關(guān)鍵詞的大小寫的, 因此，如下例中的 SELECT 語句可以有多種寫法。因此下面兩個不同寫法的語句對 SQL 來說是一樣的。

SELECT First_Name, Last_Name
FROM Employees
WHERE Last_Name LIKE "Washington"

select First_Name, Last_Name from Employees where
Last_Name like "Washington"

　　然而，引號里的內(nèi)容是區(qū)分大小寫的：在名字"Washington" 里 "W" 必須被大寫，并且余下的字符必須是小寫的。

　　對于標(biāo)識，不同的 DBMS 有不同的要求，例如, 某些 DBMSs 要求那些列名及表名必須跟創(chuàng)建時的一樣，有些則沒有此要求。為安全起見，我們?nèi)渴褂么髮憳?biāo)識如 COFFEES、SUPPLIERS，因為我們是那樣定義他們的。

　　到止我們寫了創(chuàng)建 COFFEES 表的 SQL 語句。現(xiàn)在我們在它外面加上引號（使它成為字符串），并且字符串賦值給變量 createTableCoffees，在以后的 JDBC 代碼中我們可以使用此變量。正如看到的，DBMS 并不在意分行，但對 Java 語言來，String 對象分行是通不過編譯的。因而，我們可以用加號 (+) 把每一行的串連接。

String createTableCoffees = "CREATE TABLE COFFEES " +
"(COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, " +
"SALES INTEGER, TOTAL INTEGER)";

　　我們在 CREATE TABLE 語句中使用的數(shù)據(jù)類型是通用的 SQL 類型（也稱 JDBC 類型）它們在類 java.sql.Types 中定義。DBMSs 通常使用這些標(biāo)準的類型，因此，當(dāng)你要嘗試一些 JDBC 應(yīng)用程序時，你可以直接使用 CreateCoffees.java 應(yīng)用程序，它使用了 CREATE TABLE 語句。如果你的 DBMS 使用了它的自己的本地的類型名字，我們?yōu)槟愎?yīng)其它的應(yīng)用程序，我們將在后面詳細解釋。

　　在運用任何應(yīng)用程序前，當(dāng)然，我們將讓你了解 JDBC 的基礎(chǔ)。

創(chuàng)建 JDBC Statements 對象
　　Statement 對象用于把 SQL 語句發(fā)送到 DBMS 。你只須簡單地創(chuàng)建一個 Statement 對象并且然后執(zhí)行它，使用適當(dāng)?shù)姆椒▓?zhí)行你發(fā)送的 SQL 語句。對 SELECT 語句來說，可以使用 executeQuery。要創(chuàng)建或修改表的語句，使用的方法是 executeUpdate。

　　需要一個活躍的連接的來創(chuàng)建 Statement 對象的實例。在下面的例子中，我們使用我們的 Connection 對象 con 創(chuàng)建 Statement 對象 stmt：

Statement stmt = con.createStatement();

　　到此 stmt 已經(jīng)存在了，但它還沒有把 SQL 語句傳遞到 DBMS。我們需要提供 SQL 語句作為參數(shù)提供給我們使用的 Statement 的方法。例如，在下面的代碼段里，我們使用上面例子中的 SQL 語句作為 executeUpdate 的參數(shù)：

stmt.executeUpdate("CREATE TABLE COFFEES " +
"(COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, " +
"SALES INTEGER, TOTAL INTEGER)");

　　因為我們已經(jīng)把 SQL 語句賦給了 createTableCoffees 變量，我們可以如下方式書寫代碼：

stmt.executeUpdate(createTableCoffees);

執(zhí)行語句
　　我們使用 executeUpdate 方法是因為在 createTableCoffees 中的 SQL 語句是 DDL （數(shù)據(jù)定義語言）語句。創(chuàng)建表，改變表，刪除表都是 DDL 語句的例子，要用 executeUpdate 方法來執(zhí)行。你也可以從它的名字里看出，方法 executeUpdate 也被用于執(zhí)行更新表 SQL 語句。實際上，相對于創(chuàng)建表來說，executeUpdate 用于更新表的時間更多，因為表只需要創(chuàng)建一次，但經(jīng)常被更新。

　　被使用最多的執(zhí)行 SQL 語句的方法是 executeQuery。這個方法被用來執(zhí)行 SELECT 語句，它幾乎是使用最多的 SQL 語句。馬上你將看到如何使用這個方法。

在表中輸入數(shù)據(jù)
　　我們已經(jīng)顯示了如何通過指定列名、數(shù)據(jù)類型來創(chuàng)建表 COFFEES，但是這僅僅建立表的結(jié)構(gòu)。表還沒有任何數(shù)據(jù)。我們將次輸入一行數(shù)據(jù)到表中，提供每列的信息，注意插入的數(shù)據(jù)顯示順序跟表創(chuàng)建時候是一樣的，既缺省順序。

　　下列代碼插入一個行數(shù)據(jù)，COF_NAME 的值為 Colombian，SUP_ID 為 101，PRICE 為 7.99，SALES 0，TOTAL 0。就象創(chuàng)建 COFFEES 表一樣，我們創(chuàng)建一 Statement 對象，并執(zhí)行 executeUpdate 方法。

　　因為 SQL 語句一行顯示不下，因此我們把它分為兩行，并用加號 (+) 相連。特別要注意的是，在 COFFEES 和 VALUES 之間要有空格。這個空格必須在引號之內(nèi)并且要在 COFFEES 跟 VALUES 之間；沒有這個空格，SQL 語句將被錯誤地被讀作為 "INSERT INTO COFFEESVALUES ..."，并且 DBMS 將尋找表 COFFEESVALUES。還要注意的是在 coffee name 上我們使用了單引號。

Statement stmt = con.createStatement();
stmt.executeUpdate(
"INSERT INTO COFFEES " +
"VALUES ('Colombian', 101, 7.99, 0, 0)");

　　下面的代碼把第二行插入到表 COFFEES 中。我們可以在使用 Statement 對象而無須為每次執(zhí)行創(chuàng)建一個新的。

stmt.executeUpdate("INSERT INTO COFFEES " +
"VALUES ('French_Roast', 49, 8.99, 0, 0)");

　　剩下行的數(shù)據(jù)如下：

stmt.executeUpdate("INSERT INTO COFFEES " +
"VALUES ('Espresso', 150, 9.99, 0, 0)");
stmt.executeUpdate("INSERT INTO COFFEES " +
"VALUES ('Colombian_Decaf', 101, 8.99, 0, 0)");
stmt.executeUpdate("INSERT INTO COFFEES " +
"VALUES ('French_Roast_Decaf', 49, 9.99, 0, 0)");

從表中取得數(shù)據(jù)
　　既然表 COFFEES 中已經(jīng)有數(shù)據(jù)了，我們就可以寫一個 SELECT 語句來取得這些值。下面的 SQL 語句中星號 (*) 表示選擇所有的列。因為沒有用 WHERE 子句來限制所選的行，因此下面的 SQL 語句選擇的是整個表。

SELECT * FROM COFFEES

　　結(jié)果是整個表的數(shù)據(jù)，如下：

COF_NAME SUP_ID PRICE SALES TOTAL
--------------- ------ ----- ----- -----
Colombian 101 7.99 0 0
French_Roast 49 8.99 0 0
Espresso 150 9.99 0 0
Colombian_Decaf 101 8.99 0 0
French_Roast_Decaf 49 9.99 0 0

　　如果你直接在數(shù)據(jù)庫系統(tǒng)里輸入 SQL 查詢語句，你將在你的終端上看到如上的結(jié)果。當(dāng)我們通過一個 Java 應(yīng)用程序存取一個數(shù)據(jù)庫時，正如我們馬上要做的一樣，我們需要檢索結(jié)果以便我們能使用他們。你將在下一節(jié)看到如何實現(xiàn)。

這是 SELECT 語句的另一個例子，這將得到咖啡及其各自每磅單價的列表。

SELECT COF_NAME, PRICE FROM COFFEES

查詢的結(jié)果集將具有如下形式：

COF_NAME PRICE
-------- ---------- -----
Colombian 7.99
French_Roast 8.99
Espresso 9.99
Colombian_Decaf 8.99
French_Roast_Decaf 9.99

上面 SELECT 語句取得了所有咖啡的名字及價格。而下面的 SELECT 語句限制那些每磅價格低于 $9.00 的咖啡才被選擇。
SELECT COF_NAME, PRICE
FROM COFFEES
WHERE PRICE < 9.00

結(jié)果集將具有如下形式：

COF_NAME PRICE
-------- ------- -----
Colombian 7.99
French_Roast 8.99
Colombian Decaf 8.99

JDBC 入門 -- 開始
你需要做的第一事情是你要正確的安裝。這包含下列幾個步驟：

在你的計算機上安裝 Java 和 JDBC
　　Java 數(shù)據(jù)庫連接 (JDBC) 是一個標(biāo)準 SQL（Structured Query Language，結(jié)構(gòu)化查詢語言）數(shù)據(jù)庫訪問接口, 可以為多種關(guān)系數(shù)據(jù)庫提供統(tǒng)一訪問。JDBC（Java DataBase Connection，Java 數(shù)據(jù)庫連接） 也提供一種基準，據(jù)此可以構(gòu)建更高級的工具和接口。 目前的 JDK（Java Development Kit，Java 開發(fā)工具包）軟件捆綁包括 JDBC 和 JDBC-ODBC（Open DataBase Connection，開放式數(shù)據(jù)庫連接）橋。這些包也可獨立得到，以跟 JDK 1.0 一起使用。應(yīng)該注意的是，本文的示例使用了 JDBC 2.0 接口，需要 JDK 2.0 來運行，不能在 JDK 1.1 下運行。

　　你可以從 http://java.sun.com/products/JDK/CurrentRelease 找到最新版。

安裝驅(qū)動程序
　　你的驅(qū)動程序應(yīng)該有安裝方法。為特定的 DBMSs 寫的 JDBC 驅(qū)動程序安裝時只要拷貝到你的計算機上就可以了。并不需要特殊的配置。

　　如果你下載的是 Solaris 或 Windows JDK1.1 版本，橋作為包 sun.jdbc.odbc 與 JDK 一起自動安裝。有關(guān)安裝和配置 ODBC 的信息，請咨詢 ODBC 驅(qū)動程序廠商。橋無須特殊配置。有關(guān)客戶機安裝和配置信息，請咨詢數(shù)據(jù)庫廠商。

如果需要，安裝數(shù)據(jù)庫系統(tǒng)
　　如果你不能確認是否安裝了數(shù)據(jù)庫系統(tǒng)，你需要按照供應(yīng)商的要求安裝數(shù)據(jù)庫。大多數(shù)用戶都已經(jīng)安裝了數(shù)據(jù)庫，可繼續(xù)使用他們安裝好的數(shù)據(jù)庫。

配置數(shù)據(jù)庫
　　我們假設(shè)數(shù)據(jù)庫 COFFEEBREAK 已經(jīng)存在。（創(chuàng)建一個數(shù)據(jù)庫并不困難，但需要一定的權(quán)限并通常是由數(shù)據(jù)庫管理員來做）你還需要在此數(shù)據(jù)庫里創(chuàng)建本教程作為例子使用的表。我們有意限制表的大小跟及數(shù)目，以便于管理。

　　假設(shè)我們的數(shù)據(jù)庫是在一個咖啡館里使用， 咖啡豆按磅賣，而咖啡則以杯為單位。為了簡單起見，還假定經(jīng)營者只需要 2 張表，分別存放不同種類的咖啡及咖啡供應(yīng)商的有關(guān)信息。

　　首先我們演示怎么打開一個 DBMS 連接， 及 JDBC 是怎么發(fā)送 SQL 語句到你的 DBMS。通過這些代碼，我們將表明使用 JDBC 傳遞 SQL 語句到你的 DBMS 并處理返回的結(jié)果是非常簡單的。

　　所有的代碼在主要的幾個 DBMS 產(chǎn)品做了測試。然而, 如果你使用 JDBC-ODBC 橋來連接舊版本 ODBC 驅(qū)動程序時，可能會遇到一些兼容性問題。 

七、如何選擇合適的JDBC產(chǎn)品？

有關(guān)JDBC最新的信息，有興趣的讀者可以查閱JDBC的官方網(wǎng)站--即JavaSoft的主頁，其URL為： http：//Java.sun.com/products/jdbc

　　1. JavaSoft框架

　　JavaSoft提供三種JDBC產(chǎn)品組件，它們是Java開發(fā)工具包（JDK）的組成部份：JDBC驅(qū)動程序管理器、JDBC驅(qū)動程序測試工具包和JDBC-ODBC橋。

　　JDBC驅(qū)動程序管理器是JDBC體系結(jié)構(gòu)的支柱。它實際上很小，也很簡單；其主要作用是把Java應(yīng)用程序連接到正確的JDBC驅(qū)動程序上，然后即退出。

　　JDBC驅(qū)動程序測試工具包為使JDBC驅(qū)動程序運行您的程序提供一定的可信度。只有通過JDBC驅(qū)動程序測試的驅(qū)動程序才被認為是符合JDBC標(biāo)準TM的。

　　JDBC-ODBC橋使ODBC驅(qū)動程序可被用作JDBC驅(qū)動程序。它的實現(xiàn)為JDBC的快速發(fā)展提供了一條途徑，其長遠目標(biāo)提供一種訪問某些不常見的DBMS（如果對這些不常見的DBMS未實現(xiàn)JDBC）的方法。

　　2. JDBC驅(qū)動程序的類型

　　目前比較常見的JDBC驅(qū)動程序可分為以下四個種類：

　?。?）JDBC-ODBC橋加ODBC驅(qū)動程序

　　JavaSoft橋產(chǎn)品利用ODBC驅(qū)動程序提供JDBC訪問。注意，必須將ODBC二進制代碼（許多情況下還包括數(shù)據(jù)庫客戶機代碼）加載到使用該驅(qū)動程序的每個客戶機上。因此，這種類型的驅(qū)動程序最適合于企業(yè)網(wǎng)（這種網(wǎng)絡(luò)上客戶機的安裝不是主要問題），或者是用Java編寫的三層結(jié)構(gòu)的應(yīng)用程序服務(wù)器代碼。

　　（2）本地API

　　這種類型的驅(qū)動程序把客戶機API上的JDBC調(diào)用轉(zhuǎn)換為Oracle、Sybase、Informix、DB2或其它DBMS的調(diào)用。注意，象橋驅(qū)動程序一樣，這種類型的驅(qū)動程序要求將某些二進制代碼加載到每臺客戶機上。

　　（3）JDBC網(wǎng)絡(luò)純Java驅(qū)動程序

　　這種驅(qū)動程序?qū)DBC轉(zhuǎn)換為與DBMS無關(guān)的網(wǎng)絡(luò)協(xié)議，之后這種協(xié)議又被某個服務(wù)器轉(zhuǎn)換為一種DBMS協(xié)議。這種網(wǎng)絡(luò)服務(wù)器中間件能夠?qū)⑺募僇ava客戶機連接到多種不同的數(shù)據(jù)庫上。所用的具體協(xié)議取決于提供者。通常，這是最為靈活的JDBC驅(qū)動程序。有可能所有這種解決方案的提供者都提供適合于Intranet用的產(chǎn)品。為了使這些產(chǎn)品也支持Internet訪問，它們必須處理Web所提出的安全性、通過防火墻的訪問等方面的額外要求。幾家提供者正將JDBC驅(qū)動程序加到他們現(xiàn)有的數(shù)據(jù)庫中間件產(chǎn)品中。

　?。?）本地協(xié)議純Java驅(qū)動程序

　　這種類型的驅(qū)動程序?qū)DBC調(diào)用直接轉(zhuǎn)換為DBMS所使用的網(wǎng)絡(luò)協(xié)議。這將允許從客戶機機器上直接調(diào)用DBMS服務(wù)器，是Intranet訪問的一個很實用的解決方法。由于許多這樣的協(xié)議都是專用的，因此數(shù)據(jù)庫提供者自己將是主要來源，有幾家提供者已在著手做這件事了。

　　據(jù)專家預(yù)計第（3）、（4）類驅(qū)動程序?qū)⒊蔀閺腏DBC訪問數(shù)據(jù)庫的首方法。第（1）、（2）類驅(qū)動程序在直接的純Java驅(qū)動程序還沒有上市前會作為過渡方案來使用。對第（1）、（2）類驅(qū)動程序可能會有一些變種，這些變種要求有連接器，但通常這些是更加不可取的解決方案。第（3）、（4）類驅(qū)動程序提供了Java的所有優(yōu)點，包括自動安裝（例如，通過使用JDBC驅(qū)動程序的appletapplet來下載該驅(qū)動程序）。

3. JDBC驅(qū)動程序的獲取

　　目前已有幾十個（1）類的驅(qū)動程序，即可與Javasoft橋聯(lián)合使用的ODBC驅(qū)動程序的驅(qū)動程序。有大約十多個屬于種類（2）的驅(qū)動程序是以DBMS的本地API為基礎(chǔ)編寫的。只有幾個屬于種類（3）的驅(qū)動程序，其首批提供者是SCO、OpenHorizon、Visigenic和WebLogic。此外，JavaSoft和數(shù)據(jù)庫連接的領(lǐng)先提供者Intersolv還合作研制了JDBC-ODBC橋和JDBC驅(qū)動程序測試工具包。

八、如何建立JDBC連接？

　　Connection 對象代表與數(shù)據(jù)庫的連接。連接過程包括所執(zhí)行的 SQL 語句和在該連接上所返回的結(jié)果。一個應(yīng)用程序可與單個數(shù)據(jù)庫有一個或多個連接，或者可與許多數(shù)據(jù)庫有連接。

　　1. 打開連接

　　與數(shù)據(jù)庫建立連接的標(biāo)準方法是調(diào)用DriverManager.getConnection方法。該方法接受含有某個URL的字符串。DriverManager類（即所謂的JDBC管理層）將嘗試找到可與那個URL所代表的數(shù)據(jù)庫進行連接的驅(qū)動程序。DriverManager類存有已注冊的Driver類的清單。當(dāng)調(diào)用方法getConnection時，它將檢查清單中的每個驅(qū)動程序，直到找到可與URL中指定的數(shù)據(jù)庫進行連接的驅(qū)動程序為止。Driver的方法connect使用這個URL來建立實際的連接。

　　用戶可繞過JDBC管理層直接調(diào)用Driver方法。這在以下特殊情況下將很有用：當(dāng)兩個驅(qū)動器可同時連接到數(shù)據(jù)庫中，而用戶需要明確地選用其中特定的驅(qū)動器。但一般情況下，讓DriverManager類處理打開連接這種事將更為簡單。

　　下述代碼顯示如何打開一個與位于URL"jdbc：odbc：wombat"的數(shù)據(jù)庫的連接。所用的用戶標(biāo)識符為"freely"，口令為"ec"：

　　String url = "jdbc：odbc：wombat"；
　　Connection con = DriverManager.getConnection（url， "freely"， "ec"）；

　　2. 一般用法的URL

　　由于URL常引起混淆，我們將先對一般URL作簡單說明，然后再討論JDBCURL。URL（統(tǒng)一資源定位符）提供在Internet上定位資源所需的信息?？蓪⑺胂鬄橐粋€地址。URL的第一部份指定了訪問信息所用的協(xié)議，后面總是跟著冒號。常用的協(xié)議有"ftp"（代表"文件傳輸協(xié)議"）和"http"（代表"超文本傳輸協(xié)議"）。如果協(xié)議是"file"，表示資源是在某個本地文件系統(tǒng)上而非在Internet上（下例用于表示我們所描述的部分；它并非URL的組成部分）。

　　ftp：//Javasoft.com/docs/JDK-1_apidocs.zip
　　http：//Java.sun.com/products/jdk/CurrentRelease
　　file：/home/haroldw/docs/books/tutorial/summary.html

　　URL的其余部份（冒號后面的）給出了數(shù)據(jù)資源所處位置的有關(guān)信息。如果協(xié)議是file，則URL的其余部份是文件的路徑。對于ftp和http協(xié)議，URL的其余部份標(biāo)識了主機并可選地給出某個更詳盡的地址路徑。例如，以下是JavaSoft主頁的URL。該URL只標(biāo)識了主機：http：//Java.sun.com。從該主頁開始瀏覽，就可以進到許多其它的網(wǎng)頁中，其中之一就是JDBC主頁。JDBC主頁的URL更為具體，它具體表示為：
http：//Java.sun.com/products/jdbc

　　3. JDBC URL

　　JDBC URL提供了一種標(biāo)識數(shù)據(jù)庫的方法，可以使相應(yīng)的驅(qū)動程序能識別該數(shù)據(jù)庫并與之建立連接。實際上，驅(qū)動程序編程員將決定用什么JDBC URL來標(biāo)識特定的驅(qū)動程序。用戶不必關(guān)心如何來形成JDBC URL；他們只須使用與所用的驅(qū)動程序一起提供的URL即可。JDBC的作用是提供某些約定，驅(qū)動程序編程員在構(gòu)造他們的JDBC URL時應(yīng)該遵循這些約定。

　　由于JDBC URL要與各種不同的驅(qū)動程序一起使用，因此這些約定應(yīng)非常靈活。首先，它們應(yīng)允許不同的驅(qū)動程序使用不同的方案來命名數(shù)據(jù)庫。例如，odbc子協(xié)議允許（但并不是要求）URL含有屬性值。

　　其次，JDBC URL應(yīng)允許驅(qū)動程序編程員將一切所需的信息編入其中。這樣就可以讓要與給定數(shù)據(jù)庫對話的applet打開數(shù)據(jù)庫連接，而無須要求用戶去做任何系統(tǒng)管理工作。

　　最后，JDBC URL應(yīng)允許某種程度的間接性。也就是說，JDBC URL可指向邏輯主機或數(shù)據(jù)庫名，而這種邏輯主機或數(shù)據(jù)庫名將由網(wǎng)絡(luò)命名系統(tǒng)動態(tài)地轉(zhuǎn)換為實際的名稱。這可以使系統(tǒng)管理員不必將特定主機聲明為JDBC名稱的一部份。網(wǎng)絡(luò)命名服務(wù)（例如DNS、NIS和DCE）有多種，而對于使用哪種命名服務(wù)并無限制。
JDBC URL的標(biāo)準語法如下所示。它由三部分組成，各部分間用冒號分隔：
jdbc：＜子協(xié)遙荊海甲用疲?br> 　　JDBC URL的三個部分可分解如下：

　?。?）jdbc協(xié)議：JDBC URL中的協(xié)議總是jdbc。

　?。?）＜子協(xié)議＞：驅(qū)動程序名或數(shù)據(jù)庫連接機制（這種機制可由一個或多個驅(qū)動程序支持）的名稱。子協(xié)議名的典型示例是"odbc"，該名稱是為用于指定ODBC風(fēng)格的數(shù)據(jù)資源名稱的URL專門保留的。例如，為了通過JDBC-ODBC橋來訪問某個數(shù)據(jù)庫，可以用如下所示的URL：jdbc：odbc：book。本例中，子協(xié)議為"odbc"，子名稱"book"是本地ODBC數(shù)據(jù)資源。如果要用網(wǎng)絡(luò)命名服務(wù)（這樣JDBC URL中的數(shù)據(jù)庫名稱不必是實際名稱），則命名服務(wù)可以作為子協(xié)議。例如，可用如下所示的URL：jdbc：dcenaming：accounts。本例中，該URL指定了本地DCE命名服務(wù)應(yīng)該將數(shù)據(jù)庫名稱"accounts"解析為更為具體的可用于連接真實數(shù)據(jù)庫的名稱。

　?。?）＜子名稱＞：種標(biāo)識數(shù)據(jù)庫的方法。子名稱可以依不同的子協(xié)議而變化。它還可以有子名稱的子名稱（含有驅(qū)動程序編程員所選的任何內(nèi)部語法）。使用子名稱的目的是為定位數(shù)據(jù)庫提供足夠的信息。前例中，因為ODBC將提供其余部份的信息，因此用"book"就已足夠。然而，位于遠程服務(wù)器上的數(shù)據(jù)庫需要更多的信息。例如，如果數(shù)據(jù)庫是通過Internet來訪問的，則在JDBC URL中應(yīng)將網(wǎng)絡(luò)地址作為子名稱的一部份包括進去，且必須遵循如下所示的標(biāo)準URL命名約定：//主機名：端口/子協(xié)議。

　　假設(shè)"dbnet"是個用于將某個主機連接到Internet上的協(xié)議，則JDBC URL應(yīng)為：jdbc：dbnet：//wombat：356/fred。

　　4. "odbc"子協(xié)議

　　子協(xié)議odbc是一種特殊情況。它是為用于指定ODBC風(fēng)格的數(shù)據(jù)資源名稱的URL而保留的，并具有下列特性：允許在子名稱（數(shù)據(jù)資源名稱）后面指定任意多個屬性值。odbc子協(xié)議的完整語法為：

　　jdbc：odbc：＜數(shù)據(jù)資源名稱＞[；＜屬性名＞=＜屬性值＞]，因此，以下都是合法的jdbc：odbc名稱：
　　jdbc：odbc：qeor7
　　jdbc：odbc：wombat
　　jdbc：odbc：wombat；CacheSize=20；ExtensionCase=LOWER
　　jdbc：odbc：qeora；UID=kgh；PWD=fooey

　　5. 注冊子協(xié)議

　　驅(qū)動程序編程員可保留某個名稱以將之用作JDBC URL的子協(xié)議名。當(dāng)DriverManager類將此名稱加到已注冊的驅(qū)動程序清單中時，為之保留該名稱的驅(qū)動程序應(yīng)能識別該名稱并與它所標(biāo)識的數(shù)據(jù)庫建立連接。例如，odbc是為JDBC-ODBC橋而保留的。假設(shè)有個Miracle公司，它可能會將"miracle"注冊為連接到其Miracle DBMS上的JDBC驅(qū)動程序的子協(xié)議，從而使其他人都無法使用這個名稱。

　　JavaSoft目前作為非正式代理負責(zé)注冊JDBC子協(xié)議名稱。要注冊某個子協(xié)議名稱，請發(fā)送電子郵件到下述地址：jdbc@wombat.eng.sun.com。

　　6. 發(fā)送SQL語句

　　連接一旦建立，就可用來向它所涉及的數(shù)據(jù)庫傳送SQL語句。JDBC對可被發(fā)送的SQL語句類型不加任何限制。這就提供了很大的靈活性，即允許使用特定的數(shù)據(jù)庫語句或甚至于非SQL語句。然而，它要求用戶自己負責(zé)確保所涉及的數(shù)據(jù)庫可以處理所發(fā)送的SQL語句，否則將自食其果。例如，如果某個應(yīng)用程序試圖向不支持儲存程序的DBMS發(fā)送儲存程序調(diào)用，就會失敗并將拋出異常。JDBC要求驅(qū)動程序應(yīng)至少能提供ANSI SQL-2 Entry Level功能才可算是符合JDBC標(biāo)準TM的。這意味著用戶至少可信賴這一標(biāo)準級別的功能。

　　JDBC提供了三個類，用于向數(shù)據(jù)庫發(fā)送SQL語句。Connection接口中的三個方法可用于創(chuàng)建這些類的實例。下面列出這些類及其創(chuàng)建方法：

　　（1）Statement：由方法createStatement所創(chuàng)建。Statement對象用于發(fā)送簡單的SQL語句。

　?。?）PreparedStatement：由方法prepareStatement所創(chuàng)建。PreparedStatement對象用于發(fā)送帶有一個或多個輸入?yún)?shù)（IN參數(shù)）的SQL語句。PreparedStatement擁有一組方法，用于設(shè)置IN參數(shù)的值。執(zhí)行語句時，這些IN參數(shù)將被送到數(shù)據(jù)庫中。PreparedStatement的實例擴展了Statement，因此它們都包括了Statement的方法。PreparedStatement對象有可能比Statement對象的效率更高，因為它已被預(yù)編譯過并存放在那以供將來使用。

　?。?）CallableStatement：由方法prepareCall所創(chuàng)建。CallableStatement對象用于執(zhí)行SQL儲存程序─一組可通過名稱來調(diào)用（就象函數(shù)的調(diào)用那樣）的SQL語句。CallableStatement對象從PreparedStatement中繼承了用于處理IN參數(shù)的方法，而且還增加了用于處理OUT參數(shù)和INOUT參數(shù)的方法。

　　不過通常來說createStatement方法用于簡單的SQL語句（不帶參數(shù)）、prepareStatement方法用于帶一個或多個IN參數(shù)的SQL語句或經(jīng)常被執(zhí)行的簡單SQL語句，而prepareCall方法用于調(diào)用已儲存過程。

　　7. 事務(wù)

　　事務(wù)由一個或多個這樣的語句組成：這些語句已被執(zhí)行、完成并被提交或還原。當(dāng)調(diào)用方法commit或rollback時，當(dāng)前事務(wù)即告就結(jié)束，另一個事務(wù)隨即開始。缺省情況下，新連接將處于自動提交模式。也就是說，當(dāng)執(zhí)行完語句后，將自動對那個語句調(diào)用commit方法。這種情況下，由于每個語句都是被單獨提交的，因此一個事務(wù)只由一個語句組成。如果禁用自動提交模式，事務(wù)將要等到commit或rollback方法被顯式調(diào)用時才結(jié)束，因此它將包括上一次調(diào)用commit或rollback方法以來所有執(zhí)行過的語句。對于第二種情況，事務(wù)中的所有語句將作為組來提交或還原。

　　方法commit使SQL語句對數(shù)據(jù)庫所做的任何更改成為永久性的，它還將釋放事務(wù)持有的全部鎖。而方法rollback將棄去那些更改。有時用戶在另一個更改生效前不想讓此更改生效。這可通過禁用自動提交并將兩個更新組合在一個事務(wù)中來達到。如果兩個更新都是成功，則調(diào)用commit方法，從而使兩個更新結(jié)果成為永久性的；如果其中之一或兩個更新都失敗了，則調(diào)用rollback方法，以將值恢復(fù)為進行更新之前的值。

　　大多數(shù)JDBC驅(qū)動程序都支持事務(wù)。事實上，符合JDBC的驅(qū)動程序必須支持事務(wù)。DatabaseMetaData給出的信息描述DBMS所提供的事務(wù)支持水平。

　　8. 事務(wù)隔離級別

　　如果DBMS支持事務(wù)處理，它必須有某種途徑來管理兩個事務(wù)同時對一個數(shù)據(jù)庫進行操作時可能發(fā)生的沖突。用戶可指定事務(wù)隔離級別，以指明DBMS應(yīng)該花多大精力來解決潛在沖突。例如，當(dāng)事務(wù)更改了某個值而第二個事務(wù)卻在該更改被提交或還原前讀取該值時該怎么辦。

　　假設(shè)第一個事務(wù)被還原后，第二個事務(wù)所讀取的更改值將是無效的，那么是否可允許這種沖突？JDBC用戶可用以下代碼來指示DBMS允許在值被提交前讀取該值（"dirty讀取"），其中con是當(dāng)前連接：
con.setTransactionIsolation（TRANSACTION_READ_UNCOMMITTED）；

　　事務(wù)隔離級別越高，為避免沖突所花的精力也就越多。Connection接口定義了五級，其中最低級別指定了根本就不支持事務(wù)，而最高級別則指定當(dāng)事務(wù)在對某個數(shù)據(jù)庫進行操作時，任何其它事務(wù)不得對那個事務(wù)正在讀取的數(shù)據(jù)進行任何更改。通常，隔離級別越高，應(yīng)用程序執(zhí)行的速度也就越慢（由于用于鎖定的資源耗費增加了，而用戶間的并發(fā)操作減少了）。在決定采用什么隔離級別時，開發(fā)人員必須在性能需求和數(shù)據(jù)一致性需求之間進行權(quán)衡。當(dāng)然，實際所能支持的級別取決于所涉及的DBMS的功能。

　　當(dāng)創(chuàng)建Connection對象時，其事務(wù)隔離級別取決于驅(qū)動程序，但通常是所涉及的數(shù)據(jù)庫的缺省值。用戶可通過調(diào)用setIsolationLevel方法來更改事務(wù)隔離級別。新的級別將在該連接過程的剩余時間內(nèi)生效。要想只改變一個事務(wù)的事務(wù)隔離級別，必須在該事務(wù)開始前進行設(shè)置，并在該事務(wù)結(jié)束后進行復(fù)位。我們不提倡在事務(wù)的中途對事務(wù)隔離級別進行更改，因為這將立即觸發(fā)commit方法的調(diào)用，使在此之前所作的任何更改變成永久性的。

九、JDBC驅(qū)動管理內(nèi)幕是怎么樣的？

　　DriverManager 類是 JDBC 的管理層，作用于用戶和驅(qū)動程序之間。它跟蹤可用的驅(qū)動程序，并在數(shù)據(jù)庫和相應(yīng)驅(qū)動程序之間建立連接。另外，DriverManager類也處理諸如驅(qū)動程序登錄時間限制及登錄和跟蹤消息的顯示等事務(wù)。

　　對于簡單的應(yīng)用程序，一般程序員需要在此類中直接使用的唯一方法是DriverManager.getConnection。正如名稱所示，該方法將建立與數(shù)據(jù)庫的連接。JDBC允許用戶調(diào)用DriverManager的方法getDriver、getDrivers和registerDriver及Driver的方法connect。但多數(shù)情況下，讓DriverManager類管理建立連接的細節(jié)為上策。

　　1. 跟蹤可用驅(qū)動程序

　　DriverManager類包含一列Driver類，它們已通過調(diào)用方法DriverManager.registerDriver對自己進行了注冊。所有Driver類都必須包含有一個靜態(tài)部分。它創(chuàng)建該類的實例，然后在加載該實例時DriverManager類進行注冊。這樣，用戶正常情況下將不會直接調(diào)用DriverManager.registerDriver；而是在加載驅(qū)動程序時由驅(qū)動程序自動調(diào)用。加載Driver類，然后自動在DriverManager中注冊的方式有兩種：

　?。?）調(diào)用方法Class.forName

　　這將顯式地加載驅(qū)動程序類。由于這與外部設(shè)置無關(guān)，因此推薦使用這種加載驅(qū)動程序的方法。以下代碼加載類acme.db.Driver：Class.forName（"acme.db.Driver"）。

　　如果將acme.db.Driver編寫為加載時創(chuàng)建實例，并調(diào)用以該實例為參數(shù)的DriverManager.registerDriver（本該如此），則它在DriverManager的驅(qū)動程序列表中，并可用于創(chuàng)建連接。

　?。?）將驅(qū)動程序添加到Java.lang.System的屬性jdbc.drivers中

　　這是一個由DriverManager類加載的驅(qū)動程序類名的列表，由冒號分隔：初始化DriverManager類時，它搜索系統(tǒng)屬性jdbc.drivers，如果用戶已輸入了一個或多個驅(qū)動程序，則DriverManager類將試圖加載它們。以下代碼說明程序員如何在~/.hotJava/properties中輸入三個驅(qū)動程序類（啟動時，HotJava將把它加載到系統(tǒng)屬性列表中）：

　　jdbc.drivers=foo.bah.Driver：wombat.sql.Driver：bad.test.ourDriver；

　　對DriverManager方法的第一次調(diào)用將自動加載這些驅(qū)動程序類。注意：加載驅(qū)動程序的第二種方法需要持久的預(yù)設(shè)環(huán)境。如果對這一點不能保證，則調(diào)用方法Class.forName顯式地加載每個驅(qū)動程序就顯得更為安全。這也是引入特定驅(qū)動程序的方法，因為一旦DriverManager類被初始化，它將不再檢查jdbc.drivers屬性列表。

　　在以上兩種情況中，新加載的Driver類都要通過調(diào)用DriverManager.registerDriver類進行自我注冊。如上所述，加載類時將自動執(zhí)行這一過程。

　　由于安全方面的原因，JDBC管理層將跟蹤哪個類加載器提供哪個驅(qū)動程序。這樣，當(dāng)DriverManager類打開連接時，它僅使用本地文件系統(tǒng)或與發(fā)出連接請求的代碼相同的類加載器提供的驅(qū)動程序。

　　2. 建立連接

　　加載Driver類并在DriverManager類中注冊后，它們即可用來與數(shù)據(jù)庫建立連接。當(dāng)調(diào)用DriverManager.getConnection方法發(fā)出連接請求時，DriverManager將檢查每個驅(qū)動程序，查看它是否可以建立連接。

　　有時可能有多個JDBC驅(qū)動程序可以與給定的URL連接。例如，與給定遠程數(shù)據(jù)庫連接時，可以使用JDBC-ODBC橋驅(qū)動程序、JDBC到通用網(wǎng)絡(luò)協(xié)議驅(qū)動程序或數(shù)據(jù)庫廠商提供的驅(qū)動程序。在這種情況下測試驅(qū)動程序的順序至關(guān)重要，因為DriverManager將使用它所找到的第一個可以成功連接到給定URL的驅(qū)動程序。

　　首先DriverManager試圖按注冊的順序使用每個驅(qū)動程序（jdbc.drivers中列出的驅(qū)動程序總是先注冊）。它將跳過代碼不可信任的驅(qū)動程序，除非加載它們的源與試圖打開連接的代碼的源相同。它通過輪流在每個驅(qū)動程序上調(diào)用方法Driver.connect，并向它們傳遞用戶開始傳遞給方法DriverManager.getConnection的URL來對驅(qū)動程序進行測試，然后連接第一個認出該URL的驅(qū)動程序。這種方法初看起來效率不高，但由于不可能同時加載數(shù)十個驅(qū)動程序，因此每次連接實際只需幾個過程調(diào)用和字符串比較。

　　以下代碼是通常情況下用驅(qū)動程序（例如JDBC-ODBC橋驅(qū)動程序）建立連接所需所有步驟的示例：

Class.forName（"sun.jdbc.odbc.JdbcOdbcDriver"）；//加載驅(qū)動程序
String url = "jdbc：odbc：fred"；
DriverManager.getConnection（url，"userID"，"passwd"）；

十、如何利用JDBC發(fā)送SQL語句？

　　Statement對象用于將SQL語句發(fā)送到數(shù)據(jù)庫中。實際上有三種Statement對象，它們都作為在給定連接上執(zhí)行SQL語句的包容器：Statement、PreparedStatement（它從Statement繼承而來）和CallableStatement（它從PreparedStatement繼承而來）。它們都專用于發(fā)送特定類型的SQL語句：Statement對象用于執(zhí)行不帶參數(shù)的簡單SQL語句；PreparedStatement對象用于執(zhí)行帶或不帶IN參數(shù)的預(yù)編譯SQL語句；CallableStatement對象用于執(zhí)行對數(shù)據(jù)庫已存儲過程的調(diào)用。

　　Statement接口提供了執(zhí)行語句和獲取結(jié)果的基本方法；PreparedStatement接口添加了處理IN參數(shù)的方法；而CallableStatement添加了處理OUT參數(shù)的方法。

　　1. 創(chuàng)建Statement對象

　　建立了到特定數(shù)據(jù)庫的連接之后，就可用該連接發(fā)送SQL語句。Statement對象用Connection的方法createStatement創(chuàng)建，如下列代碼段中所示：

Connection con = DriverManager.getConnection（url，"sunny"，""）；
Statement stmt = con.createStatement（）；

　　為了執(zhí)行Statement對象，被發(fā)送到數(shù)據(jù)庫的SQL語句將被作為參數(shù)提供給Statement的方法：

　　ResultSet rs = stmt.executeQuery（"SELECT a，b，c FROM Table2"）；

　　2. 使用Statement對象執(zhí)行語句

　　Statement接口提供了三種執(zhí)行SQL語句的方法：executeQuery、executeUpdate和execute。使用哪一個方法由SQL語句所產(chǎn)生的內(nèi)容決定。

　　方法executeQuery用于產(chǎn)生單個結(jié)果集的語句，例如SELECT語句。方法executeUpdate用于執(zhí)行INSERT、UPDATE或DELETE語句以及SQL DDL（數(shù)據(jù)定義語言）語句，例如CREATE TABLE和DROP TABLE。INSERT、UPDATE或DELETE語句的效果是修改表中零行或多行中的一列或多列。executeUpdate的返回值是一個整數(shù)，指示受影響的行數(shù)（即更新計數(shù)）。對于CREATE TABLE或DROP TABLE等不操作行的語句，executeUpdate的返回值總為零。

　　執(zhí)行語句的所有方法都將關(guān)閉所調(diào)用的Statement對象的當(dāng)前打開結(jié)果集（如果存在）。這意味著在重新執(zhí)行Statement對象之前，需要完成對當(dāng)前ResultSet對象的處理。應(yīng)注意，繼承了Statement接口中所有方法的PreparedStatement接口都有自己的executeQuery、executeUpdate和execute方法。Statement對象本身不包含SQL語句，因而必須給Statement.execute方法提供SQL語句作為參數(shù)。PreparedStatement對象并不需要SQL語句作為參數(shù)提供給這些方法，因為它們已經(jīng)包含預(yù)編譯SQL語句。

　　CallableStatement對象繼承這些方法的PreparedStatement形式。對于這些方法的PreparedStatement或CallableStatement版本，使用查詢參數(shù)將拋出SQLException。

　　3. 語句完成

　　當(dāng)連接處于自動提交模式時，其中所執(zhí)行的語句在完成時將自動提交或還原。語句在已執(zhí)行且所有結(jié)果返回時，即認為已完成。對于返回一個結(jié)果集的executeQuery方法，在檢索完ResultSet對象的所有行時該語句完成。對于方法executeUpdate，當(dāng)它執(zhí)行時語句即完成。但在少數(shù)調(diào)用方法execute的情況中，在檢索所有結(jié)果集或它生成的更新計數(shù)之后語句才完成。

　　有些DBMS將已存儲過程中的每條語句視為獨立的語句；而另外一些則將整個過程視為一個復(fù)合語句。在啟用自動提交時，這種差別就變得非常重要，因為它影響什么時候調(diào)用commit方法。在前一種情況中，每條語句單獨提交；在后一種情況中，所有語句同時提交。

　　4. 關(guān)閉Statement對象

　　Statement對象將由Java垃圾收集程序自動關(guān)閉。而作為一種好的編程風(fēng)格，應(yīng)在不需要Statement對象時顯式地關(guān)閉它們。這將立即釋放DBMS資源，有助于避免潛在的內(nèi)存問題。

　　5. 使用方法execute

　　execute方法應(yīng)該僅在語句能返回多個ResultSet對象、多個更新計數(shù)或ResultSet對象與更新計數(shù)的組合時使用。當(dāng)執(zhí)行某個已存儲過程或動態(tài)執(zhí)行未知SQL字符串（即應(yīng)用程序程序員在編譯時未知）時，有可能出現(xiàn)多個結(jié)果的情況，盡管這種情況很少見。例如，用戶可能執(zhí)行一個已存儲過程，并且該已存儲過程可執(zhí)行更新，然后執(zhí)行選擇，再進行更新，再進行選擇，等等。通常使用已存儲過程的人應(yīng)知道它所返回的內(nèi)容。

　　因為方法execute處理非常規(guī)情況，所以獲取其結(jié)果需要一些特殊處理并不足為怪。例如，假定已知某個過程返回兩個結(jié)果集，則在使用方法execute執(zhí)行該過程后，必須調(diào)用方法getResultSet獲得第一個結(jié)果集，然后調(diào)用適當(dāng)?shù)膅etXXX方法獲取其中的值。要獲得第二個結(jié)果集，需要先調(diào)用getMoreResults方法，然后再調(diào)用getResultSet方法。如果已知某個過程返回兩個更新計數(shù)，則首先調(diào)用方法getUpdateCount，然后調(diào)用getMoreResults，并再次調(diào)用getUpdateCount。

　　對于不知道返回內(nèi)容，則情況更為復(fù)雜。如果結(jié)果是ResultSet對象，則方法execute返回true；如果結(jié)果是Javaint，則返回false。如果返回int，則意味著結(jié)果是更新計數(shù)或執(zhí)行的語句是DL命令。在調(diào)用方法execute之后要做的第一件事情是調(diào)用getResultSet或getUpdateCount。調(diào)用方法getResultSet可以獲得兩個或多個ResultSet對象中第一個對象；或調(diào)用方法getUpdateCount可以獲得兩個或多個更新計數(shù)中第一個更新計數(shù)的內(nèi)容。

　　當(dāng)SQL語句的結(jié)果不是結(jié)果集時，則方法getResultSet將返回null。這可能意味著結(jié)果是一個更新計數(shù)或沒有其它結(jié)果。在這種情況下，判斷null真正含義的唯一方法是調(diào)用方法getUpdateCount，它將返回一個整數(shù)。這個整數(shù)為調(diào)用語句所影響的行數(shù)；如果為-1則表示結(jié)果是結(jié)果集或沒有結(jié)果。如果方法getResultSet已返回null（表示結(jié)果不是ResultSet對象），則返回值-1表示沒有其它結(jié)果。也就是說，當(dāng)下列條件為真時表示沒有結(jié)果（或沒有其它結(jié)果）：

　?。ǎ╯tmt.getResultSet（）==null）&&（stmt.getUpdateCount（）==-1））

　　如果已經(jīng)調(diào)用方法getResultSet并處理了它返回的ResultSet對象，則有必要調(diào)用方法getMoreResults以確定是否有其它結(jié)果集或更新計數(shù)。如果getMoreResults返回true，則需要再次調(diào)用getResultSet來檢索下一個結(jié)果集。如上所述，如果getResultSet返回null，則需要調(diào)用getUpdateCount來檢查null是表示結(jié)果為更新計數(shù)還是表示沒有其它結(jié)果。

　　當(dāng)getMoreResults返回false時，它表示該SQL語句返回一個更新計數(shù)或沒有其它結(jié)果。因此需要調(diào)用方法getUpdateCount來檢查它是哪一種情況。在這種情況下，當(dāng)下列條件為真時表示沒有其它結(jié)果：

　?。ǎ╯tmt.getMoreResults（）==false）&&（stmt.getUpdateCount（）==-1））

　　下面的代碼演示了一種方法用來確認已訪問調(diào)用方法execute所產(chǎn)生的全部結(jié)果集和更新計數(shù)：

stmt.execute（queryStringWithUnknownResults）；
while（true）{
introwCount=stmt.getUpdateCount（）；
if（rowCount＞0）{//它是更新計數(shù)
System.out.println（"Rows changed="+count）；
stmt.getMoreResults（）；
continue；
}
if（rowCount==0）{//DDL命令或0個更新
System.out.println（"No rows changed or statement was DDL command"）；
stmt.getMoreResults（）；
continue；
}
//執(zhí)行到這里，證明有一個結(jié)果集
//或沒有其它結(jié)果
ResultSet rs=stmt.getResultSet（）；
if（rs!=null）{
...//使用元數(shù)據(jù)獲得關(guān)于結(jié)果集列的信息
while（rs.next（））{
...//處理結(jié)果
stmt.getMoreResults（）；
continue；
}
break；//沒有其它結(jié)果

十一、如何獲得SQL語句的執(zhí)行結(jié)果？

　　ResultSet包含符合SQL語句中條件的所有行，并且它通過一套get方法（這些get方法可以訪問當(dāng)前行中的不同列）提供了對這些行中數(shù)據(jù)的訪問。ResultSet.next方法用于移動到ResultSet中的下一行，使下一行成為當(dāng)前行。

　　下面的代碼段是執(zhí)行SQL語句的示例。該SQL語句將返回行集合，其中列1為int，列2為String，而列3則為字節(jié)數(shù)組：

Java.sql.Statementstmt=conn.createStatement（）；
ResultSet r=stmt.executeQuery（"SELECT a，b，c FROM Table1"）；
while（r.next（））{
//打印當(dāng)前行的值。
Int i=r.getInt（"a"）；
String s=r.getString（"b"）；
Float f=r.getFloat（"c"）；
System.out.println（"ROW="+i+" "+s+" "+f）；
}

　　1. 行和光標(biāo)

　　ResultSet維護指向其當(dāng)前數(shù)據(jù)行的光標(biāo)。每調(diào)用一次next方法，光標(biāo)向下移動一行。

　　最初它位于第一行之前，因此第一次調(diào)用next將把光標(biāo)置于第一行上，使它成為當(dāng)前行。隨著每次調(diào)用next導(dǎo)致光標(biāo)向下移動一行，按照從上至下的次序獲取ResultSet行。

　　在ResultSet對象或其父輩Statement對象關(guān)閉之前，光標(biāo)一直保持有效。在SQL中，結(jié)果表的光標(biāo)是有名字的。如果數(shù)據(jù)庫允許定位更新或定位刪除，則需要將光標(biāo)的名字作為參數(shù)提供給更新或刪除命令?？赏ㄟ^調(diào)用方法getCursorName獲得光標(biāo)名。

　　DatabaseMetaData.supportsPositionedDelete和supportsPositionedUpdate方法來檢查特定連接是否支持這些操作。當(dāng)DBMS支持定位更新和刪除操作時，DBMS/驅(qū)動程序必須確保適當(dāng)鎖定選定行，以使定位更新不會導(dǎo)致更新異常或其它并發(fā)問題。

　　2. 列

　　方法getXXX提供了獲取當(dāng)前行中某列值的途徑。在每一行內(nèi)，可按任何次序獲取列值。但為了保證可移植性，應(yīng)該從左至右獲取列值，并且一次性地讀取列值。

　　列名或列號可用于標(biāo)識要從中獲取數(shù)據(jù)的列。例如，如果ResultSet對象rs的第二列名為"title"，并將值存儲為字符串，則下列任一代碼將獲取存儲在該列中的值：

　　String s=rs.getString（"title"）；
　　String s=rs.getString（2）；

　　注意列是從左至右編號的，并且從列1開始。同時，用作getXXX方法的輸入的列名不區(qū)分大小寫。

　　提供使用列名這個選項的目的是為了讓在查詢中指定列名的用戶可使用相同的名字作為getXXX方法的參數(shù)。另一方面，如果select語句未指定列名（例如在"select * from table1"中或列是導(dǎo)出的時），則應(yīng)該使用列號。這些情況下，用戶將無法確切知道列名。

　　有些情況下，SQL查詢返回的結(jié)果集中可能有多個列具有相同的名字。如果列名用作getXXX方法的參數(shù)，則getXXX將返回第一個匹配列名的值。因而，如果多個列具有相同的名字，則需要使用列索引來確保檢索了正確的列值。這時，使用列號效率要稍微高一些。

　　關(guān)于ResultSet中列的信息，可通過調(diào)用方法ResultSet.getMetaData得到。返回的ResultSetMetaData對象將給出其ResultSet對象各列的編號、類型和屬性。

　　如果列名已知，但不知其索引，則可用方法findColumn得到其列號。

　　3. 數(shù)據(jù)類型和轉(zhuǎn)換

　　對于getXXX方法，JDBC驅(qū)動程序試圖將基本數(shù)據(jù)轉(zhuǎn)換成指定Java類型，

　　然后返回適合的Java值。例如，如果getXXX方法為getString，而基本數(shù)據(jù)庫中數(shù)據(jù)類型為VARCHAR，則JDBC驅(qū)動程序?qū)裋ARCHAR轉(zhuǎn)換成JavaString。getString的返回值將為JavaString對象。

　　4. 對非常大的行值使用流
　　ResultSet可以獲取任意大的LONGVARBINARY或LONGVARCHAR數(shù)據(jù)。方法getBytes和getString將數(shù)據(jù)返回為大的塊（最大為Statement.getMaxFieldSize的返回值）。但是，以較小的固定塊獲取非常大的數(shù)據(jù)可能會更方便，而這可通過讓ResultSet類返回Java.io.Input流來完成。從該流中可分塊讀取數(shù)據(jù)。注意：必須立即訪問這些流，因為在下一次對ResultSet調(diào)用getXXX時它們將自動關(guān)閉（這是由于基本實現(xiàn)對大塊數(shù)據(jù)訪問有限制）。

　　JDBCAPI具有三個獲取流的方法，分別具有不同的返回值：

　　·getBinaryStream：返回只提供數(shù)據(jù)庫原字節(jié)而不進行任何轉(zhuǎn)換的流。

　　·getAsciiStream返回提供單字節(jié)ASCII字符的流。

　　·getUnicodeStream返回提供雙字節(jié)Unicode字符的流。

　　注意：它不同于Java流，后者返回?zé)o類型字節(jié)并可（例如）通用于ASCII和Unicode字符。下列代碼演示了getAsciiStream的用法：

Java.sql.Statementstmt=con.createStatement（）；
ResultSet r=stmt.executeQuery（"SELECT x FROM Table2"）；
//現(xiàn)在以4K塊大小獲取列1結(jié)果：
byte buff=newbyte[4096]；
while（r.next（））{
Java.io.InputStream fin=r.getAsciiStream（1）；
for（；；）{
intsize=fin.read（buff）；
if（size==-1）{//到達流末尾
break；
}
//將新填充的緩沖區(qū)發(fā)送到ASCII輸出流：
output.write（buff，0，size）；
}
}

　　5. NULL結(jié)果值

　　要確定給定結(jié)果值是否是JDBC NULL，必須先讀取該列，然后使用ResultSet.wasNull
方法檢查該次讀取是否返回JDBC NULL。

　　當(dāng)使用ResultSet.getXXX方法讀取JDBC NULL時，方法wasNull將返回下列值之一：

　?。?）Javanull值

　　對于返回Java對象的getXXX方法（例如getString、getBigDecimal、getBytes、getDate、getTime、getTimestamp、getAsciiStream、getUnicodeStream、getBinaryStream、getObject等）。

　　（2）零值：對于getByte、getShort、getInt、getLong、getFloat和getDouble。

　　（3）false值：對于getBoolean。

　　6. 可選結(jié)果集或多結(jié)果集

　　通常使用executeQuery（它返回單個ResultSet）或executeUpdate（它可用于任何數(shù)據(jù)庫修改語句，并返回更新行數(shù)）可執(zhí)行SQL語句。但有些情況下，應(yīng)用程序在執(zhí)行語句之前不知道該語句是否返回結(jié)果集。此外，有些已存儲過程可能返回幾個不同的結(jié)果集和/或更新計數(shù)。

　　為了適應(yīng)這些情況，JDBC提供了一種機制，允許應(yīng)用程序執(zhí)行語句，然后處理由結(jié)果集和更新計數(shù)組成的任意集合。這種機制的原理是首先調(diào)用一個完全通用的execute方法，然后調(diào)用另外三個方法，getResultSet、getUpdateCount和getMoreResults。這些方法允許應(yīng)用程序一次一個地研究語句結(jié)果，并確定給定結(jié)果是ResultSet還是更新計數(shù)。

　　用戶不必關(guān)閉ResultSet；當(dāng)產(chǎn)生它的Statement關(guān)閉、重新執(zhí)行或用于從多結(jié)果序列中獲取下一個結(jié)果時，該ResultSet將被Statement自動關(guān)閉。

十二、基于JDBC有哪些數(shù)據(jù)庫通用訪問方法？

　　1. 通用數(shù)據(jù)庫Bean設(shè)計

　　本實例中對數(shù)據(jù)庫連接和執(zhí)行SQL語句等通用數(shù)據(jù)庫操作進行了封裝，通過實現(xiàn)DBConnBean和DBQueryBean兩個JavaBean來完成上述功能。其中DBConnBean負責(zé)Java應(yīng)用程序和數(shù)據(jù)庫的連接；DBQueryBean提供了一組執(zhí)行標(biāo)準SQL的功能，可以實現(xiàn)標(biāo)準SQL完成的所有功能。其功能代碼分別如下所示：

　　① DBConnBean.Java的源代碼如下所示：

package dbaccess；
import Java.sql.*；
import Java.util.*；
import Java.io.*；
public class DBConnBean
implements Serializable{

private String DBDriver = "sun.jdbc.odbc.JdbcOdbcDriver"；
private String DBHost = "127.0.0.1"；
private String DBName = "demo"；
private String conp = "jdbc：odbc：db_demo"；
private String username = ""；
private String password = ""；
private boolean xdebug = true；

public Connection con = null；

public String sql = null；

Statement stmt = null；
public ResultSet result = null；
private int affectedRows = 0；

public DBConnBean（）
{
xdebug = true；
con = null；
sql = null；
}
public Connection Connect（）
throws Exception
{
String msg = null；
try
{
Class.forName（DBDriver）.newInstance（）；
}
catch（Exception e）
{
msg = "加載數(shù)據(jù)庫驅(qū)動失敗"；
if （xdebug） msg += "（驅(qū)動'"+DBDriver+"'）"；
throw new Exception（msg）；
}
try
{
String conStr = conp；
con = DriverManager.getConnection（conStr，username，password）；
}
catch（SQLException e）
{
msg = "!!數(shù)據(jù)庫連接失敗"；
if （xdebug）
{
msg += "（錯誤信息='" + e.getMessage（）+"' SQL狀態(tài)值='" + e.getSQLState（）+"' 錯誤代碼='" + e.getErrorCode（）+"'）"；
}
throw new Exception（msg）；
}
return con；
}
protected void finalize（）
throws Throwable
{
super.finalize（）；
if （stmt != null） stmt.close（）；
if （result != null） result.close（）；
}
//最近一次對數(shù)據(jù)庫查詢受影響的行數(shù)
public int getAffectedRows（）
{
return affectedRows；
}
public Connection getCon（）
{
return con；
}
public String getConp（）
{
return conp；
}
public String getDBDriver（）
{
return DBDriver；
}
public String getDBName（）
{
return DBName；
}
public boolean getDebug（）
{
return xdebug；
}
public String getPassword（）
{
return password；
}
public ResultSet getResult（）
{
return result；
}
public String getSql（）
{
return sql；
}
public String getUsername（）
{
return username；
}
public void over（）
throws Throwable
{
finalize（）；
}
public ResultSet query（）
throws Exception
{
result = null；
affectedRows = 0；
if （con == null）
Connect（）；
if （stmt == null）
stmt = con.createStatement（）；
if （sql.substring（0，6）.equalsIgnoreCase（"select"））
{
result = stmt.executeQuery（sql）；
}
else
{
affectedRows = stmt.executeUpdate（sql）；
}
return result；
}
public ResultSet query（String s）
throws Exception
{
sql = s；
return query（）；
}
public void setDBDriver（String s）
{
DBDriver = s；
}
public void setDebug（boolean b）
{
xdebug = b；
}
public void setgetConp（String s）
{
conp = s；
}
public void setgetDBName（String s）
{
DBName = s；
}
public void setgetUsername（String s）
{
username = s；
}
public void setPassword（String s）
{
password = s；
}
public void setSql（String s）
{
sql = s；
}
}

② DBQueryBean.Java的源代碼如下所示：
package dbaccess；
import Java.sql.*；
import Java.util.*；
import Java.io.*；
import Java.lang.reflect.*；

public class DBQueryBean
implements Serializable
{
DBConnBean dbc；
String sql = null；
int rowcount = 0；
int colcount = 0；
// int limitcount = 0；
Vector result = null；
public String _WATCH = ""；

public DBQueryBean（）
{
dbc = new DBConnBean（）；
try {
dbc.Connect（）；
} catch（Exception e） {
handleException（e）；
}
}
protected void finalize（）
throws Throwable
{
super.finalize（）；
if （dbc != null） dbc.over（）；
if （result != null） result.removeAllElements（）；
}
public String get（int row， int col）
{
if （result==null || row ＞= result.size（）） return null；
String r[] = （String[]）result.elementAt（row）；
if （col ＞= Java.lang.reflect.Array.getLength（r）） return null；
return r[col]；
}
public int getAffRows（） { return dbc.getAffectedRows（）； }
public int getColumncount（） {
return colcount；
}
public String[] getRow（int row）
{
if （result==null || row ＞= result.size（）） return null；
return （String []）result.elementAt（row）；
/*String ret[] = new String[colcount]；
Vector r = （Vector）result.elementAt（row）；
for （int i=0； i＜colcount； i++）
ret[i] = （String）r.elementAt（i）；
return ret；*/
}
public int getRowcount（） {
return rowcount；
}
public void handleException（Exception e）
{
_WATCH = e.getMessage（）；
}
public void init（）
{
rowcount = 0；
colcount = 0；
// limitcount = 0；
result = null；
}
public void over（）
throws Throwable
{
finalize（）；
}
public int query（String sql）
{
result = new Vector（）；
int ret = 0；
try {
ResultSet rs = dbc.query（sql）；
if （rs == null）
{
ret = dbc.getAffectedRows（）；
}
else
{
ResultSetMetaData rm = rs.getMetaData（）；
colcount = rm.getColumnCount（）；
while （rs.next（））
{
String row[] = new String[colcount]；
for （int i=0； i＜colcount； i++）
row[i] = rs.getString（i+1）；
result.addElement（row）；
rowcount++；
}
rs.close（）； // to release the resource.
ret = result.size（）；
}
}
catch（Exception e）
{
handleException（e）；
return -1；
}

return ret；
}
}

　　2. 數(shù)據(jù)庫表結(jié)構(gòu)

　　本實例中主要出現(xiàn)了三個數(shù)據(jù)庫表，表名和字段分別如下所示：

　　計劃采購表：jhcg_table

字段名稱 中文名稱 類型 長度
Goods_no 物品編號 vchar 10
Goods_name 物品名稱 Vchar 50
Amount 采購數(shù)量 Int
Price 采購單價 float
Gold 幣種 Vchar 15
Units 單位 Vchar 10
Date 時間 Date
Remark 備注 vchar 100

　　庫存統(tǒng)計表：kctj_table

字段名稱 中文名稱 類型 長度
Goods_no 物品編號 Vchar 10
Goods_name 物品名稱 Vchar 50
amount 庫存數(shù)量 Int
Date 時間 Date

remark 備注 Vchar 100

　　實際采購表：sjcg_table

字段名稱 中文名稱 類型 長度
Goods_no 物品編號 Vchar 10
Goods_name 物品名稱 Vchar 50
Amount 采購數(shù)量 Int
Price Price 采購單價 Float
Gold 幣種 Vchar 15
Units 采購單位 Vchar 10
Date 時間 Date
Remark 備注 vchar 100

　　其中業(yè)務(wù)邏輯非常簡單，即根據(jù)計劃采購表和庫存統(tǒng)計表生成實際采購表。同時，對各表完成數(shù)據(jù)庫的增、刪、改、查等通用操作。

　　3. JSP設(shè)計

　　① 插入操作

　　完成對數(shù)據(jù)庫表的記錄插入功能，其中計劃采購表的插入主頁面（insert_jhcg.htm）為：

　　insert_jhcg.htm將用戶輸入傳送給demo_insert_jhcg.jsp，完成插入操作。改jsp文件的功能代碼為：
＜html＞
＜body＞
＜jsp：useBean id="DBConn" class="dbaccess.DBConnBean" scope="page"/＞
＜jsp：useBean id="DBBean" class="dbaccess.DBQueryBean" scope="page"/＞
＜hr＞
＜!--test JavaBean--＞
＜%
if （DBConn == null||DBBean == null）{
out.println（"JavaBean not found!"）；
return；
}
%＞

＜!--try db_demo connection--＞
＜%
try{
DBConn.Connect（）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞

＜!--execute sql statement--＞
＜%
String insGoodno = request.getParameter（"ed_jhcg_no"）；
String insGoodname = request.getParameter（"ed_jhcg_name"）；
int insAmount = （Integer.valueOf（request.getParameter（"ed_jhcg_amount"）））.intValue（）；
float insPrice = （Float.valueOf（request.getParameter（"ed_jhcg_price"）））.floatValue（）；
String insGold = request.getParameter（"ed_jhcg_gold"）；
String insUnit = request.getParameter（"ed_jhcg_unit"）；
String insRemark = request.getParameter（"ed_jhcg_remark"）；
String sqlStatement = "insert into jhcg_table（good_no，good_name，amount，
price，gold，unit，remark） values（"+"'"+insGoodno+"'"+"，"+"'"+insGoodname+"'"+"，
"+insAmount+"，"+insPrice+"，"+"'"+insGold+"'"+"，"+"'"+insUnit+"'"+"，"+"'"+
insRemark+"'"+"）"；
try{
DBBean.query（sqlStatement）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞
＜/body＞
＜/html＞

　　② 查詢操作

　　該查詢主頁面主要提供對三個數(shù)據(jù)庫表的條件查詢功能，

　　query.htm將用戶選擇查詢的數(shù)據(jù)庫表和查詢條件發(fā)送給demo_query.jsp，由jsp文件完成數(shù)據(jù)庫查詢操作和查詢結(jié)果集的返回及顯示，其功能代碼如下：
＜html＞
＜body＞
＜%
String sqlStatement；
String sqlField = ""；
String whichTable = ""；
String whereClause = ""；
String queryNo = ""；
String queryName = ""；
%＞
＜jsp：useBean id="DBConn" class="dbaccess.DBConnBean" scope="page"/＞
＜jsp：useBean id="DBBean" class="dbaccess.DBQueryBean" scope="page"/＞
＜hr＞
＜!--test JavaBean--＞
＜%
if （DBConn == null||DBBean == null）{
out.println（"JavaBean not found!"）；
return；
}
%＞

＜!--try db_demo connection--＞
＜%
try{
DBConn.Connect（）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞

＜!--prepare sql statement--＞
＜%
String queryRequest = request.getParameter（"rb_request"）；
//out.println（"queryRequest："+queryRequest）；
String whichCB = ""；
if （queryRequest.equals（"1"））{
whichCB = "ck_jhcg"；
whichTable = "jhcg_table"；
queryNo = request.getParameter（"ed_jhcg_no"）；
queryName = request.getParameter（"ed_jhcg_name"）；
if （!queryNo.equals（""））
whereClause = " where good_no="+"'"+queryNo+"'"；
if （!queryName.equals（""））{
if （!queryNo.equals（""））
whereClause += " and good_name="+"'"+queryName+"'"；
else whereClause = " where good_name="+"'"+queryName+"'"；
}
}
if （queryRequest.equals（"2"））{
whichCB = "ck_kctj"；
whichTable = "kctj_table"；
queryNo = request.getParameter（"ed_kctj_no"）；
queryName = request.getParameter（"ed_kctj_name"）；
if （!queryNo.equals（""））
whereClause = " where good_no="+"'"+queryNo+"'"；
if （!queryName.equals（""））{
if （!queryNo.equals（""））
whereClause += " and good_name="+"'"+queryName+"'"；
else whereClause = " where good_name="+"'"+queryName+"'"；
}

}
if （queryRequest.equals（"3"））{
whichCB = "ck_sjcg"；
whichTable = "sjcg_table"；
queryNo = request.getParameter（"ed_sjcg_no"）；
queryName = request.getParameter（"ed_sjcg_name"）；
if （!queryNo.equals（""））
whereClause = " where good_no="+"'"+queryNo+"'"；
if （!queryName.equals（""））{
if （!queryNo.equals（""））
whereClause += " and good_name="+"'"+queryName+"'"；
else whereClause = " where good_name="+"'"+queryName+"'"；
}

}
String[] printTitle = request.getParameterValues（whichCB）；

%＞
＜!--create query sql statement--＞
＜%
sqlStatement = "select "；
for（int i = 0；i＜printTitle.length；i++）{
sqlField += printTitle[i]+"，"；
}
sqlStatement += sqlField.substring（0，sqlField.length（）-1）+" from "+whichTable；
if （!whereClause.equals（""））
sqlStatement += whereClause；
%＞
＜!--show query response--＞
＜%
try{
DBBean.query（sqlStatement）；
}catch（Exception e）{
out.println（"Database Error!"）；
}
int rows = DBBean.getRowcount（）；
int cols = DBBean.getColumncount（）；
%＞
＜Table align="center" width="80%" border=1＞
＜tr align=center＞
＜%
for（int i = 0；i ＜ printTitle.length；i++）{
out.println（"＜td＞＜b＞"）；
out.println（printTitle[i]）；
out.println（"＜/b＞＜/td＞"）；
}
%＞
＜/tr＞
＜%
for （int i = 0；i ＜ rows；i++）{
out.println（"＜tr＞"）；
for （int j = 0；j ＜ cols；j++）
out.println（"＜td＞"+DBBean.get（i，j）+"＜/td＞"）；
out.println（"＜/tr＞"）；
}
%＞
＜/Table＞
＜br＞
＜hr＞
＜/body＞
＜/html＞

　　③ 生成實際采購表

　　生成數(shù)據(jù)庫表是一個隱式操作，程序根據(jù)計劃采購表和庫存統(tǒng)計表的相應(yīng)字段生成實際采購表，不需要用戶的任何輸入，其功能代碼如下（demo_create.jsp）：

＜%@page import="Java.util.*"%＞
＜html＞
＜body＞
＜jsp：useBean id="DBConn" class="dbaccess.DBConnBean" scope="page"/＞
＜jsp：useBean id="DBBean" class="dbaccess.DBQueryBean" scope="page"/＞
＜hr＞
＜!--test JavaBean--＞
＜%
if （DBConn == null||DBBean == null）{
out.println（"JavaBean not found!"）；
return；
}
%＞

＜!--try db_demo connection--＞
＜%
try{
DBConn.Connect（）；
}catch（Exception e）{
out.println（e.getMessage（））；
}
%＞

＜!--prepare sql statement--＞
＜%
int amount_jhcg，amount_kctj；
Vector updateRs = new Vector（）；
DBBean.query（"delete * from sjcg_table"）； //delete all old records in sjcg_table
DBBean.query（"select jhcg_table.good_no，jhcg_table.good_name，jhcg_table.amount，kctj_table.amount，jhcg_table.unit from jhcg_table left join kctj_table on kctj_table.good_no=jhcg_table.good_no"）；
int rows = DBBean.getRowcount（）；
int cols = DBBean.getColumncount（）；
for （int i = 0；i ＜ rows；i++）{
String record[] = new String[4]；
record[0] = DBBean.get（i，0）；
record[1] = DBBean.get（i，1）；
amount_jhcg = （Integer.valueOf（DBBean.get（i，2）））.intValue（）；
if （DBBean.get（i，3） == null） amount_kctj = 0；
else amount_kctj = （Integer.valueOf（DBBean.get（i，3）））.intValue（）；
record[2] = Integer.toString（amount_jhcg - amount_kctj）；
record[3] = DBBean.get（i，4）；
updateRs.addElement（record）；
}
for （int i = 0；i ＜ rows；i++）{
String insRecord[] = （String []）updateRs.elementAt（i）；
String insGoodno，insGoodname，insUnit，insAmount；
insGoodno = insRecord[0]；
insGoodname = insRecord[1]；
insAmount = insRecord[2]；
insUnit = insRecord[3]；
String sqlStatement = "insert into sjcg_table（good_no，good_name，amount，unit） values?quot;+"'"+insGoodno+"'"+"，"+"'"+insGoodname+"'"+"，"+insAmount+"，"+"'"+insUnit+"'"+"）"；
DBBean.query（sqlStatement）；
DBBean.query（"delete * from sjcg_table where amount＜=0"）；
}
%＞
＜/body＞
＜/html＞

　　上述的開發(fā)工具綜合應(yīng)用介紹了基于Java開發(fā)電子商務(wù)應(yīng)用系統(tǒng)的全過程，包括應(yīng)用開發(fā)平臺搭建、業(yè)務(wù)流程分析、JavaBean封裝和JSP開發(fā)等內(nèi)容，其中JSP開發(fā)中涉及到了通用SQL（查詢和插入數(shù)據(jù)庫表）和游標(biāo)操作（生成實際采購表），基本可以完成任何網(wǎng)絡(luò)數(shù)據(jù)庫應(yīng)用的需求。本實例基本上可以將前面介紹的基于Java的電子商務(wù)開發(fā)技術(shù)串接起來，指導(dǎo)讀者進行電子商務(wù)應(yīng)用開發(fā)。

十三、如何在JSP中實現(xiàn)分頁顯示？

　　分頁顯示是Web數(shù)據(jù)庫應(yīng)用中經(jīng)常需要遇到的問題，當(dāng)用戶的數(shù)據(jù)庫查詢結(jié)果遠遠超過了計算機屏幕的顯示能力的時候，我們該如何合理的將數(shù)據(jù)呈現(xiàn)給用戶呢？答案就是數(shù)據(jù)庫分頁顯示，可以完美的解決上述問題。下面是一個數(shù)據(jù)庫分頁操作的通用實例，對任何數(shù)據(jù)庫平臺上的分頁功能都有很好的借鑒意義。

＜%@ page contentType="text/html;charset=8859_1" %＞
＜%
//變量聲明
Java.sql.Connection sqlCon; //數(shù)據(jù)庫連接對象
Java.sql.Statement sqlStmt; //SQL語句對象
Java.sql.ResultSet sqlRst; //結(jié)果集對象

Java.lang.String strCon; //數(shù)據(jù)庫連接字符串
Java.lang.String strSQL; //SQL語句

int intPageSize; //一頁顯示的記錄數(shù)
int intRowCount; //記錄總數(shù)
int intPageCount; //總頁數(shù)
int intPage; //待顯示頁碼
Java.lang.String strPage;

int i;

//設(shè)置一頁顯示的記錄數(shù)
intPageSize = 2;

//取得待顯示頁碼
strPage = request.getParameter("page");
if(strPage==null){//表明在QueryString中沒有page這一個參數(shù)，此時顯示第一頁數(shù)據(jù)
intPage = 1;
}
else{//將字符串轉(zhuǎn)換成整型
intPage = Java.lang.Integer.parseInt(strPage);
if(intPage＜1) intPage = 1;
}

//裝載JDBC驅(qū)動程序
Java.sql.DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

//設(shè)置數(shù)據(jù)庫連接字符串
strCon = "jdbc:oracle:thin:@linux:1521:ora4cweb";

//連接數(shù)據(jù)庫
sqlCon = Java.sql.DriverManager.getConnection(strCon,"hzq","hzq");

//創(chuàng)建一個可以滾動的只讀的SQL語句對象
sqlStmt = sqlCon.createStatement(Java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,Java.sql.ResultSet.CONCUR_READ_ONLY);

//準備SQL語句
strSQL = "select name,age from test";

//執(zhí)行SQL語句并獲取結(jié)果集
sqlRst = sqlStmt.executeQuery(strSQL);

//獲取記錄總數(shù)
sqlRst.last();
intRowCount = sqlRst.getRow();

//記算總頁數(shù)
intPageCount = (intRowCount+intPageSize-1) / intPageSize;

//調(diào)整待顯示的頁碼
if(intPage＞intPageCount) intPage = intPageCount;
%＞

＜html＞
＜head＞
＜meta http-equiv="Content-Type" content="text/html; charset=gb2312"＞
＜title＞JSP數(shù)據(jù)庫操作例程 - 數(shù)據(jù)分頁顯示 - JDBC 2.0 - Oracle＜/title＞
＜/head＞

＜body＞

＜table border="1" cellspacing="0" cellpadding="0"＞
＜tr＞
＜th＞姓名＜/th＞
＜th＞年齡＜/th＞
＜/tr＞

＜%
if(intPageCount＞0){
//將記錄指針定位到待顯示頁, 的第一條記錄上
sqlRst.absolute((intPage-1) * intPageSize + 1);

//顯示數(shù)據(jù)
i = 0;
while(i＜intPageSize && !sqlRst.isAfterLast()){
%＞
＜tr＞
＜td＞＜%=sqlRst.getString(1)%＞＜/td＞
＜td＞＜%=sqlRst.getString(2)%＞＜/td＞
＜/tr＞
＜%
sqlRst.next();
i++; <, BR>}
}
%＞

＜/table＞

第＜%=intPage%＞頁 共＜%=intPageCount%＞頁
＜%if(intPage＜intPageCount){%＞＜/a＞＜%}%＞ ＜%if(intPage＞1){%＞

＜/body＞
＜/html＞

＜%
//關(guān)閉結(jié)果集
sqlRst.close();

//關(guān)閉SQL語句對象
sqlStmt.close();