MySQL模式下HiKariCP串連池配置依賴/設定檔和範例程式碼 - ApsaraDB for OceanBase

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

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

前提條件

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

操作步驟

說明

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

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

步驟一：將 hikaricp-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&useSSL=false
```
參數說明：
- $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=******&useSSL=false
```

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

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

樣本如下：

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

代碼如下：

...
jdbcUrl=jdbc:mysql://xxx.xxx.xxx.xxx:3306/test?useSSL=false
username=test_user001
password=******
...

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

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

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

obclient [(none)]> SELECT * FROM test.test_hikaricp;

返回結果如下：

+------+-------------+
| id   | name        |
+------+-------------+
|    1 | test_update |
+------+-------------+
1 row in set

專案代碼介紹

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

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

hikaricp-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>指定專案的名稱為hikaricp-mysql-client。
3. 通過<version>專案的版本號碼為1.0-SNAPSHOT。
代碼如下：
```
    <groupId>com.example</groupId>
    <artifactId>hikaricp-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>
```
設定項目所相依元件。
1. 添加mysql-connector-java依賴庫，用於與資料庫進行互動：
  1. 通過<groupId>指定依賴項所屬的組織為mysql。
  2. 通過<artifactId>指定依賴項的名稱為mysql-connector-java。
  3. 通過<version>指定依賴項的版本號碼為5.1.40。
  代碼如下：
```
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>
```
2. 添加HikariCP依賴庫，用於實現高效能的 JDBC 串連池：
  1. 通過<groupId>指定依賴項所屬的組織為com.zaxxer。
  2. 通過<artifactId>指定依賴項的名稱為HikariCP。
  3. 通過<version>指定依賴項的版本號碼為3.3.1。
  代碼如下：
```
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>3.3.1</version>
        </dependency>
```
3. 添加logback-classic依賴庫，用於方便地進行日誌記錄和管理：
  1. 通過<groupId>指定依賴項所屬的組織為ch.qos.logback。
  2. 通過<artifactId>指定依賴項的名稱為logback-classic。
  3. 通過<version>指定依賴項的版本號碼為1.2.5。
  代碼如下：
```
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.5</version>
        </dependency>
```

db.properties 代碼介紹

db.properties是本文樣本的串連池設定檔，其中包含了串連池的配置屬性。這些屬性包括資料庫 URL、使用者名稱、密碼、串連池其他可選項。

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

設定資料庫串連參數。
1. 設定資料庫串連的 URL，包括主機 IP、連接埠號碼、需要訪問的資料庫。
2. 設定資料庫使用者名稱。
3. 設定資料庫密碼。
代碼如下：
```
jdbcUrl=jdbc:mysql://$host:$port/$database_name?useSSL=false
username=$user_name
password=$password
```
參數解釋：
- $host：OceanBase 資料庫連接的網域名稱。
- $port：OceanBase 資料庫連接連接埠，MySQL 模式租戶預設是 3306。
- $database_name：需要訪問的資料庫名稱。
- $user_name：租戶的串連帳號。
- $password：提供賬戶密碼。
配置其他串連池的參數。
1. 啟用先行編譯 SQL 陳述式的緩衝。
2. 設定先行編譯 SQL 陳述式的緩衝大小為 250。
3. 設定串連的最大生命週期為 1800000 毫秒（30 分鐘），超過這個時間串連將被關閉。
4. 設定串連的空閑逾時時間為 600000 毫秒（10 分鐘），超過這個時間且串連處於空閑狀態時，串連將被關閉。
5. 設定串連的逾時時間為 30000 毫秒（30 秒），超過這個時間仍未獲得串連時，將拋出異常。
代碼如下：
```
dataSource.cachePrepStmts=true
dataSource.prepStmtCacheSize=250
dataSource.maxLifetime=1800000
dataSource.idleTimeout=600000
dataSource.connectionTimeout=30000
```

重要

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

HikariCP 串連池常用基本參數：

分類	參數	預設值	描述
必選參數	dataSourceClassName	N/A	用於指定 JDBC 驅動程式提供的 DataSource 類的名稱。重要 `dataSourceClassName`通常不需要顯式配置，因為 HikariCP 可以自動檢測和載入適當的驅動程式。
	jdbcUrl	N/A	用於指定 JDBC 串連資料庫的 URL。
	username	N/A	用於指定串連資料庫時使用的使用者名稱。
	password	N/A	指定串連資料庫時使用的密碼。
