JDBC - 快速指南

什麼是 JDBC？

JDBC 代表 **J**ava **D**ata**b**ase **C**onnectivity，它是一個標準的 Java API，用於在 Java 程式語言和各種資料庫之間建立獨立於資料庫的連線。

JDBC 庫包含以下每個任務的 API，這些任務通常與資料庫使用相關聯。

連線到資料庫。
建立 SQL 或 MySQL 語句。
在資料庫中執行 SQL 或 MySQL 查詢。
檢視和修改結果記錄。

從根本上說，JDBC 是一種規範，它提供了一組完整的介面，允許以可移植的方式訪問底層資料庫。Java 可用於編寫不同型別的可執行檔案，例如 -

Java 應用程式
Java Applet
Java Servlet
Java ServerPages (JSP)
企業 JavaBeans (EJB)。

所有這些不同的可執行檔案都能夠使用 JDBC 驅動程式訪問資料庫並利用儲存的資料。

JDBC 提供與 ODBC 相同的功能，允許 Java 程式包含獨立於資料庫的程式碼。

先決條件

在繼續學習之前，您需要對以下兩個主題有很好的瞭解 -

JDBC 架構

JDBC API 支援用於資料庫訪問的兩層和三層處理模型，但通常，JDBC 架構由兩層組成 -

**JDBC API** - 提供應用程式到 JDBC 管理器的連線。
**JDBC 驅動程式 API** - 支援 JDBC 管理器到驅動程式的連線。

JDBC API 使用驅動程式管理器和特定於資料庫的驅動程式來提供對異構資料庫的透明連線。

JDBC 驅動程式管理器確保使用正確的驅動程式訪問每個資料來源。驅動程式管理器能夠支援連線到多個異構資料庫的多個併發驅動程式。

以下是架構圖，它顯示了驅動程式管理器相對於 JDBC 驅動程式和 Java 應用程式的位置 -

常見的 JDBC 元件

JDBC API 提供以下介面和類 -

**DriverManager** - 此類管理資料庫驅動程式列表。使用通訊子協議將來自 Java 應用程式的連線請求與正確的資料庫驅動程式匹配。第一個識別 JDBC 下某個特定子協議的驅動程式將用於建立資料庫連線。
**Driver** - 此介面處理與資料庫伺服器的通訊。您很少會直接與 Driver 物件互動。相反，您使用 DriverManager 物件，它管理此型別的物件。它還抽象了與使用 Driver 物件相關的細節。
**Connection** - 此介面包含所有用於聯絡資料庫的方法。連線物件表示通訊上下文，即所有與資料庫的通訊都僅透過連線物件進行。
**Statement** - 您使用從此介面建立的物件將 SQL 語句提交到資料庫。一些派生介面除了執行儲存過程外還接受引數。
**ResultSet** - 這些物件在使用 Statement 物件執行 SQL 查詢後儲存從資料庫檢索到的資料。它充當迭代器，允許您遍歷其資料。
**SQLException** - 此類處理資料庫應用程式中發生的任何錯誤。

JDBC 4.0 包

java.sql 和 javax.sql 是 JDBC 4.0 的主要包。這是撰寫本教程時的最新 JDBC 版本。它提供了與資料來源互動的主要類。

這些包中的新功能包括以下方面的更改 -

自動載入資料庫驅動程式。
異常處理改進。
增強的 BLOB/CLOB 功能。
連線和語句介面增強。
國家字元集支援。
SQL ROWID 訪問。
SQL 2003 XML 資料型別支援。
註解。

JDBC - SQL 語法

**S**tructured **Q**uery **L**anguage (SQL) 是一種標準化語言，允許您對資料庫執行操作，例如建立條目、讀取內容、更新內容和刪除條目。

SQL 幾乎受您可能使用的任何資料庫支援，它允許您編寫獨立於底層資料庫的資料庫程式碼。

本章概述了 SQL，這是理解 JDBC 概念的先決條件。在閱讀完本章後，您將能夠建立、讀取、更新和刪除（通常稱為 **CRUD** 操作）資料庫中的資料。

要詳細瞭解 SQL，您可以閱讀我們的 MySQL 教程。

建立資料庫

CREATE DATABASE 語句用於建立新的資料庫。語法如下 -

SQL> CREATE DATABASE DATABASE_NAME;

示例

以下 SQL 語句建立一個名為 EMP 的資料庫 -

SQL> CREATE DATABASE EMP;

刪除資料庫

DROP DATABASE 語句用於刪除現有資料庫。語法如下 -

SQL> DROP DATABASE DATABASE_NAME;

**注意** - 要建立或刪除資料庫，您必須在資料庫伺服器上具有管理員許可權。請謹慎操作，刪除資料庫將導致資料庫中儲存的所有資料丟失。

建立表

CREATE TABLE 語句用於建立新表。語法如下 -

SQL> CREATE TABLE table_name
(
   column_name column_data_type,
   column_name column_data_type,
   column_name column_data_type
   ...
);

示例

以下 SQL 語句建立一個名為 Employees 的表，其中包含四個列 -

SQL> CREATE TABLE Employees
(
   id INT NOT NULL,
   age INT NOT NULL,
   first VARCHAR(255),
   last VARCHAR(255),
   PRIMARY KEY ( id )
);

刪除表

DROP TABLE 語句用於刪除現有表。語法如下 -

SQL> DROP TABLE table_name;

示例

以下 SQL 語句刪除名為 Employees 的表 -

SQL> DROP TABLE Employees;

插入資料

INSERT 的語法如下所示，其中 column1、column2 等代表將出現在相應列中的新資料 -

SQL> INSERT INTO table_name VALUES (column1, column2, ...);

示例

以下 SQL INSERT 語句在之前建立的 Employees 資料庫中插入新行 -

SQL> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');

選擇資料

SELECT 語句用於從資料庫中檢索資料。SELECT 的語法如下 -

SQL> SELECT column_name, column_name, ...
     FROM table_name
     WHERE conditions;

WHERE 子句可以使用比較運算子，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 運算子。

示例

以下 SQL 語句從 Employees 表中選擇 age、first 和 last 列，其中 id 列為 100 -

SQL> SELECT first, last, age 
     FROM Employees 
     WHERE id = 100;

以下 SQL 語句從 Employees 表中選擇 age、first 和 last 列，其中 *first* 列包含 *Zara* -

SQL> SELECT first, last, age 
     FROM Employees 
     WHERE first LIKE '%Zara%';

更新資料

UPDATE 語句用於更新資料。UPDATE 的語法如下 -

SQL> UPDATE table_name
     SET column_name = value, column_name = value, ...
     WHERE conditions;

WHERE 子句可以使用比較運算子，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 運算子。

示例

以下 SQL UPDATE 語句更改 id 為 100 的員工的 age 列 -

SQL> UPDATE Employees SET age=20 WHERE id=100;

刪除資料

DELETE 語句用於從表中刪除資料。DELETE 的語法如下 -

SQL> DELETE FROM table_name WHERE conditions;

WHERE 子句可以使用比較運算子，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 運算子。

示例

以下 SQL DELETE 語句刪除 id 為 100 的員工的記錄 -

SQL> DELETE FROM Employees WHERE id=100;

JDBC - 環境配置

要開始使用 JDBC 進行開發，您應該按照以下步驟設定 JDBC 環境。我們假設您正在 Windows 平臺上工作。

安裝 Java

Java SE 可免費下載。要下載請點選此處，請下載與您的作業系統相容的版本。

按照說明下載 Java，然後執行 **.exe** 檔案以在您的計算機上安裝 Java。在您的計算機上安裝 Java 後，您需要設定環境變數以指向正確的安裝目錄。

為 Windows 2000/XP 設定路徑

假設您已將 Java 安裝在 c:\Program Files\java\jdk 目錄中 -

右鍵單擊“我的電腦”，然後選擇“屬性”。
在“高階”選項卡下單擊“環境變數”按鈕。
現在，編輯“Path”變數，並在其末尾新增 Java 可執行檔案目錄的路徑。例如，如果路徑當前設定為 `C:\Windows\System32`，則按以下方式編輯它

C:\Windows\System32;c:\Program Files\java\jdk\bin

為 Windows 95/98/ME 設定路徑

假設您已將 Java 安裝在 c:\Program Files\java\jdk 目錄中 -

編輯“C:\autoexec.bat”檔案，並在末尾新增以下行 -

SET PATH = %PATH%;C:\Program Files\java\jdk\bin

為 Linux、UNIX、Solaris、FreeBSD 設定路徑

環境變數 PATH 應設定為指向 Java 二進位制檔案安裝的位置。如果您在執行此操作時遇到問題，請參考您的 shell 文件。

例如，如果您使用 bash 作為您的 shell，則您將在您的 **.bashrc** 檔案末尾新增以下行 -

export PATH = /path/to/java:$PATH'

安裝 J2SE 開發工具包後，您將自動獲得兩個 JDBC 包 **java.sql** 和 **javax.sql**。

安裝資料庫

當然，您將需要最重要的東西是一個實際執行的資料庫，其中包含您可以查詢和修改的表。

安裝最適合您的資料庫。您可以有很多選擇，最常見的是 -

