Hoe werkt @Transactional, inclusief propagation en rollback?

Question

IT Interview Practice · Accepted Answer

`@Transactional` wikkelt een methode in een database-transactie: Spring opent er een voordat de methode draait en commit wanneer hij normaal terugkeert — of doet een **rollback** als hij een exception gooit. Onder de motorkap is het een **AOP-proxy**, wat de bron is van de meeste valkuilen.

## Basisgebruik

```java
@Service
public class TransferService {

@Transactional // commit bij succes, rollback bij RuntimeException
    public void transfer(Long from, Long to, BigDecimal amount) {
        accounts.debit(from, amount);
        accounts.credit(to, amount); // als DIT gooit, wordt de debit ook teruggedraaid
    }
}
```

## De standaard rollback-regel (een klassieke valkuil)

Standaard doet Spring alleen een rollback bij **unchecked** exceptions (`RuntimeException`) en `Error` — **niet** bij checked exceptions. Als je een checked exception gooit, *commit* de transactie. Overschrijf dit expliciet:

```java
@Transactional(rollbackFor = Exception.class) // rollback ook bij checked
public void process() throws IOException { /* ... */ }
```

## Propagation

Propagation bepaalt wat er gebeurt wanneer een transactionele methode een andere aanroept:

- **REQUIRED** (default): sluit aan bij de transactie van de aanroeper, of start er een als die er niet is.
- **REQUIRES_NEW**: schort de transactie van de aanroeper op en draai in een verse, onafhankelijke transactie — handig voor audit logs die moeten persisteren, zelfs als het buitenste werk wordt teruggedraaid.

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

## De self-invocation-valkuil

Omdat `@Transactional` via een proxy werkt, omzeilt het aanroepen van de ene `@Transactional`-methode vanuit een andere methode *in dezelfde klasse* de proxy — de annotatie wordt stilzwijgend genegeerd. Roep over beans heen aan, of injecteer jezelf.

## Waarom het belangrijk is

Transacties zijn waar datacorrectheid leeft, dus interviewers duwen hier hard. De rollback-regel bij checked exceptions en de self-invocation-bug zijn de twee vragen die betrouwbaar mensen die `@Transactional` *hebben gebruikt* scheiden van wie het *begrijpt*.

Basisgebruik

De standaard rollback-regel (een klassieke valkuil)

Propagation

De self-invocation-valkuil

Waarom het belangrijk is

Gerelateerde vragen