Proxool 串連池串連 OceanBase 資料庫樣本程式

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

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

前提條件

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

操作步驟

說明

本文中給出的操作步驟是在 Windows 環境下使用 IntelliJ IDEA Community Edition 2021.3.2 編譯和運行該專案的步驟。如果您使用的是其他動作系統內容或編譯器，那麼操作步驟可能會略有不同。

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

步驟一：將 proxool-mysql-client 專案匯入到 IntelliJ IDEA 中

開啟 IntelliJ IDEA。
在歡迎介面上，點擊 Open 選項，導航到您的專案目錄，選擇專案的根目錄，點擊 OK。
IntelliJ IDEA 會自動檢測項目類型並附加元件目。
說明
當使用 IntelliJ IDEA 匯入 Maven 專案時，IntelliJ IDEA 會自動檢測專案中的pom.xml檔案，並根據檔案中描述的依賴關係自動下載所需的依賴庫，並將它們添加到專案中。
（可選）手動匯入未解析的依賴項。
如果pom.xml檔案中對應的依賴項都自動匯入到了專案中，請忽略此步驟。
通過 IntelliJ IDEA 的 Sync 視窗的提示，可以發現proxool-cglib和proxool依賴項未解析。proxool-mysql-client專案根目錄下的lib的檔案夾中有proxool-cglib和proxool的jar檔案，將其添加到專案，步驟如下：
1. 在 IntelliJ IDEA 中，點擊 File->Project Structure 進入專案結構設定。
2. 在左側面板中，選擇 Modules。
3. 在右側的模組列表中，選擇 Dependencies 選項卡，點擊此頁面上的+表徵圖，選擇 JARs or directories。
4. 在彈出的對話方塊中，導航到存放jar檔案的lib目錄，選中jar檔案，點擊 OK。
5. 在 Dependencies 選項卡下，會看到新加入的jar檔案出現在列表中。
6. 點擊 Apply 或 OK 儲存更改。

步驟二：擷取 OceanBase 資料庫 URL

聯絡 OceanBase 資料庫部署人員或者管理員擷取相應的資料庫連接串。
樣本如下：
```
obclient -hxxx.xxx.xxx.xxx -P3306 -utest_user001 -p****** -Dtest -A
```
更多串連串的資訊，請參見擷取串連參數。
根據 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=******
```

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

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

樣本如下：

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

代碼如下：

...
jdbc-1.proxool.driver-url=jdbc:mysql://xxx.xxx.xxx.xxx:3306/test?useSSL=false
jdbc-1.user=test_user
jdbc-1.password=******
...

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

在專案導覽列中，找到並展開 src/main/java/com.example 目錄。
右鍵點擊 Main 檔案，選擇 Run 'Main.main()'。
IntelliJ IDEA 會自動編譯和運行該專案，並在運行面板中顯示輸出結果。

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

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

返回結果如下：

+------+---------------+
| c1   | c2            |
+------+---------------+
|    6 | test_update   |
|    7 | test_insert7  |
|    8 | test_insert8  |
|    9 | test_insert9  |
|   10 | test_insert10 |
+------+---------------+
5 rows in set

專案代碼介紹

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

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

proxool-mysql-client
├── lib
│    ├── proxool-0.9.1.jar
│    └── proxool-cglib.jar
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── example
│       │           └── Main.java
│       └── resources
│           └── db.properties
└── pom.xml

檔案說明：

lib：存放專案所需的依賴庫檔案。
proxool-0.9.1.jar：Proxool 串連池庫檔案。
proxool-cglib.jar：用於支援 Proxool 串連池的 CGLib 庫檔案。
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>指定專案的名稱為proxool-mysql-client。
3. 通過<version>專案的版本號碼為1.0-SNAPSHOT。
代碼如下：
```
    <groupId>com.example</groupId>
    <artifactId>proxool-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>定義依賴項：
1. 添加mysql-connector-java庫，用於串連和操作資料庫：
  1. 通過<groupId>指定依賴項所屬的組織為mysql。
  2. 通過<artifactId>指定依賴項的名稱為mysql-connector-java。
  3. 通過<version>指定依賴項的版本號碼為5.1.47。
  代碼如下：
