Proxool 连接池连接 OceanBase AI 数据库示例程序

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

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

前提条件

• 您已安装 OceanBase AI 数据库并且创建了租户。

• 您已安装 JDK 1.8 和 Maven。

• 您已安装 IntelliJ IDEA。

  说明

  本文档运行代码使用的工具是 IntelliJ IDEA Community Edition 2021.3.2 版本，您也可以根据个人喜好选择适合自己的工具运行的示例代码。

操作步骤

1. 将 proxool-mysql-client 项目导入到 IntelliJ IDEA 中。
2. 获取 OceanBase AI 数据库URL。
3. 修改 proxool-mysql-client 项目中的数据库连接信息。
4. 运行 proxool-mysql-client 项目。

步骤一：将 proxool-mysql-client 项目导入到 IntelliJ IDEA 中

1. 打开 IntelliJ IDEA。

2. 在欢迎界面上，点击 Open 选项，导航到您的项目目录，选择项目的根目录，点击 OK。

   

3. IntelliJ IDEA 会自动检测项目类型并加载项目。

   说明

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

   

4. （可选）手动导入未解析的依赖项。

   如果 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 AI 数据库URL

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

   示例如下：

   obclient -hxxx.xxx.xxx.xxx -P2881 -utest_user001@mysql001 -p****** -Dtest -A
   

   更多连接串的信息，请参见 通过 OBClient 连接 OceanBase 租户。

2. 根据 OceanBase AI 数据库连接串信息填写下面 URL 的对应信息。

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

   参数说明：

   • $host：提供 OceanBase AI 数据库连接 IP。OceanBase 数据库代理（OceanBase Database Proxy，ODP）连接方式使用的是一个 ODP 地址；直连方式使用的是 OBServer 节点的 IP 地址。

   • $port：提供 OceanBase AI 数据库连接端口。ODP 连接的方式默认是 2883，在部署 ODP 时可自定义；直连方式默认是 2881，在部署 OceanBase AI 数据库时可自定义。

   • $database_name：需要访问的数据库名称。

     注意

     连接租户的用户需要拥有该数据库的 CREATE、INSERT、DELETE、UPDATE 和 SELECT 权限。更多有关用户权限的信息，请参见 MySQL 模式下的权限分类。

   • user_name：提供租户的连接账户。ODP 连接的方式格式：用户名@租户名#集群名 或者 集群名:租户名:用户名；直连方式格式：用户名@租户名。

   • password：提供账户密码。

   更多有关 MySQL Connector/J 连接属性信息，请参见 Configuration Properties。

   示例如下：

   jdbc:mysql://xxx.xxx.xxx.xxx:2881/test?user=test_user001@mysql001&password=******
   

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

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

示例如下：

• OBServer 节点的 IP 地址为 xxx.xxx.xxx.xxx。
• 访问端口使用的是 2881。
• 需要访问的数据库名称为 test。
• 租户的连接账户是 test_user001@mysql001。mysql001 是在 OceanBase AI 数据库中创建的一个用户租户，test_user001 是租户 mysql001 的用户名称。
• 密码是 ******。

代码如下：

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

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

1. 在项目导航栏中，找到并展开 src/main/java/com.example 目录。

2. 右键点击 Main 文件，选择 Run 'Main.main()'。

3. IntelliJ IDEA 会自动编译和运行该项目，并在运行面板中显示输出结果。

   

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

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> 指定项目的名称为 proxool-mysql-client。
   3. 通过 <version> 项目的版本号为 1.0-SNAPSHOT。

   代码如下：

       <groupId>com.example</groupId>
       <artifactId>proxool-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> 定义依赖项：

   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 是本文示例的连接池配置文件，其中包含了连接池的配置属性。

本文 db.properties 文件是一个属性文件的示例，用于配置一个名为 jdbc-1 的数据源的连接池属性。主要包括以下几个部分：

1. 设置数据源的别名为 TEST。

   代码如下：

   jdbc-1.proxool.alias=TEST
   

2. 配置数据库连接参数。

   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 AI 数据库连接 IP。ODP 连接方式使用的是一个 ODP 地址；直连方式使用的是 OBServer 节点的 IP 地址。
   • $port：提供 OceanBase AI 数据库连接端口。ODP 连接的方式默认是 2883，在部署 ODP 时可自定义；直连方式默认是 2881，在部署 OceanBase AI 数据库时可自定义。
   • $database_name：需要访问的数据库名称。
   • $user_name：提供租户的连接账户。ODP 连接的常用格式：用户名@租户名#集群名 或者 集群名:租户名:用户名；直连方式格式：用户名@租户名。
   • $password：提供账户密码。

3. 配置其他 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
   

常用配置参数说明:

Main.java 代码介绍

Main.java 文件是示例程序的一部分，用于演示通过 Proxool 连接池获取数据库连接，并执行一系列数据库操作，包括创建表、插入数据、删除数据、更新数据、查询数据，并将查询结果打印出来。

本文 Main.java 文件的代码主要包括以下几个部分：

1. 导入所需的类和接口。

   定义代码所在的包，并导入 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;
   

2. 定义类名和方法。

   定义一个 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. 定义了用于创建表的方法。

   代码如下：

   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 语句的方法
       // 定义用于查询数据的方法
   }
   

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

   定义一个私有静态方法 executeDDLStatements()，用于执行 DDL（数据定义语言）语句，包括创建表的语句。具体步骤如下：

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

4. 定义用于执行 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");
       }
   

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

   定义一个私有静态方法 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"));
               }
           }
       }
   

完整的代码展示

<?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>

#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

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

相关文档

• 更多 MySQL Connector/J 的信息，请参见 Overview of MySQL Connector/J。
• 更多使用 Proxool 连接池的信息，请参见 Introduction for Users。