Java与Oracle数据库批量入库：ARRAY和TABLE类型操作指南

一人一猫浪迹天涯

于 2024-10-03 13:34:23 发布

阅读量539

点赞数 18

本文链接：https://blog.csdn.net/weixin_34374684/article/details/142700369

版权

本文还有配套的精品资源，点击获取

简介：在Java与Oracle数据库交互中，使用ARRAY和TABLE类型可以提升批量入库操作的效率。本文将介绍如何通过Java定义和操作Oracle的ARRAY和TABLE类型，实现高效的数据批量插入，包括驱动和连接设置、类型定义、Java类型映射、批量数据准备、存储过程调用以及资源关闭等步骤。同时，也提到了在使用中需要注意的细节，如异常处理和事务管理，并简述了使用Spring框架中的简化操作方法。 ARRAY类型

1. Oracle ARRAY和TABLE类型概念

在数据处理领域，Oracle数据库凭借其强大的功能和稳定性，成为了企业级应用的首选。为了应对复杂的数据操作需求，Oracle提供了ARRAY和TABLE类型，这是处理嵌套表和数组数据的两种集合类型。ARRAY类型，顾名思义，它用于存储固定长度的数组数据，非常适合于那些元素数量不会变化的场景。而TABLE类型则提供了更大的灵活性，可以存储不定长度的数据集合，使得动态数组的操作成为可能。

接下来，我们将深入探讨这两种类型的使用场景、性能特点和编程时的注意事项。理解这些基础概念，对于设计高效的数据库模式和编写高效的SQL代码至关重要。我们将从ARRAY和TABLE的定义开始，逐步展开深入的讨论，通过实际的例子来展示这些类型的强大功能，为接下来深入探讨它们在Java中的应用打下坚实的基础。

2. Java操作Oracle数据库设置与连接

2.1 环境准备与JDBC驱动加载

为了在Java中操作Oracle数据库，首先需要确保你的开发环境中已经安装了Oracle数据库，并且正确配置了环境变量。接下来，为了能够让Java应用程序能够与Oracle数据库进行通信，需要在项目中加载合适的JDBC驱动。

在Java项目中，添加JDBC驱动的方式通常有以下几种： 1. 使用Maven或Gradle等依赖管理工具，在项目的构建文件中添加依赖。 2. 手动下载Oracle JDBC驱动jar包，添加到项目的类路径中。 3. 在项目的运行环境中指定驱动jar包的位置。

使用Maven添加Oracle JDBC驱动依赖的示例代码如下所示：

<dependency>
    <groupId>com.oracle.database.jdbc</groupId>
    <artifactId>ojdbc8</artifactId>
    <version>**.*.*.*</version>
</dependency>

2.2 数据库URL配置与连接建立

配置数据库URL是连接Oracle数据库的关键步骤，URL格式通常遵循如下结构：

jdbc:oracle:thin:@[host][:port]:SID

其中： - jdbc:oracle:thin: 是JDBC连接Oracle数据库的协议标识。 - @ 符号后跟随的是数据库服务器的地址，可以是IP地址或主机名。 - :port 是数据库服务的端口号，默认是1521。 - :SID 是Oracle数据库的服务标识符。

建立连接时，可以使用 DriverManager.getConnection() 方法。这需要一个数据库URL、用户名以及密码参数。以下是一个连接Oracle数据库的Java代码示例：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class OracleConnectionExample {
    public static void main(String[] args) {
        String url = "jdbc:oracle:thin:@localhost:1521:orcl";
        String user = "your_username";
        String password = "your_password";

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            if (conn != null) {
                System.out.println("Connected to the database!");
            }
        } catch (SQLException e) {
            System.out.println("Unable to connect to database: " + e.getMessage());
        }
    }
}

在此代码块中， try-with-resources 语句用于自动管理资源，确保在结束时关闭连接。

2.3 连接池的创建与使用

在实际开发中，频繁地打开和关闭数据库连接会消耗大量的系统资源。为了优化资源使用并提高性能，推荐使用连接池来管理数据库连接。常见的连接池有Apache DBCP、C3P0和HikariCP等。

