从零玩转GaussDB：Java开发者必学的JDBC操作指南

数据库运维之道 2025-03-19

284

一、内容概述

手把手教学系列：基于华为云GaussDB的完整JDBC开发流程。内容涵盖：

✅ 环境搭建：JDK配置与驱动加载避坑指南

✅ 五大核心操作：建表→单条插入→批量插入→查询→事务控制

✅ 实战代码片段解析（含读写分离配置技巧）

详细过程见《GaussDB实验手册》https://lab.huaweicloud.com/experiment-detail_2442

二、实验操作

1 加载驱动，连接数据库，配置负载均衡

1）执行以下命令，下载GaussDB jdbc驱动，并存放于 libs目录下。

mkdir -p opt/expt/db/libs
cd /opt/expt/db/libs
wget https://sandbox-expriment-files.obs.cn-north-1.myhuaweicloud.com/20220525/opengaussjdbc.jar

2）执行以下命令，下载JDK软件包，并配置环境。

wget https://sandbox-expriment-files.obs.cn-north-1.myhuaweicloud.com:443/20220525/OpenJDK11U-jdk_x64_linux_openj9_linuxXL_11.0.10_9_openj9-0.24.0.tar.gz
tar xzvf OpenJDK11U-jdk_x64_linux_openj9_linuxXL_11.0.10_9_openj9-0.24.0.tar.gz
mv jdk-11.0.10+9 /usr/lib/
ln -s usr/lib/jdk-11.0.10+9/bin/java usr/local/bin/java
ln -s usr/lib/jdk-11.0.10+9/bin/javac usr/local/bin/javac

3）实验环境

执行以下命令，验证java运行命令是否就绪：

java -version
openjdk version "11.0.10" 2021-01-19
OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.10+9)
Eclipse OpenJ9 VM AdoptOpenJDK (build openj9-0.24.0, JRE 11 Linux amd64-64-Bit 20210120_821 (JIT enabled, AOT enabled)
OpenJ9   - 345e1b09e
OMR      - 741e94ea8
JCL      - 0a86953833 based on jdk-11.0.10+9)

执行以下命令，验证javac运行命令是否就绪：

javac -version
javac 11.0.10

4）执行以下命令，在指定目录创建

mkdir -p opt/expt/db/basic
cd /opt/expt/db/basic

5）使用vi命令，将以下代码内容写入exptConnection.java文件中。输入结束后，使用”:wq”保存退出vim编辑。

vi exptConnection.java

// 包路径声明：通常对应项目目录结构


package expt.db.basic;


// 导入JDBC核心类库
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;


public class exptConnection {
    // 静态常量定义（对应图片中的驱动概述）
    // 1. JDBC驱动类全名（华为OpenGauss专用驱动）
    static final String JDBC_DRIVER = "com.huawei.opengauss.jdbc.Driver";
	// 2. 数据库连接地址（包含多个主机地址和端口，支持高可用配置）
    static final String DB_URL = "jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo";
	// 3. 数据库用户名和密码（实际使用建议通过配置文件读取）
    static final String USER = "db_dev";
    static final String PASS = "yourpassword";
    static final String PARM = "autoBalance=true";
    // 构建完整连接URL（包含用户名密码参数）
    static String connection_url = DB_URL + "?user=" + USER + "&password=" + PASS + "&" + PARM;


	// 主方法：程序入口
    public static void main(String[] args) {
        getConnect();// 调用连接方法
    }


	// 获取数据库连接的核心方法（对应图片中的JDBC接口实现）
    public static Connection getConnect() {
        Connection conn = null;


        // 驱动注册流程（关键步骤）
        try {
		// 通过反射加载驱动类（旧版JDBC必须步骤）
            Class.forName(JDBC_DRIVER);
        } catch (Exception e) {
            e.printStackTrace();// 驱动加载失败时打印错误
            return null;
        }


        // 连接数据库操作
        System.out.println("connecting database...");
        try {
		// 打印最终连接URL（调试用，实际需隐藏敏感信息）
            System.out.println("connection url is: " + connection_url);
		// 通过DriverManager获取数据库连接实例（核心API）
            conn = DriverManager.getConnection(connection_url);
		// 连接成功提示
            System.out.println("connection successfully!");
            return conn;
        } catch (Exception e) {
            e.printStackTrace();// 连接异常处理
            return null;
        }
    }
   }

