Hur fungerar @Transactional, inklusive propagation och rollback?

Question

IT Interview Practice · Accepted Answer

`@Transactional` omsluter en metod i en databastransaktion: Spring öppnar en innan metoden körs och committar när den returnerar normalt — eller gör **rollback** om den kastar ett undantag. Under huven är det en **AOP-proxy**, vilket är källan till de flesta fallgroparna.

## Grundläggande användning

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

## Standardregeln för rollback (en klassisk fälla)

Som standard gör Spring rollback endast vid **unchecked** undantag (`RuntimeException`) och `Error` — **inte** vid checked undantag. Om du kastar ett checked undantag *committas* transaktionen. Åsidosätt det explicit:

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

## Propagation

Propagation avgör vad som händer när en transaktionell metod anropar en annan:

- **REQUIRED** (standard): gå med i anroparens transaktion, eller starta en om ingen finns.
- **REQUIRES_NEW**: pausa anroparens transaktion och kör i en ny, oberoende — användbart för granskningsloggar som måste bestå även om det yttre arbetet rullas tillbaka.

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

## Fällan med self-invocation

Eftersom `@Transactional` fungerar via en proxy kringgår ett anrop av en `@Transactional`-metod från en annan metod *i samma klass* proxyn — annotationen ignoreras tyst. Anropa mellan beans, eller injicera dig själv.

## Varför det är viktigt

Transaktioner är där datakorrekthet bor, så intervjuare pressar hårt här. Rollback-regeln för checked undantag och self-invocation-buggen är de två frågorna som pålitligt skiljer dem som *har använt* `@Transactional` från dem som *förstår* det.

Grundläggande användning

Standardregeln för rollback (en klassisk fälla)

Propagation

Fällan med self-invocation

Varför det är viktigt

Relaterade frågor