DBCP串連池串連MySQL模式OceanBase資料庫的樣本程式-OceanBase-阿里雲

本文將介紹如何使用 DBCP 串連池、MySQL Connector/J 和 OceanBase 資料庫構建一個應用程式，實現基本的資料庫操作，包括建立表、插入、刪除、更新和查詢資料等。

點擊下載 dbcp-mysql-client 樣本工程

前提條件

您已安裝 OceanBase 資料庫並且建立了 MySQL 模式租戶。
您已安裝 JDK 1.8 和 Maven。
您已安裝 Eclipse。
說明
本文檔運行代碼使用的工具是 Eclipse IDE for Java Developers 2022-03 版本，您也可以根據個人喜好選擇適合自己的工具啟動並執行範例程式碼。

操作步驟

說明

本文中給出的操作步驟是在 Windows 環境下使用 Eclipse IDE for Java Developers 2022-03 編譯和運行該專案的步驟。如果您使用的是其他動作系統內容或編譯器，那麼操作步驟可能會略有不同。

將dbcp-mysql-client專案匯入到 Eclipse 中。
擷取 OceanBase 資料庫 URL。
修改dbcp-mysql-client專案中的資料庫連接資訊。
運行dbcp-mysql-client專案。

步驟一：將 dbcp-mysql-client 專案匯入到 Eclipse 中

開啟 Eclipse，在功能表列上選擇 File->Open Projects from File System。
在彈出的對話方塊中，點擊 Directory 按鈕選擇專案所在的目錄，然後點擊 Finish 完成匯入。
說明
當使用 Eclipse 匯入 Maven 專案時，Eclipse 會自動檢測專案中的pom.xml檔案，並根據檔案中描述的依賴關係自動下載所需的依賴庫，並將它們添加到專案中。
查看專案情況。

步驟二：擷取 OceanBase 資料庫 URL

聯絡 OceanBase 資料庫部署人員或者管理員擷取相應的資料庫連接串。
樣本如下：
```
obclient -hxxx.xxx.xxx.xxx -P3306 -utest_user001 -p****** -Dtest
```
更多串連串的資訊，請參見擷取串連參數。
根據 OceanBase 資料庫連接串資訊填寫下面 URL 的對應資訊。
```
jdbc:mysql://$host:$port/$database_name?user=$user_name&password=$password
```
參數說明：
- $host：OceanBase 資料庫連接的網域名稱。
- $port：OceanBase 資料庫連接連接埠，MySQL 模式租戶預設是 3306。
- $database_name：需要訪問的資料庫名稱。
- $user_name：租戶的串連帳號。
- $password：提供賬戶密碼。
更多有關 MySQL Connector/J 串連屬性資訊，請參見 Configuration Properties。
樣本如下：
```
jdbc:mysql://xxx.xxx.xxx.xxx:3306/test?user=test_user001&password=******
```

步驟三：修改 dbcp-mysql-client 專案中的資料庫連接資訊

根據 步驟二：擷取 OceanBase 資料庫 URL 中擷取的資訊修改檔案dbcp-mysql-client/src/main/resources/db.properties中的資料庫連接資訊。

樣本如下：

OBServer 節點的 IP 位址為xxx.xxx.xxx.xxx。
訪問連接埠使用的是 3306。
需要訪問的資料庫名稱為test。
租戶的串連賬戶是test_user001。
密碼是******。

代碼如下：

...
url=jdbc:mysql://xxx.xxx.xxx.xxx:3306/test
username=test_user001
password=******
...

步驟四：運行 dbcp-mysql-client 專案

在專案導航器視圖中，找到並展開 src/main/java 目錄。
右鍵點擊 Main.java 檔案，然後選擇 Run As->Java Application。
在 Eclipse 的控制台視窗中來查看專案的日誌資訊和輸出結果。

也可以在 OceanBase 用戶端（OBClient）中執行以下 SQL 陳述式查看結果。

obclient [test]> SELECT * FROM test_tbl1;

返回結果如下：

+------+--------------+
| id   | name         |
+------+--------------+
|    5 | test_update  |
|    6 | test_insert6 |
|    7 | test_insert7 |
|    8 | test_insert8 |
|    9 | test_insert9 |
+------+--------------+
5 rows in set

專案代碼介紹

點擊 dbcp-mysql-client 下載專案代碼，是一個名稱為dbcp-mysql-client.zip的壓縮包。

解壓後，得到一個名為dbcp-mysql-client的檔案夾。目錄結構如下所示：