```
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
```
2. 添加proxool-cglib依賴庫，用於支援 Proxool 串連池的 CGLib 庫：
  1. 通過<groupId>指定依賴項所屬的組織為proxool。
  2. 通過<artifactId>指定依賴項的名稱為proxool-cglib。
  3. 通過<version>指定依賴項的版本號碼為0.9.1。
  代碼如下：
```
        <dependency>
            <groupId>proxool</groupId>
            <artifactId>proxool-cglib</artifactId>
            <version>0.9.1</version>
        </dependency>
```
3. 添加proxool依賴庫，Proxool 串連池的核心庫：
  1. 通過<groupId>指定依賴項所屬的組織為proxool。
  2. 通過<artifactId>指定依賴項的名稱為proxool。
  3. 通過<version>指定依賴項的版本號碼為0.9.1。
  代碼如下：
```
        <dependency>
            <groupId>proxool</groupId>
            <artifactId>proxool</artifactId>
            <version>0.9.1</version>
        </dependency>
```
4. 添加commons-logging依賴庫，用於在應用程式中進行日誌記錄的通用日誌庫：
  1. 通過<groupId>指定依賴項所屬的組織為commons-logging。
  2. 通過<artifactId>指定依賴項的名稱為commons-logging。
  3. 通過<version>指定依賴項的版本號碼為1.2。
  代碼如下：
```
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
```

db.properties 代碼介紹

db.properties是本文樣本的串連池設定檔，其中包含了串連池的配置屬性。

說明

使用.properties檔案配置 Proxool 串連池時，需要遵循以下規則：

以jdbc為首碼的自訂名稱來標識每個串連池。可以自訂這個名稱，用於唯一標識每個串連池。
Proxool 串連池的相關屬性應該以proxool.為首碼，這些屬性將被用於配置 Proxool 串連池自身的屬性。
沒有以jdbc為首碼的屬性將會被忽略，不會被 Proxool 使用。
沒有以proxool.為首碼的屬性將被傳遞給實際的資料庫連接，即這些屬性將被傳遞給實際的資料庫驅動程式。

更多配置 Proxool 串連池的方法，請參見Configuration。

本文db.properties檔案是一個屬性檔案的樣本，用於配置一個名為jdbc-1的資料來源的串連池屬性。主要包括以下幾個部分：

設定資料來源的別名為TEST。
代碼如下：
```
jdbc-1.proxool.alias=TEST
```
設定資料庫串連參數。
1. 設定驅動程式的類名，這裡是 MySQL JDBC 驅動的類名com.mysql.jdbc.Driver。
2. 設定資料庫連接的 URL，包括主機 IP、連接埠號碼、需要訪問的資料庫和額外的串連屬性。
3. 設定資料庫使用者名稱。
4. 設定資料庫密碼。
代碼如下：
```
jdbc-1.proxool.driver-class=com.mysql.jdbc.Driver
jdbc-1.proxool.driver-url=jdbc:mysql://$host:$port/$database_name?useSSL=false
jdbc-1.user=$user_name
jdbc-1.password=$password
```
參數解釋：
- $host：OceanBase 資料庫連接的網域名稱。
- $port：OceanBase 資料庫連接連接埠，MySQL 模式租戶預設是 3306。
- $database_name：需要訪問的資料庫名稱。
- $user_name：租戶的串連帳號。
- $password：提供賬戶密碼。
配置其他 Proxool 串連池的參數。
1. 設定串連池的最大串連數為 8。
2. 設定串連池的最小串連數為 5。
3. 設定串連池中可用的串連數量為 4。
4. 設定串連池的詳細模式為開啟，即顯示更多的日誌資訊。
5. 設定串連池的統計資訊記錄周期為 10 秒、1 分鐘和 1 天。
6. 設定串連池統計資訊記錄的記錄層級為錯誤層級。
代碼如下：
```
jdbc-1.proxool.maximum-connection-count=8
jdbc-1.proxool.minimum-connection-count=5
jdbc-1.proxool.prototype-count=4
jdbc-1.proxool.verbose=true
jdbc-1.proxool.statistics=10s,1m,1d
jdbc-1.proxool.statistics-log-level=error
```

重要

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

常用配置參數說明：

配置	預設值	說明

