Hvordan fungerer @Transactional, inkludert propagation og rollback?

Question

IT Interview Practice · Accepted Answer

`@Transactional` pakker en metode inn i en databasetransaksjon: Spring åpner en før metoden kjører og committer når den returnerer normalt — eller **ruller tilbake** hvis den kaster. Under panseret er det en **AOP-proxy**, som er kilden til de fleste fallgruvene.

## Grunnleggende bruk

```java
@Service
public class TransferService {

@Transactional // commit ved suksess, rull tilbake ved RuntimeException
    public void transfer(Long from, Long to, BigDecimal amount) {
        accounts.debit(from, amount);
        accounts.credit(to, amount); // hvis DENNE kaster, rulles debiteringen også tilbake
    }
}
```

## Standard rollback-regelen (en klassisk felle)

Som standard ruller Spring bare tilbake på **unchecked** unntak (`RuntimeException`) og `Error` — **ikke** på checked unntak. Hvis du kaster et checked unntak, *committer* transaksjonen. Overstyr det eksplisitt:

```java
@Transactional(rollbackFor = Exception.class) // rull tilbake på checked også
public void process() throws IOException { /* ... */ }
```

## Propagation

Propagation avgjør hva som skjer når en transaksjonell metode kaller en annen:

- **REQUIRED** (standard): bli med i kallerens transaksjon, eller start en hvis ingen finnes.
- **REQUIRES_NEW**: suspender kallerens transaksjon og kjør i en ny, uavhengig en — nyttig for revisjonslogger som må lagres selv om det ytre arbeidet rulles tilbake.

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

## Self-invocation-fellen

Fordi `@Transactional` fungerer via en proxy, omgår det å kalle én `@Transactional`-metode fra en annen metode *i samme klasse* proxyen — annotasjonen ignoreres stille. Kall på tvers av beans, eller injiser deg selv.

## Hvorfor det er viktig

Transaksjoner er der datakorrekthet bor, så intervjuere presser hardt her. Rollback-regelen for checked unntak og self-invocation-bugen er de to spørsmålene som pålitelig skiller de som har *brukt* `@Transactional` fra de som *forstår* det.

Grunnleggende bruk

Standard rollback-regelen (en klassisk felle)

Propagation

Self-invocation-fellen

Hvorfor det er viktig

Relaterte spørsmål