Spring and JDBC Transactions

In this chapter, you will explore how Spring manages transactions when working with JDBC. You will gain a clear understanding of the internal mechanics that allow Spring to handle database transactions effectively, ensuring data consistency and integrity.

Managing JDBC Transactions with DataSourceTransactionManager

Spring uses the DataSourceTransactionManager to handle transactions when you interact with a database using JDBC. This manager coordinates transaction boundaries and ensures database consistency.

How DataSourceTransactionManager Works

• Creates a new database connection from the configured DataSource when a transaction starts;
• Binds the connection to the current thread, so all JDBC operations within the transaction use the same connection;
• Sets the connection's autoCommit property to false to allow multiple statements to execute as a single transaction;
• Manages commit or rollback based on the outcome of your code;
• Unbinds and closes the connection when the transaction ends.

Connection Binding to Threads

When you start a transaction, Spring binds the JDBC connection to the thread that started it. This means any JDBC calls you make within the same thread will use the same connection. This thread-bound connection is stored in a thread-local variable, making it invisible to other threads and preventing accidental sharing.

Example:

If you annotate a method with @Transactional, Spring ensures all JDBC operations in that method use the same connection:

@Transactional
public void updateAccountBalance(Long accountId, BigDecimal amount) {
    // All JDBC operations here use the same connection
}

Controlling autoCommit

By default, JDBC connections use autoCommit = true, which means each SQL statement is committed immediately. DataSourceTransactionManager sets autoCommit to false at the start of a transaction. This allows you to group multiple statements into a single transaction. When your method completes successfully, Spring commits the transaction. If an exception occurs, Spring rolls back all changes made during the transaction.

Summary:

• Spring automatically manages the lifecycle of JDBC connections within a transaction;
• Connections are bound to the current thread for the transaction's duration;
• autoCommit is disabled to allow transaction control;
• Commit or rollback is handled automatically by Spring based on method execution.

This approach provides consistent, reliable transaction management without requiring you to write manual commit or rollback logic.