备注：DB_URL变量对应的值中，"192.168.0.72:8000/demo" 需修改为当前实际所使用数据库对应的主节点IP地址，"yourpassword" 修改为新创建的用户db_dev的密码。GaussDB主节点的IP可通过点击GaussDB实例名称，进入信息页面查看：滑动到节点列表处，就可以看到主节点IP:

6）执行以下命令，进行编译：

javac -d . exptConnection.java

编译完成后，会在当前目录下编译生成class数据文件及对应目录结构。执行yum命令安装tree工具：

yum install tree

执行tree命令查看目录结构：

tree

7）执行以下命令，运行对应代码文件

java -cp opt/expt/db/libs/opengaussjdbc.jar:. expt.db.basic.exptConnection
connecting database...
connection url is: jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo?user=db_dev&password=gaussdb#_1
Mar 18, 2025 11:17:15 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [96eeda8e-7b69-4e89-b7c0-7e1f046bfe2e] Try to connect. IP: 192.168.0.158:8000
Mar 18, 2025 11:17:15 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [192.168.0.146:60182/192.168.0.158:8000] Connection is established. ID: 96eeda8e-7b69-4e89-b7c0-7e1f046bfe2e
Mar 18, 2025 11:17:15 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Connect complete. ID: 96eeda8e-7b69-4e89-b7c0-7e1f046bfe2e
connection successfully!

8）JDBC设置读写分离

将参数修改为targetServerType=master，则尝试连接到url连接串中的主节点，如果找不到主节点将抛出异常（设置targetServerType=slave，则尝试连接到url连接串中的备节点，如果找不到备节点将抛出异常；设置targetServerType=preferSlave，则尝试连接到url连接串中的备节点，如果备节点不可用，将连接到主节点，否则抛出异常）。本实验只进行主库的连接。

static final String PARM = "targetServerType=master";

9）重新编译后运行程序。

javac -d . exptConnection.java
java -cp opt/expt/db/libs/opengaussjdbc.jar:. expt.db.basic.exptConnection
connecting database...
connection url is: jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo?user=db_dev&password=gaussdb#_1
Mar 18, 2025 11:19:42 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [b5a80e69-3e24-4518-8b52-dbf9194a5fad] Try to connect. IP: 192.168.0.158:8000
Mar 18, 2025 11:19:43 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [192.168.0.146:60194/192.168.0.158:8000] Connection is established. ID: b5a80e69-3e24-4518-8b52-dbf9194a5fad
Mar 18, 2025 11:19:43 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Connect complete. ID: b5a80e69-3e24-4518-8b52-dbf9194a5fad
connection successfully!

2 执行建表语句

1）执行以下命令，创建exptCreateTable.java文件。

cd /opt/expt/db/basic

2）使用vi命令，将以下代码内容写入exptCreateTable.java文件中，修改正确的DB_URL,PASS值。输入结束后，使用”:wq”保存退出vim编辑。执行建表语句，在之前的连接前提下，修改主函数部分，即建表语句。

vi exptCreateTable.java

// 包路径声明：通常对应项目模块结构
package expt.db.basic;


// 导入JDBC核心类库
import java.sql.*;
import java.util.Properties;


public class exptCreateTable {
    // 静态常量定义（对应图片中的JDBC接口配置）
    // 1. OpenGauss数据库JDBC驱动类名
    static final String JDBC_DRIVER = "com.huawei.opengauss.jdbc.Driver";
    // 2. 数据库连接地址（支持多节点高可用配置）
    static final String DB_URL = "jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo";
    // 3. 数据库用户名和密码
    static final String USER = "db_dev";
    static final String PASS = "yourpassword";
    // 4. 连接参数：强制连接到主节点（避免写入只读副本）
    static final String PARM = "targetServerType=master";
    // 5. 完整连接URL（包含用户名、密码、模式等参数）
    static String connection_url = DB_URL + "?user=" + USER + "&password=" + PASS 
                                 + "&currentSchema=db_dev" + "&" + PARM;


    // 获取数据库连接的方法（对应图片中的JDBC接口实现）
    public static Connection getConnect() {
        Connection conn = null;


        // 驱动注册（关键步骤）
        try {
            Class.forName(JDBC_DRIVER); // 加载JDBC驱动类
        } catch (Exception e) {
            e.printStackTrace(); // 驱动加载失败时打印错误
            return null;
        }


        // 建立数据库连接
        System.out.println("connecting database...");
        try {
            // 打印最终连接URL（调试用，实际需隐藏敏感信息）
            System.out.println("connection url is: " + connection_url);
            // 通过DriverManager获取连接对象
            conn = DriverManager.getConnection(connection_url);
            System.out.println("connection successfully!");
            return conn;
        } catch (Exception e) {
            e.printStackTrace(); // 连接异常处理
            return null;
        }
    }


