Wie funktioniert @Transactional, einschließlich Propagation und Rollback?

Question

IT Interview Practice · Accepted Answer

`@Transactional` wickelt eine Methode in eine Datenbanktransaktion: Spring öffnet eine, bevor die Methode läuft, und committet, wenn sie normal zurückkehrt – oder macht einen **Rollback**, wenn sie eine Exception wirft. Unter der Haube ist es ein **AOP-Proxy**, was die Quelle der meisten Fallstricke ist.

## Grundlegende Verwendung

```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
    }
}
```

## Die Standard-Rollback-Regel (eine klassische Falle)

Standardmäßig macht Spring nur bei **unchecked** Exceptions (`RuntimeException`) und `Error` einen Rollback – **nicht** bei checked Exceptions. Wenn du eine checked Exception wirfst, *committet* die Transaktion. Überschreibe das explizit:

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

## Propagation

Propagation entscheidet, was passiert, wenn eine transaktionale Methode eine andere aufruft:

- **REQUIRED** (Standard): der Transaktion des Aufrufers beitreten oder eine starten, falls keine existiert.
- **REQUIRES_NEW**: die Transaktion des Aufrufers aussetzen und in einer frischen, unabhängigen laufen – nützlich für Audit-Logs, die bestehen bleiben müssen, selbst wenn die äußere Arbeit zurückgerollt wird.

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

## Die Self-Invocation-Falle

Weil `@Transactional` über einen Proxy funktioniert, umgeht der Aufruf einer `@Transactional`-Methode aus einer anderen Methode *derselben Klasse* den Proxy – die Annotation wird stillschweigend ignoriert. Rufe über Beans hinweg auf oder injiziere self.

## Warum es wichtig ist

Transaktionen sind der Ort, an dem die Datenkorrektheit lebt, deshalb bohren Interviewer hier hart nach. Die Rollback-Regel bei checked Exceptions und der Self-Invocation-Bug sind die zwei Fragen, die zuverlässig Leute, die `@Transactional` *verwendet* haben, von denen trennen, die es *verstehen*.

Grundlegende Verwendung

Die Standard-Rollback-Regel (eine klassische Falle)

Propagation

Die Self-Invocation-Falle

Warum es wichtig ist

Ähnliche Fragen