**MySQL DB** - MySQL 是一個開源資料庫。您可以從 MySQL 官方網站下載它。我們建議下載完整的 Windows 安裝程式。

此外，下載並安裝 MySQL Administrator 以及 MySQL Query Browser。這些是基於 GUI 的工具，將使您的開發更加輕鬆。

最後，下載並解壓縮 MySQL Connector/J（MySQL JDBC 驅動程式）到一個方便的目錄中。在本教程中，我們將假設您已將驅動程式安裝在 C:\Program Files\MySQL\mysql-connector-java-5.1.8 中。

相應地，將 CLASSPATH 變數設定為 C:\Program Files\MySQL\mysql-connector-java-5.1.8\mysql-connector-java-5.1.8-bin.jar。您的驅動程式版本可能因您的安裝而異。

設定資料庫憑據

當我們安裝 MySQL 資料庫時，其管理員 ID 設定為 **root**，並且它允許您設定您選擇的密碼。

使用 root ID 和密碼，您可以建立另一個使用者 ID 和密碼，或者您可以使用 root ID 和密碼用於您的 JDBC 應用程式。

有各種資料庫操作，例如資料庫建立和刪除，這需要管理員 ID 和密碼。

對於 JDBC 教程的其餘部分，我們將使用 MySQL 資料庫，其中 ID 為 **guest**，密碼為 **guest123**。

如果您沒有足夠的許可權來建立新使用者，那麼您可以要求您的資料庫管理員 (DBA) 為您建立一個使用者 ID 和密碼。

建立資料庫

要建立 **TUTORIALSPOINT** 資料庫，請執行以下步驟 -

步驟 1

開啟 **命令提示符** 並更改為安裝目錄，如下所示 -

C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>

**注意** - **mysqld.exe** 的路徑可能因 MySQL 在系統上的安裝位置而異。您還可以檢視有關如何啟動和停止資料庫伺服器的文件。

步驟 2

如果資料庫伺服器尚未執行，請執行以下命令啟動它。

C:\Program Files\MySQL\bin>mysqld
C:\Program Files\MySQL\bin>

步驟 3

透過執行以下命令建立TUTORIALSPOINT資料庫：

C:\Program Files\MySQL\bin> mysqladmin create TUTORIALSPOINT -u guest -p
Enter password: ********
C:\Program Files\MySQL\bin>

建立表

要在TUTORIALSPOINT資料庫中建立Employees表，請使用以下步驟：

步驟 1

開啟 **命令提示符** 並更改為安裝目錄，如下所示 -

C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>

步驟 2

如下登入資料庫：

C:\Program Files\MySQL\bin>mysql -u guest -p
Enter password: ********
mysql>

步驟 3

如下建立Employees表：

mysql> use TUTORIALSPOINT;
mysql> create table Employees
    -> (
    -> id int not null,
    -> age int not null,
    -> first varchar (255),
    -> last varchar (255)
    -> );
Query OK, 0 rows affected (0.08 sec)
mysql>

建立資料記錄

最後，您需要在Employee表中建立一些記錄，如下所示：

mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)

mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)

mysql>

要全面瞭解MySQL資料庫，請學習MySQL教程。

現在您已準備好開始使用JDBC進行實驗。下一章將為您提供一個JDBC程式設計的示例。

JDBC - 示例程式碼

本章提供了一個如何建立簡單JDBC應用程式的示例。這將向您展示如何開啟資料庫連線、執行SQL查詢以及顯示結果。

本模板示例中提到的所有步驟都將在本教程的後續章節中進行解釋。

建立JDBC應用程式

構建JDBC應用程式涉及以下六個步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立一個Connection物件，該物件表示與資料庫的物理連線。
執行查詢 - 需要使用Statement型別的物件來構建和提交SQL語句到資料庫。
從結果集中提取資料 - 需要使用適當的ResultSet.getXXX()方法從結果集中檢索資料。
清理環境 - 需要顯式地關閉所有資料庫資源，而不是依賴JVM的垃圾回收。

示例程式碼

此示例可以作為您將來需要建立自己的JDBC應用程式時的模板。

此示例程式碼是基於上一章中完成的環境和資料庫設定編寫的。

將以下示例複製並貼上到FirstExample.java中，編譯並執行如下：

import java.sql.*;

