Java & MySQL 快速指南

Java & MySQL - 概述

JDBC 代表 **J**ava **D**ata**b**ase **C**onnectivity，它是 Java 程式語言與各種資料庫之間進行資料庫無關連線的標準 Java API。

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

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

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

Java 應用程式
Java 小程式
Java Servlet
Java ServerPages (JSP)
企業 JavaBean (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 資料型別支援。
註釋。

Java & MySQL - 環境設定

要開始使用 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 資料庫** - 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 程式設計的示例。

Java & MySQL - 示例程式碼

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

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

建立 JDBC 應用程式

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

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

示例程式碼

這個示例可以作為模板，供您將來建立自己的JDBC應用程式時使用。

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

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

import java.sql.*;

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 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 TestApplication.java
C:\>

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

C:\>java TestApplication
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:\>

Java & MySQL - 連線

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

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

匯入JDBC包 − 向您的Java程式新增import語句，以匯入Java程式碼中所需的類。
資料庫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驅動程式

您必須在類路徑中擁有所需的JDBC驅動程式。在本例中，您將CLASSPATH變數設定為C:\Program Files\MySQL\mysql-connector-java-5.1.8\mysql-connector-java-5.1.8-bin.jar。您的驅動程式版本可能因安裝而異。

資料庫URL構造

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

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

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

構造資料庫URL是建立連線時出現的大部分問題所在。

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

資料庫管理系統	JDBC驅動程式名稱	URL格式
MySQL	com.mysql.jdbc.Driver	jdbc:mysql://hostname/ databaseName

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

建立連線物件

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

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

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

由於您使用的是MySQL驅動程式，因此您將為URL的資料庫部分指定一個host:port:databaseName值。

如果您有一個TCP/IP地址為192.0.0.1，主機名為localhost的主機，並且您的MySQL監聽器配置為監聽預設埠3306，並且您的資料庫名為TUTORIALSPOINT，則完整的資料庫URL將是：

jdbc:mysql:///TUTORIALSPOINT

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

String URL = "jdbc:mysql:///TUTORIALSPOINT";
String USER = "guest";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);

使用資料庫URL和Properties物件

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

DriverManager.getConnection(String url, Properties info);

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

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

import java.util.*;

String URL = "jdbc:mysql:///TUTORIALSPOINT";
Properties info = new Properties( );
info.put( "user", "guest" );
info.put( "password", "guest123" );

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

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

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

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

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

C:\>java FirstExample
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:\>

Java & MySQL - 異常處理

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

當發生異常情況時，會丟擲異常。“丟擲”這個詞意味著當前程式執行停止，控制權重定向到最近的適用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
}
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 TestApplication {
   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 TestApplication.java
C:\>

如果執行TestApplication沒有問題，則會產生以下結果；否則，將捕獲相應的錯誤並顯示錯誤訊息：

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

Java & MySQL - Statement

JDBC Statement介面定義了方法和屬性，以啟用將SQL命令傳送到MySQL資料庫並從資料庫檢索資料。Statement用於對資料庫進行通用訪問。當您在執行時使用靜態SQL語句時，它很有用。Statement介面不能接受引數。

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

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();
}

我們使用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 Employees";
   static final String UPDATE_QUERY = "UPDATE Employees set age=30 WHERE id=103";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement();
         ) {
         // Let us check if it returns a true Result Set or not.
         Boolean ret = stmt.execute(UPDATE_QUERY);
         System.out.println("Return value is : " + ret.toString() );

         // Let us update age of the record with ID = 103;
         int rows = stmt.executeUpdate(UPDATE_QUERY);
         System.out.println("Rows impacted : " + rows );

         // Let us select all the records and display them.
         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"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

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

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

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

C:\>java TestApplication
Return value is : false
Rows impacted : 1
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 30, First: Sumit, Last: Mittal
C:\>

Java & MySQL - 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();
}