配置	預設值	說明
alias	N/A	用於設定串連池別名。可以用於標識一個串連池，在多個串連池的情況下很有用。
driver-class	N/A	用於設定資料庫驅動程式類名。
driver-url	N/A	用於設定資料庫連接 URL，包括主機 IP、連接埠號碼、需要訪問的 Schema 和可選的資料庫驅動參數。
username	N/A	用於設定資料庫使用者名稱。
password	N/A	用於設定資料庫密碼。
maximum-connection-count	15	用於設定串連池的最大串連數。預設值為 15，表示串連池最多可以建立 15 個串連。
minimum-connection-count	5	用於設定串連池的最小串連數。預設值為 5，表示串連池將始終保持至少 5 個串連。
prototype-count	0	用於設定串連池的原型串連數。預設值為 0，表示串連池不會主動建立額外的串連。與`minimum-connection-count`不同的是，`prototype-count`這個屬性會考慮當前活動串連的數量。如果可用串連數少於設定的`prototype-count`，串連池會建立更多的串連（前提是未達到最大串連數）。例如，如果有 3 個活動串連和 2 個可用串連，但`prototype-count`設定為 4，那麼串連池將嘗試建立另外 2 個串連。 `prototype-count`的目的是在當前活動串連的基礎上維持一定數量的備用串連。這些備用串連可以避免在高負載期間由於串連池中可用串連不足而導致的串連請求被阻塞。通過建立更多的串連，串連池可以更好地應對並發請求，提高應用程式的效能和響應速度。在調整這個屬性時，需要考慮應用程式的並發需求和資料庫的配置。如果應用程式預計會有較高的並發請求，可以適當增加`prototype-count`；如果應用程式的並發請求較少，可以將該屬性設定為 0，以減少資源消耗。
verbose	false	用於設定串連池的詳細輸出模式。預設值為`false`，即安靜模式。當`verbose`屬性設定為`true`時，串連池將輸出更詳細的資訊，以便開發人員進行調試和監控。這些資訊可能包括串連池的狀態、串連的建立和釋放、串連的使用方式等。開啟`verbose`模式可以協助開發人員更好地瞭解串連池的運行情況，以及檢查串連的分配和回收是否正常。這對於排查串連泄漏、效能問題和調優非常有用。在生產環境中，通常不建議將`verbose`設定為`true`，因為它會產生大量的輸出資訊，可能影響系統的效能和記錄檔的大小。通常情況下，建議將`verbose`設定為`false`，只在需要時臨時開啟以進行調試和監控。
statistics	null	用於配置統計資訊的採樣長度，即串連池使用狀況統計。採樣長度可以設定為以逗號分隔的時間單位，例如`10s,15m`表示每 10 秒和每 15 分鐘採樣一次。可用的單位有`s`（秒）、`m`（分鐘）、`h`（小時）和`d`（天）。預設值為`null`，表示不採集統計資訊。當設定`statistics`屬性時，串連池將定期採樣串連池的統計資訊，如活動串連數、空閑串連數、串連請求數等。採樣長度決定了統計資訊的粒度和採樣頻率。
statistics-log-level	null	用於設定統計資訊的記錄層級，即日誌統計跟蹤類型。可選的記錄層級有`DEBUG`、`INFO`、`WARN`、`ERROR`和`FATAL`。預設值為`null`，表示不記錄統計資訊日誌。當設定了`statistics-log-level`屬性後，串連池會將產生的統計資訊以指定的記錄層級記錄下來。這些統計資訊可以包括串連池的狀態、串連的建立和釋放、串連的使用方式等。
test-after-use	N/A	用於設定串連在關閉後是否進行測試。如果將該屬性設定為`true`，並且定義了`house-keeping-test-sql`屬性，那麼每個串連在關閉（即返回到串連池）後都會進行測試。如果串連測試失敗，則該串連會被丟棄。串連池中的串連在使用完畢後通常會被放回串連池中以供重複使用。`test-after-use`屬性的作用是在串連放回串連池後，對該串連進行測試，以確保串連的可用性和有效性。串連測試通常使用`house-keeping-test-sql`屬性指定的 SQL 陳述式。通過開啟`test-after-use`功能，串連池可以及時檢測到停用串連，並將其從串連池中移除，以避免應用程式擷取到無效的串連。這可以提高應用程式的穩定性和可靠性。需要注意的是，為了使用`test-after-use`功能，需要預先設定好`house-keeping-test-sql`屬性，該屬性用於定義串連測試所使用的 SQL 陳述式。這樣串連池才能根據`house-keeping-test-sql`定義的規則來對串連進行測試和判斷。
house-keeping-test-sql	N/A	用於設定串連池中空閑串連的測試 SQL 陳述式。當串連池的管家線程發現有空閑串連時，會使用該 SQL 陳述式對這些串連進行測試。測試 SQL 陳述式應該是非常快速執行的，例如檢查當前日期等操作。如果沒有定義該屬性，則不進行串連測試。MySQL 模式可用`SELECT CURRENT_DATE`或者`SELECT 1`。Oracle 模式可用`SELECT sysdate FROM DUAL`或者`SELECT 1 FROM DUAL`。
trace	false	用於設定是否記錄每個 SQL 調用的日誌資訊。當設定為`true`時，每個 SQL 調用將被記錄在日誌中（`DEBUG`層級），並顯示執行時間。也可以通過註冊`ConnectionListener`（參見`ProxoolFacade`）來擷取這些資訊。預設值為`false`。開啟`trace`功能可能會產生大量的日誌輸出，特別是在高並發和頻繁 SQL 調用的情況下。在生產環境中，建議謹慎使用，以避免產生過多的日誌和對系統效能造成不必要的影響。
maximum-connection-lifetime	4 小時	用於設定串連的最大生命週期。即串連在被銷毀之前存在的最長時間（單位為毫秒）。預設值為 4 小時。串連的生命週期是指串連從建立到銷毀的時間段。通過設定`maximum-connection-lifetime`屬性，可以限制串連在串連池中存在的最長時間，以避免串連過久未使用或出現資源泄漏的情況。
maximum-active-time	5 分鐘	用於設定線程的最大啟用時間。當串連池的管家線程發現某個線程的啟用時間超過此設定時，它將終止該線程。因此，請確保將此屬性設定為大於預期最慢回應時間的值。預設值為 5 分鐘。守護進程會把串連池中多餘的可用線程（未用的、超過這個時間的）終止，最終保留的串連數量就是`minimum-connection-count`規定的數量。守護進程會根據`house-keeping-sleep-time`參數設定的時間隔定時檢查。
maximum-new-connections	N/A	用於設定串連池每次同時建立的最大新串連數。該屬性已被棄用（Deprecated）。建議使用`simultaneous-build-throttle`屬性替代。
simultaneous-build-throttle	10	用於設定在任何時刻串連池可以同時建立的最大串連數。也就是說，即將建立但尚未可用的新串連數的上限。因為串連的建立可能使用多個線程（例如按需建立串連時），並且在決定建立串連和串連可用之間需要一定的時間，所以我們需要一種方式來確保不會同時有大量線程決定建立串連。 `simultaneous-build-throttle`屬性的作用是限制串連池同時建立新串連的數量，以控制串連池的並發性。當達到最大並發串連數時，進一步請求新串連的線程將被阻塞，直到有可用的串連或超過指定的逾時時間。通過設定適當的`simultaneous-build-throttle`屬性，可以平衡串連池的並發性和資源消耗。預設值為 10，意味著串連池可以同時建立的最大串連數為 10。
overload-without-refusal-lifetime	60	用於協助確定串連池的狀態。如果在指定的時間閾值內（單位為毫秒）拒絕了串連請求，則表示串連池處於過載狀態。預設值為 60 秒。
test-before-use	N/A	用於設定是否在提供串連之前對每個串連進行測試。如果將該屬性設定為`true`，則在嚮應用程式提供串連之前，每個串連都會通過執行預定義的測試 SQL（由`house-keeping-test-sql`屬性定義）進行測試。如果串連測試失敗，則該串連將被丟棄，串連池將選擇另一個可用的串連。如果所有串連都測試失敗，則會建立一個新的串連。如果新串連測試失敗，則會拋出`SQLException`。需要注意一點，對於 MySQL 資料庫還必須在串連參數裡加上`autoReconnect=true`參數，否則即使開啟了`test-before-use`參數，仍然不能重串連。
fatal-sql-exception	null	用於配置 SQL 異常的檢測和處理。它是一個逗號分隔的訊息片段列表。當發生`SQLException`時，它的訊息會與這些訊息片段進行比較。如果它包含任何一個訊息片段（區分大小寫），則被視為致命的 SQL 異常。這將導致串連被丟棄。無論發生什麼情況，異常都會被重新拋出，以便使用者瞭解發生了什麼。您還可以選擇配置不同的異常被拋出（參見`fatal-sql-exception-wrapper-class`屬性）。預設值為`null`。需要注意的是，如果設定了`fatal-sql-exception-wrapper-class`屬性，可以配置一個替代的異常類來拋出。這樣可以自訂處理 SQL 異常的方式。
fatal-sql-exception-wrapper-class	null	用於配置致命 SQL 異常的異常封裝。當配置了`fatal-sql-exception`屬性時，預設行為是丟棄導致致命`SQLException`的異常，並將原始異常直接拋給使用者。使用該屬性，您可以將`SQLException`封裝在另一個異常中。這個異常可以是任何您想要的，只要它繼承自`SQLException`或`RuntimeException`。Proxool 提供了兩個類供您使用，如果您不想自己構建異常類的話：`FatalSQLException`和`FatalRuntimeException`。要使用這些類，您應該根據需要將該屬性設定為`org.logicalcobwebs.proxool.FatalSQLException`或`org.logicalcobwebs.proxool.FatalRuntimeException`。預設值為`null`，表示不封裝致命`SQLException`。預設值為 null。需要注意的是，異常封裝類必須是`SQLException`或`RuntimeException`的子類。
house-keeping-sleep-time	30秒	用於設定串連池的維護線程（house keeping thread）的休眠時間。維護線程負責檢查所有串連的狀態，判斷是否需要銷毀或建立串連。預設值為 30 秒，意味著維護線程將每隔 30 秒執行一次維護任務。
injectable-connection-interface	N/A	用於允許 Proxool 實現委託 Connection 對象中定義的方法。
injectable-statement-interface	N/A	用於允許 Proxool 實現委託 Statement 對象中定義的方法。
injectable-prepared-statement-interface	N/A	用於允許 Proxool 實現委託 PreparedStatement 對象中定義的方法。
injectable-callable-statement-interface	N/A	用於允許 Proxool 實現委託 CallableStatement 對象中定義的方法。
jndi-name	N/A	用於指定串連池在 JNDI (Java Naming and Directory Interface) 中註冊的名稱。