public class FirstExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Employees";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(QUERY);) {
         // Extract data from result set
         while (rs.next()) {
            // Retrieve by column name
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac FirstExample.java
C:\>

執行FirstExample時，會產生以下結果：

C:\>java FirstExample
Connecting to database...
Creating statement...
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - 驅動程式型別

什麼是JDBC驅動程式？

JDBC驅動程式實現了JDBC API中定義的介面，用於與您的資料庫伺服器互動。

例如，使用JDBC驅動程式可以開啟資料庫連線，並透過傳送SQL或資料庫命令與之互動，然後使用Java接收結果。

JDK附帶的Java.sql包包含各種類及其定義的行為，其實際實現是在第三方驅動程式中完成的。第三方供應商在其資料庫驅動程式中實現了java.sql.Driver介面。

JDBC驅動程式型別

JDBC驅動程式的實現有所不同，因為Java執行在各種各樣的作業系統和硬體平臺上。Sun將實現型別分為四類：型別1、2、3和4，下面將對其進行解釋：

型別1 - JDBC-ODBC橋接驅動程式

在型別1驅動程式中，使用JDBC橋接來訪問安裝在每個客戶端機器上的ODBC驅動程式。使用ODBC需要在您的系統上配置一個數據源名稱（DSN），該名稱表示目標資料庫。

當Java剛釋出時，這是一個有用的驅動程式，因為大多數資料庫只支援ODBC訪問，但現在這種型別的驅動程式僅推薦用於實驗用途或在沒有其他替代方案可用時使用。

JDK 1.2附帶的JDBC-ODBC橋接是這種驅動程式的一個很好的例子。

型別2 - JDBC-Native API

在型別2驅動程式中，JDBC API呼叫被轉換為特定於資料庫的本機C/C++ API呼叫。這些驅動程式通常由資料庫供應商提供，並以與JDBC-ODBC橋接相同的方式使用。必須在每個客戶端機器上安裝供應商特定的驅動程式。

如果我們更改資料庫，則必須更改本機API，因為它特定於某個資料庫，並且現在大多數都已過時，但是使用型別2驅動程式可能會提高一些速度，因為它消除了ODBC的開銷。

Oracle呼叫介面（OCI）驅動程式是型別2驅動程式的一個示例。

型別3 - JDBC-Net純Java

在型別3驅動程式中，使用三層方法來訪問資料庫。JDBC客戶端使用標準網路套接字與中介軟體應用程式伺服器通訊。然後，套接字資訊由中介軟體應用程式伺服器轉換為DBMS所需的呼叫格式，並轉發到資料庫伺服器。

這種型別的驅動程式非常靈活，因為它不需要在客戶端安裝任何程式碼，並且單個驅動程式實際上可以提供對多個數據庫的訪問。

您可以將應用程式伺服器視為JDBC“代理”，這意味著它代表客戶端應用程式進行呼叫。因此，您需要了解應用程式伺服器的配置才能有效地使用此驅動程式型別。

您的應用程式伺服器可能會使用型別1、2或4驅動程式與資料庫通訊，瞭解細微差別將非常有幫助。

型別4 - 100%純Java

在型別4驅動程式中，基於純Java的驅動程式透過套接字連線直接與供應商的資料庫通訊。這是資料庫中最有效的驅動程式，通常由供應商本身提供。

這種型別的驅動程式非常靈活，您不需要在客戶端或伺服器上安裝特殊的軟體。此外，這些驅動程式可以動態下載。

MySQL的Connector/J驅動程式是型別4驅動程式。由於其網路協議的專有性，資料庫供應商通常提供型別4驅動程式。

應該使用哪個驅動程式？

如果您正在訪問一種型別的資料庫，例如Oracle、Sybase或IBM，則首選的驅動程式型別是4。

如果您的Java應用程式同時訪問多種型別的資料庫，則型別3是首選的驅動程式。

型別2驅動程式在型別3或型別4驅動程式尚未可用於您的資料庫的情況下很有用。

型別1驅動程式不被視為部署級驅動程式，通常僅用於開發和測試目的。

JDBC - 連線

安裝了相應的驅動程式後，就可以使用JDBC建立資料庫連線了。

建立JDBC連線所涉及的程式設計非常簡單。以下是這四個簡單的步驟：

匯入JDBC包 - 在您的Java程式中新增import語句，以匯入Java程式碼中所需的類。
註冊JDBC驅動程式 - 此步驟會導致JVM將所需的驅動程式實現載入到記憶體中，以便它可以滿足您的JDBC請求。
資料庫URL制定 - 這是建立指向要連線的資料庫的格式正確的地址。
建立連線物件 - 最後，編寫對DriverManager物件的getConnection( )方法的呼叫以建立實際的資料庫連線。

匯入JDBC包

Import語句告訴Java編譯器在哪裡可以找到程式碼中引用的類，並且放置在原始碼的開頭。

要使用標準JDBC包（允許您在SQL表中選擇、插入、更新和刪除資料），請將以下import新增到原始碼中：

import java.sql.* ;  // for standard JDBC programs
import java.math.* ; // for BigDecimal and BigInteger support

註冊JDBC驅動程式

在使用驅動程式之前，必須在程式中註冊它。註冊驅動程式是將Oracle驅動程式的類檔案載入到記憶體中的過程，以便可以將其用作JDBC介面的實現。

您只需要在程式中註冊一次驅動程式。您可以透過兩種方式之一註冊驅動程式。

方法一 - Class.forName()

註冊驅動程式最常見的方法是使用Java的Class.forName()方法，動態地將驅動程式的類檔案載入到記憶體中，這會自動註冊它。此方法是首選方法，因為它允許您使驅動程式註冊可配置且可移植。

以下示例使用Class.forName( )來註冊Oracle驅動程式：

try {
   Class.forName("oracle.jdbc.driver.OracleDriver");
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}

您可以使用getInstance()方法解決不相容的JVM，但是您必須為另外兩個異常編寫程式碼，如下所示：

try {
   Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
catch(IllegalAccessException ex) {
   System.out.println("Error: access problem while loading!");
   System.exit(2);
catch(InstantiationException ex) {
   System.out.println("Error: unable to instantiate driver!");
   System.exit(3);
}

方法二 - DriverManager.registerDriver()

您可以用來註冊驅動程式的第二種方法是使用靜態DriverManager.registerDriver()方法。

如果您使用的是非JDK相容的JVM（例如Microsoft提供的JVM），則應使用registerDriver()方法。

以下示例使用registerDriver()來註冊Oracle驅動程式：

try {
   Driver myDriver = new oracle.jdbc.driver.OracleDriver();
   DriverManager.registerDriver( myDriver );
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}

資料庫URL制定

載入驅動程式後，可以使用DriverManager.getConnection()方法建立連線。為了便於參考，我列出了三個過載的DriverManager.getConnection()方法：

getConnection(String url)
getConnection(String url, Properties prop)
getConnection(String url, String user, String password)

這裡每種形式都需要一個數據庫URL。資料庫URL是指向資料庫的地址。

制定資料庫URL是建立連線時出現的大多數問題所在。

下表列出了常用的JDBC驅動程式名稱和資料庫URL。

RDBMS	JDBC驅動程式名稱	URL格式
MySQL	com.mysql.jdbc.Driver	jdbc:mysql://主機名/資料庫名稱
ORACLE	oracle.jdbc.driver.OracleDriver	jdbc:oracle:thin:@主機名:埠號:資料庫名稱
DB2	COM.ibm.db2.jdbc.net.DB2Driver	jdbc:db2:主機名:埠號/資料庫名稱
Sybase	com.sybase.jdbc.SybDriver	jdbc:sybase:Tds:主機名:埠號/資料庫名稱

URL格式中所有突出顯示的部分都是靜態的，您只需要根據資料庫設定更改其餘部分。

建立連線物件

我們列出了三種形式的DriverManager.getConnection()方法來建立連線物件。

使用帶有使用者名稱和密碼的資料庫URL

getConnection()最常用的形式要求您傳遞資料庫URL、使用者名稱和密碼：

假設您使用的是Oracle的thin驅動程式，您將為URL的資料庫部分指定主機:埠:資料庫名稱值。

如果您在TCP/IP地址192.0.0.1處有一個主機，主機名為amrood，並且您的Oracle監聽器配置為偵聽埠1521，並且您的資料庫名為EMP，則完整的資料庫URL將為：

jdbc:oracle:thin:@amrood:1521:EMP

現在您必須使用適當的使用者名稱和密碼呼叫getConnection()方法以獲取Connection物件，如下所示：

String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
String USER = "username";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);

僅使用資料庫URL

DriverManager.getConnection() 方法的第二種形式只需要一個數據庫 URL。

DriverManager.getConnection(String url);

但是，在這種情況下，資料庫 URL 包含使用者名稱和密碼，並具有以下通用形式：

jdbc:oracle:driver:username/password@database

因此，上述連線可以如下建立：

String URL = "jdbc:oracle:thin:username/password@amrood:1521:EMP";
Connection conn = DriverManager.getConnection(URL);

使用資料庫 URL 和屬性物件

DriverManager.getConnection() 方法的第三種形式需要一個數據庫 URL 和一個 Properties 物件。

DriverManager.getConnection(String url, Properties info);

Properties 物件儲存一組關鍵字-值對。它用於在呼叫 getConnection() 方法期間將驅動程式屬性傳遞給驅動程式。

要建立與前面示例相同的連線，請使用以下程式碼：

import java.util.*;

String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
Properties info = new Properties( );
info.put( "user", "username" );
info.put( "password", "password" );

Connection conn = DriverManager.getConnection(URL, info);

關閉 JDBC 連線

在 JDBC 程式的末尾，需要顯式關閉所有與資料庫的連線以結束每個資料庫會話。但是，如果您忘記了，Java 的垃圾收集器將在清理過時物件時關閉連線。

依賴垃圾收集，尤其是在資料庫程式設計中，是一種非常糟糕的程式設計實踐。您應該養成始終使用與連線物件關聯的 close() 方法關閉連線的習慣。

為了確保連線已關閉，您可以在程式碼中提供一個“finally”塊。finally 塊始終執行，無論是否發生異常。

要關閉上述開啟的連線，應如下呼叫 close() 方法：

conn.close();

顯式關閉連線可以節省 DBMS 資源，這將使您的資料庫管理員感到高興。

為了更好地理解，我們建議您學習我們的 JDBC - 示例程式碼教程。

JDBC - 語句

獲得連線後，我們可以與資料庫互動。JDBC 的Statement、CallableStatement 和PreparedStatement 介面定義了允許您傳送 SQL 或 PL/SQL 命令並從資料庫接收資料的方法和屬性。

它們還定義了有助於彌合 Java 和資料庫中使用的 SQL 資料型別之間資料型別差異的方法。

下表總結了每個介面的目的，以決定使用哪個介面。

介面	推薦用途
Statement	將其用於對資料庫的通用訪問。在執行時使用靜態 SQL 語句時很有用。Statement 介面不能接受引數。
PreparedStatement	當您計劃多次使用 SQL 語句時使用它。PreparedStatement 介面在執行時接受輸入引數。
CallableStatement	當您要訪問資料庫儲存過程時使用它。CallableStatement 介面也可以接受執行時輸入引數。

Statement 物件

建立 Statement 物件

在可以使用 Statement 物件執行 SQL 語句之前，需要使用 Connection 物件的 createStatement() 方法建立一個，如下例所示：

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

建立 Statement 物件後，就可以使用它透過其三個 execute 方法之一來執行 SQL 語句。

boolean execute (String SQL)：如果可以檢索 ResultSet 物件，則返回布林值 true；否則，返回 false。使用此方法執行 SQL DDL 語句或當您需要使用真正的動態 SQL 時。
int executeUpdate (String SQL)：返回受 SQL 語句執行影響的行數。使用此方法執行您期望獲得受影響行數的 SQL 語句 - 例如，INSERT、UPDATE 或 DELETE 語句。
ResultSet executeQuery (String SQL)：返回一個 ResultSet 物件。當您期望獲得結果集時使用此方法，就像使用 SELECT 語句一樣。

關閉 Statement 物件

就像關閉 Connection 物件以節省資料庫資源一樣，出於同樣的原因，您也應該關閉 Statement 物件。

簡單地呼叫 close() 方法即可完成工作。如果您首先關閉 Connection 物件，它也會關閉 Statement 物件。但是，您應該始終顯式關閉 Statement 物件以確保正確清理。

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   stmt.close();
}

為了更好地理解，我們建議您學習 Statement - 示例教程。

PreparedStatement 物件

PreparedStatement 介面擴充套件了 Statement 介面，這為您提供了額外的功能，並且與通用 Statement 物件相比具有一些優勢。

此語句使您可以靈活地動態提供引數。

建立 PreparedStatement 物件

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

JDBC 中的所有引數都由？符號表示，該符號稱為引數標記。在執行 SQL 語句之前，必須為每個引數提供值。

setXXX() 方法將值繫結到引數，其中XXX表示您希望繫結到輸入引數的值的 Java 資料型別。如果您忘記提供值，將會收到 SQLException。

每個引數標記由其序數位置引用。第一個標記表示位置 1，下一個表示位置 2，依此類推。此方法不同於 Java 陣列索引，Java 陣列索引從 0 開始。

所有用於與資料庫互動的Statement 物件的方法（a）execute()、（b）executeQuery() 和（c）executeUpdate() 也適用於 PreparedStatement 物件。但是，這些方法已修改為使用可以輸入引數的 SQL 語句。

關閉 PreparedStatement 物件

就像關閉 Statement 物件一樣，出於同樣的原因，您也應該關閉 PreparedStatement 物件。

簡單地呼叫 close() 方法即可完成工作。如果您首先關閉 Connection 物件，它也會關閉 PreparedStatement 物件。但是，您應該始終顯式關閉 PreparedStatement 物件以確保正確清理。

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   pstmt.close();
}

為了更好地理解，讓我們學習 Prepare - 示例程式碼。

CallableStatement 物件

就像 Connection 物件建立 Statement 和 PreparedStatement 物件一樣，它也建立 CallableStatement 物件，該物件將用於執行對資料庫儲存過程的呼叫。

建立 CallableStatement 物件

