How does @Transactional work, including propagation and rollback?

Question

IT Interview Practice · Accepted Answer

`@Transactional` wraps a method in a database transaction: Spring opens one before the method runs and commits when it returns normally — or **rolls back** if it throws. Under the hood it is an **AOP proxy**, which is the source of most gotchas.

## Basic usage

```java
@Service
public class TransferService {

@Transactional // commit on success, roll back on RuntimeException
    public void transfer(Long from, Long to, BigDecimal amount) {
        accounts.debit(from, amount);
        accounts.credit(to, amount); // if THIS throws, the debit is rolled back too
    }
}
```

## The default rollback rule (a classic trap)

By default Spring rolls back only on **unchecked** exceptions (`RuntimeException`) and `Error` — **not** on checked exceptions. If you throw a checked exception, the transaction *commits*. Override it explicitly:

```java
@Transactional(rollbackFor = Exception.class) // roll back on checked too
public void process() throws IOException { /* ... */ }
```

## Propagation

Propagation decides what happens when a transactional method calls another:

- **REQUIRED** (default): join the caller's transaction, or start one if none exists.
- **REQUIRES_NEW**: suspend the caller's transaction and run in a fresh, independent one — useful for audit logs that must persist even if the outer work rolls back.

```java
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void writeAuditLog(String event) { /* commits independently */ }
```

## The self-invocation trap

Because `@Transactional` works via a proxy, calling one `@Transactional` method from another method *in the same class* bypasses the proxy — the annotation is silently ignored. Call across beans, or inject self.

## Why it matters

Transactions are where data correctness lives, so interviewers push hard here. The checked-exception rollback rule and the self-invocation bug are the two questions that reliably separate people who *used* `@Transactional` from those who *understand* it.

Basic usage

The default rollback rule (a classic trap)

Propagation

The self-invocation trap

Why it matters

Related questions