    // 主方法：程序入口（创建表的操作）
    public static void main(String[] args) throws SQLException {
        // 获取数据库连接
        Connection conn = getConnect();


        // 创建Statement对象（用于执行SQL语句）
        Statement statement = conn.createStatement();


        // 执行建表SQL（对应图片中的JDBC接口开发流程）
        String sql = "create table test_table ("
                   + "id int, "
                   + "name varchar(10), "
                   + "destination varchar(20), "
                   + "uuid varchar(36))";
        statement.execute(sql);


        // 输出执行成功提示
        System.out.println("execute successfully!");


        // 注意：实际开发中需关闭statement和connection！
    }
}

3）编译后运行程序，回显显示execute successfully!表示创建表完成。

javac -d . exptCreateTable.java
java -cp opt/expt/db/libs/opengaussjdbc.jar:. expt.db.basic.exptCreateTable
connecting database...
connection url is: jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo?user=db_dev&password=gaussdb#_1&currentSchema=db_dev&targetServerType=master
Mar 18, 2025 11:27:35 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [e5b94e3d-662f-4cf8-8986-a92f8f59a7cf] Try to connect. IP: 192.168.0.158:8000
Mar 18, 2025 11:27:35 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [192.168.0.146:60238/192.168.0.158:8000] Connection is established. ID: e5b94e3d-662f-4cf8-8986-a92f8f59a7cf
Mar 18, 2025 11:27:35 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Known status of host 192.168.0.158:8000 is Master
Mar 18, 2025 11:27:35 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Connect complete. ID: e5b94e3d-662f-4cf8-8986-a92f8f59a7cf
connection successfully!
execute successfully!

3 执行插入语句

1）执行以下命令，创建exptInsert.java文件。

cd /opt/expt/db/basic

2）使用vi命令，将以下代码内容写入exptInsert.java文件中,修改正确的DB_URL,PASS值。输入结束后，使用”:wq”保存退出vim编辑。

vi exptInsert.java

// 包路径声明：通常对应项目模块结构
package expt.db.basic;


// 导入JDBC核心类库
import java.sql.*;
import java.util.Properties;
import java.util.UUID;


public class exptInsert {
    // 静态常量定义（对应图片中的JDBC接口配置）
    // 1. OpenGauss数据库JDBC驱动类名
    static final String JDBC_DRIVER = "com.huawei.opengauss.jdbc.Driver";
    // 2. 数据库连接地址（支持多节点高可用配置）
    static final String DB_URL = "jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo";
    // 3. 数据库用户名和密码
    static final String USER = "db_dev";
    static final String PASS = "yourpassword";
    // 4. 连接参数：强制连接到主节点（用于写入操作）
    static final String PARM = "targetServerType=master";
    // 5. 完整连接URL（包含用户名、密码、模式等参数）
    static String connection_url = DB_URL + "?user=" + USER + "&password=" + PASS 
                                 + "&currentSchema=db_dev" + "&" + PARM;


    // 获取数据库连接的方法（对应图片中的驱动概述和JDBC接口介绍）
    public static Connection getConnect() {
        Connection conn = null;


        // 驱动注册（关键步骤）
        try {
            Class.forName(JDBC_DRIVER); // 加载JDBC驱动类
        } catch (Exception e) {
            e.printStackTrace();       // 驱动加载失败时打印错误
            return null;
        }


        // 建立数据库连接
        System.out.println("connecting database...");
        try {
            // 打印最终连接URL（调试用，实际需隐藏敏感信息）
            System.out.println("connection url is: " + connection_url);
            // 通过DriverManager获取连接对象
            conn = DriverManager.getConnection(connection_url);
            System.out.println("connection successfully!");
            return conn;
        } catch (Exception e) {
            e.printStackTrace();       // 连接异常处理
            return null;
        }
    }


