Understanding Spring Transaction Management: @EnableTransactionManagement, Transaction Propagation, and Synchronization

Spring transaction management is a core feature of the Spring Framework that enables declarative transaction handling using annotations and configuration classes. This guide walks through the complete lifecycle of a Spring-managed transaction, from enabling the feature to handling complex propagation scenarios.

1. @EnableTransactionManagement Working Principle

Enabling Spring transactions adds an @EnableTransactionManagement annotation, which registers two beans in the container:

AutoProxyRegistrar

ProxyTransactionManagementConfiguration

AutoProxyRegistrar registers an InfrastructureAdvisorAutoProxyCreator bean that scans for Advisor types and creates dynamic proxies when necessary. The ProxyTransactionManagementConfiguration defines three additional beans:

BeanFactoryTransactionAttributeSourceAdvisor

AnnotationTransactionAttributeSource (the pointcut for @Transactional)

TransactionInterceptor (the advice that executes transaction logic)

The AnnotationTransactionAttributeSource checks whether a class or method is annotated with @Transactional. If so, a proxy is created and its invoke() method delegates to TransactionInterceptor.

2. Spring Transaction Basic Execution Principle

During bean creation, InfrastructureAdvisorAutoProxyCreator determines whether the bean matches BeanFactoryTransactionAttributeSourceAdvisor. If a match is found, a proxy is generated. When a proxied method is invoked, the interceptor performs the following steps:

Obtain a PlatformTransactionManager and create a new database connection.

Set the connection’s autocommit to false.

Execute the target method (business logic) via MethodInvocation.proceed().

If no exception occurs, commit the transaction.

If an exception occurs, roll back the transaction.

3. Detailed Execution Flow

The detailed flow is illustrated in a diagram (link omitted) and includes the creation of a TransactionSynchronization object to listen to transaction lifecycle events.

4. Transaction Propagation Mechanism

When one transactional method calls another, Spring must decide whether to join the existing transaction or start a new one. The propagation behavior is determined by the propagation attribute of @Transactional. Common scenarios include:

Both methods share the same transaction (default REQUIRED).

Each method runs in its own transaction ( REQUIRES_NEW).

Methods run without a transaction ( NOT_SUPPORTED).

For REQUIRES_NEW, the current transaction is suspended (removed from ThreadLocal) and a new connection is created for the inner method. After the inner method completes, its transaction is committed or rolled back, and the original transaction is resumed.

5. Propagation Categories and Case Analyses

Four typical cases are demonstrated with code snippets:

@Component
public class UserService {
    @Autowired
    private UserService userService;

    @Transactional
    public void test() {
        // test method sql
        userService.a();
    }

    @Transactional
    public void a() {
        // a method sql
    }
}

In the default REQUIRED case, both test and a share a single transaction, which is committed only if no exception occurs. When an exception is thrown in a, the whole transaction rolls back.

When a is annotated with propagation = Propagation.REQUIRES_NEW, a new transaction is started for a. If a fails, its transaction rolls back independently, and the outer transaction can still commit or roll back based on its own outcome.

6. Forced Rollback

Even if an exception is caught and handled, you can force a rollback by calling:

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

This marks the current transaction for rollback when the method completes.

7. TransactionSynchronization

Spring provides TransactionSynchronization callbacks to monitor transaction states such as suspend, resume, beforeCommit, afterCommit, and afterCompletion. Example registration:

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
    @Override public void suspend() { System.out.println("suspend"); }
    @Override public void resume() { System.out.println("resume"); }
    @Override public void beforeCommit(boolean readOnly) { System.out.println("beforeCommit"); }
    @Override public void afterCommit() { System.out.println("afterCommit"); }
    @Override public void afterCompletion(int status) { System.out.println("afterCompletion"); }
});

These callbacks are useful for resource cleanup, logging, or custom actions during transaction lifecycle.

Overall, the article equips developers with a deep understanding of how Spring manages transactions, how to configure propagation behavior, and how to control transaction outcomes programmatically.