假設您需要執行以下 Oracle 儲存過程：

CREATE OR REPLACE PROCEDURE getEmpName 
   (EMP_ID IN NUMBER, EMP_FIRST OUT VARCHAR) AS
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END;

注意：上述儲存過程是為 Oracle 編寫的，但我們使用的是 MySQL 資料庫，因此讓我們按如下方式為 MySQL 編寫相同的儲存過程，以便在 EMP 資料庫中建立它：

DELIMITER $$

DROP PROCEDURE IF EXISTS `EMP`.`getEmpName` $$
CREATE PROCEDURE `EMP`.`getEmpName` 
   (IN EMP_ID INT, OUT EMP_FIRST VARCHAR(255))
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END $$

DELIMITER ;

存在三種類型的引數：IN、OUT 和 INOUT。PreparedStatement 物件僅使用 IN 引數。CallableStatement 物件可以使用所有三個引數。

以下是每個引數的定義：

引數	描述
IN	在建立 SQL 語句時值未知的引數。您可以使用 setXXX() 方法將值繫結到 IN 引數。
OUT	由其返回的 SQL 語句提供的引數值。您可以使用 getXXX() 方法從 OUT 引數中檢索值。
INOUT	提供輸入和輸出值的引數。您可以使用 setXXX() 方法繫結變數，並使用 getXXX() 方法檢索值。

以下程式碼片段顯示瞭如何使用Connection.prepareCall() 方法根據前面的儲存過程例項化CallableStatement 物件：

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

String 變數 SQL 表示儲存過程，其中包含引數佔位符。

使用 CallableStatement 物件的方式與使用 PreparedStatement 物件非常相似。在執行語句之前，必須將值繫結到所有引數，否則將收到 SQLException。

如果您有 IN 引數，只需遵循適用於 PreparedStatement 物件的相同規則和技術；使用與您正在繫結的 Java 資料型別相對應的 setXXX() 方法。

當您使用 OUT 和 INOUT 引數時，必須使用其他 CallableStatement 方法 registerOutParameter()。registerOutParameter() 方法將 JDBC 資料型別繫結到儲存過程預期返回的資料型別。

呼叫儲存過程後，您可以使用適當的 getXXX() 方法從 OUT 引數中檢索值。此方法將檢索到的 SQL 型別的值轉換為 Java 資料型別。

關閉 CallableStatement 物件

就像關閉其他 Statement 物件一樣，出於同樣的原因，您也應該關閉 CallableStatement 物件。

簡單地呼叫 close() 方法即可完成工作。如果您首先關閉 Connection 物件，它也會關閉 CallableStatement 物件。但是，您應該始終顯式關閉 CallableStatement 物件以確保正確清理。

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   cstmt.close();
}

為了更好地理解，我建議您學習 Callable - 示例程式碼。

JDBC - 結果集

讀取資料庫查詢資料的 SQL 語句將資料返回到結果集中。SELECT 語句是從資料庫中選擇行並在結果集中檢視它們的標準方法。java.sql.ResultSet 介面表示資料庫查詢的結果集。

ResultSet 物件維護一個指向結果集中當前行的遊標。“結果集”一詞是指 ResultSet 物件中包含的行和列資料。

ResultSet 介面的方法可以分為三類：

導航方法：用於在遊標周圍移動。
獲取方法：用於檢視遊標指向的當前行的列中的資料。
更新方法：用於更新當前行的列中的資料。然後也可以在底層資料庫中更新這些更新。

遊標是根據 ResultSet 的屬性可移動的。這些屬性是在建立生成 ResultSet 的相應 Statement 時指定的。

JDBC 提供以下連線方法來建立具有所需 ResultSet 的語句：

createStatement(int RSType, int RSConcurrency);
prepareStatement(String SQL, int RSType, int RSConcurrency);
prepareCall(String sql, int RSType, int RSConcurrency);

第一個引數指示 ResultSet 物件的型別，第二個引數是兩個 ResultSet 常量之一，用於指定結果集是隻讀的還是可更新的。

ResultSet 型別

可能的 RSType 如下所示。如果您未指定任何 ResultSet 型別，則將自動獲得一個 TYPE_FORWARD_ONLY 型別的結果集。

型別	描述
ResultSet.TYPE_FORWARD_ONLY	遊標只能在結果集中向前移動。
ResultSet.TYPE_SCROLL_INSENSITIVE	遊標可以向前和向後滾動，並且結果集對結果集建立後其他人對資料庫所做的更改不敏感。
ResultSet.TYPE_SCROLL_SENSITIVE。	遊標可以向前和向後滾動，並且結果集對結果集建立後其他人對資料庫所做的更改敏感。

ResultSet 的併發性

下面給出可能的 RSConcurrency。如果未指定任何併發型別，則會自動獲得一個 CONCUR_READ_ONLY 型別。

併發性	描述
ResultSet.CONCUR_READ_ONLY	建立一個只讀結果集。這是預設設定
ResultSet.CONCUR_UPDATABLE	建立一個可更新的結果集。

到目前為止我們編寫的所有示例都可以按如下方式編寫，它初始化一個 Statement 物件以建立一個只向前、只讀的 ResultSet 物件 -

try {
   Statement stmt = conn.createStatement(
                           ResultSet.TYPE_FORWARD_ONLY,
                           ResultSet.CONCUR_READ_ONLY);
}
catch(Exception ex) {
   ....
}
finally {
   ....
}

導航結果集

ResultSet 介面中包含幾個涉及移動遊標的方法，包括 -

序號	方法和描述
1	public void beforeFirst() throws SQLException 將遊標移動到第一行之前。
2	public void afterLast() throws SQLException 將遊標移動到最後一行之後。
3	public boolean first() throws SQLException 將遊標移動到第一行。
4	public void last() throws SQLException 將遊標移動到最後一行。
5	public boolean absolute(int row) throws SQLException 將遊標移動到指定行。
6	public boolean relative(int row) throws SQLException 從遊標當前指向的位置向前或向後移動給定行數。
7	public boolean previous() throws SQLException 將遊標移動到前一行。如果前一行超出結果集範圍，則此方法返回 false。
8	public boolean next() throws SQLException 將遊標移動到下一行。如果結果集中沒有更多行，則此方法返回 false。
9	public int getRow() throws SQLException 返回遊標指向的行號。
10	public void moveToInsertRow() throws SQLException 將遊標移動到結果集中的一個特殊行，該行可用於將新行插入資料庫。會記住當前遊標位置。
11	public void moveToCurrentRow() throws SQLException 如果遊標當前位於插入行，則將遊標移回當前行；否則，此方法不執行任何操作

為了更好地理解，讓我們學習導航 - 示例程式碼。

檢視結果集

ResultSet 介面包含數十個用於獲取當前行資料的方法。

每種可能的資料型別都有一個 get 方法，並且每個 get 方法都有兩個版本 -

一個接受列名。
一個接受列索引。

例如，如果您感興趣的列包含一個 int，則需要使用 ResultSet 的 getInt() 方法之一 -

序號	方法和描述
1	public int getInt(String columnName) throws SQLException 返回名為 columnName 的列中當前行中的 int。
2	public int getInt(int columnIndex) throws SQLException 返回指定列索引中當前行中的 int。列索引從 1 開始，這意味著行的第一列為 1，行的第二列為 2，依此類推。

類似地，ResultSet 介面中為所有八種 Java 基本資料型別以及 java.lang.String、java.lang.Object 和 java.net.URL 等常見型別提供了 get 方法。

還有一些方法可以獲取 SQL 資料型別 java.sql.Date、java.sql.Time、java.sql.TimeStamp、java.sql.Clob 和 java.sql.Blob。請檢視文件以獲取有關使用這些 SQL 資料型別的更多資訊。

為了更好地理解，讓我們學習檢視 - 示例程式碼。

更新結果集

ResultSet 介面包含一組用於更新結果集資料的方法。

與 get 方法一樣，每種資料型別都有兩個 update 方法 -

一個接受列名。
一個接受列索引。

例如，要更新結果集當前行的 String 列，可以使用以下 updateString() 方法之一 -

序號	方法和描述
1	public void updateString(int columnIndex, String s) throws SQLException 將指定列中的 String 更改為 s 的值。
2	public void updateString(String columnName, String s) throws SQLException 與上一個方法類似，只是列由其名稱而不是索引指定。

有八種基本資料型別的 update 方法，以及 String、Object、URL 和 java.sql 包中的 SQL 資料型別。

更新結果集中的行會更改 ResultSet 物件中當前行的列，但不會更改底層資料庫。要將對資料庫中行的更改更新，需要呼叫以下方法之一。

序號	方法和描述
1	public void updateRow() 透過更新資料庫中的相應行來更新當前行。
2	public void deleteRow() 從資料庫中刪除當前行
3	public void refreshRow() 重新整理結果集中的資料以反映資料庫中的任何最新更改。
4	public void cancelRowUpdates() 取消對當前行所做的任何更新。
5	public void insertRow() 將一行插入資料庫。只有當遊標指向插入行時才能呼叫此方法。

為了更好地理解，讓我們學習更新 - 示例程式碼。

JDBC - 資料型別