    // 主方法：程序入口（执行插入操作）
    public static void main(String[] args) throws SQLException {
        // 获取数据库连接
        Connection conn = getConnect();


        // 创建Statement对象（用于执行SQL语句）
        Statement statement = conn.createStatement();


        // 构建并执行INSERT语句（对应图片中的JDBC接口开发流程）
        String sql = "INSERT INTO test_table(id, name, destination, uuid) "
                   + "VALUES (2, 'zhangsan', 'hangzhou', 123456789)";
        boolean isSuccess = statement.execute(sql); // 执行SQL


        // 输出受影响的行数（插入操作影响的行数）
        System.out.println("Number of rows affected： " + statement.getUpdateCount());


        // 注意：实际开发中需关闭statement和connection！
    }
}

3）编译后运行程序，回显显示“Number of rows affected: 1”表示数据插入成功。

javac -d . exptInsert.java
java -cp opt/expt/db/libs/opengaussjdbc.jar:. expt.db.basic.exptInsert
connecting database...
connection url is: jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo?user=db_dev&password=gaussdb#_1&currentSchema=db_dev&targetServerType=master
Mar 18, 2025 11:32:42 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [5c7b5536-23d5-4120-95e9-4e66debc1823] Try to connect. IP: 192.168.0.158:8000
Mar 18, 2025 11:32:42 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [192.168.0.146:60272/192.168.0.158:8000] Connection is established. ID: 5c7b5536-23d5-4120-95e9-4e66debc1823
Mar 18, 2025 11:32:42 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Known status of host 192.168.0.158:8000 is Master
Mar 18, 2025 11:32:42 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Connect complete. ID: 5c7b5536-23d5-4120-95e9-4e66debc1823
connection successfully!
Number of rows affected\uff1a 1

4 执行查询语句

1）执行以下命令，创建exptQuery.java文件。

cd opt/expt/db/basic

2）使用vi命令，将以下代码内容写入exptQuery.java文件中,修改正确的DB_URL,PASS值。输入结束后，使用”:wq”保存退出vim编辑。

vi exptQuery.java

package expt.db.basic;


import java.sql.*;
import java.util.Properties;
import java.util.UUID;


public class exptQuery {
    // 数据库连接配置常量
    static final String JDBC_DRIVER = "com.huawei.opengauss.jdbc.Driver"; // OpenGauss JDBC驱动类
    static final String DB_URL = "jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo"; // 数据库地址（支持多节点）
    static final String USER = "db_dev";      // 数据库用户名
    static final String PASS = "yourpassword";  // 数据库密码
    static final String PARM = "targetServerType=master"; // 连接参数：强制连接主节点


    // 构建完整连接URL（包含模式参数）
    static String connection_url = DB_URL + "?user=" + USER + "&password=" + PASS 
                                 + "&currentSchema=db_dev" + "&" + PARM;