dbcp-mysql-client
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── example
│       │           └── Main.java
│       └── resources
│           └── db.properties
└── pom.xml

檔案說明：

src：原始碼根目錄。
main：主代碼目錄，包含應用程式的主要邏輯。
java：Java 原始碼目錄。
com：Java 包目錄。
example：樣本專案的包目錄。
Main.java：主類程式樣本檔案，包含建立表、插入、刪除、更新和查詢資料等邏輯。
resources：資源檔目錄，包含設定檔等。
db.properties：串連池的設定檔，包含了資料庫連接的相關參數。
pom.xml：Maven 專案的設定檔，用於管理專案的依賴和構建設定。

pom.xml 代碼介紹

pom.xml檔案是 Maven 專案的設定檔，定義了專案的依賴項、外掛程式和構建規則等資訊。Maven 是一個 Java 專案管理工具，可以自動下載依賴項、編譯和打包專案等操作。

本文pom.xml檔案的代碼主要包括以下幾個部分：

檔案聲明語句。
聲明本檔案是一個 XML 檔案，使用的 XML 版本是1.0，字元編碼方式是UTF-8。
代碼如下：
```
<?xml version="1.0" encoding="UTF-8"?>
```
配置 POM 的命名空間和 POM 模型版本。
1. 通過xmlns指定 POM 的命名空間為http://maven.apache.org/POM/4.0.0。
2. 通過xmlns:xsi指定 XML 命名空間http://www.w3.org/2001/XMLSchema-instance。
3. 通過xsi:schemaLocation指定 POM 的命名空間為http://maven.apache.org/POM/4.0.0和 POM 的 XSD 檔案的位置為http://maven.apache.org/xsd/maven-4.0.0.xsd。
4. 通過<modelVersion>元素指定了該 POM 檔案使用的 POM 模型版本為4.0.0。
代碼如下：
```
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

 

</project>
```
配置基本資料。
1. 通過<groupId>指定專案所屬組織為com.example。
2. 通過<artifactId>指定專案的名稱為dbcp-mysql-client。
3. 通過<version>專案的版本號碼為1.0-SNAPSHOT。
代碼如下：
```
    <groupId>com.example</groupId>
    <artifactId>dbcp-mysql-client</artifactId>
    <version>1.0-SNAPSHOT</version>
```
設定項目源檔案的屬性。
指定 Maven 的編譯器外掛程式為maven-compiler-plugin，並設定了原始碼和目標 Java 版本都為 8。這意味著專案的原始碼使用 Java 8 特性編寫，且編譯後的位元組碼也將相容 Java 8 運行時環境。這樣設定可以確保專案在編譯和運行時能夠正確地處理 Java 8 的文法和特性。
說明
Java 1.8 和 Java 8 是同一個版本的不同命名方式。
代碼如下：
```
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
```
設定項目所相依元件。
通過<dependency>定義依賴項：
- MySQL JDBC 依賴項：
  1. 通過<groupId>指定依賴項所屬的組織為mysql。
  2. 通過<artifactId>指定依賴項的名稱為mysql-connector-java。
  3. 通過<version>指定依賴項的版本號碼為5.1.47。
- dbcp 依賴項：
  1. 通過<groupId>指定依賴項所屬的組織為org.apache.commons。
  2. 通過<artifactId>指定依賴項的名稱為commons-dbcp2。
  3. 通過<version>指定依賴項的版本號碼為2.9.0。
代碼如下：
```
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
```

db.properties 代碼介紹

db.properties是本文樣本的串連池設定檔，其中包含了串連池的配置屬性。這些屬性包括驅動程式的類名、資料庫URL、使用者名稱、密碼、串連池的大小和限制、串連的逾時時間以及處理被遺棄串連的選項。

本文db.properties檔案的代碼主要包括以下幾個部分：

