Configuring Transaction Propagation, Isolation Levels, and Rollback Rules

When working with complex business logic or multi-step operations, transactions play a vital role in ensuring data consistency and reliability. The Spring Framework, a powerful and widely used framework for building Java applications, provides robust support for managing transactions. In this article, we will explore how to configure transaction propagation, isolation levels, and rollback rules in the Spring Framework.

Transaction Propagation

Transaction propagation defines how transactions are propagated from one method to another when they are called within the same transactional context. Spring provides several propagation options:

  1. Propagation.REQUIRED: This is the default propagation behavior in Spring. It ensures that the method execution runs within a transaction. If a transaction already exists, the method uses it; otherwise, a new transaction is created.

  2. Propagation.REQUIRES_NEW: With this propagation, a new transaction is always created for the annotated method. If there's an existing transaction, it is suspended until the method execution completes.

  3. Propagation.SUPPORTS: This propagation option supports a transaction if one already exists. It allows the method to execute non-transactionally if no transaction exists.

  4. Propagation.NOT_SUPPORTED: This propagation option specifies that the annotated method should always execute non-transactionally, even if a transaction is present.

  5. Propagation.MANDATORY: This propagation enforces that an existing transaction is present when the annotated method is called. If no transaction exists, a TransactionRequiredException is thrown.

  6. Propagation.NEVER: This propagation specifies that the annotated method should never execute within a transaction. If a transaction is active, a NestedTransactionNotSupportedException is thrown.

  7. Propagation.NESTED: This propagation uses a nested transaction if a current transaction exists. It starts a new savepoint within the existing transaction and rolls back to that savepoint instead of rolling back the entire transaction.

To configure transaction propagation, we can use the @Transactional annotation with the propagation attribute, e.g. @Transactional(propagation = Propagation.REQUIRED).

Isolation Levels

Isolation levels determine how transactions interact and isolate each other's changes. Different isolation levels provide different guarantees of data consistency and concurrency. Spring supports the following isolation levels:

  1. Isolation.DEFAULT: This is the default isolation level determined by the underlying database or transaction manager.

  2. Isolation.READ_UNCOMMITTED: This isolation level allows reading uncommitted changes made by other transactions, making it the least restrictive level but prone to dirty reads, non-repeatable reads, and phantom reads.

  3. Isolation.READ_COMMITTED: This level ensures that a transaction can only read committed changes made by other transactions. It avoids dirty reads but can still result in non-repeatable reads and phantom reads.

  4. Isolation.REPEATABLE_READ: This isolation level guarantees that a transaction will always see the same committed data throughout its execution. It prevents dirty reads and non-repeatable reads but may still encounter phantom reads.

  5. Isolation.SERIALIZABLE: This is the highest isolation level, ensuring that a transaction sees the database state as if no other transaction was executing concurrently. It prevents all anomalies but may result in reduced performance due to increased locking.

To configure the isolation level, we can use the @Transactional annotation with the isolation attribute, e.g. @Transactional(isolation = Isolation.READ_COMMITTED).

Rollback Rules

In some scenarios, it is necessary to specify custom rules for rolling back a transaction based on certain exceptions. The Spring Framework allows us to define rollback rules using the rollbackFor and noRollbackFor attributes of the @Transactional annotation. Here's how we can configure rollback rules:

  1. rollbackFor: Specify the exceptions (or an array of exceptions) for which the transaction should be rolled back. For example, @Transactional(rollbackFor = {CustomException.class, AnotherException.class}) will trigger a rollback if either CustomException or AnotherException is thrown.

  2. noRollbackFor: Specify the exceptions (or an array of exceptions) that should not cause the transaction to be rolled back. For example, @Transactional(noRollbackFor = NullPointerException.class) will prevent a rollback if a NullPointerException occurs.

By default, Spring rolls back the transaction for any unchecked (runtime) exceptions and errors.


Configuring transaction propagation, isolation levels, and rollback rules is essential for building reliable and consistent applications. The Spring Framework offers a flexible and comprehensive approach to handling transactions, enabling developers to fine-tune the behavior according to their specific requirements. Understanding these configuration options empowers developers to build robust and efficient applications using the Spring Framework.

noob to master © copyleft