JDBC 驅動程式在將 Java 資料型別傳送到資料庫之前將其轉換為相應的 JDBC 型別。它對大多數資料型別使用預設對映。例如，Java int 轉換為 SQL INTEGER。建立預設對映是為了在驅動程式之間提供一致性。

下表總結了呼叫 PreparedStatement 或 CallableStatement 物件的 setXXX() 方法或 ResultSet.updateXXX() 方法時 Java 資料型別轉換為的預設 JDBC 資料型別。

SQL	JDBC/Java	setXXX	updateXXX
VARCHAR	java.lang.String	setString	updateString
CHAR	java.lang.String	setString	updateString
LONGVARCHAR	java.lang.String	setString	updateString
BIT	boolean	setBoolean	updateBoolean
NUMERIC	java.math.BigDecimal	setBigDecimal	updateBigDecimal
TINYINT	byte	setByte	updateByte
SMALLINT	short	setShort	updateShort
INTEGER	int	setInt	updateInt
BIGINT	long	setLong	updateLong
REAL	float	setFloat	updateFloat
FLOAT	float	setFloat	updateFloat
DOUBLE	double	setDouble	updateDouble
VARBINARY	byte[ ]	setBytes	updateBytes
BINARY	byte[ ]	setBytes	updateBytes
DATE	java.sql.Date	setDate	updateDate
TIME	java.sql.Time	setTime	updateTime
TIMESTAMP	java.sql.Timestamp	setTimestamp	updateTimestamp
CLOB	java.sql.Clob	setClob	updateClob
BLOB	java.sql.Blob	setBlob	updateBlob
ARRAY	java.sql.Array	setARRAY	updateARRAY
REF	java.sql.Ref	SetRef	updateRef
STRUCT	java.sql.Struct	SetStruct	updateStruct

JDBC 3.0 增強了對 BLOB、CLOB、ARRAY 和 REF 資料型別的支援。ResultSet 物件現在具有 updateBLOB()、updateCLOB()、updateArray() 和 updateRef() 方法，使您能夠直接操作伺服器上的相應資料。

setXXX() 和 updateXXX() 方法使您能夠將特定 Java 型別轉換為特定 JDBC 資料型別。setObject() 和 updateObject() 方法使您能夠將幾乎任何 Java 型別對映到 JDBC 資料型別。

ResultSet 物件為每種資料型別提供相應的 getXXX() 方法以檢索列值。每種方法都可以與列名或其序數位置一起使用。

SQL	JDBC/Java	setXXX	getXXX
VARCHAR	java.lang.String	setString	getString
CHAR	java.lang.String	setString	getString
LONGVARCHAR	java.lang.String	setString	getString
BIT	boolean	setBoolean	getBoolean
NUMERIC	java.math.BigDecimal	setBigDecimal	getBigDecimal
TINYINT	byte	setByte	getByte
SMALLINT	short	setShort	getShort
INTEGER	int	setInt	getInt
BIGINT	long	setLong	getLong
REAL	float	setFloat	getFloat
FLOAT	float	setFloat	getFloat
DOUBLE	double	setDouble	getDouble
VARBINARY	byte[ ]	setBytes	getBytes
BINARY	byte[ ]	setBytes	getBytes
DATE	java.sql.Date	setDate	getDate
TIME	java.sql.Time	setTime	getTime
TIMESTAMP	java.sql.Timestamp	setTimestamp	getTimestamp
CLOB	java.sql.Clob	setClob	getClob
BLOB	java.sql.Blob	setBlob	getBlob
ARRAY	java.sql.Array	setARRAY	getARRAY
REF	java.sql.Ref	SetRef	getRef
STRUCT	java.sql.Struct	SetStruct	getStruct

日期和時間資料型別

java.sql.Date 類對映到 SQL DATE 型別，java.sql.Time 和 java.sql.Timestamp 類分別對映到 SQL TIME 和 SQL TIMESTAMP 資料型別。

以下示例顯示了 Date 和 Time 類如何將標準 Java 日期和時間值格式化為與 SQL 資料型別要求匹配。

import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.*;

public class SqlDateTime {
   public static void main(String[] args) {
      //Get standard date and time
      java.util.Date javaDate = new java.util.Date();
      long javaTime = javaDate.getTime();
      System.out.println("The Java Date is:" + 
             javaDate.toString());

      //Get and display SQL DATE
      java.sql.Date sqlDate = new java.sql.Date(javaTime);
      System.out.println("The SQL DATE is: " + 
             sqlDate.toString());

      //Get and display SQL TIME
      java.sql.Time sqlTime = new java.sql.Time(javaTime);
      System.out.println("The SQL TIME is: " + 
             sqlTime.toString());
      //Get and display SQL TIMESTAMP
      java.sql.Timestamp sqlTimestamp =
      new java.sql.Timestamp(javaTime);
      System.out.println("The SQL TIMESTAMP is: " + 
             sqlTimestamp.toString());
     }//end main
}//end SqlDateTime

現在讓我們如下編譯上述示例：

C:\>javac SqlDateTime.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java SqlDateTime
The Java Date is:Tue Aug 18 13:46:02 GMT+04:00 2009
The SQL DATE is: 2009-08-18
The SQL TIME is: 13:46:02
The SQL TIMESTAMP is: 2009-08-18 13:46:02.828
C:\>

處理 NULL 值

SQL 使用 NULL 值和 Java 使用 null 是不同的概念。因此，要在 Java 中處理 SQL NULL 值，可以使用三種策略 -

避免使用返回基本資料型別的 getXXX( ) 方法。
對基本資料型別使用包裝類，並使用 ResultSet 物件的 wasNull( ) 方法測試接收 getXXX( ) 方法返回值的包裝類變數是否應設定為 null。
使用基本資料型別和 ResultSet 物件的 wasNull( ) 方法測試接收 getXXX( ) 方法返回值的基本變數是否應設定為您選擇表示 NULL 的可接受值。

以下是一個處理 NULL 值的示例 -

Statement stmt = conn.createStatement( );
String sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);

int id = rs.getInt(1);
if( rs.wasNull( ) ) {
   id = 0;
}

JDBC - 事務

如果您的 JDBC 連線處於自動提交模式（預設情況下），則每個 SQL 語句在完成時都會提交到資料庫。

對於簡單的應用程式，這可能很好，但是您可能希望關閉自動提交併管理自己的事務，原因有三個 -

提高效能。
維護業務流程的完整性。
使用分散式事務。

事務使您能夠控制是否以及何時將更改應用於資料庫。它將單個 SQL 語句或一組 SQL 語句視為一個邏輯單元，如果任何語句失敗，則整個事務都會失敗。

為了啟用手動事務支援而不是 JDBC 驅動程式預設使用的自動提交模式，請使用 Connection 物件的setAutoCommit() 方法。如果將布林值 false 傳遞給 setAutoCommit()，則關閉自動提交。您可以傳遞布林值 true 以再次將其開啟。

例如，如果您有一個名為 conn 的 Connection 物件，請編寫以下程式碼以關閉自動提交 -

conn.setAutoCommit(false);

提交 & 回滾

完成更改並想要提交更改後，請在連線物件上呼叫commit() 方法，如下所示 -

conn.commit( );

否則，要回滾使用名為 conn 的 Connection 對資料庫進行的更新，請使用以下程式碼 -

conn.rollback( );

以下示例說明了提交和回滾物件的用法 -

try{
   //Assume a valid connection object conn
   conn.setAutoCommit(false);
   Statement stmt = conn.createStatement();
   
   String SQL = "INSERT INTO Employees  " +
                "VALUES (106, 20, 'Rita', 'Tez')";
   stmt.executeUpdate(SQL);  
   //Submit a malformed SQL statement that breaks
   String SQL = "INSERTED IN Employees  " +
                "VALUES (107, 22, 'Sita', 'Singh')";
   stmt.executeUpdate(SQL);
   // If there is no error.
   conn.commit();
}catch(SQLException se){
   // If there is any error.
   conn.rollback();
}

在這種情況下，以上所有 INSERT 語句都不會成功，所有內容都將回滾。

為了更好地理解，讓我們學習提交 - 示例程式碼。

使用儲存點

新的 JDBC 3.0 儲存點介面為您提供了額外的交易控制。大多數現代 DBMS 在其環境中支援儲存點，例如 Oracle 的 PL/SQL。

設定儲存點時，您在事務中定義了一個邏輯回滾點。如果在儲存點之後發生錯誤，您可以使用回滾方法撤消所有更改或僅撤消儲存點之後進行的更改。

Connection 物件有兩個新方法可以幫助您管理儲存點 -

setSavepoint(String savepointName) - 定義一個新的儲存點。它還返回一個 Savepoint 物件。
releaseSavepoint(Savepoint savepointName) - 刪除儲存點。請注意，它需要一個 Savepoint 物件作為引數。此物件通常是 setSavepoint() 方法生成的儲存點。

有一個rollback (String savepointName) 方法，它將工作回滾到指定的儲存點。

以下示例說明了 Savepoint 物件的用法 -