Main.java 代碼介紹

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

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

匯入所需的類和介面。
定義代碼所在的包，並匯入 Proxool 和 JDBC 相關的類。這些類用於實現資料庫連接池的配置和管理，以及執行 SQL 陳述式。通過使用 Proxool 串連池，可以提高資料庫操作的效能和可靠性。具體步驟如下：
1. 定義了代碼所在的包為com.example，該包用於存放當前 Java 類。
2. 匯入 Proxool 的配置類org.logicalcobwebs.proxool.configuration.PropertyConfigurator。
3. 匯入用於讀取設定檔的輸入資料流類java.io.InputStream。
4. 匯入 JDBC 的 Connection 類java.sql.Connection。
5. 匯入 JDBC 的 DriverManager 類java.sql.DriverManager。
6. 匯入 JDBC 的 ResultSet 類java.sql.ResultSet。
7. 匯入 JDBC 的 Statement 類java.sql.Statement。
8. 匯入用於載入設定檔的 Properties 類java.util.Properties。
代碼如下：
```
package com.example;

import org.logicalcobwebs.proxool.configuration.PropertyConfigurator;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
```
定義類名和方法。
定義一個 Java 程式的入口方法，其中通過讀取設定檔擷取資料庫連接資訊，在使用 Proxool 驅動程式建立資料庫連接後，依次調用定義好的方法執行 DDL 語句、DML 語句和查詢語句。捕獲並列印可能發生的異常資訊。這段代碼的目的是執行資料庫相關的操作，並通過日誌記錄器進行日誌記錄。具體步驟如下：
1. 定義了一個名為 Main 的公用類。
  1. 定義了一個名為DB_PROPERTIES_FILE的私人靜態常量，表示資料庫配置（屬性）檔案的路徑。這個常量可以在代碼中引用，以便載入和讀取屬性檔案。
  2. 定義一個公用靜態方法main，作為程式的起始執行點。
    1. 用於捕獲可能發生異常的代碼塊。
      1. 建立一個Properties對象，用於讀取設定檔中的屬性。
      2. 使用 Main 類的類載入器擷取設定檔的輸入資料流。
      3. 使用載入的輸入資料流載入設定檔，將屬性載入到Properties對象中。
      4. 使用載入的屬性配置串連池。
      5. 動態載入 Proxool 資料庫驅動程式。
      6. 使用 Proxool 驅動程式建立資料庫連接。
      7. 建立一個Statement對象。
      8. 調用定義好的方法executeDDLStatements()，執行 DDL 語句，是建立表的操作。
      9. 調用定義好的方法executeDMLStatements()，執行 DML 語句，是插入、更新和刪除資料的操作。
      10. 調用定義好的方法executeQueryStatements()，執行查詢語句，擷取資料。
    2. 捕獲並列印可能發生的異常資訊。