以下使用HikariCP创建连接池的示例代码：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class HikariCPExample {
    public static void main(String[] args) {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
        config.setUsername("your_username");
        config.setPassword("your_password");
        config.addDataSourceProperty("cachePrepStmts", "true");
        config.addDataSourceProperty("prepStmtCacheSize", "250");
        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");

        HikariDataSource ds = new HikariDataSource(config);
        // 使用ds来获取连接和执行数据库操作
        // ...
        // 关闭数据源以释放连接池资源
        ds.close();
    }
}

在此代码段中，首先创建了 HikariConfig 对象，用来配置连接池参数。然后，通过这个配置对象创建了 HikariDataSource 实例，它可以被用来获取数据库连接。在使用完毕后，应当关闭 HikariDataSource 以释放资源。

在实际生产环境中，连接池参数的配置需要根据实际业务负载和数据库的性能进行调整，以获得最佳的性能表现。

3. 定义Oracle ARRAY和TABLE类型SQL语句

在上一章中，我们介绍了Oracle数据库中ARRAY和TABLE类型的基本概念。本章将深入探讨如何在SQL语句中定义和使用这两种类型，以便为后续的Java代码操作提供一个坚实的基础。我们将从数据结构的定义开始，然后过渡到存储过程中的应用，最终展示如何在SQL层面进行复杂数据的操作。

3.1 定义ARRAY和TABLE类型

在Oracle中，ARRAY和TABLE类型通常在PL/SQL中定义。ARRAY类型被称作"VARRAY"（可变数组），而TABLE类型则类似于SQL Server中的表类型，但其在PL/SQL中有特定的语法和用途。

3.1.1 定义VARRAY类型

VARRAY是一种有序的集合，可以有固定的最大长度。定义VARRAY的语法如下：

CREATE OR REPLACE TYPE array_type AS VARRAY(n) OF element_type;

这里的 n 是数组的最大长度， element_type 是数组元素的类型。

3.1.2 定义嵌套表类型

嵌套表（TABLE）则是一种无序集合，其元素的个数可以动态变化。定义嵌套表类型的语法如下：

CREATE OR REPLACE TYPE table_type AS TABLE OF element_type;

element_type 可以是Oracle支持的任何数据类型。

3.2 在存储过程中使用ARRAY和TABLE类型

使用ARRAY和TABLE类型可以大大简化数据操作，特别是在需要处理集合数据时。在存储过程中使用这些类型的示例代码如下：

CREATE OR REPLACE PROCEDURE proc_array_example(p_array IN array_type) IS
BEGIN
  -- 使用VARRAY类型的存储过程逻辑
END proc_array_example;

对于嵌套表：

CREATE OR REPLACE PROCEDURE proc_table_example(p_table IN table_type) IS
BEGIN
  -- 使用嵌套表类型的存储过程逻辑
END proc_table_example;

3.2.1 存储过程逻辑分析

在上述存储过程定义中，我们可以看到通过IN参数传递VARRAY或嵌套表类型到存储过程中。这意味着存储过程可以接收一个数组或者集合作为参数，然后在存储过程内部进行操作。这样的操作通常涉及到集合数据的查询、插入、更新或删除等操作。

3.2.2 存储过程应用示例

假设有一个业务需求，需要批量插入一些数据到一个表中，我们可以使用嵌套表来实现这个需求：

DECLARE
  TYPE my_table_type IS TABLE OF my_table%ROWTYPE;
  my_table_values my_table_type;
BEGIN
  -- 填充my_table_values集合
  FORALL i IN 1..my_table_values.COUNT
    INSERT INTO my_table VALUES my_table_values(i);
END;

在上述示例中，我们首先声明了一个与 my_table 表结构相同的嵌套表类型 my_table_type 。然后，我们通过循环使用 FORALL 语句批量插入数据。

3.3 批量操作的策略调整

在批量操作时，策略调整非常重要，因为不同的业务场景和数据规模需要不同的处理方式。在SQL层面，我们可以进行以下策略调整：

分批处理 ：当处理大量数据时，将数据分批次处理可以避免一次性占用过多资源，同时也能减少错误恢复的时间。
性能优化 ：创建索引和使用合适的事务管理策略是提高SQL操作性能的关键。
并行处理 ：利用Oracle的并行查询和DML特性，可以显著提高处理大量数据时的性能。

3.3.1 分批处理策略

分批处理是将大量数据分批次进行操作，每批处理的数据量需要根据业务需求和系统资源进行调整。