設定資料庫串連參數。
1. 設定驅動程式的類名，這裡是 MySQL JDBC 驅動的類名com.mysql.jdbc.Driver。
2. 設定資料庫連接的 URL，包括主機 IP、連接埠號碼、需要訪問的資料庫等資訊。
3. 設定資料庫使用者名稱。
4. 設定資料庫密碼。
5. 設定串連屬性，其中useSSL=false表示不使用 SSL 加密串連，characterEncoding=UTF-8表示使用 UTF-8 編碼進行資料轉送。
代碼如下：
```
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://$host:$port/$database_name
username=$user_name
password=$password
connectionProperties=useSSL=false;characterEncoding=UTF-8
```
參數解釋：
- $host：OceanBase 資料庫連接的網域名稱。
- $port：OceanBase 資料庫連接連接埠，MySQL 模式租戶預設是 3306。
- $database_name：需要訪問的資料庫名稱。
- $user_name：租戶的串連帳號。
- $password：提供賬戶密碼。
配置其他 DBCP 串連池的參數。
1. 設定串連池的初始大小為30，即串連池中最初要建立的串連數。
2. 設定串連池的最大串連數為30，即串連池中允許存在的最大串連數。
3. 設定串連池中允許保持空閑狀態的最大串連數為10。
4. 設定串連池中保持空閑狀態的最小串連數為5。如果空閑串連數低於此值，串連池將建立新的串連。
5. 設定從串連池擷取串連時的最大等待時間（以毫秒為單位）為1000。如果串連池中的所有串連都被佔用，並且沒有可用的串連，擷取串連的操作將會等待，直到有可用的串連或超過最大等待時間。
6. 刪除放棄的串連之前的逾時時間（單位為秒）為1。
  說明
  removeAbandonedTimeout的預設值為 300 秒，本樣本中是為了測試程式才配置為 1 秒。您可以根據實際情況適當調整該值以滿足應用程式的需求。
7. 程式中的串連不使用後是否被串連池回收：
  - 設定是否在維護過程中檢測並清除被遺棄的串連，設定為true。
  - 設定是否在從串連池借用串連時檢測並清除被遺棄的串連，設定為true。
代碼如下：
```
initialSize=30
maxTotal=30
maxIdle=10
minIdle=5
maxWaitMillis=1000
removeAbandonedTimeout=1

removeAbandonedOnMaintenance=true
removeAbandonedOnBorrow=true
```

重要

具體的屬性（參數）配置取決於專案需求和資料庫的特點，建議您根據實際情況進行調整和配置。更多 DBCP 串連池參數的資訊，請參見 BasicDataSource Configuration Parameters。

DBCP 串連池基本資料來源配置參數：

分類	屬性	預設值	描述
必選參數	driverClass	N/A	指定資料庫驅動程式的類名。
	url	N/A	指定串連資料庫時使用的 URL。
	username	N/A	指定串連資料庫時使用的使用者名稱。
	password	N/A	指定串連資料庫時使用的密碼。
建議設定的參數	initialSize	0	指定串連池的初始大小，即串連池啟動時建立的初始串連數。如果將其設定為大於 0 的值，則在串連池初始化時會建立指定數量的串連。這可以提前建立串連並減少用戶端第一次請求串連時的延遲。
	maxTotal	8	指定串連池的最大串連數，即串連池中允許存在的最大串連數。如果將其設定為負數，表示沒有限制。
	maxIdle	8	指定在不釋放額外串連的情況下，串連池中允許保持空閑狀態的最大串連數。如果將其設定為負數，表示沒有限制。
	minIdle	0	指定在不釋放額外串連的情況下，串連池中保持空閑狀態的最小串連數。如果將其設定為負數，表示沒有限制。
	maxWaitMillis	indefinitely	指定從串連池擷取串連時的最大等待時間（以毫秒為單位）。設定為 -1，表示無限等待。如果設定為一個正數，當串連池中的串連都被佔用時，等待擷取串連的操作將會等待指定的時間，超過時間後將會拋出異常。
	validationQuery	N/A	指定用於驗證串連是否有效 SQL 查詢語句。如果指定，此查詢必須是至少返回一行的`SQL SELECT`語句。如果未指定，串連將通過調用`isValid()`方法進行驗證。
	testOnBorrow	true	指定在從串連池借用對象時是否進行驗證。如果對象無法驗證，它將從串連池中刪除，將嘗試借用另一個對象。
	testWhileIdle	false	指定串連池是否在空閑時進行驗證。如果設定為`true`，串連池將定期執行驗證查詢來檢查空閑串連的有效性。如果對象未能通過驗證，它將從串連池中刪除。