2. 定義了用於建立表、執行 DML 語句和查詢資料的方法。
代碼如下：
```
public class Main {
    private static final String DB_PROPERTIES_FILE = "/db.properties";

    public static void main(String[] args) {
        try {
            Properties properties = new Properties();
            InputStream is = Main.class.getResourceAsStream(DB_PROPERTIES_FILE);
            properties.load(is);
            PropertyConfigurator.configure(properties);

            Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
            try (Connection conn = DriverManager.getConnection("proxool.TEST");
                Statement stmt = conn.createStatement()) {
                executeDDLStatements(stmt);
                executeDMLStatements(stmt);
                executeQueryStatements(stmt);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 定義用於建立表的方法
    // 定義用於執行 DML 語句的方法
    // 定義用於查詢資料的方法
}
```
定義用於建立表的方法。
定義一個私人靜態方法executeDDLStatements()，用於執行 DDL（資料定義語言 (Data Definition Language)）語句，包括建立表的語句。具體步驟如下：
1. 定義一個私人靜態方法executeDDLStatements()，它接收一個Statement對象作為參數，並可能拋出Exception異常。
2. 使用execute()方法執行 SQL 陳述式，建立一個名為test_proxool的表，該表有兩列c1和c2，分別為INT類型和VARCHAR(32)類型。
代碼如下：
```
    private static void executeDDLStatements(Statement stmt) throws Exception {
        stmt.execute("CREATE TABLE test_proxool (c1 INT, c2 VARCHAR(32))");
    }
```
定義用於執行 DML 語句的方法。
定義一個私人靜態方法executeDMLStatements()，用於執行 DML（資料操作語言）語句，包括插入資料、刪除資料和更新資料的語句。具體步驟如下：
1. 定義一個私人靜態方法executeDMLStatements()，它接收一個Statement對象作為參數，如果在執行過程中出現異常，方法將拋出Exception異常。
2. 使用for迴圈，從 1 到 10 進行迭代。在迴圈中，使用execute()方法執行 SQL 插入語句，將變數i和相關的字串值插入到test_proxool表中。
3. 執行 SQL 刪除語句，從test_proxool表中刪除c1列值小於等於 5 的行。
4. 執行 SQL 更新語句，將test_proxool表中c1列值為 6 的行的c2列更新為test_update。
代碼如下：
```
    private static void executeDMLStatements(Statement stmt) throws Exception {
        for (int i = 1; i <= 10; i++) {
            stmt.execute("INSERT INTO test_proxool VALUES (" + i + ",'test_insert" + i + "')");
        }
        stmt.execute("DELETE FROM test_proxool WHERE c1 <= 5");
        stmt.execute("UPDATE test_proxool SET c2 = 'test_update' WHERE c1 = 6");
    }
```
定義用於查詢資料的方法。
定義一個私人靜態方法executeQueryStatements()，用於執行SELECT查詢語句並處理結果。具體步驟如下：
1. 定義一個私人靜態方法executeQueryStatements()，它接收一個Statement對象作為參數，如果在執行過程中出現異常，方法將拋出Exception異常。
2. 使用executeQuery()方法執行SELECT查詢語句，並將結果儲存在ResultSet對象rs中。在這裡，查詢返回了test_proxool表中的所有資料。使用try-with-resources語句，確保在使用完ResultSet後自動關閉它。
3. 使用while迴圈和next()方法迭代ResultSet對象rs中的每一行資料。在每次迭代中，rs.next()方法將指標移動到結果集的下一行。如果還有下一行資料可用，則該方法返回true，否則返回false。在while迴圈中，只要rs.next()返回true，就表示還有更多的行資料可用。迴圈體內的代碼將執行，並處理當前行的資料。當所有行的資料都被處理完畢後，rs.next()將返回false，迴圈結束。
4. 通過getInt()和getString()方法擷取當前行中指定列名的值，並將它們列印到控制台。在這裡，列印了c1和c2列的值。getInt()方法用於擷取整數值，getString()方法用於擷取字串值。
代碼如下：
```
    private static void executeQueryStatements(Statement stmt) throws Exception {
        try (ResultSet rs = stmt.executeQuery("SELECT * FROM test_proxool")) {
            while (rs.next()) {
                System.out.println(rs.getInt("c1") + "   " + rs.getString("c2"));
            }
        }
    }
```

