使用HikariCP连接池连接MySQL模式OceanBase数据库的示例程序-云数据库 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.");
        }
    }
}

HikariCP 连接池连接 OceanBase 数据库示例程序