try{
   //Assume a valid connection object conn
   conn.setAutoCommit(false);
   Statement stmt = conn.createStatement();
   
   //set a Savepoint
   Savepoint savepoint1 = conn.setSavepoint("Savepoint1");
   String SQL = "INSERT INTO Employees " +
                "VALUES (106, 20, 'Rita', 'Tez')";
   stmt.executeUpdate(SQL);  
   //Submit a malformed SQL statement that breaks
   String SQL = "INSERTED IN Employees " +
                "VALUES (107, 22, 'Sita', 'Tez')";
   stmt.executeUpdate(SQL);
   // If there is no error, commit the changes.
   conn.commit();

}catch(SQLException se){
   // If there is any error.
   conn.rollback(savepoint1);
}

在這種情況下，以上所有 INSERT 語句都不會成功，所有內容都將回滾。

為了更好地理解，讓我們學習儲存點 - 示例程式碼。

JDBC - 異常

異常處理允許您以受控方式處理異常情況，例如程式定義的錯誤。

當發生異常情況時，會丟擲異常。術語“丟擲”表示當前程式執行停止，並且控制權將重定向到最近適用的 catch 子句。如果不存在適用的 catch 子句，則程式的執行結束。

JDBC 異常處理與 Java 異常處理非常相似，但對於 JDBC 而言，您將處理的最常見異常是java.sql.SQLException。

SQLException 方法

SQLException 既可能發生在驅動程式中也可能發生在資料庫中。當發生此類異常時，型別為 SQLException 的物件將傳遞給 catch 子句。

傳遞的 SQLException 物件具有以下方法可用於檢索有關異常的更多資訊 -

方法	描述
getErrorCode( )	獲取與異常關聯的錯誤號。
getMessage( )	獲取 JDBC 驅動程式的錯誤訊息（由驅動程式處理），或獲取資料庫錯誤的 Oracle 錯誤號和訊息。
getSQLState( )	獲取 XOPEN SQLstate 字串。對於 JDBC 驅動程式錯誤，此方法不會返回任何有用的資訊。對於資料庫錯誤，將返回五位數的 XOPEN SQLstate 程式碼。此方法可能返回 null。
getNextException( )	獲取異常鏈中的下一個 Exception 物件。
printStackTrace( )	將當前異常或可丟擲物件及其回溯列印到標準錯誤流。
printStackTrace(PrintStream s)	將此可丟擲物件及其回溯列印到您指定的列印流。
printStackTrace(PrintWriter w)	將此可丟擲物件及其回溯列印到您指定的列印寫入器。

透過利用從 Exception 物件獲得的資訊，您可以捕獲異常並適當地繼續您的程式。以下是 try 塊的一般形式 -

try {
   // Your risky code goes between these curly braces!!!
}
catch(Exception ex) {
   // Your exception handling code goes between these 
   // curly braces, similar to the exception clause 
   // in a PL/SQL block.
}
finally {
   // Your must-always-be-executed code goes between these 
   // curly braces. Like closing database connection.
}

示例

學習以下示例程式碼以瞭解try....catch...finally 塊的用法。

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "{call getEmpName (?, ?)}";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         CallableStatement stmt = conn.prepareCall(QUERY);
      ) {		      
         // Bind values into the parameters.
         stmt.setInt(1, 1);  // This would set ID
         // Because second parameter is OUT so register it
         stmt.registerOutParameter(2, java.sql.Types.VARCHAR);
         //Use execute method to run stored procedure.
         System.out.println("Executing stored procedure..." );
         stmt.execute();
         //Retrieve employee name with getXXX method
         String empName = stmt.getString(2);
         System.out.println("Emp Name with ID: 1 is " + empName);
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在，讓我們按如下方式編譯以上示例 -

C:\>javac JDBCExample.java
C:\>

當您執行JDBCExample時，如果沒有任何問題，它會產生以下結果，否則會捕獲相應的錯誤並顯示錯誤訊息 -

C:\>java JDBCExample
Executing stored procedure...
Emp Name with ID: 1 is Zara
C:\>

嘗試透過傳遞錯誤的資料庫名稱或錯誤的使用者名稱或密碼來執行以上示例，並檢查結果。

JDBC - 批處理

批處理允許您將相關的 SQL 語句分組到一個批次中，並使用一次呼叫提交到資料庫。

當您一次向資料庫傳送多個 SQL 語句時，您可以減少通訊開銷，從而提高效能。

JDBC 驅動程式不需要支援此功能。您應該使用DatabaseMetaData.supportsBatchUpdates() 方法來確定目標資料庫是否支援批更新處理。如果您的 JDBC 驅動程式支援此功能，則該方法返回 true。
Statement、PreparedStatement 和CallableStatement 的addBatch() 方法用於將單個語句新增到批次中。executeBatch() 用於開始執行所有一起分組的語句。
executeBatch() 返回一個整數陣列，陣列的每個元素代表相應更新語句的更新計數。
就像您可以將語句新增到批次以進行處理一樣，您也可以使用clearBatch() 方法將其刪除。此方法會刪除您使用 addBatch() 方法新增的所有語句。但是，您無法選擇性地選擇要刪除哪個語句。

使用 Statement 物件進行批處理

以下是使用 Statement 物件進行批處理的典型步驟序列 -

使用createStatement() 方法建立 Statement 物件。
使用setAutoCommit() 將自動提交設定為 false。
使用在建立的語句物件上addBatch() 方法將任意數量的 SQL 語句新增到批處理中。
使用在建立的語句物件上executeBatch() 方法執行所有 SQL 語句。
最後，使用commit() 方法提交所有更改。

示例

以下程式碼片段提供了一個使用 Statement 物件進行批更新的示例 -

// Create statement object
Statement stmt = conn.createStatement();

// Set auto-commit to false
conn.setAutoCommit(false);

// Create SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
             "VALUES(200,'Zia', 'Ali', 30)";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);

// Create one more SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
             "VALUES(201,'Raj', 'Kumar', 35)";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);

// Create one more SQL statement
String SQL = "UPDATE Employees SET age = 35 " +
             "WHERE id = 100";
// Add above SQL statement in the batch.
stmt.addBatch(SQL);

// Create an int[] to hold returned values
int[] count = stmt.executeBatch();

//Explicitly commit statements to apply changes
conn.commit();

為了更好地理解，讓我們學習批處理 - 示例程式碼。

使用 PrepareStatement 物件進行批處理

以下是使用 PrepareStatement 物件進行批處理的典型步驟序列 -

建立帶有佔位符的 SQL 語句。
使用prepareStatement() 方法建立 PrepareStatement 物件。
使用setAutoCommit() 將自動提交設定為 false。
使用在建立的語句物件上addBatch() 方法將任意數量的 SQL 語句新增到批處理中。
使用在建立的語句物件上executeBatch() 方法執行所有 SQL 語句。
最後，使用commit() 方法提交所有更改。

以下程式碼片段提供了一個使用 PrepareStatement 物件進行批更新的示例 -

// Create SQL statement
String SQL = "INSERT INTO Employees (id, first, last, age) " +
             "VALUES(?, ?, ?, ?)";

// Create PrepareStatement object
PreparedStatemen pstmt = conn.prepareStatement(SQL);

//Set auto-commit to false
conn.setAutoCommit(false);

// Set the variables
pstmt.setInt( 1, 400 );
pstmt.setString( 2, "Pappu" );
pstmt.setString( 3, "Singh" );
pstmt.setInt( 4, 33 );
// Add it to the batch
pstmt.addBatch();

// Set the variables
pstmt.setInt( 1, 401 );
pstmt.setString( 2, "Pawan" );
pstmt.setString( 3, "Singh" );
pstmt.setInt( 4, 31 );
// Add it to the batch
pstmt.addBatch();

//add more batches
.
.
.
.
//Create an int[] to hold returned values
int[] count = stmt.executeBatch();

//Explicitly commit statements to apply changes
conn.commit();

為了更好地理解，讓我們學習批處理 - 示例程式碼。

JDBC - 儲存過程

在討論JDBC - 語句章節時，我們已經學習瞭如何在 JDBC 中使用儲存過程。本章與該部分類似，但會為您提供有關 JDBC SQL 轉義語法的更多資訊。

就像 Connection 物件建立 Statement 和 PreparedStatement 物件一樣，它也建立 CallableStatement 物件，該物件將用於執行對資料庫儲存過程的呼叫。

建立 CallableStatement 物件

假設您需要執行以下 Oracle 儲存過程：

CREATE OR REPLACE PROCEDURE getEmpName 
   (EMP_ID IN NUMBER, EMP_FIRST OUT VARCHAR) AS
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END;

注意 - 以上儲存過程是為 Oracle 編寫的，但我們正在使用 MySQL 資料庫，因此讓我們按如下方式為 MySQL 編寫相同的儲存過程，以便在 EMP 資料庫中建立它。

DELIMITER $$

DROP PROCEDURE IF EXISTS `EMP`.`getEmpName` $$
CREATE PROCEDURE `EMP`.`getEmpName` 
   (IN EMP_ID INT, OUT EMP_FIRST VARCHAR(255))
BEGIN
   SELECT first INTO EMP_FIRST
   FROM Employees
   WHERE ID = EMP_ID;
END $$

DELIMITER ;

存在三種類型的引數 - IN、OUT 和 INOUT。PreparedStatement 物件僅使用 IN 引數。CallableStatement 物件可以使用所有三種引數。

以下是每個引數的定義：