我們使用try with resources，它會自動處理資源關閉。以下示例演示了所有上述概念。

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

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

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

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 Employees";
   static final String UPDATE_QUERY = "UPDATE Employees set age=? WHERE id=?";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         PreparedStatement stmt = conn.prepareStatement(UPDATE_QUERY);
      ) {		      
         // Bind values into the parameters.
         stmt.setInt(1, 35);  // This would set age
         stmt.setInt(2, 102); // This would set ID

         // Let us update age of the record with ID = 102;
         int rows = stmt.executeUpdate();
         System.out.println("Rows impacted : " + rows );

         // Let us select all the records and display them.
         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"));
         }
         rs.close();
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

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

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

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

C:\>java TestApplication
Return value is : false
Rows impacted : 1
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
ID: 102, Age: 35, First: Zaid, Last: Khan
ID: 103, Age: 30, First: Sumit, Last: Mittal
C:\>

Java & MySQL - CallableStatement

CallableStatement介面用於執行對資料庫儲存過程的呼叫。

假設您需要在TUTORIALSPOINT資料庫中執行以下儲存過程：

DELIMITER $$

DROP PROCEDURE IF EXISTS `TUTORIALSPOINT`.`getEmpName` $$
CREATE PROCEDURE `TUTORIALSPOINT`.`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 {
   . . .
}

字串變數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();
}

我們使用try with resources，它會自動處理資源關閉。以下示例演示了所有上述概念。

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

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

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

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 = "{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, 102);  // 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: 102 is " + empName);
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

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

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

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

C:\>java TestApplication
Executing stored procedure...
Emp Name with ID: 102 is Zaid
C:\>

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 = 表 {LEFT|RIGHT|FULL} OUTER JOIN {表 | outer-join} on 搜尋條件。例如：

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

Java & MySQL - ResultSet

從資料庫查詢讀取資料的 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 {
   ....
}

Java & MySQL - 導航 ResultSet

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 如果遊標當前位於插入行，則將遊標移回當前行；否則，此方法不執行任何操作。

以下示例使用了前面描述的一些導航方法。

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

將以下示例複製並貼上到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 Employees";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_READ_ONLY);
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		
         // Move cursor to the last row.
         System.out.println("Moving cursor to the last...");
         rs.last();

         // Extract data from result set
         System.out.println("Displaying record...");
         //Retrieve by column name
         int id  = rs.getInt("id");
         int age = rs.getInt("age");
         String first = rs.getString("first");
         String last = rs.getString("last");

         // Display values
         System.out.print("ID: " + id);
         System.out.print(", Age: " + age);
         System.out.print(", First: " + first);
         System.out.println(", Last: " + last);

         // Move cursor to the first row.
         System.out.println("Moving cursor to the first row...");
         rs.first();

         // Extract data from result set
         System.out.println("Displaying record...");
         // Retrieve by column name
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         last = rs.getString("last");

         // Display values
         System.out.print("ID: " + id);
         System.out.print(", Age: " + age);
         System.out.print(", First: " + first);
         System.out.println(", Last: " + last);
         // Move cursor to the first row.

         System.out.println("Moving cursor to the next row...");
         rs.next();

         // Extract data from result set
         System.out.println("Displaying record...");
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         last = rs.getString("last");

         // Display values
         System.out.print("ID: " + id);
         System.out.print(", Age: " + age);
         System.out.print(", First: " + first);
         System.out.println(", Last: " + last);		

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

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

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

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

C:\>java TestApplication
Moving cursor to the last...
Displaying record...
ID: 103, Age: 30, First: Sumit, Last: Mittal
Moving cursor to the first row...
Displaying record...
ID: 100, Age: 18, First: Zara, Last: Ali
Moving cursor to the next row...
Displaying record...
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
C:\>

Java & MySQL - 檢視 ResultSet

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 資料型別的資訊。

以下示例使用了前面描述的一些檢視方法。

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

將以下示例複製並貼上到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 Employees";

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_READ_ONLY);
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		
         // Move cursor to the last row.
         System.out.println("Moving cursor to the last...");
         rs.last();

         // Extract data from result set
         System.out.println("Displaying record...");
         //Retrieve by column name
         int id  = rs.getInt("id");
         int age = rs.getInt("age");
         String first = rs.getString("first");
         String last = rs.getString("last");

         // Display values
         System.out.print("ID: " + id);
         System.out.print(", Age: " + age);
         System.out.print(", First: " + first);
         System.out.println(", Last: " + last);

         // Move cursor to the first row.
         System.out.println("Moving cursor to the first row...");
         rs.first();

         // Extract data from result set
         System.out.println("Displaying record...");
         // Retrieve by column name
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         last = rs.getString("last");

         // Display values
         System.out.print("ID: " + id);
         System.out.print(", Age: " + age);
         System.out.print(", First: " + first);
         System.out.println(", Last: " + last);
         // Move cursor to the first row.

         System.out.println("Moving cursor to the next row...");
         rs.next();

         // Extract data from result set
         System.out.println("Displaying record...");
         id  = rs.getInt("id");
         age = rs.getInt("age");
         first = rs.getString("first");
         last = rs.getString("last");

         // Display values
         System.out.print("ID: " + id);
         System.out.print(", Age: " + age);
         System.out.print(", First: " + first);
         System.out.println(", Last: " + last);		

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

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

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

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

C:\>java TestApplication
Moving cursor to the last...
Displaying record...
ID: 103, Age: 30, First: Sumit, Last: Mittal
Moving cursor to the first row...
Displaying record...
ID: 100, Age: 18, First: Zara, Last: Ali
Moving cursor to the next row...
Displaying record...
ID: 101, Age: 25, First: Mehnaz, Last: Fatma
C:\>

Java & MySQL - 更新 ResultSet

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 與前面方法類似，只是列由其名稱而不是索引指定。

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

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

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

以下示例使用了在 ResultSet 教程中描述的 **ResultSet.CONCUR_UPDATABLE** 和 **ResultSet.TYPE_SCROLL_INSENSITIVE**。此示例將解釋對錶的 INSERT、UPDATE 和 DELETE 操作。

需要注意的是，您正在使用的表應正確設定主鍵。讓我們先更新我們的參考表。

刪除表並按如下方式重新建立表 **Employees**：

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

建立資料記錄

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

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

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

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

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

mysql>

將以下示例複製並貼上到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 Employees";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
         ResultSet.TYPE_SCROLL_INSENSITIVE,
         ResultSet.CONCUR_UPDATABLE);
         ResultSet rs = stmt.executeQuery(QUERY);
      ) {		

         System.out.println("List result set for reference....");
         printResultSet(rs);

         // Loop through result set and add 5 in age
         // Move to Before first position so while-loop works properly
         rs.beforeFirst();
         //STEP 7: Extract data from result set
         while(rs.next()){
            // Retrieve by column name
            int newAge = rs.getInt("age") + 5;
            rs.updateDouble( "age", newAge );
            rs.updateRow();
         }
         System.out.println("List result set showing new ages...");
         printResultSet(rs);

         // Insert a record into the table.
         // Move to insert row and add column data with updateXXX()
         System.out.println("Inserting a new record...");
         rs.moveToInsertRow();
         rs.updateString("first","John");
         rs.updateString("last","Paul");
         rs.updateInt("age",40);
         // Commit row
         rs.insertRow();

         System.out.println("List result set showing new set...");
         printResultSet(rs);	

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

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

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

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

C:\>java TestApplication
List result set for reference....
ID: 1, Age: 18, First: Zara, Last: Ali
ID: 2, Age: 25, First: Mahnaz, Last: Fatma
ID: 3, Age: 30, First: Zaid, Last: Khan
ID: 4, Age: 28, First: Sumit, Last: Mittal

List result set showing new ages...
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal

Inserting a new record...
List result set showing new set...
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul

List the record before deleting...
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
C:\>

Java & MySQL - 事務

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

對於簡單的應用程式來說，這可能足夠了，但是有三個原因可以解釋為什麼您可能想要關閉自動提交併自行管理事務：

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

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

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

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

conn.setAutoCommit(false);

提交和回滾

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

conn.commit( );

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

conn.rollback( );

使用儲存點

新的 JDBC 3.0 儲存點介面為您提供了額外的交易控制。

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

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

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

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

Java & MySQL - 提交 & 回滾

完成更改並想要提交更改後，請在連線物件上呼叫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 語句都將失敗，所有內容都將回滾。

以下示例使用了描述的commit 和rollback。

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

將以下示例複製並貼上到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 Employees";
   static final String INSERT_QUERY = "INSERT INTO Employees (first, last, age) values('Rita', 'Tez', 20)";
   static final String INSERT_QUERY_2 = "INSERT INTO Employees (first, last, age) values('Sita', 'Singh', 20)";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {

      Connection conn = null;
      Statement stmt = null;
      try{
         // Open a connection
         System.out.println("Connecting to database...");
         conn = DriverManager.getConnection(DB_URL,USER,PASS);

         // Set auto commit as false.
         conn.setAutoCommit(false);

         // Execute a query to create statment with
         // required arguments for RS example.
         System.out.println("Creating statement...");
         stmt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE);

         // INSERT a row into Employees table
         System.out.println("Inserting one row....");
         stmt.executeUpdate(INSERT_QUERY);  

         // INSERT one more row into Employees table
         stmt.executeUpdate(INSERT_QUERY_2);

         // Commit data here.
         System.out.println("Commiting data here....");
         conn.commit();

         // Now list all the available records.
         String sql = "SELECT id, first, last, age FROM Employees";
         ResultSet rs = stmt.executeQuery(sql);
         System.out.println("List result set for reference....");
         printResultSet(rs);

         // Clean-up environment
         rs.close();
         stmt.close();
         conn.close();
      }catch(SQLException se){
         se.printStackTrace();
         // If there is an error then rollback the changes.
         System.out.println("Rolling back data here....");
         try{
            if(conn!=null)
               conn.rollback();
            }catch(SQLException se2){
               se2.printStackTrace();
            }
         }catch(Exception e){
            e.printStackTrace();
         }finally{
            // finally block used to close resources
         try{
            if(stmt!=null)
               stmt.close();
         }catch(SQLException se2){
            se2.printStackTrace();
         } 
            try{
               if(conn!=null)
                  conn.close();
            }catch(SQLException se){
               se.printStackTrace();
         }
      }		   
   }
}

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

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

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

C:\>java TestApplication
Connecting to database...
Creating statement...
Inserting one row....
Commiting data here....
List result set for reference....
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 6, Age: 20, First: Rita, Last: Tez
ID: 7, Age: 20, First: Sita, Last: Singh
C:\>

Java 和 MySQL - 儲存點

新的 JDBC 3.0 儲存點介面為您提供了額外的交易控制。大多數現代資料庫管理系統都在其環境中支援儲存點，例如 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 語句都將失敗，所有內容都將回滾。

以下示例使用了描述的setSavepoint 和rollback。

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

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

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Savepoint;
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 Employees";
   static final String DELETE_QUERY = "DELETE FROM Employees WHERE ID = 8";
   static final String DELETE_QUERY_1 = "DELETE FROM Employees WHERE ID = 9";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE);				
      ) {		

         conn.setAutoCommit(false);
         ResultSet rs = stmt.executeQuery(QUERY);
         System.out.println("List result set for reference....");
         printResultSet(rs);

         // delete row having ID = 8
         // But save point before doing so.
         Savepoint savepoint1 = conn.setSavepoint("ROWS_DELETED_1");
         System.out.println("Deleting row....");
         stmt.executeUpdate(DELETE_QUERY);  
         // Rollback the changes after save point 1.
         conn.rollback(savepoint1);

         // delete rows having ID = 9
         // But save point before doing so.
         conn.setSavepoint("ROWS_DELETED_2");
         System.out.println("Deleting row....");

         stmt.executeUpdate(DELETE_QUERY_1);  

         rs = stmt.executeQuery(QUERY);
         System.out.println("List result set for reference....");
         printResultSet(rs);

         // Clean-up environment
         rs.close();

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

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

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

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

C:\>java TestApplication
List result set for reference....
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 20, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh

Deleting row....
Deleting row....
List result set for reference....
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 20, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
C:\>

Java & MySQL - 批次處理

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

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

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

使用 Statement 物件進行批次處理

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

使用createStatement() 方法建立一個 Statement 物件。
使用setAutoCommit() 將自動提交設定為 false。
使用在建立的 statement 物件上addBatch() 方法將任意數量的 SQL 語句新增到批處理中。
使用在建立的 statement 物件上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。
使用在建立的 statement 物件上addBatch() 方法將任意數量的 SQL 語句新增到批處理中。
使用在建立的 statement 物件上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();

Java 和 MySQL - 使用 Statement 物件進行批次處理

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

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

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

將以下示例複製並貼上到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";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         Statement stmt = conn.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE)
            ) {		      
         conn.setAutoCommit(false);	    	  

         ResultSet rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);

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

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

         // Create one more SQL statement
         SQL = "UPDATE Employees SET age = 35 " +
         "WHERE id = 7";
         // 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();

         rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);	  

         stmt.close();
         rs.close();

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

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

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

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

C:\>java TestApplication
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 20, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh

ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 35, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh
ID: 10, Age: 30, First: Zia, Last: Ali
ID: 11, Age: 35, First: Raj, Last: Kumar
C:\>

Java 和 MySQL - 使用 PrepareStatement 物件進行批次處理

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

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

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

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

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 INSERT_QUERY = "INSERT INTO Employees(first,last,age) VALUES(?, ?, ?)";

   public static void printResultSet(ResultSet rs) throws SQLException{
      // Ensure we start with first row
      rs.beforeFirst();
      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();
   }

   public static void main(String[] args) {
      // Open a connection
      try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
         PreparedStatement stmt = conn.prepareStatement(INSERT_QUERY,
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_UPDATABLE)
      ) {		      
         conn.setAutoCommit(false);	    	  

         ResultSet rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);

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

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

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

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

         rs = stmt.executeQuery("Select * from Employees");
         printResultSet(rs);	  

         stmt.close();
         rs.close();

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

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

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

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

C:\>java TestApplication
ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 35, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh
ID: 10, Age: 30, First: Zia, Last: Ali
ID: 11, Age: 35, First: Raj, Last: Kumar

ID: 1, Age: 23, First: Zara, Last: Ali
ID: 2, Age: 30, First: Mahnaz, Last: Fatma
ID: 3, Age: 35, First: Zaid, Last: Khan
ID: 4, Age: 33, First: Sumit, Last: Mittal
ID: 5, Age: 40, First: John, Last: Paul
ID: 7, Age: 35, First: Sita, Last: Singh
ID: 8, Age: 20, First: Rita, Last: Tez
ID: 9, Age: 20, First: Sita, Last: Singh
ID: 10, Age: 30, First: Zia, Last: Ali
ID: 11, Age: 35, First: Raj, Last: Kumar
ID: 12, Age: 33, First: Pappu, Last: Singh
ID: 13, Age: 31, First: Pawan, Last: Singh
C:\>

Java & MySQL - 流式資料

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

可以使用以下方法來流式傳輸資料：

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

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

此示例將建立一個數據庫表 XML_Data，然後將 XML 內容寫入此表。

將以下示例複製並貼上到TestApplication.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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 建立資料庫示例

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

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

必需步驟

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

**匯入包** - 需要您包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用 *import java.sql.* 就足夠了。
開啟連線 − 需要使用DriverManager.getConnection() 方法建立一個 Connection 物件，該物件代表與資料庫伺服器的物理連線。
要建立新資料庫，在準備資料庫 URL 時無需提供任何資料庫名稱，如下例所示。
**執行查詢** - 需要使用 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:///";
   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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 選擇資料庫示例

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

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

必需步驟

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

匯入包 − 需要包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用import java.sql.* 就足夠了。
開啟連線 − 需要使用DriverManager.getConnection() 方法建立一個 Connection 物件，該物件代表與選定資料庫的物理連線。
準備資料庫 URL 時會選擇資料庫。以下示例將與STUDENTS 資料庫建立連線。
清理環境 − 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) {
      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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 刪除資料庫示例

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

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

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

必需步驟

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

**匯入包** - 需要您包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用 *import java.sql.* 就足夠了。
開啟連線 − 需要使用DriverManager.getConnection() 方法建立一個 Connection 物件，該物件代表與資料庫伺服器的物理連線。
刪除資料庫不需要資料庫名稱在資料庫 URL 中。以下示例將刪除STUDENTS 資料庫。
執行查詢 − 需要使用 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:///";
   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 TestApplication.java
C:\>

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

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

Java 和 MySQL - 建立表示例

本章提供了一個關於如何使用 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:\>

Java 和 MySQL - 刪除表示例

本章提供了一個關於如何使用 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 = "DROP TABLE REGISTRATION";
         stmt.executeUpdate(sql);
         System.out.println("Table deleted in given database...");   	  
      } catch (SQLException e) {
         e.printStackTrace();
      } 
   }
}

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

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

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

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

Java 和 MySQL - 插入記錄示例

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

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

必需步驟

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

**匯入包** - 需要您包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用 *import java.sql.* 就足夠了。
註冊 JDBC 驅動程式 − 需要初始化驅動程式，以便您可以開啟與資料庫的通訊通道。
開啟連線 − 需要使用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();
      ) {		      
         // 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 TestApplication.java
C:\>

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

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

Java & MySQL - 選擇記錄示例

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

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

必需步驟

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

**匯入包** - 需要您包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用 *import java.sql.* 就足夠了。
開啟連線 − 需要使用DriverManager.getConnection() 方法建立一個 Connection 物件，該物件代表與資料庫伺服器的物理連線。
執行查詢 − 需要使用 Statement 型別物件來構建和提交 SQL 語句，以從表中選擇（即提取）記錄。
提取資料 − 一旦 SQL 查詢執行完畢，您就可以從表中提取記錄。
清理環境 − 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();
         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 TestApplication.java
C:\>

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

C:\>java TestApplication
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:\>

Java & MySQL - 更新記錄示例

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

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

必需步驟

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

**匯入包** - 需要您包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用 *import java.sql.* 就足夠了。
開啟連線 − 需要使用DriverManager.getConnection() 方法建立一個 Connection 物件，該物件代表與資料庫伺服器的物理連線。
執行查詢 − 需要使用 Statement 型別物件來構建和提交 SQL 語句以更新表中的記錄。此查詢使用IN和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();
      ) {		      
         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 TestApplication.java
C:\>

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

C:\>java TestApplication
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:\>

Java & MySQL - 刪除記錄示例

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

要執行以下示例，您可以將使用者名稱和密碼替換為您實際的使用者名稱和密碼。
您正在使用的 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();
      ) {		      
         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 TestApplication.java
C:\>

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

C:\>java TestApplication
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:\>

Java & MySQL - 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:\>

Java & MySQL - LIKE 子句示例

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

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

必需步驟

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

**匯入包** - 需要您包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用 *import java.sql.* 就足夠了。
開啟連線 − 需要使用DriverManager.getConnection() 方法建立一個 Connection 物件，該物件代表與資料庫伺服器的物理連線。
執行查詢 − 需要使用 Statement 型別物件來構建和提交 SQL 語句以提取符合給定條件的表記錄。此查詢使用LIKE子句選擇記錄，例如選擇所有名字以“za”開頭的學生。
清理環境 − 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 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 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: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
C:\>

Java & MySQL - 資料排序示例

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

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

必需步驟

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

**匯入包** - 需要您包含包含資料庫程式設計所需的 JDBC 類的包。大多數情況下，使用 *import java.sql.* 就足夠了。
開啟連線 − 需要使用DriverManager.getConnection() 方法建立一個 Connection 物件，該物件代表與資料庫伺服器的物理連線。
執行查詢 − 需要使用 Statement 型別物件來構建和提交 SQL 語句以對錶中的記錄進行排序。這些查詢使用asc和desc子句以升序和降序對資料進行排序。
清理環境 − 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 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 TestApplication.java
C:\>

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

C:\>java TestApplication
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:\>

列印頁面