完整的代碼展示

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>proxool-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>proxool</groupId>
            <artifactId>proxool-cglib</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>proxool</groupId>
            <artifactId>proxool</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
</project>

db.properties

#alias: the alias of the data source
jdbc-1.proxool.alias=TEST
#driver-class: driver name
jdbc-1.proxool.driver-class=com.mysql.jdbc.Driver
#driver-url: url connection string, username and password must be determined
jdbc-1.proxool.driver-url=jdbc:mysql://$host:$port/$database_name?useSSL=false
jdbc-1.user=$user_name
jdbc-1.password=$password
#The maximum number of database connections. The default is 15
jdbc-1.proxool.maximum-connection-count=8
#The minimum number of database connections, defaults to 5
jdbc-1.proxool.minimum-connection-count=5
#The number of available connections in the Connection pool. If the number of connections in the current Connection pool is less than this value, new connections will be established (assuming that the maximum number of available connections is not exceeded). For example, if we have three active connections and two available connections, and our prototype count is 4, the database Connection pool will try to establish another two connections. This is different from the minimum connection count Minimum connection count also counts active connections. Prototype count is the number of spare connections
jdbc-1.proxool.prototype-count=4
#verbose: detailed information settings. Parameter bool value
jdbc-1.proxool.verbose=true
#statistics: connection pool usage statistics. Parameter "10s, 1m, 1d"
jdbc-1.proxool.statistics=10s,1m,1d
#statistics-log-level:  log statistics tracking type. Parameter 'ERROR' or 'INFO'
jdbc-1.proxool.statistics-log-level=error