    /**
     * 获取数据库连接
     * @return Connection对象（成功）  null（失败）
     */
    public static Connection getConnect() {
        Connection conn = null;


        // 1. 驱动注册（加载JDBC驱动类）
        try {
            Class.forName(JDBC_DRIVER); // 强制加载指定驱动类
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }


        // 2. 建立数据库连接
        System.out.println("connecting database...");
        try {
            // 打印调试信息（实际生产环境需隐藏敏感信息）
            System.out.println("connection url is: " + connection_url);


            // 通过DriverManager获取数据库连接
            conn = DriverManager.getConnection(connection_url);
            System.out.println("connection successfully!");
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 关闭数据库连接
     * @param conn 要关闭的连接对象
     */
    public static void closeConnect(Connection conn) {
        System.out.println("closing connection...");
        try {
            if (conn != null) {
                conn.close(); // 释放数据库连接资源
                System.out.println("connection closed!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 打印结果集中的所有记录
     * @param rs 要打印的结果集对象
     */
    public static void printAllRecords(ResultSet rs) {
        try {
            // 获取结果集元数据（包含列名、类型等信息）
            ResultSetMetaData metaData = rs.getMetaData();


            // 打印表头（列名）
            for (int i = 0; i < metaData.getColumnCount(); i++) {
                System.out.print(metaData.getColumnName(i + 1) + "\t");
            }
            System.out.println();


            // 遍历所有数据行
            while (rs.next()) {
                for (int i = 0; i < metaData.getColumnCount(); i++) {
                    // 按字符串格式打印每列数据
                    System.out.print(rs.getString(i + 1) + "\t");
                }
                System.out.println();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 主程序入口
     */
    public static void main(String[] args) throws SQLException {
        // 1. 获取数据库连接
        Connection conn = getConnect();
        ResultSet resultSet = null;


        try {
            // 2. 创建预编译语句（防止SQL注入）
            PreparedStatement preparedStatement = conn.prepareStatement(
                "SELECT * FROM test_table WHERE id=?;"); // 参数化查询


            // 3. 设置查询参数（第一个参数的位置是1）
            preparedStatement.setObject(1, 2);


            // 4. 执行查询并获取结果集
            resultSet = preparedStatement.executeQuery();


            // 5. 打印所有查询结果
            printAllRecords(resultSet);
        } finally {
            // 6. 关闭数据库连接（建议放在finally块确保执行）
            closeConnect(conn);
        }
    }
}

3）编译后运行程序，回显显示“影响行数： 1”表示数据插入成功。

javac -d . exptQuery.java
java -cp opt/expt/db/libs/opengaussjdbc.jar:. expt.db.basic.exptQuery
connecting database...
connection url is: jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo?user=db_dev&password=gaussdb#_1&currentSchema=db_dev&targetServerType=master
Mar 18, 2025 11:45:42 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [6e6eecc0-49e4-4797-967f-674766426b5b] Try to connect. IP: 192.168.0.158:8000
Mar 18, 2025 11:45:43 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [192.168.0.146:60338/192.168.0.158:8000] Connection is established. ID: 6e6eecc0-49e4-4797-967f-674766426b5b
Mar 18, 2025 11:45:43 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Known status of host 192.168.0.158:8000 is Master
Mar 18, 2025 11:45:43 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Connect complete. ID: 6e6eecc0-49e4-4797-967f-674766426b5b
connection successfully!
id	name	destination	uuid	
2	zhangsan	hangzhou	123456789	
closing connection...
connection closed!

5 批量插入数据

1）执行以下命令，创建exptBatchInsert.java文件。

cd /opt/expt/db/basic

2）使用vi命令，将以下代码内容写入exptBatchInsert.java文件中,修改正确的DB_URL,PASS值。输入结束后，使用”:wq”保存退出vim编辑。第一个进行单条插入，第二个进行批量插入。

vi exptBatchInsert.java

package expt.db.basic;


import java.sql.*;
import java.util.Properties;
import java.util.UUID;


/**
 * 批量插入数据库操作示例（对应图片中的JDBC接口开发流程）
 */
public class exptBatchInsert {
    //------------------------------
    // 1. 数据库连接配置（对应图片中的驱动概述）
    //------------------------------
    static final String JDBC_DRIVER = "com.huawei.opengauss.jdbc.Driver"; // OpenGauss驱动类
    static final String DB_URL = "jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo"; // 多节点高可用地址
    static final String USER = "db_dev";      // 数据库账号
    static final String PASS = "yourpassword";  // 数据库密码
    static final String PARM = "targetServerType=master"; // 强制连接主节点
    static String connection_url = DB_URL + "?user=" + USER + "&password=" + PASS 
                                 + "&currentSchema=db_dev" + "&" + PARM; // 完整连接URL


    /**
     * 2. 获取数据库连接（对应图片中的JDBC接口实现）
     */
    public static Connection getConnect() {
        Connection conn = null;


        // 驱动注册（关键步骤）
        try {
            Class.forName(JDBC_DRIVER); // 加载JDBC驱动类
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }


        // 建立数据库连接
        System.out.println("connecting database...");
        try {
            System.out.println("connection url is: " + connection_url);
            conn = DriverManager.getConnection(connection_url); // 核心连接方法
            System.out.println("connection successfully!");
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 3. 关闭数据库连接（资源释放）
     */
    public static void closeConnect(Connection conn) {
        System.out.println("closing connection...");
        try {
            if (conn != null) {
                conn.close(); // 释放连接资源
                System.out.println("connection closed!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 4. 单条插入模式（对应图片中的单条插入说明）
     * @param begin 起始ID
     * @param count 插入数量
     */
    public static int insertRecordOnceATime(int begin, int count) {
        PreparedStatement preparedStatement;
        int index = begin;


        try {
            Connection conn = getConnect();
            conn.setAutoCommit(true); // 开启自动提交


            // 创建预编译语句（防止SQL注入）
            String targetQuery = "INSERT INTO test_table(id, name, destination, uuid) VALUES(?, ?, ?, ?)";
            preparedStatement = conn.prepareStatement(targetQuery);


            long start = System.currentTimeMillis(); // 计时开始


            // 循环执行单条插入
            for( ; index < begin+count; index++) {
                // 设置四个参数
                preparedStatement.setInt(1, index);
                preparedStatement.setString(2, "name-"+index);
                preparedStatement.setString(3, "destination-"+index);
                preparedStatement.setString(4, UUID.randomUUID().toString());


                // 单次执行并计时
                long startInternal = System.currentTimeMillis();
                preparedStatement.executeUpdate();
                System.out.println("each transaction time taken = " 
                    + (System.currentTimeMillis() - startInternal) + " ms");
            }


            // 输出总耗时
            long end = System.currentTimeMillis();
            System.out.println("total time taken = " + (end - start) + " ms");
            System.out.println("avg total time taken = " + (end - start)/ count + " ms");


            // 资源关闭
            preparedStatement.close();
            closeConnect(conn);


        } catch (SQLException ex) {
            // 异常处理（打印详细错误信息）
            System.err.println("SQLException information");
            while (ex != null) {
                System.err.println("Error msg: " + ex.getMessage());
                ex = ex.getNextException();
            }
        }
        return index; // 返回最后插入的ID
    }


    /**
     * 5. 批量插入模式（对应图片中的批量插入说明）
     */
    public static void insertRecordBatch(int begin, int count) {
        PreparedStatement preparedStatement;
        int index = begin;


        try {
            Connection conn = getConnect();
            conn.setAutoCommit(true);


            // 创建预编译语句
            String targetQuery = "INSERT INTO test_table(id, name, destination, uuid) VALUES(?, ?, ?, ?)";
            preparedStatement = conn.prepareStatement(targetQuery);


            // 批量添加参数
            for( ; index < begin+count; index++) {
                preparedStatement.setInt(1, index);
                preparedStatement.setString(2, "name-"+index);
                preparedStatement.setString(3, "destination-"+index);
                preparedStatement.setString(4, UUID.randomUUID().toString());
                preparedStatement.addBatch(); // 添加到批处理
            }


            // 执行批处理并计时
            long start = System.currentTimeMillis();
            int[] inserted = preparedStatement.executeBatch(); // 批量执行
            long end = System.currentTimeMillis();


            // 输出性能数据
            System.out.println("total time taken to insert the batch = " + (end - start) + " ms");
            System.out.println("avg time per record = " + (end - start)/count + " ms");
            preparedStatement.close();
            closeConnect(conn);
            System.out.println("row influence number is: " + inserted.length); // 影响行数
        } catch (SQLException ex) {
            // 异常处理
            System.err.println("SQLException information");
            while (ex != null) {
                System.err.println("Error msg: " + ex.getMessage());
                ex = ex.getNextException();
            }
            throw new RuntimeException("Error");
        }
    }


    /**
     * 6. 主方法（执行演示）
     */
    public static void main(String[] args) throws SQLException {
        int current;
        // 先执行1000次单条插入
        current = insertRecordOnceATime(1, 1000);
        // 再执行1000次批量插入
        insertRecordBatch(current, 1000);
    }
}

3）编译后运行程序，从运行结果中看，批量插入只需24ms，而单条插入单条提交插入需要2967ms。

javac -d . exptBatchInsert.java
java -cp /opt/expt/db/libs/opengaussjdbc.jar:. expt.db.basic.exptBatchInsert
closing connection...
connection closed!
connecting database...
connection url is: jdbc:opengauss://192.168.0.158:8000,192.168.0.198:8000,192.168.0.122:8000/demo?user=db_dev&password=gaussdb#_1&currentSchema=db_dev&targetServerType=master
Mar 18, 2025 11:52:37 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [0ec82011-8956-4787-a761-4f3775578c4b] Try to connect. IP: 192.168.0.158:8000
Mar 18, 2025 11:52:37 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: [192.168.0.146:60376/192.168.0.158:8000] Connection is established. ID: 0ec82011-8956-4787-a761-4f3775578c4b
Mar 18, 2025 11:52:37 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Known status of host 192.168.0.158:8000 is Master
Mar 18, 2025 11:52:37 AM com.huawei.opengauss.jdbc.core.v3.ConnectionFactoryImpl openConnectionImpl
INFO: Connect complete. ID: 0ec82011-8956-4787-a761-4f3775578c4b
connection successfully!
total time taken to insert the batch = 29 ms
avg time per record = 0 ms
closing connection...
connection closed!
row influence number is: 1000

6 关闭自动提交

1）执行以下命令，修订exptBatchInsert.java文件。

cd /opt/expt/db/basic
vi exptBatchInsert.java
conn.setAutoCommit(true);

文章转载自数据库运维之道，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

从零玩转GaussDB：Java开发者必学的JDBC操作指南

评论