What is Transaction Management in Spring Boot?

Transaction Management in Spring Boot is a mechanism used to ensure that database operations are executed safely, reliably, and consistently.

It guarantees that:

All operations succeed together
Or all operations fail together

In simple words:

“Transaction management ensures data consistency during database operations.”

Why Transaction Management is Needed

Enterprise applications often perform multiple database operations together.

Examples:

Bank money transfer
Order placement
Payment processing
Ticket booking

If one operation fails in the middle:

Database may become inconsistent
Incorrect data may be stored

Transaction management prevents these problems.

Real-Time Banking Example

Suppose:

₹10,000 transferred from Account A to Account B

Steps:

Deduct money from Account A
Add money to Account B

Problem:

If step 1 succeeds
But step 2 fails

Money disappears from the system.

Transaction management solves this issue.

What is a Transaction?

A transaction is:

A group of database operations
Executed as a single unit

Main Goal of Transactions

Transactions maintain:

Data consistency
Reliability
Integrity

ACID Properties of Transactions

Transactions follow ACID properties.

1. Atomicity

Either:

All operations succeed
Or all operations fail

2. Consistency

Database remains valid before and after transaction.

3. Isolation

Transactions do not interfere with each other.

4. Durability

Once committed, data remains permanent even after system failure.

What is @Transactional Annotation?

Spring Boot provides:

@Transactional

annotation for transaction management.

Basic Example

@Transactional
public void transferMoney() {

}

How @Transactional Works

Spring automatically:

Starts transaction
Executes operations
Commits transaction if successful
Rolls back if failure occurs

Money Transfer Example

@Service
public class BankService {

    @Transactional
    public void transferMoney(

            Long fromAccount,

            Long toAccount,

            Double amount
    ) {

        withdraw(fromAccount, amount);

        deposit(toAccount, amount);
    }
}

Successful Transaction Flow


Start Transaction
       ↓
Withdraw Money
       ↓
Deposit Money
       ↓
Commit Transaction

Failed Transaction Flow


Start Transaction
       ↓
Withdraw Money
       ↓
Deposit Fails
       ↓
Rollback Transaction

What is Commit?

Commit means:

Permanently save changes into database

What is Rollback?

Rollback means:

Undo all changes made during transaction

Generated SQL Example

UPDATE accounts
SET balance = balance - 10000
WHERE id = 1;

UPDATE accounts
SET balance = balance + 10000
WHERE id = 2;

If Exception Occurs

Spring automatically performs:

ROLLBACK

Transaction Management Architecture


Application
     ↓
Spring Transaction Manager
     ↓
Hibernate/JPA
     ↓
Database

What is PlatformTransactionManager?

Spring internally uses:

PlatformTransactionManager

to manage transactions.

Default Transaction Behavior

By default:

Rollback occurs only for RuntimeException

Example

@Transactional
public void processPayment() {

    throw new RuntimeException();
}

Transaction rolls back automatically.

Rollback for Checked Exception

Checked exceptions require explicit configuration.

Example

@Transactional(
    rollbackFor = Exception.class
)
public void processPayment()
        throws Exception {

}

Propagation in Transactions

Propagation defines:

How transactions behave inside other transactions

Main Propagation Types

Propagation Type	Description
REQUIRED	Use existing transaction or create new
REQUIRES_NEW	Always create new transaction
SUPPORTS	Use existing transaction if available
NOT_SUPPORTED	Run without transaction

Propagation Example

@Transactional(
    propagation =
    Propagation.REQUIRES_NEW
)

Isolation Levels

Isolation controls:

How transactions interact with each other

Main Isolation Levels

Isolation Level	Description
READ_UNCOMMITTED	Can read uncommitted data
READ_COMMITTED	Reads only committed data
REPEATABLE_READ	Ensures repeated reads are same
SERIALIZABLE	Highest isolation level

Isolation Example

@Transactional(
    isolation =
    Isolation.READ_COMMITTED
)

Read-Only Transactions

Read-only transactions improve performance for fetch operations.

Example

@Transactional(readOnly = true)
public List<Student> getStudents() {

    return repository.findAll();
}

Advantages of Transaction Management

Maintains data consistency
Prevents partial updates
Automatic rollback support
Improves reliability
Simplifies database operations

Disadvantages of Improper Transactions

Deadlocks
Performance issues
Long-running transactions
Database locking problems

Real-Time Example in E-Commerce Application

Order placement may involve:

Saving order
Updating inventory
Processing payment

If payment fails:

Entire transaction should rollback

Best Practices for Transaction Management

Keep transactions short
Use readOnly for fetch operations
Avoid long-running transactions
Handle exceptions properly
Use proper isolation levels

Common Interview Questions on Transaction Management