java jdbc 实现批量操作的两阶段提交，核心在于利用 connection 的 setautocommit(false) 开启事务，通过 addbatch() 和 executebatch() 执行 sql，并在成功时调用 commit()，在异常时调用 rollback()。这种机制确保了批量操作的原子性：要么所有语句都生效，要么全部回滚，不会出现部分成功部分失败的数据不一致状态。
JDBC 事务中如何配置批量执行与自动提交
要实现批量操作，必须显式关闭自动提交模式。默认情况下，JDBC 连接是自动提交的，每条 SQL 都会立即生效。通过调用 connection.setAutoCommit(false)，后续的所有 SQL 语句都会被缓存到事务中，直到显式调用 commit() 才真正写入数据库。在执行过程中，使用 PreparedStatement.addBatch() 将多条 SQL 加入批次，最后通过 executeBatch() 一次性发送给数据库驱动处理。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class BatchTransactionExample {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(url, user, password)) {
// 1. 关闭自动提交，开启事务
conn.setAutoCommit(false);
String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
// 2. 添加批量数据
for (int i = 0; i < 100; i++) {
pstmt.setString(1, "User" + i);
pstmt.setString(2, "user" + i + "@example.com");
pstmt.addBatch();
}
// 3. 执行批量操作
int[] results = pstmt.executeBatch();
// 4. 手动提交事务
conn.commit();
System.out.println("批量插入成功，共影响行数: " + results.length);
} catch (Exception e) {
// 5. 发生异常则回滚
conn.rollback();
e.printStackTrace();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}上述代码展示了标准的 JDBC 批量事务流程。首先获取连接并禁用自动提交。接着创建 PreparedStatement，在循环中设置参数并调用 addBatch()。执行 executeBatch() 后，如果未抛出异常，则调用 commit() 提交事务。如果在任何步骤发生异常，catch 块会捕获异常并调用 rollback()，确保数据库状态恢复到事务开始前的样子。
立即学习“Java免费学习笔记（深入）”；
两阶段提交在 JDBC 中的具体表现与验证
在单数据库场景下，JDBC 的“两阶段提交”实际上是指事务的 prepare（执行）和 commit（确认）过程。第一阶段是 executeBatch()，数据库引擎解析并执行所有 SQL，但此时数据并未持久化到磁盘或对其他事务可见。第二阶段是 commit()，数据库将事务日志刷盘并正式提交。如果在这两个阶段之间发生崩溃或异常，事务会自动回滚。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class VerifyBatchResult {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(url, user, password)) {
conn.setAutoCommit(false);
String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, "TestUser");
pstmt.setString(2, "test@example.com");
pstmt.addBatch();
pstmt.executeBatch();
// 模拟在提交前检查
// 此时数据尚未提交，其他事务不可见
conn.commit();
// 验证数据是否已存在
ResultSet rs = conn.createStatement().executeQuery("SELECT * FROM users WHERE name='TestUser'");
if (rs.next()) {
System.out.println("数据已成功提交并可见");
}
} catch (Exception e) {
conn.rollback();
System.out.println("事务回滚，数据未提交");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}通过上述验证代码，可以看到在 commit() 之前，即使 executeBatch() 执行成功，数据对其他事务也是不可见的（取决于隔离级别）。只有当 commit() 成功返回后，数据才真正持久化。如果在 commit() 之前抛出异常，rollback() 会被调用，数据不会进入数据库。这种机制保证了数据的强一致性。
批量操作中如何处理主键冲突导致的回滚
在批量插入过程中，如果某条记录导致主键冲突（Duplicate Key），整个事务可能会根据数据库配置和驱动行为而回滚或部分失败。例如，MySQL 在默认模式下，如果一条 SQL 出错，后续的 SQL 可能仍会执行，但 executeBatch() 会抛出 BatchUpdateException。此时，必须调用 rollback() 来撤销所有已执行的语句，以保持数据一致性。
import java.sql.BatchUpdateException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class HandleBatchConflict {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(url, user, password)) {
conn.setAutoCommit(false);
String sql = "INSERT INTO users (id, name) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
// 假设 id=1 已存在
pstmt.setInt(1, 1);
pstmt.setString(2, "ExistingUser");
pstmt.addBatch();
pstmt.setInt(1, 2);
pstmt.setString(2, "NewUser");
pstmt.addBatch();
try {
pstmt.executeBatch();
conn.commit();
} catch (BatchUpdateException e) {
// 捕获批量更新异常
System.err.println("批量更新失败，原因: " + e.getMessage());
conn.rollback(); // 回滚整个事务
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}在上述代码中，第一条插入语句因主键冲突失败，导致 executeBatch() 抛出 BatchUpdateException。程序捕获该异常后，调用 rollback()，确保两条插入语句都不会生效。这种处理方式避免了部分数据入库的问题，保证了事务的原子性。开发者在处理批量操作时，应始终包裹在 try-catch 块中，并确保在异常路径上调用 rollback()。