引數	描述
IN	在建立 SQL 語句時值未知的引數。您可以使用 setXXX() 方法將值繫結到 IN 引數。
OUT	其值由返回它的 SQL 語句提供的引數。您可以使用 getXXX() 方法檢索 OUT 引數的值。
INOUT	提供輸入和輸出值的引數。您可以使用 setXXX() 方法繫結變數，並使用 getXXX() 方法檢索值。

以下程式碼片段顯示瞭如何使用Connection.prepareCall() 方法根據前面的儲存過程例項化CallableStatement 物件：

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

String 變數 SQL 表示儲存過程，帶有引數佔位符。

使用 CallableStatement 物件很像使用 PreparedStatement 物件。您必須在執行語句之前將值繫結到所有引數，否則您將收到 SQLException。

如果您有 IN 引數，只需遵循適用於 PreparedStatement 物件的相同規則和技術；使用與您正在繫結的 Java 資料型別相對應的 setXXX() 方法。

呼叫儲存過程後，您可以使用適當的 getXXX() 方法從 OUT 引數中檢索值。此方法將檢索到的 SQL 型別的值轉換為 Java 資料型別。

關閉 CallableStatement 物件

就像關閉其他 Statement 物件一樣，出於同樣的原因，您也應該關閉 CallableStatement 物件。

