Mastering Spring Transaction Management: From Basics to Advanced Scenarios

Why Transaction Management?

Without a transaction manager, coordinating multiple database operations across methods or classes requires manual handling of connections, which quickly becomes error‑prone and leads to resource leaks.

public void methodA(){
    Connection conn = acquireConnection();
    try{
        int updated = conn.prepareStatement().executeUpdate();
        methodB(conn);
        conn.commit();
    }catch(Exception e){
        conn.rollback();
    }finally{
        releaseConnection(conn);
    }
}

public void methodB(Connection conn){
    int updated = conn.prepareStatement().executeUpdate();
}

Using ThreadLocal to store the connection is a crude alternative, but still requires explicit bind/unbind logic.

static ThreadLocal<Connection> connHolder = new ThreadLocal<>();

public void methodA(){
    Connection conn = acquireConnection();
    connHolder.set(conn);
    try{
        int updated = conn.prepareStatement().executeUpdate();
        methodB();
        conn.commit();
    }catch(Exception e){
        conn.rollback();
    }finally{
        releaseConnection(conn);
        connHolder.remove();
    }
}

public void methodB(){
    Connection conn = connHolder.get();
    int updated = conn.prepareStatement().executeUpdate();
}

Spring’s transaction manager eliminates these boiler‑plate steps.

What Spring Transaction Management Solves

Spring automatically manages resources such as JDBC Connection, Hibernate Session, or MyBatis SqlSession. It also supports nested transactions where child methods need independent commits or rollbacks.

Nested Transactions

A call chain where each method has its own transaction is a nested‑transaction scenario.

public void methodA(){
    int updated = connection.prepareStatement().executeUpdate();
    methodB();
}

public void methodB(){
    // independent work
}

Spring classifies this as a nested transaction regardless of whether the same or different physical transaction is used.

Transaction Propagation

Propagation determines whether a child method joins the current transaction or starts a new one. Spring defines three broad categories:

Prefer the current transaction.

Start a new transaction, ignoring the current one.

Execute without any transaction.

For example, making methodB use a new transaction corresponds to Propagation.REQUIRES_NEW.

@Transactional
public void methodA(){
    jdbcTemplate.batchUpdate(updateSql, params);
    methodB();
}

// New independent transaction
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB(){
    jdbcTemplate.batchUpdate(updateSql, params);
}

Rollback Strategy

By default, any thrown exception triggers a rollback. However, you can fine‑tune this behavior, e.g., prevent rollback for certain exception types:

@Transactional(propagation = Propagation.REQUIRES_NEW, noRollbackFor = Exception.class)
public void methodB(){
    jdbcTemplate.batchUpdate(updateSql, params);
}

Transaction Manager Model

The core of Spring’s transaction handling is the PlatformTransactionManager interface, which provides three operations:

interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
    void commit(TransactionStatus status) throws TransactionException;
    void rollback(TransactionStatus status) throws TransactionException;
}

A TransactionDefinition captures propagation, isolation, read‑only, and rollback settings, while TransactionStatus holds the runtime state of a specific transaction.

Resource Acquisition

When obtaining a transaction, Spring checks whether a transaction already exists. If it does, the behavior depends on the propagation setting; otherwise a new transaction is started.

public final TransactionStatus getTransaction(TransactionDefinition def) {
    Object transaction = doGetTransaction();
    if (isExistingTransaction(transaction)) {
        return handleExistingTransaction(def, transaction, debug);
    } else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED
            || def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW
            || def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
        return startTransaction(def, transaction, debug, null);
    } else {
        // no transaction
    }
}

Suspend and Resume

For REQUIRES_NEW, Spring suspends the current transaction, creates a new one, and later resumes the original after the nested call finishes.

Commit and Rollback

Only the outermost (new) transaction actually performs a commit or rollback; inner transactions merely mark the status and let the outer transaction finalize the work.

public void commit(TransactionStatus status) {
    if (status.isNewTransaction()) {
        // real commit
        doCommit(status.getTransaction(), status.getDefinition());
        // resume any suspended resources
    }
}

public void rollback(TransactionStatus status) {
    if (status.isNewTransaction()) {
        // real rollback
        doRollback(status.getTransaction(), status.getDefinition());
    } else {
        status.setRollbackOnly();
    }
    // resume suspended resources if any
}

Declarative vs Programmatic Transaction Management

Spring offers three ways to drive the transaction manager:

XML‑based AOP (legacy).

Annotation‑based AOP using @Transactional (the most common).

Programmatic TransactionTemplate (manual control).

Declarative (Auto) Mode

The TransactionInterceptor obtains a transaction, proceeds with the target method, then commits or rolls back based on the outcome.

public Object invoke(MethodInvocation invocation) throws Throwable {
    TransactionStatus txStatus = transactionManager.getTransaction(attr);
    try {
        Object ret = invocation.proceed();
        transactionManager.commit(txStatus);
        return ret;
    } catch (Throwable ex) {
        transactionManager.rollback(txStatus);
        throw ex;
    }
}

Programmatic (Manual) Mode

TransactionTemplate

gives full control over when to commit or roll back.

public <T> T execute(TransactionCallback<T> action) throws TransactionException {
    TransactionStatus status = transactionManager.getTransaction(this);
    try {
        T result = action.doInTransaction(status);
        transactionManager.commit(status);
        return result;
    } catch (Throwable ex) {
        transactionManager.rollback(status);
        throw ex;
    }
}

Both approaches share the same underlying PlatformTransactionManager, allowing mixed usage within a single transaction context.

Conclusion

Spring’s transaction management revolves around an abstract transaction manager. Whether using XML, annotations, or TransactionTemplate, the core mechanics—resource acquisition, propagation handling, suspend/resume, commit, and rollback—remain consistent, providing a flexible yet powerful way to handle database consistency.