Main.java

package com.example;

import org.logicalcobwebs.proxool.configuration.PropertyConfigurator;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class Main {
    private static final String DB_PROPERTIES_FILE = "/db.properties";

    public static void main(String[] args) {
        try {
            Properties properties = new Properties();
            InputStream is = Main.class.getResourceAsStream(DB_PROPERTIES_FILE);
            properties.load(is);
            PropertyConfigurator.configure(properties);

            Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
            try (Connection conn = DriverManager.getConnection("proxool.TEST");
                Statement stmt = conn.createStatement()) {
                executeDDLStatements(stmt);
                executeDMLStatements(stmt);
                executeQueryStatements(stmt);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void executeDDLStatements(Statement stmt) throws Exception {
        stmt.execute("CREATE TABLE test_proxool (c1 INT, c2 VARCHAR(32))");
    }

    private static void executeDMLStatements(Statement stmt) throws Exception {
        for (int i = 1; i <= 10; i++) {
            stmt.execute("INSERT INTO test_proxool VALUES (" + i + ",'test_insert" + i + "')");
        }
        stmt.execute("DELETE FROM test_proxool WHERE c1 <= 5");
        stmt.execute("UPDATE test_proxool SET c2 = 'test_update' WHERE c1 = 6");
    }

    private static void executeQueryStatements(Statement stmt) throws Exception {
        try (ResultSet rs = stmt.executeQuery("SELECT * FROM test_proxool")) {
            while (rs.next()) {
                System.out.println(rs.getInt("c1") + "   " + rs.getString("c2"));
            }
        }
    }
}