選擇性參數	connectionProperties	N/A	指定以索引值對形式的額外串連屬性，這些屬性將在擷取資料庫連接時傳遞給底層的 JDBC驅動程式。字串的格式必須是`propertyName=property;` 重要 `username`和`password`屬性將被明確傳遞，因此不需要在此處包含它們。
選擇性參數	removeAbandonedOnMaintenance removeAbandonedOnBorrow	false	這兩個參數用於控制在串連被認為是被遺棄的情況下的移除行為。 `removeAbandonedOnMaintenance`：如果將此參數設定為`true`，串連池會在維護迴圈（當驅逐結束時）中移除被認為是被遺棄的串連。但是，此參數只在啟用維護迴圈（通過設定`timeBetweenEvictionRunsMillis`為正值）時才會生效。 `removeAbandonedOnBorrow`：如果將此參數設定為`true`，在每次從串連池中借用串連時，串連池會檢查是否存在被認為是被遺棄的串連，並將其移除。此外，移除操作還需要滿足以下兩個條件： `getNumActive() > getMaxTotal() - 3`：當前活動串連數大於最大串連數減去 3。 `getNumIdle() < 2`：當前空閑串連數小於 2。通過設定以上兩個參數為`true`，串連池可以自動檢測和移除被遺棄的串連。被遺棄的串連是指長時間未被使用的串連，可能是由於應用程式沒有正確關閉串連而導致的。通過移除這些被遺棄的串連，可以釋放資料庫資源並提高串連池的效能和效率。

Main.java 代碼介紹

Main.java檔案是樣本程式的一部分，用於示範通過 DBCP 串連池擷取資料庫連接，並執行一系列資料庫操作，包括建立表、插入資料、刪除資料、更新資料、查詢資料，並將查詢結果列印出來。

本文Main.java檔案的代碼主要包括以下幾個部分：

匯入所需的類和介面。
匯入所需的類和介面，其中包括了用於讀取檔案、資料庫操作和資料庫連接池的相關類和介面。這些類和介面在後續的代碼中會被使用到。
1. 聲明一個名為com.example的包，該包用於存放當前 Java 類。
2. 匯入java.io.FileInputStream類，用於讀取檔案。
3. 匯入java.sql.Connection介面，表示與資料庫的串連。
4. 匯入java.sql.PreparedStatement介面，表示先行編譯的 SQL 陳述式。
5. 匯入java.sql.ResultSet介面，表示資料庫查詢的結果集。
6. 匯入java.sql.SQLException異常類，表示 SQL 操作異常。
7. 匯入java.util.Properties類，用於載入設定檔。
8. 匯入org.apache.commons.dbcp2.BasicDataSource類，表示資料庫連接池。
9. 匯入org.apache.commons.dbcp2.BasicDataSourceFactory類，用於建立資料庫連接池。
代碼如下：
```
package com.example;

import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
```

定義類名和方法。

建立 Main 類，並定義了一個main方法作為程式的進入點。
在main方法中，首先調用createDataSource()方法建立串連池對象dataSource。
使用try-with-resources語句，在串連池對象的生命週期結束時自動關閉資源。
在try代碼塊中，調用getConnection()方法從串連池中擷取一個資料庫連接對象conn。
依次調用createTable()、insertData()、deleteData()、updateData()和queryData()方法，執行相應的資料庫操作。
在發生異常時，通過catch塊列印異常資訊。

代碼如下：

public class Main {

