要正確處理JDBC事務(wù)，必須先關(guān)閉自動(dòng)提交模式，再執(zhí)行多個(gè)操作，最後根據(jù)結(jié)果提交或回滾；1. 調(diào)用conn.setAutoCommit(false)以開始事務(wù)；2. 執(zhí)行多個(gè)SQL操作，如INSERT和UPDATE；3. 若所有操作成功則調(diào)用conn.commit()，若發(fā)生異常則調(diào)用conn.rollback()確保數(shù)據(jù)一致性；同時(shí)應(yīng)使用try-with-resources管理資源，妥善處理異常並關(guān)閉連接，避免連接洩漏；此外建議使用連接池、設(shè)置保存點(diǎn)實(shí)現(xiàn)部分回滾，並保持事務(wù)盡可能短以提升性能。

Handling transactions in Java with JDBC is essential when you need to ensure data consistency across multiple database operations. By default, JDBC runs in auto-commit mode, meaning each SQL statement is treated as a separate transaction and committed immediately. To manage transactions manually — for example, when you want several operations to succeed or fail together — you need to disable auto-commit and explicitly control when to commit or roll back.

Here's how to properly handle transactions using JDBC:

1. Disable Auto-Commit Mode

Before starting your transaction, turn off auto-commit so that multiple operations can be grouped together:

 Connection conn = dataSource.getConnection();
conn.setAutoCommit(false);

Once disabled, no changes will be saved to the database until you call commit() .

2. Execute Multiple Operations

Now you can execute multiple SQL statements (INSERT, UPDATE, DELETE, etc.) as part of the same transaction:

 try (PreparedStatement ps1 = conn.prepareStatement("INSERT INTO accounts (id, balance) VALUES (?, ?)")) {
    ps1.setInt(1, 1001);
    ps1.setDouble(2, 500.0);
    ps1.executeUpdate();
}

try (PreparedStatement ps2 = conn.prepareStatement("UPDATE accounts SET balance = balance - ? WHERE id = ?")) {
    ps2.setDouble(1, 200.0);
    ps2.setInt(2, 1000);
    ps2.executeUpdate();
}

These operations won't be visible to other transactions until committed.

3. Commit or Roll Back Based on Outcome

After all operations, if everything succeeded, call commit() :

 conn.commit();

If any exception occurs, roll back the entire transaction to maintain consistency:

 try {
    // ... your JDBC operations
    conn.commit();
} catch (SQLException e) {
    try {
        conn.rollback();
    } catch (SQLException ex) {
        ex.printStackTrace();
    }
    throw e;
}

Always wrap the rollback in a try-catch block because it can also throw an exception.

4. Use Try-With-Resources and Proper Exception Handling

To ensure resources are closed and connections are not leaked, use try-with-resources and handle exceptions carefully:

 Connection conn = null;
try {
    conn = dataSource.getConnection();
    conn.setAutoCommit(false);

    // Perform DB operations
    try (PreparedStatement ps1 = conn.prepareStatement("INSERT INTO logs (msg) VALUES (?)")) {
        ps1.setString(1, "Transaction started");
        ps1.executeUpdate();
    }

    try (PreparedStatement ps2 = conn.prepareStatement("UPDATE accounts SET balance = ? WHERE id = ?")) {
        ps2.setDouble(1, 1000.0);
        ps2.setInt(2, 1001);
        ps2.executeUpdate();
    }

    conn.commit();
} catch (SQLException 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();
        }
    }
}

Best Practices

• Always rollback on error : Never leave a transaction open after an exception.
• Keep transactions short : Long-running transactions can lock resources and hurt performance.
• Use connection pooling in production : Tools like HikariCP help manage connections efficiently.
• Avoid catching and swallowing exceptions : Make sure errors don't prevent rollback.
• Consider savepoints for partial rollbacks (advanced use case):

 Savepoint sp = conn.setSavepoint("before_risky_operation");
// ... risky operation
// If something goes wrong:
conn.rollback(sp);

Basically, handling transactions in JDBC comes down to three key steps: disable auto-commit, group your operations, then commit or rollback based on success. It's simple but easy to get wrong if you don't handle exceptions and cleanup properly.

以上是如何使用JDBC處理Java的交易？的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！