DECLARE
  CURSOR cursor_batch IS
    SELECT id, value FROM my_table
    WHERE batch_size = 100; -- 每批处理的记录数

BEGIN
  FOR record IN cursor_batch LOOP
    -- 对每条记录进行操作
  END LOOP;
END;

3.3.2 性能优化策略

性能优化通常从索引、查询优化以及事务管理方面着手。在使用ARRAY或嵌套表时，尤其注意不要在循环中进行DML操作，这会严重影响性能。

3.3.3 并行处理策略

在处理大量数据时，可以利用Oracle的并行特性来加快执行速度。

ALTER SESSION ENABLE PARALLEL DML;

INSERT /*+ parallel(my_table, 4) */ INTO my_table
SELECT id, value FROM source_table;

在上述示例中， parallel 提示使得 INSERT 操作并行执行， 4 是并行的级别。

3.3.4 性能调整表格

以下是一个表格，用于比较不同批量操作策略的优缺点：

| 策略 | 优点 | 缺点 | | --- | --- | --- | | 分批处理 | 减少资源消耗，提高错误恢复效率 | 可能需要额外的逻辑来管理批次 | | 性能优化 | 提高操作效率，减少响应时间 | 需要深入了解索引和查询优化 | | 并行处理 | 极大提高数据处理速度 | 对系统资源要求高，可能导致争用 |

通过本章节的介绍，我们深入理解了如何在SQL语句中定义和使用Oracle的ARRAY和TABLE类型。同时，我们也探讨了批量操作的策略调整，以及如何在SQL层面实施优化以提升性能。接下来，让我们进一步探讨如何在Java代码中映射并操作这些类型的数据。

4. Java类型与Oracle ARRAY和TABLE类型的映射

在本章中，我们将深入探讨Java数据类型与Oracle数据库中ARRAY和TABLE类型之间的映射关系。理解这种映射关系对于在Java中处理Oracle数据库的复杂数据结构是至关重要的。映射不仅包括数据类型的转换，还涉及如何在Java中操作这些类型的数据，以及如何将Java对象持久化到Oracle数据库中。

Java数据类型与Oracle ARRAY的映射

ARRAY类型在Oracle数据库中的定义

在Oracle数据库中，ARRAY类型用于定义固定长度的数组数据。例如，可以创建一个数组来存储员工的ID信息。在SQL中定义ARRAY类型的基本语法如下：

CREATE OR REPLACE TYPE emp_id_array AS VARRAY(5) OF NUMBER;
/

这段代码定义了一个名为 emp_id_array 的ARRAY类型，它可以存储最多5个NUMBER类型的数据。

Java中处理Oracle ARRAY类型的数据

在Java中，处理Oracle ARRAY类型的数据通常需要使用Oracle JDBC提供的API。Oracle JDBC提供了 OracleArray 接口和相应的实现类来处理ARRAY数据。以下是一个简单的例子，展示了如何在Java中创建和操作一个Oracle ARRAY类型：

import oracle.sql.ARRAY;
import oracle.sql.ArrayDescriptor;
import java.sql.Connection;
import java.sql.SQLException;

public class OracleArrayExample {
    public static ARRAY createEmpIdArray(Connection conn) throws SQLException {
        // 创建ARRAY类型的描述符
        ArrayDescriptor arrayDescriptor = ArrayDescriptor.createDescriptor("EMP_ID_ARRAY", conn);
        // 创建一个ARRAY对象，填充数据
        ARRAY empIds = new ARRAY(arrayDescriptor, conn, new Number[] {100, 200, 300});
        return empIds;
    }
}

在上述代码中，首先通过 ArrayDescriptor.createDescriptor 方法创建了一个描述符对象，指定了ARRAY类型名称和连接对象。然后，通过 ARRAY 构造函数创建了一个 OracleArray 对象，并传入了数据数组。

数据类型的转换和逻辑分析

在进行数据类型转换时，需要注意数据类型的一致性。例如，如果Oracle ARRAY类型存储的是数字，那么在Java中应使用 Number 数组或者其子类来创建 ARRAY 对象。这样可以确保数据在Java和数据库之间的准确映射和转换。

Java数据类型与Oracle TABLE的映射

TABLE类型在Oracle数据库中的定义

Oracle的TABLE类型用于定义不定长度的集合数据。例如，可以创建一个TABLE类型来存储不定数量的员工信息。在SQL中定义TABLE类型的基本语法如下：