常用選擇性參數	autoCommit	true	用於控制串連池返回的串連的預設自動認可行為。
	connectionTimeout	30000	用於控制用戶端從串連池擷取串連時的最大等待時間。單位為毫秒，預設值是 30000（30 秒）。最低可接受的連線逾時時間是 250 毫秒。
	idleTimeout	600000	用於控制串連在池中閒置最大時間。單位為毫秒，預設值是 600000（10 分鐘）。該設定有如下限制：僅在`minimumIdle`小於`maximumPoolSize`時生效。當串連池中的串連達到`minimumIdle`數量時，空閑串連不會被回收。只有當串連數超過`minimumIdle`時，串連才可能被回收。
	keepaliveTime	0	用於控制串連保活的頻率，以防止串連被資料庫或網路基礎設施逾時。單位為毫秒，預設值是 0，表示禁用串連保活。該值必須小於`maxLifetime`屬性的值。
	maxLifetime	1800000	用於控制串連在串連池中的最大生命週期。已經被使用的串連不會被自動回收，只有當串連被關閉時，才會從串連池中移除。單位為毫秒，預設值是 1800000（30 分鐘）。如果將`maxLifetime`設定為 0，表示串連在串連池中沒有最大生命週期的限制，即串連的生命週期是無限的。
	connectionTestQuery	N/A	用於執行串連池向資料庫發送的串連測試查詢。它在從串連池中擷取串連之前執行，以驗證與資料庫的串連是否仍然有效。
	minimumIdle	N/A	用於控制串連池中保持的最小空閑串連數量。如果空閑串連數低於這個值，並且串連池中的總串連數少於`maximumPoolSize`，HikariCP 會儘力快速且高效地添加額外的串連。預設情況下，`minimumIdle`屬性的值與`maximumPoolSize`屬性相同。
	maximumPoolSize	10	用於控制串連池允許的最大大小，包括空閑和正在使用的串連。這個值決定了與資料庫後端的實際串連數的最大數量。
	poolName	N/A	用於表示使用者定義的串連池名稱。在日誌記錄和 JMX 管理主控台中，這個名稱主要用於識別串連池和串連池配置。預設情況下，它會被自動產生一個名稱。

Main.java 代碼介紹

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

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

