DBCP 连接池连接 seekdb 示例程序

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

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

前提条件

• 您已安装 seekdb。

• 您已安装 JDK 1.8 和 Maven。

• 您已安装 Eclipse。

  信息

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

操作步骤

信息

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

1. 将 dbcp-mysql-client 项目导入到 Eclipse 中。
2. 获取 seekdb URL。
3. 修改 dbcp-mysql-client 项目中的数据库连接信息。
4. 运行 dbcp-mysql-client 项目。

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

1. 打开 Eclipse，在菜单栏上选择 File -> Open Projects from File System。

2. 在弹出的对话框中，点击 Directory 按钮选择项目所在的目录，然后点击 Finish 完成导入。

   信息

   当使用 Eclipse 导入 Maven 项目时，Eclipse 会自动检测项目中的 pom.xml 文件，并根据文件中描述的依赖关系自动下载所需的依赖库，并将它们添加到项目中。

   

3. 查看项目情况。

   

步骤二：获取 seekdb URL

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

   示例如下：

   mysql -hxxx.xxx.xxx.xxx -P2881 -uroot -p****** -Dtest

   更多连接串的信息，请参见 通过 MySQL 连接 seekdb。

2. 根据 seekdb 连接串信息填写下面 URL 的对应信息。

   jdbc:mysql://$host:$port/$database_name?user=$user_name&password=$password

   参数说明：

   • $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=root&password=******

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

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

示例如下：

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

代码如下：

...
url=jdbc:mysql://xxx.xxx.xxx.xxx:2881/test
username=root
password=******
...

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

1. 在项目导航器视图中，找到并展开 src/main/java 目录。

2. 右键点击 Main.java 文件，然后选择 Run As -> Java Application。

   

3. 在 Eclipse 的控制台窗口中来查看项目的日志信息和输出结果。

   

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

   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 文件的代码主要包括以下几个部分：

1. 文件声明语句。

   声明本文件是一个 XML 文件，使用的 XML 版本是 1.0，字符编码方式是 UTF-8。

   代码如下：

   <?xml version="1.0" encoding="UTF-8"?>

2. 配置 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>

3. 配置基本信息。

   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>

4. 配置项目源文件的属性。

   指定 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>

5. 配置项目所依赖组件。

   通过 <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. 配置数据库连接参数。

   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：提供 seekdb 的连接 IP。使用实际的 IP 替换，也可以使用本地 IP 及 127.0.0.1。
   • $port：提供 seekdb 接端口。使用实际的端口替换，默认是 2881，在部署 seekdb 时可自定义。
   • $database_name：需要访问的数据库名称。
   • $user_name：提供连接账户。格式：用户名 。
   • $password：提供账户密码。

2. 配置其他 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. 导入所需的类和接口。

   导入所需的类和接口，其中包括了用于读取文件、数据库操作和数据库连接池的相关类和接口。这些类和接口在后续的代码中会被使用到。

   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;

2. 定义类名和方法。

   1. 创建 Main 类，并定义了一个 main 方法作为程序的入口点。
   2. 在 main 方法中，首先调用 createDataSource() 方法创建连接池对象 dataSource。
   3. 使用 try-with-resources 语句，在连接池对象的生命周期结束时自动关闭资源。
   4. 在 try 代码块中，调用 getConnection() 方法从连接池中获取一个数据库连接对象 conn。
   5. 依次调用 createTable()、insertData()、deleteData()、updateData() 和 queryData() 方法，执行相应的数据库操作。
   6. 在发生异常时，通过 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();
           }
       }
       
       // 创建连接池
       // 定义用于创建表的方法
       // 定义用于插入数据的方法
       // 定义用于删除数据的方法
       // 定义用于更新数据的方法
       // 定义用于查询数据的方法
   }

3. 创建连接池。

   提供一个方便创建数据库连接池的方法，通过读取配置文件中的参数来初始化连接池对象。具体步骤如下：

   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);
       }

4. 定义用于创建表的方法。

   提供一个方法，用于在数据库中创建指定的表。它接受一个连接对象作为参数，并使用预编译的方式执行创建表的 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();
           }
       }

5. 定义用于插入数据的方法。

   提供一个方法，用于向数据库中的表插入指定的数据。它接受一个连接对象作为参数，并使用预编译的方式执行插入数据的 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();
               }
           }
       }

6. 定义用于删除数据的方法。

   提供一个方法，用于从数据库中删除满足特定条件的数据。它接受一个连接对象作为参数，并使用预编译的方式执行删除数据的 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();
           }
       }

7. 定义用于更新数据的方法。

   提供一个方法，用于更新数据库中满足特定条件的数据。它接受一个连接对象作为参数，并使用预编译的方式执行更新数据的 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();
           }
       }

8. 定义用于查询数据的方法。

   提供一个方法，用于查询数据库中的数据并进行处理。它接受一个连接对象作为参数，并使用预编译的方式执行查询数据的 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

# Database Connect Information
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://$host:$port/$database_name
username=$user_name
password=$password
connectionProperties=useSSL=false;characterEncoding=UTF-8

# ConnectionPool Parameters
initialSize=30
maxTotal=30
maxIdle=10
minIdle=5
maxWaitMillis=1000
removeAbandonedTimeout=1

removeAbandonedOnMaintenance=true
removeAbandonedOnBorrow=true

Main.java

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;

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();
        }
    }
    
    // Create ConnectionPool
    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);
    }
    
    // Create table
    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();
        }
    }
    
    // Insert data
    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();
            }
        }
    }
    
    // Delete data
    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();
        }
    }
    
    // Update data
    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();
        }
    }
    
    // Query data
    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);
                }
            }
        }
    }
}

相关文档

更多 MySQL Connector/J 的信息，请参见 Overview of MySQL Connector/J。