CREATE OR REPLACE TYPE emp_info_table AS TABLE OF VARCHAR2(100);
/

这段代码定义了一个名为 emp_info_table 的TABLE类型，它是一个不定长度的集合，每个元素都是 VARCHAR2 类型，长度为100。

Java中处理Oracle TABLE类型的数据

与ARRAY类型类似，Oracle JDBC也提供了 OracleStruct 接口和相应的实现类来处理TABLE数据。以下是一个简单的例子，展示了如何在Java中创建和操作一个Oracle TABLE类型：

import oracle.sql.STRUCT;
import oracle.sql.StructDescriptor;
import java.sql.Connection;
import java.sql.SQLException;

public class OracleTableExample {
    public static STRUCT createEmpInfoTable(Connection conn) throws SQLException {
        // 创建STRUCT类型的描述符
        StructDescriptor structDescriptor = StructDescriptor.createDescriptor("EMP_INFO_TABLE", conn);
        // 创建一个STRUCT对象，填充数据
        STRUCT empInfo = new STRUCT(structDescriptor, conn, new Object[] {"John Doe", "***"});
        return empInfo;
    }
}

在上述代码中，首先通过 StructDescriptor.createDescriptor 方法创建了一个描述符对象，指定了TABLE类型名称和连接对象。然后，通过 STRUCT 构造函数创建了一个 OracleStruct 对象，并传入了数据对象数组。

数据类型的转换和逻辑分析

在处理Oracle TABLE类型时，需要明确TABLE中每个元素的数据类型，并在Java中创建相应类型的数组。这里，每个元素都是一个对象数组，每个对象代表一个字段。在实际应用中，根据TABLE中元素的结构，可能需要创建更复杂的数据结构（例如对象或者自定义类）来匹配TABLE的每个元素。

映射关系的总结

Java类型与Oracle ARRAY和TABLE类型之间的映射关系是双向的。不仅需要考虑如何在Java中创建和操作这些Oracle复杂类型的数据，还需要考虑如何将这些数据类型持久化到数据库中。理解并熟练应用这些映射关系，可以大大提高开发效率和数据处理的准确性。

通过上述的章节内容，我们已经深入理解了在Java中如何映射和操作Oracle数据库中的ARRAY和TABLE类型。这为我们后续章节中实现复杂数据结构的批量操作打下了坚实的基础。

5. Java代码中批量数据的准备方法

在进行批量数据库操作时，合理地准备数据是提高效率的关键。本章将深入探讨如何在Java中准备批量数据，并分析如何将这些数据有效地组织为数组或集合的形式以支持批量操作。我们将使用实际的代码示例来展示这一过程，并提供详细的逻辑分析和参数说明，确保即使是经验丰富的IT从业者也能从中获益。

5.1 批量数据准备的必要性

在进行大量数据操作时，一次性处理多条记录通常比逐条记录处理更加高效。批量操作可以减少数据库交互次数，从而减少网络延迟和数据库的负载，提高整体性能。因此，掌握批量数据的准备方法对于Java开发者而言至关重要。

5.1.1 数据准备的性能影响

数据准备的效率直接影响到批量操作的性能。如果数据准备得当，可以显著减少数据库操作的时间消耗，提高系统吞吐量。

5.1.2 批量数据的组织形式

批量数据在Java中可以以数组（Array）或集合（如List）的形式存在。选择哪种形式取决于数据的特性和操作的需求。

5.2 使用Java集合组织批量数据

5.2.1 使用List进行批量数据处理

List是一种常见的集合类型，它适合在Java中存储和管理批量数据。例如，可以使用 ArrayList 来动态存储数据。

示例代码

List<YourDataType> dataList = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    YourDataType data = new YourDataType();
    // Set data properties
    dataList.add(data);
}

5.2.2 使用Set避免数据重复

如果批量数据需要去重，可以考虑使用Set集合，如 HashSet 。

示例代码

Set<YourDataType> dataSet = new HashSet<>();
while (dataCondition()) {
    YourDataType data = new YourDataType();
    // Set data properties
    dataSet.add(data);
}

5.3 使用数组组织批量数据

5.3.1 一维数组的使用

数组是Java中一种简单但高效的批量数据存储方式。一维数组适用于存储结构相同的数据。