匯入所需的類和包。
1. 定義當前 Java 檔案的包名為com.example，用於組織和管理 Java 類。
2. 匯入java.sql.Connection類，用於建立和管理與資料庫的串連。
3. 匯入java.sql.PreparedStatement類，用於執行先行編譯的 SQL 陳述式。
4. 匯入java.sql.ResultSet類，用於處理查詢結果集。
5. 匯入java.sql.SQLException類，用於處理 SQL 異常。
6. 匯入 HikariCP 的HikariConfig類，用於配置 HikariCP 串連池。
7. 匯入 HikariCP 的HikariDataSource類，用於建立和管理 HikariCP 串連池。
代碼如下：
```
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;
```
定義類名和方法。
定義一個 Main 類，其中的main方法作為程式的入口。在main方法中，通過讀取db.properties檔案來配置 HikariCP 串連池，並擷取資料庫連接。然後依次調用了一系列的方法來建立表、插入資料、查詢資料、更新資料和刪除資料。如果在操作過程中發生SQLException異常，則會列印異常資訊的堆疊追蹤。具體步驟如下：
1. 定義一個名為 Main 的公用類。
2. 定義 Main 類的入口方法main。
3. 建立一個 HikariConfig 對象，並通過指定的db.properties檔案進行配置。
4. 建立一個 HikariDataSource 對象，並在try-with-resources塊中擷取一個資料庫連接。
5. 調用用於建立表的方法，傳遞了擷取的資料庫連接對象，建立表test_hikaricp。
6. 調用用於插入資料的方法，傳遞了擷取的資料庫連接對象和資料參數，插入(1,'A1')和(2,'A2')兩行資料。
7. 調用用於查詢資料的方法，傳遞了擷取的資料庫連接對象，查看資料插入情況。
8. 調用用於更新資料的方法，傳遞了擷取的資料庫連接對象和更新參數，將id為1的行中name列的值更新為test_update。
9. 調用用於查詢資料的方法，傳遞了擷取的資料庫連接對象，查看更新資料情況。
10. 調用了一個用於刪除資料的方法，傳遞了擷取的資料庫連接對象和刪除參數，將id為2的行刪除。
11. 調用了一個用於查詢資料的方法，傳遞了擷取的資料庫連接對象，查看刪除資料情況。
12. 如果在try塊中發生了SQLException異常，將列印異常的堆疊追蹤資訊。
13. 定義用於建立表、插入資料、查詢資料、更新資料和刪除資料的方法。
代碼如下：
```
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();
        }
    }

    // 定義用於建立表的方法
    // 定義用於插入資料的方法
    // 定義用於查詢資料的方法
    // 定義用於更新資料的方法
    // 定義用於刪除資料的方法
}
```
定義用於建立表的方法。
定義一個私人靜態方法createTable，用於在資料庫中建立一個名為test_hikaricp的表，該表包含id列和name列。具體步驟如下：
1. 定義一個私人靜態方法createTable，該方法接受一個 Connection 對象作為參數，並聲明可能拋出SQLException異常。
2. 定義一個 SQL 陳述式字串，用於建立名為test_hikaricp的表，表包含id列（資料類型為INT）和name列（資料類型為VARCHAR(50)）。
3. 使用連線物件conn建立一個先行編譯的 SQL 陳述式對象pstmt，並在try-with-resources塊中使用該對象。
4. 執行 SQL 陳述式，建立名為test_hikaricp的表。
5. 在控制台輸出列印訊息，表示表建立成功。
代碼如下：
```
    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.");
        }
    }
```
定義用於插入資料的方法。
定義一個私人靜態方法insertData，用於向資料庫中的表test_hikaricp插入資料。具體步驟如下：
1. 定義一個私人靜態方法insertData，該方法接受一個 Connection 對象、一個整數類型的id參數和一個字串類型的name參數，並聲明可能拋出SQLException異常。
2. 定義一個 SQL 陳述式字串，用於向名為test_hikaricp的表中插入資料，資料包括id和name列。
3. 使用連線物件conn建立一個先行編譯的 SQL 陳述式對象pstmt，並在try-with-resources塊中使用該對象。
4. 設定 SQL 陳述式中第一個參數?的值為id。
5. 設定 SQL 陳述式中第二個參數?的值為name。
6. 執行 SQL 陳述式，向表中插入資料。
7. 在控制台輸出列印訊息，表示資料插入成功。
代碼如下：
```
    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.");
        }
    }
```
定義用於查詢資料的方法。
定義一個私人靜態方法selectData，用於從資料庫中查詢表test_hikaricp的資料。具體步驟如下：
1. 定義一個私人靜態方法selectData，該方法接受一個 Connection 對象作為參數，並聲明可能拋出SQLException異常。
2. 定義一個 SQL 陳述式字串，用於查詢名為test_hikaricp的表中的所有資料。
3. 使用連線物件conn建立一個先行編譯的 SQL 陳述式對象pstmt，並在try-with-resources塊中使用該對象。同時，通過調用executeQuery()方法執行 SQL 查詢，並返回查詢結果集對象rs。
4. 在控制台輸出列印訊息，表示正在列印使用者資料。
5. 遍曆查詢結果集，使用next()方法檢查結果集中是否還有下一行資料，如果有，則進入迴圈。
6. 從結果集中擷取id列的值，並將其賦給變數id。
7. 從結果集中擷取name列的值，並將其賦給變數name。
8. 在控制台輸出列印每行資料的id和name值。
9. 在控制台輸出一個空行。
代碼如下：
```
    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();
        }
    }
```
定義用於更新資料的方法。
定義一個私人靜態方法updateData，用於更新資料庫中表test_hikaricp中的資料。具體步驟如下：
1. 定義一個私人靜態方法updateData，該方法接受一個 Connection 對象、一個字串類型的name參數和一個整數類型的id參數，並聲明可能拋出SQLException異常。
2. 定義一個 SQL 陳述式字串，用於更新名為test_hikaricp的表中的資料，將name列的值更新為指定的name，條件是id列的值等於指定的id。
3. 使用連線物件conn建立一個先行編譯的 SQL 陳述式對象pstmt，並在try-with-resources塊中使用該對象。
4. 設定 SQL 陳述式中第一個參數?的值為name。
5. 設定 SQL 陳述式中第二個參數?的值為id。
6. 執行 SQL 陳述式，更新表中的資料。
7. 在控制台輸出列印訊息，表示資料更新成功。
代碼如下：
```
    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.");
        }
    }
```
定義用於刪除資料的方法。
定義一個私人靜態方法deleteData，用於從資料庫中刪除表test_hikaricp中滿足條件的資料。具體步驟如下：
1. 定義一個私人靜態方法deleteData，該方法接受一個 Connection 對象和一個整數類型的id參數，並聲明可能拋出SQLException異常。
2. 定義一個 SQL 陳述式字串，用於從名為test_hikaricp的表中刪除滿足條件id = ?的資料。
3. 使用連線物件conn建立一個先行編譯的 SQL 陳述式對象pstmt，並在try-with-resources塊中使用該對象。
4. 設定 SQL 陳述式中第一個參數?的值為id。
5. 執行 SQL 陳述式，從表中刪除滿足條件的資料。
6. 在控制台輸出列印訊息，表示資料刪除成功。
代碼如下：
```
    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.");
        }
    }
```

完整的代碼展示

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.oceanbase</groupId>
    <artifactId>hikaricp-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.40</version>
        </dependency>
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>3.3.1</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.5</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：HikariCP 串連池串連 OceanBase 資料庫樣本程式