版本：V1.0.0

HikariCP 连接池连接 seekdb 示例程序

本文将介绍如何使用 HikariCP 连接池、MySQL Connector/J 和 seekdb 构建一个应用程序，实现基本的数据库操作，包括创建表、插入、删除、更新和查询数据等。

点击下载 hikaricp-mysql-client 示例工程

前提条件

您已安装 seekdb。
您已安装 JDK 1.8 和 Maven。
您已安装 Eclipse。

信息
本文档运行代码使用的工具是 Eclipse IDE for Java Developers 2022-03 版本，您也可以根据个人喜好选择适合自己的工具运行的示例代码。

操作步骤

信息

本文中给出的操作步骤是在 Windows 环境下使用 Eclipse IDE for Java Developers 2022-03 编译和运行该项目的步骤。如果您使用的是其他操作系统环境或编译器，那么操作步骤可能会略有不同。

将 hikaricp-mysql-client 项目导入到 Eclipse 中。
获取 seekdb 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 文件，并根据文件中描述的依赖关系自动下载所需的依赖库，并将它们添加到项目中。
查看项目情况。

步骤二：获取 seekdb URL

联系 seekdb 部署人员或者管理员获取相应的数据库连接串。

示例如下：
```
mysql -hxxx.xxx.xxx.xxx -P2881 -uroot -p****** -Dtest
```
更多连接串的信息，请参见通过 MySQL 客户端连接 seekdb。
根据 seekdb 连接串信息填写下面 URL 的对应信息。
```
jdbc:mysql://$host:$port/$database_name?user=$user_name&password=$password&useSSL=false
```
参数说明：
- $host：提供 seekdb 的连接 IP。应该被实际的 IP 替换，也可以使用本地 IP 及 127.0.0.1。
- $port：提供 seekdb 接端口。应该被实际的端口替换，默认是 2881，在部署 seekdb 时可自定义。
- $database_name：需要访问的数据库名称。
- user_name：提供连接账户。格式：用户名 。
- password：提供账户密码。
更多有关 MySQL Connector/J 连接属性信息，请参见 Configuration Properties。

示例如下：
```
jdbc:mysql://xxx.xxx.xxx.xxx:2881/test?user=test_user001@mysql001&password=******&useSSL=false
```

步骤三：修改 hikaricp-mysql-client 项目中的数据库连接信息

根据 步骤二：获取 seekdb URL 中获取的信息修改文件 hikaricp-mysql-client/src/main/resources/db.properties 中的数据库连接信息。

示例如下：

seekdb 的 IP 地址为 xxx.xxx.xxx.xxx。
访问端口使用的是 2881。
需要访问的数据库名称为 test。
连接账户是 root 。
密码是 ******。

代码如下：

...
jdbcUrl=jdbc:mysql://xxx.xxx.xxx.xxx:2881/test?useSSL=false
username=root
password=******
...

步骤四：运行 hikaricp-mysql-client 项目

在项目导航器视图中，找到并展开 src/main/java 目录。
右键点击 Main.java 文件，然后选择 Run As -> Java Application。
在 Eclipse 的控制台窗口中来查看项目的日志信息和输出结果。

也可以在 seekdb 中执行以下 SQL 语句查看结果。

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：提供 seekdb 的连接 IP。使用实际的 IP 替换，也可以使用本地 IP 及 127.0.0.1。
- $port：提供 seekdb 接端口。使用实际的端口替换，默认是 2881，在部署 seekdb 时可自定义。
- $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 连接池连接 seekdb 示例程序

前提条件

操作步骤

步骤一：将 hikaricp-mysql-client 项目导入到 Eclipse 中

步骤二：获取 seekdb URL

步骤三：修改 hikaricp-mysql-client 项目中的数据库连接信息

步骤四：运行 hikaricp-mysql-client 项目

项目代码介绍

pom.xml 代码介绍

db.properties 代码介绍

Main.java 代码介绍

完整的代码展示

pom.xml

db.properties

Main.java

相关文档

Contents

前提条件​

操作步骤​

步骤一：将 hikaricp-mysql-client 项目导入到 Eclipse 中​

步骤二：获取 seekdb URL​

步骤三：修改 hikaricp-mysql-client 项目中的数据库连接信息​

步骤四：运行 hikaricp-mysql-client 项目​

项目代码介绍​

pom.xml 代码介绍​

db.properties 代码介绍​

Main.java 代码介绍​

完整的代码展示​

pom.xml​

db.properties​

Main.java​

相关文档​

Contents

前提条件

操作步骤

步骤一：将 hikaricp-mysql-client 项目导入到 Eclipse 中

步骤二：获取 seekdb URL

步骤三：修改 hikaricp-mysql-client 项目中的数据库连接信息

步骤四：运行 hikaricp-mysql-client 项目

项目代码介绍

pom.xml 代码介绍

db.properties 代码介绍

Main.java 代码介绍

完整的代码展示

pom.xml

db.properties

Main.java

相关文档