示例代码

YourDataType[] dataArray = new YourDataType[1000];
for (int i = 0; i < 1000; i++) {
    dataArray[i] = new YourDataType();
    // Set data properties
}

5.3.2 多维数组的使用

多维数组可以存储更复杂的数据结构，适用于需要按层级组织数据的情况。

示例代码

YourDataType[][] dataArray = new YourDataType[10][10];
for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        dataArray[i][j] = new YourDataType();
        // Set data properties
    }
}

5.4 代码逻辑分析与参数说明

在上述示例中，我们创建了不同类型的批量数据存储结构。每种方式都有其特点和适用场景：

ArrayList 是动态数组实现，可以根据数据的实际数量动态扩容，适合数据量未知的情况。
HashSet 提供了快速的查找性能，可以自动去重，适合需要去重的场景。
一维数组和多维数组提供了固定大小的数据存储方式，访问速度较快，适合数据量固定且结构简单的场景。

5.5 批量操作的资源管理和性能考量

在准备批量数据时，还需要考虑资源管理和性能。避免内存溢出是需要重点关注的问题，特别是在处理大量数据时。

5.5.1 资源管理

在使用集合时，需要注意集合的大小，避免过多的内存占用。使用数组时，要确保数组的大小不会超过JVM的最大内存限制。

5.5.2 性能考量

在准备批量数据时，应尽量减少不必要的对象创建，减少GC（垃圾回收）的压力，提高应用性能。

5.6 小结

通过本章节的介绍，我们了解了在Java中准备批量数据的多种方法，包括使用List、Set、数组等集合类型。每种方法都有其适用场景，开发者需要根据实际需求进行选择。此外，资源管理和性能优化也是批量数据准备中不可忽视的部分。在下一章中，我们将探讨如何利用Oracle存储过程进行批量数据操作，并演示如何在Java中调用这些存储过程。

6. 调用Oracle存储过程进行批量数据操作

前言

在数据处理中，批量操作可以显著提高效率，减少网络往返次数，降低数据库负载。Oracle存储过程提供了一种在数据库端封装业务逻辑的方式，使得复杂操作可以在数据库内完成，而不仅仅是通过简单的SQL语句。在Java中调用存储过程，可以批量插入、更新或删除数据，实现更高效的数据操作。

定义存储过程

在进行批量操作之前，首先需要在Oracle数据库中定义存储过程。存储过程是存储在数据库中的一组SQL语句，它可以接受输入参数、返回输出参数，并且可以在数据库中执行复杂的业务逻辑。

CREATE OR REPLACE PROCEDURE batch_insert_proc(
    p_table_name IN VARCHAR2,
    p_data_array IN SYS.ODCIVARCHAR2LIST
) AS
BEGIN
    FOR i IN 1..p_data_array.COUNT LOOP
        INSERT INTO TABLENAME (column1, column2)
        VALUES (p_data_array(i)(1), p_data_array(i)(2));
    END LOOP;
END batch_insert_proc;
/

上述存储过程 batch_insert_proc 接收两个参数：表名和数据数组。它遍历数据数组，并将每条记录插入到指定的表中。

Java中调用存储过程

在Java中调用Oracle存储过程，通常使用JDBC API中的 CallableStatement 。下面展示了如何在Java代码中调用上面创建的存储过程：

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.SQLException;

public class OracleStoredProcExample {
    public static void main(String[] args) throws SQLException {
        // 获取数据库连接
        try (Connection conn = Database.getConnection()) {
            // 创建CallableStatement实例
            String sql = "{ call batch_insert_proc(?, ?) }";
            try (CallableStatement cstmt = conn.prepareCall(sql)) {
                // 设置输入参数
                cstmt.setString(1, "TABLENAME");
                cstmt.setArray(2, conn.createArrayOf("VARCHAR", new String[]{"a,b", "c,d"}));

                // 调用存储过程
                cstmt.execute();
            }
        }
    }
}

在上面的Java代码中， CallableStatement 的 setArray 方法用于传递数组类型的参数给存储过程。注意， setArray 的第二个参数需要创建一个 OracleArray 对象。

批量操作的优化

批量操作通常涉及到大量的数据，这可能会消耗较多的内存和数据库资源。为了优化性能，应该考虑以下因素：