CallableStatement cstmt = null;
try {
   String SQL = "{call getEmpName (?, ?)}";
   cstmt = conn.prepareCall (SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   cstmt.close();
}

學習我們在Callable - 示例程式碼中研究了更多詳細資訊。

JDBC SQL 轉義語法

轉義語法使您可以靈活地使用透過使用標準 JDBC 方法和屬性無法獲得的特定於資料庫的功能。

一般的 SQL 轉義語法格式如下 -

{keyword 'parameters'}

以下是您在執行 JDBC 程式設計時會發現非常有用的轉義序列 -

d、t、ts 關鍵字

它們有助於識別日期、時間和時間戳文字。如您所知，沒有兩個 DBMS 以相同的方式表示時間和日期。此轉義語法告訴驅動程式以目標資料庫的格式呈現日期或時間。例如 -

{d 'yyyy-mm-dd'}

其中 yyyy = 年，mm = 月；dd = 日期。使用此語法 {d '2009-09-03'} 是 2009 年 3 月 9 日。

這是一個簡單的示例，展示瞭如何在表中插入日期 -

//Create a Statement object
stmt = conn.createStatement();
//Insert data ==> ID, First Name, Last Name, DOB
String sql="INSERT INTO STUDENTS VALUES" +
             "(100,'Zara','Ali', {d '2001-12-16'})";

stmt.executeUpdate(sql);

類似地，您可以使用以下兩種語法之一，即t 或ts -

{t 'hh:mm:ss'}

其中 hh = 小時；mm = 分鐘；ss = 秒。使用此語法 {t '13:30:29'} 是下午 1:30:29。

{ts 'yyyy-mm-dd hh:mm:ss'}

這是以上兩種語法 'd' 和 't' 的組合語法，用於表示時間戳。

escape 關鍵字

此關鍵字標識 LIKE 子句中使用的跳脫字元。在使用 SQL 萬用字元 % 時很有用，它匹配零個或多個字元。例如 -

String sql = "SELECT symbol FROM MathSymbols
              WHERE symbol LIKE '\%' {escape '\'}";
stmt.execute(sql);

如果您使用反斜槓字元 (\) 作為跳脫字元，則還必須在 Java 字串文字中使用兩個反斜槓字元，因為反斜槓也是 Java 跳脫字元。

fn 關鍵字

此關鍵字表示 DBMS 中使用的標量函式。例如，您可以使用 SQL 函式length 獲取字串的長度 -

{fn length('Hello World')}

這將返回 11，即字元字串“Hello World”的長度。

call 關鍵字

此關鍵字用於呼叫儲存過程。例如，對於需要 IN 引數的儲存過程，請使用以下語法 -

{call my_procedure(?)};

對於需要 IN 引數並返回 OUT 引數的儲存過程，請使用以下語法 -

{? = call my_procedure(?)};

oj 關鍵字

此關鍵字用於表示外部聯接。語法如下 -

{oj outer-join}

其中 outer-join = table {LEFT|RIGHT|FULL} OUTERJOIN {table | outer-join} on search-condition。例如 -

String sql = "SELECT Employees 
              FROM {oj ThisTable RIGHT
              OUTER JOIN ThatTable on id = '100'}";
stmt.execute(sql);

JDBC - 資料流

PreparedStatement 物件能夠使用輸入和輸出流來提供引數資料。這使您可以將整個檔案放入可以儲存大值的資料庫列中，例如 CLOB 和 BLOB 資料型別。

有以下方法可用於流式傳輸資料 -

setAsciiStream() - 此方法用於提供大型 ASCII 值。
setCharacterStream() - 此方法用於提供大型 UNICODE 值。
setBinaryStream() - 此方法用於提供大型二進位制值。

除了引數佔位符之外，setXXXStream() 方法還需要一個額外的引數，即檔案大小。此引數通知驅動程式應使用流向資料庫傳送多少資料。

此示例將建立一個名為 XML_Data 的資料庫表，然後將 XML 內容寫入此表。

將以下示例複製並貼上到 FirstApplication.java 中，編譯並執行如下 -

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT Data FROM XML_Data WHERE id=100";
   static final String INSERT_QUERY="INSERT INTO XML_Data VALUES (?,?)";
   static final String CREATE_TABLE_QUERY = "CREATE TABLE XML_Data (id INTEGER, Data LONG)";
   static final String DROP_TABLE_QUERY = "DROP TABLE XML_Data";
   static final String XML_DATA = "<Employee><id>100</id><first>Zara</first><last>Ali</last><Salary>10000</Salary><Dob>18-08-1978</Dob></Employee>";
   
   public static void createXMLTable(Statement stmt) 
      throws SQLException{
      System.out.println("Creating XML_Data table..." );
      //Drop table first if it exists.
      try{
         stmt.executeUpdate(DROP_TABLE_QUERY);
      }catch(SQLException se){
      }
      stmt.executeUpdate(CREATE_TABLE_QUERY);
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         PreparedStatement pstmt = conn.prepareStatement(INSERT_QUERY);
      ) {		      
         createXMLTable(stmt);

         ByteArrayInputStream bis = new ByteArrayInputStream(XML_DATA.getBytes());

         pstmt.setInt(1,100);
         pstmt.setAsciiStream(2,bis,XML_DATA.getBytes().length);
         pstmt.execute();

         //Close input stream
         bis.close();

         ResultSet rs = stmt.executeQuery(QUERY);
         // Get the first row
         if (rs.next ()){
            //Retrieve data from input stream
            InputStream xmlInputStream = rs.getAsciiStream (1);
            int c;
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            while (( c = xmlInputStream.read ()) != -1)
               bos.write(c);
            //Print results
            System.out.println(bos.toString());
         }
         // Clean-up environment
         rs.close();

      } catch (SQLException | IOException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac FirstApplication.java
C:\>

當您執行FirstApplication時，它會產生以下結果 -

C:\>java FirstApplication
Creating XML_Data table...
<Employee><id>100</id><first>Zara</first><last>Ali</last><Salary>10000</Salary><Dob>18-08-1978</Dob></Employee>
C:\>

JDBC - 建立資料庫

本教程提供了一個使用 JDBC 應用程式建立資料庫的示例。在執行以下示例之前，請確保您已準備好以下內容：

您應該具有在給定模式中建立資料庫的管理員許可權。要執行以下示例，您需要將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。

要建立新的資料庫，您無需在準備資料庫 URL 時提供任何資料庫名稱，如下例所示。
執行查詢 - 需要使用Statement型別的物件來構建和提交SQL語句到資料庫。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "CREATE DATABASE STUDENTS";
         stmt.executeUpdate(sql);
         System.out.println("Database created successfully...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
Database created successfully...
C:\>

JDBC - 選擇資料庫

本章提供了一個使用 JDBC 應用程式選擇資料庫的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您需要將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含資料庫程式設計所需的 JDBC 類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與選定資料庫的物理連線。

資料庫的選擇是在您準備資料庫 URL 時進行的。以下示例將與STUDENTS資料庫建立連線。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      System.out.println("Connecting to a selected database...");
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);) {		      
         System.out.println("Connected database successfully...");  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
Connecting to a selected database...
Connected database successfully...
C:\>

JDBC - 刪除資料庫

本章提供了一個使用 JDBC 應用程式刪除現有資料庫的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您需要將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您的 MySQL 正在執行。

注意：這是一個嚴重的操作，在繼續刪除資料庫之前，您必須做出堅定的決定，因為您資料庫中的所有內容都將丟失。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。

刪除資料庫不需要資料庫名稱在您的資料庫 URL 中。以下示例將刪除STUDENTS資料庫。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交刪除資料庫的 SQL 語句。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "DROP DATABASE STUDENTS";
         stmt.executeUpdate(sql);
         System.out.println("Database dropped successfully...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
Database dropped successfully...
C:\>

JDBC - 建立表

本章提供了一個使用 JDBC 應用程式建立表的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您的 MySQL 正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交在選定資料庫中建立表的 SQL 語句。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 TestApplication.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
          String sql = "CREATE TABLE REGISTRATION " +
                   "(id INTEGER not NULL, " +
                   " first VARCHAR(255), " + 
                   " last VARCHAR(255), " + 
                   " age INTEGER, " + 
                   " PRIMARY KEY ( id ))"; 

         stmt.executeUpdate(sql);
         System.out.println("Created table in given database...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac TestApplication.java
C:\>

當您執行TestApplication時，它會產生以下結果：

C:\>java TestApplication
Created table in given database...
C:\>

JDBC - 刪除表

本章提供了一個使用 JDBC 應用程式刪除表的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

注意重新格式化 JDBC 教程這是一個嚴重的操作，在繼續刪除表之前，您必須做出堅定的決定，因為您表中的所有內容都將丟失。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢重新格式化 JDBC 教程需要使用 Statement 型別的物件來構建和提交在選定資料庫中刪除表的 SQL 語句。
清理環境重新格式化 JDBC 教程try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "DROP TABLE REGISTRATION";
         stmt.executeUpdate(sql);
         System.out.println("Table deleted in given database...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
Table deleted in given database...
C:\>

JDBC - 插入記錄

本章提供了一個使用 JDBC 應用程式在表中插入記錄的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
註冊 JDBC 驅動程式 - 需要初始化一個驅動程式，以便您可以開啟與資料庫的通訊通道。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交將記錄插入表的 SQL 語句。
清理環境try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         // Execute a query
         System.out.println("Inserting records into the table...");          
         String sql = "INSERT INTO Registration VALUES (100, 'Zara', 'Ali', 18)";
         stmt.executeUpdate(sql);
         sql = "INSERT INTO Registration VALUES (101, 'Mahnaz', 'Fatma', 25)";
         stmt.executeUpdate(sql);
         sql = "INSERT INTO Registration VALUES (102, 'Zaid', 'Khan', 30)";
         stmt.executeUpdate(sql);
         sql = "INSERT INTO Registration VALUES(103, 'Sumit', 'Mittal', 28)";
         stmt.executeUpdate(sql);
         System.out.println("Inserted records into the table...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
Inserting records into the table...
Inserted records into the table...
C:\>

JDBC - 選擇記錄

本章提供了一個使用 JDBC 應用程式從表中選擇/獲取記錄的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交從表中選擇（即獲取）記錄的 SQL 語句。
提取資料 - 執行 SQL 查詢後，您可以從表中獲取記錄。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		      
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - 更新記錄

本章提供了一個使用 JDBC 應用程式更新表中記錄的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交更新表中記錄的 SQL 語句。此查詢使用IN和WHERE子句來更新條件記錄。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "UPDATE Registration " +
            "SET age = 30 WHERE id in (100, 101)";
         stmt.executeUpdate(sql);
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 101, Age: 30, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - 刪除記錄

本章提供了一個使用 JDBC 應用程式從表中刪除記錄的示例。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
註冊 JDBC 驅動程式 - 需要初始化一個驅動程式，以便您可以開啟與資料庫的通訊通道。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交從表中刪除記錄的 SQL 語句。此查詢使用WHERE子句來刪除條件記錄。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
      ) {		      
         String sql = "DELETE FROM Registration " +
            "WHERE id = 101";
         stmt.executeUpdate(sql);
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - WHERE 子句

本章提供了一個使用 JDBC 應用程式從表中選擇記錄的示例。這將使用 WHERE 子句新增其他條件，以便從表中選擇記錄。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含資料庫程式設計所需的 JDBC 類所在的包。大多數情況下，使用import java.sql.*就足夠了。
註冊 JDBC 驅動程式 - 需要初始化一個驅動程式，以便您可以開啟與資料庫的通訊通道。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交從表中獲取滿足給定條件的記錄的 SQL 語句。此查詢使用WHERE子句來選擇記錄。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 TestApplication.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestApplication {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();) {		      
         System.out.println("Fetching records without condition...");
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }

         // Select all records having ID equal or greater than 101
         System.out.println("Fetching records with condition...");
         String sql = "SELECT id, first, last, age FROM Registration" +
            " WHERE id >= 101 ";
         rs = stmt.executeQuery(sql);

         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac TestApplication.java
C:\>

當您執行TestApplication時，它會產生以下結果：

C:\>java TestApplication
Fetching records without condition...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Fetching records with condition...
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

JDBC - LIKE 子句

本章提供了一個使用 JDBC 應用程式從表中選擇記錄的示例。這將使用 LIKE 子句新增其他條件，以便從表中選擇記錄。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交從表中獲取滿足給定條件的記錄的 SQL 語句。此查詢使用LIKE子句來選擇記錄，以選擇所有名字以“za”開頭的學生。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();) {		      
         System.out.println("Fetching records without condition...");
         ResultSet rs = stmt.executeQuery(QUERY);
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }

         // Select all records having ID equal or greater than 101
         System.out.println("Fetching records with condition...");
         String sql = "SELECT id, first, last, age FROM Registration" +
            " WHERE first LIKE '%za%'";
         rs = stmt.executeQuery(sql);

         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
Fetching records without condition...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Fetching records with condition...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
C:\>

JDBC - 資料排序

本章提供了一個使用 JDBC 應用程式對錶中的記錄進行排序的示例。這將使用asc和desc關鍵字按升序或降序對記錄進行排序。在執行以下示例之前，請確保您已準備好以下內容：

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 MySQL 或任何其他資料庫正在執行。

必要步驟

使用 JDBC 應用程式建立新資料庫需要以下步驟：

匯入包 - 需要包含用於資料庫程式設計的JDBC類所在的包。大多數情況下，使用import java.sql.*就足夠了。
開啟連線 - 需要使用DriverManager.getConnection()方法建立 Connection 物件，該物件表示與資料庫伺服器的物理連線。
執行查詢 - 需要使用 Statement 型別的物件來構建和提交對錶中的記錄進行排序的 SQL 語句。這些查詢使用asc和desc子句按升序和降序對資料進行排序。
清理環境 - try with resources 會自動關閉資源。

示例程式碼

將以下示例複製並貼上到 JDBCExample.java 中，編譯並執行如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExample {
   static final String DB_URL = "jdbc:mysql:///TUTORIALSPOINT";
   static final String USER = "guest";
   static final String PASS = "guest123";
   static final String QUERY = "SELECT id, first, last, age FROM Registration";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();) {		      
         System.out.println("Fetching records in ascending order...");
         ResultSet rs = stmt.executeQuery(QUERY + " ORDER BY first ASC");
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }

         System.out.println("Fetching records in descending order...");
         rs = stmt.executeQuery(QUERY + " ORDER BY first DESC");
         while(rs.next()){
            //Display values
            System.out.print("ID: " + rs.getInt("id"));
            System.out.print(", Age: " + rs.getInt("age"));
            System.out.print(", First: " + rs.getString("first"));
            System.out.println(", Last: " + rs.getString("last"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

現在讓我們如下編譯上述示例：

C:\>javac JDBCExample.java
C:\>

執行JDBCExample時，它會產生以下結果 -

C:\>java JDBCExample
Fetching records in ascending order...
ID: 103, Age: 28, First: Sumit, Last: Mittal
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 100, Age: 30, First: Zara, Last: Ali
Fetching records in descending order...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>

列印頁面

JDBC - 快速指南

JDBC - 簡介

什麼是 JDBC？

先決條件

JDBC 架構

常見的 JDBC 元件

JDBC 4.0 包

JDBC - SQL 語法

建立資料庫

示例

刪除資料庫

建立表

示例

刪除表

示例

插入資料

示例

選擇資料

示例

更新資料

示例

刪除資料

示例

JDBC - 環境配置

安裝 Java

為 Windows 2000/XP 設定路徑

為 Windows 95/98/ME 設定路徑

為 Linux、UNIX、Solaris、FreeBSD 設定路徑

安裝資料庫

設定資料庫憑據

建立資料庫

步驟 1

步驟 2

步驟 3

建立表

步驟 1

步驟 2

步驟 3

建立資料記錄

JDBC - 示例程式碼

建立JDBC應用程式

示例程式碼

JDBC - 驅動程式型別

什麼是JDBC驅動程式？

JDBC驅動程式型別

型別1 - JDBC-ODBC橋接驅動程式

型別2 - JDBC-Native API

型別3 - JDBC-Net純Java

型別4 - 100%純Java

應該使用哪個驅動程式？

JDBC - 連線

匯入JDBC包

註冊JDBC驅動程式

方法一 - Class.forName()

方法二 - DriverManager.registerDriver()

資料庫URL制定

建立連線物件

使用帶有使用者名稱和密碼的資料庫URL

僅使用資料庫URL

使用資料庫 URL 和屬性物件

關閉 JDBC 連線

JDBC - 語句

Statement 物件

建立 Statement 物件

關閉 Statement 物件

PreparedStatement 物件

建立 PreparedStatement 物件

關閉 PreparedStatement 物件

CallableStatement 物件

建立 CallableStatement 物件

關閉 CallableStatement 物件

JDBC - 結果集

ResultSet 型別

ResultSet 的併發性

導航結果集

檢視結果集

更新結果集

JDBC - 資料型別

日期和時間資料型別

處理 NULL 值