Hvordan fungerer @Transactional, herunder propagation og rollback?

Question

IT Interview Practice · Accepted Answer

`@Transactional` pakker en metode ind i en databasetransaktion: Spring åbner én, før metoden kører, og committer, når den returnerer normalt — eller **ruller tilbage**, hvis den kaster en fejl. Under motorhjelmen er det en **AOP-proxy**, hvilket er kilden til de fleste faldgruber.

## Grundlæggende brug

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

## Standard-rollback-reglen (en klassisk fælde)

Som standard ruller Spring kun tilbage på **unchecked** exceptions (`RuntimeException`) og `Error` — **ikke** på checked exceptions. Hvis du kaster en checked exception, *committer* transaktionen. Overstyr det eksplicit:

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

## Propagation

Propagation afgør, hvad der sker, når en transaktionel metode kalder en anden:

- **REQUIRED** (standard): deltag i kalderens transaktion, eller start en, hvis ingen findes.
- **REQUIRES_NEW**: suspendér kalderens transaktion og kør i en frisk, uafhængig én — nyttigt til audit-logs, der skal persisteres, selv hvis det ydre arbejde ruller tilbage.

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

## Self-invocation-fælden

Fordi `@Transactional` virker via en proxy, omgår et kald af én `@Transactional`-metode fra en anden metode *i samme klasse* proxyen — annotationen ignoreres i stilhed. Kald på tværs af beans, eller injicér self.

## Hvorfor det betyder noget

Transaktioner er, hvor datakorrekthed lever, så interviewere presser hårdt her. Reglen om checked-exception-rollback og self-invocation-bug'en er de to spørgsmål, der pålideligt adskiller folk, der *har brugt* `@Transactional`, fra dem, der *forstår* det.

Grundlæggende brug

Standard-rollback-reglen (en klassisk fælde)

Propagation

Self-invocation-fælden

Hvorfor det betyder noget

Relaterede spørgsmål