批量大小 ：合理的批量大小可以减少数据库I/O的次数，但过大的批量可能会消耗过多的内存，甚至超出数据库的处理能力。需要根据实际情况进行调整。
网络延迟 ：在远程数据库操作中，网络延迟是一个不可忽视的因素。批量操作可以减少网络往返次数，从而减少网络延迟的影响。
事务控制 ：在进行批量操作时，可能需要执行多条SQL语句。合理地使用事务可以确保数据的一致性和完整性。
异常处理 ：在批量操作过程中，可能会遇到数据问题或系统错误，良好的异常处理机制可以保证错误能够被有效捕获，并做出相应的处理。

总结

调用Oracle存储过程进行批量数据操作是Java数据库编程中常见的一种模式，特别是在处理大量数据时。它不仅可以封装复杂的业务逻辑在数据库端执行，还可以通过减少网络往返次数、合理管理事务等方式来提高数据操作的效率。当然，批量操作的设计和执行也需要考虑到性能优化和资源管理，以确保系统稳定和数据安全。

通过本章节的介绍，你已经了解了如何在Java中使用JDBC API调用Oracle存储过程进行批量数据操作，并且探讨了一些相关的优化策略。在实际应用中，还需结合具体的业务场景和系统环境，对批量操作的参数进行调整，以达到最佳的性能表现。

7. 批量入库操作后的资源管理

在数据库操作中，资源管理和事务控制对于确保数据的一致性和操作的安全性至关重要。特别是涉及到批量入库操作时，良好的资源管理策略能够有效避免因操作失败导致的数据不一致问题。本章将探讨在批量入库操作后如何进行事务管理以及资源的合理释放，并提供异常处理的策略。

7.1 事务的必要性

在批量操作中，事务是一个不可忽视的概念。事务保证了一组操作要么全部成功，要么全部失败，这对于维持数据库的数据完整性和一致性至关重要。特别是在处理大量数据时，一个操作的失败可能会导致前序操作产生的数据不一致，因此，正确使用事务是保证批量入库成功的关键。

7.2 使用JDBC事务控制

在Java中操作数据库时，JDBC提供了事务控制的能力。通过获取 Connection 对象，可以使用该对象来控制事务。

Connection conn = null;
try {
    conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "username", "password");
    conn.setAutoCommit(false); // 关闭自动提交，开始一个事务

    // 执行批量操作...
    // ...

    ***mit(); // 提交事务，所有操作永久生效
} catch (Exception e) {
    if (conn != null) {
        try {
            conn.rollback(); // 回滚事务，撤销所有操作
        } catch (SQLException ex) {
            // 记录回滚失败的异常信息
            ex.printStackTrace();
        }
    }
    // 记录异常信息
    e.printStackTrace();
} finally {
    // 释放资源
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

7.3 异常处理策略

在批量操作中，异常处理策略是关键。一个合理设计的异常处理机制可以避免操作失败导致的数据不一致问题，并且帮助定位问题所在。

try {
    // 执行批量操作...
} catch (SQLException e) {
    // 在这里记录异常信息，例如使用日志记录系统记录异常堆栈
    // 同时，可以基于异常类型来决定是否回滚事务
    if (e.getErrorCode() == 12345) { // 假设12345是已知的错误码
        try {
            if (conn != null) {
                conn.rollback();
            }
        } catch (SQLException se) {
            // 这里记录回滚失败的异常信息
        }
    }
    // 可以选择重新抛出异常或者进行其他异常处理
    throw new RuntimeException(e);
}

7.4 批量操作的事务大小控制

在执行批量操作时，事务的大小需要精心控制。过大的事务可能会导致长时间的锁等待，影响系统的并发性能；而事务太小，则会增加事务的管理开销。因此，找到合适的事务大小是一个需要根据实际应用场景进行权衡的问题。

7.5 优化资源释放

在代码执行完毕后，及时释放数据库连接、声明等资源是保证数据库性能的重要措施。在Java中，通常使用 finally 块确保资源的释放，但在现代Java中，更推荐使用try-with-resources语句来自动管理资源。

try (Connection conn = DriverManager.getConnection(...);
     PreparedStatement pstmt = conn.prepareStatement("...")) {
    // 执行操作
} catch (SQLException e) {
    e.printStackTrace();
}
// try-with-resources确保了即使发生异常，资源也会被自动关闭