    public static void main(String[] args) {
        try (BasicDataSource dataSource = createDataSource()) {
            try (Connection conn = dataSource.getConnection()) {
                createTable(conn);
                insertData(conn);
                deleteData(conn);
                updateData(conn);
                queryData(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 建立串連池
    // 定義用於建立表的方法
    // 定義用於插入資料的方法
    // 定義用於刪除資料的方法
    // 定義用於更新資料的方法
    // 定義用於查詢資料的方法
}

建立串連池。
提供一個方便建立資料庫連接池的方法，通過讀取設定檔中的參數來初始化串連池對象。具體步驟如下：
1. 定義一個私人靜態方法createDataSource()，傳回型別為BasicDataSource。方法可能會拋出Exception異常。
2. 建立一個Properties對象props，用於儲存資料庫連接的配置資訊。
3. 建立一個FileInputStream對象is，用於讀取位於src/main/resources目錄下的db.properties檔案。
4. 通過load()方法，將db.properties檔案中的索引值對載入到 props 對象中。
5. 調用BasicDataSourceFactory.createDataSource(props)方法，使用props對象作為參數建立並返回一個BasicDataSource對象。
代碼如下：
```
    private static BasicDataSource createDataSource() throws Exception {
        Properties props = new Properties();
        FileInputStream is = new FileInputStream("src/main/resources/db.properties");
        props.load(is);

        return BasicDataSourceFactory.createDataSource(props);
    }
```
定義用於建立表的方法。
提供一個方法，用於在資料庫中建立指定的表。它接受一個連線物件作為參數，並使用先行編譯的方式執行建立表的 SQL 陳述式。具體步驟如下：
1. 定義一個私人靜態方法createTable()，接受一個Connection對象作為參數，方法可能會拋出SQLException異常。
2. 定義一個字串變數createTableSql，用於儲存建立表的 SQL 陳述式。SQL 陳述式中指定表名為test_tbl1，並定義了兩個列，一個是名為id的INT類型列，另一個是名為name的VARCHAR(32)類型列。
3. 使用conn.prepareStatement(createTableSql)方法建立一個PreparedStatement對象createTableStmt，該對象用於執行先行編譯的 SQL 陳述式。
4. 調用execute()方法執行 SQL 陳述式，用於建立表。
代碼如下：
```
    private static void createTable(Connection conn) throws SQLException {
        String createTableSql = "CREATE TABLE test_tbl1 (id INT, name VARCHAR(32))";
        try (PreparedStatement createTableStmt = conn.prepareStatement(createTableSql)) {
            createTableStmt.execute();
        }
    }
```
定義用於插入資料的方法。
提供一個方法，用於向資料庫中的表插入指定的資料。它接受一個連線物件作為參數，並使用先行編譯的方式執行插入資料的 SQL 陳述式。具體步驟如下：
1. 定義一個私人靜態方法insertData()，接受一個Connection對象作為參數，方法可能會拋出SQLException異常。
2. 定義一個字串變數insertDataSql，用於儲存插入資料的 SQL 陳述式。
3. 使用conn.prepareStatement(insertDataSql)方法建立一個PreparedStatement對象insertDataStmt，該對象用於執行先行編譯的 SQL 陳述式。
4. 使用for迴圈向表中插入資料：
  1. 迴圈10次，每次迴圈插入一條資料。
  2. 使用setInt()方法將迴圈變數i的值設定為 SQL 陳述式中的第一個參數值。
  3. 使用setString()方法將字串test_insert + i設定為 SQL 陳述式中的第二個參數值。
  4. 調用executeUpdate()方法執行 SQL 陳述式，用於向資料庫中插入資料。
代碼如下：
```
    private static void insertData(Connection conn) throws SQLException {
        String insertDataSql = "INSERT INTO test_tbl1 (id, name) VALUES (?, ?)";
        try (PreparedStatement insertDataStmt = conn.prepareStatement(insertDataSql)) {
            for (int i = 0; i < 10; i++) {
                insertDataStmt.setInt(1, i);
                insertDataStmt.setString(2, "test_insert" + i);
                insertDataStmt.executeUpdate();
            }
        }
    }
```
定義用於刪除資料的方法。
提供一個方法，用於從資料庫中刪除滿足特定條件的資料。它接受一個連線物件作為參數，並使用先行編譯的方式執行刪除資料的 SQL 陳述式。具體步驟如下：
1. 定義一個私人靜態方法deleteData()，接受一個Connection對象作為參數，方法可能會拋出SQLException異常。
2. 定義一個字串變數deleteDataSql，用於儲存刪除資料的 SQL 陳述式。
3. 使用conn.prepareStatement(deleteDataSql)方法建立一個PreparedStatement對象deleteDataStmt，該對象用於執行先行編譯的 SQL 陳述式。
4. 使用setInt()方法將數字 5 設定為 SQL 陳述式中的參數值。
5. 調用executeUpdate()方法執行 SQL 陳述式，用於從資料庫中刪除合格資料。
代碼如下：
```
    private static void deleteData(Connection conn) throws SQLException {
        String deleteDataSql = "DELETE FROM test_tbl1 WHERE id < ?";
        try (PreparedStatement deleteDataStmt = conn.prepareStatement(deleteDataSql)) {
            deleteDataStmt.setInt(1, 5);
            deleteDataStmt.executeUpdate();
        }
    }
```
定義用於更新資料的方法。
提供一個方法，用於更新資料庫中滿足特定條件的資料。它接受一個連線物件作為參數，並使用先行編譯的方式執行更新資料的 SQL 陳述式。具體步驟如下：
1. 定義一個私人靜態方法updateData()，接受一個Connection對象作為參數，方法可能會拋出SQLException異常。
2. 定義一個字串變數updateDataSql，用於儲存更新資料的 SQL 陳述式。
3. 使用conn.prepareStatement(updateDataSql)方法建立一個PreparedStatement對象updateDataStmt，該對象用於執行先行編譯的 SQL 陳述式。
4. 使用setString()方法將字串test_update設定為 SQL 陳述式中的第一個參數值。
5. 使用setInt()方法將數字5設定為 SQL 陳述式中的第二個參數值。
6. 調用executeUpdate()方法執行 SQL 陳述式，用於更新資料庫中合格資料。
代碼如下：
```
    private static void updateData(Connection conn) throws SQLException {
        String updateDataSql = "UPDATE test_tbl1 SET name = ? WHERE id = ?";
        try (PreparedStatement updateDataStmt = conn.prepareStatement(updateDataSql)) {
            updateDataStmt.setString(1, "test_update");
            updateDataStmt.setInt(2, 5);
            updateDataStmt.executeUpdate();
        }
    }
```
定義用於查詢資料的方法。
提供一個方法，用於查詢資料庫中的資料並進行處理。它接受一個連線物件作為參數，並使用先行編譯的方式執行查詢資料的 SQL 陳述式。具體步驟如下：
1. 定義一個私人靜態方法queryData()，接受一個Connection對象作為參數，方法可能會拋出SQLException異常。
2. 定義一個字串變數queryDataSql，用於儲存查詢資料的 SQL 陳述式。
3. 使用conn.prepareStatement(queryDataSql)方法建立一個PreparedStatement對象queryDataStmt，該對象用於執行先行編譯的 SQL 陳述式。
4. 通過queryDataStmt.executeQuery()方法執行 SQL 查詢，並使用ResultSet對象rs來接收查詢結果。
5. 使用while迴圈，通過rs.next()方法遍曆查詢結果集：
  1. 使用getInt()方法擷取結果集中名為id的列的整數值，並將其賦值給變數id。
  2. 使用getString()方法擷取結果集中名為name的列的字串值，並將其賦值給變數name。
  3. 列印輸出查詢結果的id和name。
代碼如下：
```
    private static void queryData(Connection conn) throws SQLException {
        String queryDataSql = "SELECT * FROM test_tbl1";
        try (PreparedStatement queryDataStmt = conn.prepareStatement(queryDataSql)) {
            try (ResultSet rs = queryDataStmt.executeQuery()) {
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    System.out.println("id: " + id + ", name: " + name);
                }
            }
        }
    }
```

完整的代碼展示

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>dbcp-mysql-client</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
</project>

db.properties

jdbcUrl=jdbc:mysql://$host:$port/$database_name?useSSL=false
username=$user_name
password=$password

dataSource.cachePrepStmts=true
dataSource.prepStmtCacheSize=250
dataSource.maxLifetime=1800000
dataSource.idleTimeout=600000
dataSource.connectionTimeout=30000

Main.java

package com.example;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class Main {
    public static void main(String[] args) {
        try {
            HikariConfig config = new HikariConfig("/db.properties");
            try (HikariDataSource dataSource = new HikariDataSource(config);
                 Connection conn = dataSource.getConnection()) {
                createTable(conn);

                insertData(conn, 1, "A1");
                insertData(conn, 2, "A2");

                selectData(conn);

                updateData(conn, "test_update", 1);
                selectData(conn);

                deleteData(conn, 2);
                selectData(conn);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void createTable(Connection conn) throws SQLException {
        String sql = "CREATE TABLE IF NOT EXISTS test_hikaricp (id INT, name VARCHAR(50))";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.executeUpdate();
            System.out.println("Table created successfully.");
        }
    }

    private static void insertData(Connection conn, int id, String name) throws SQLException {
        String sql = "INSERT INTO test_hikaricp (id, name) VALUES (?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.setString(2, name);
            pstmt.executeUpdate();
            System.out.println("Data inserted successfully.");
        }
    }

    private static void selectData(Connection conn) throws SQLException {
        String sql = "SELECT * FROM test_hikaricp";
        try (PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {
            System.out.println("User Data:");
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                System.out.println("ID: " + id + ", Name: " + name);
            }
            System.out.println();
        }
    }

    private static void updateData(Connection conn, String name, int id) throws SQLException {
        String sql = "UPDATE test_hikaricp SET name = ? WHERE id = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, name);
            pstmt.setInt(2, id);
            pstmt.executeUpdate();
            System.out.println("Data updated successfully.");
        }
    }

    private static void deleteData(Connection conn, int id) throws SQLException {
        String sql = "DELETE FROM test_hikaricp WHERE id = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.executeUpdate();
            System.out.println("Data deleted successfully.");
        }
    }
}

ApsaraDB for OceanBase (Deprecated)：DBCP 串連池串連 OceanBase 資料庫樣本程式