Hogyan működik a `@Transactional`, beleértve a propagációt és a rollbacket?

Question

IT Interview Practice · Accepted Answer

A `@Transactional` egy metódust adatbázis-tranzakcióba csomagol: a Spring megnyit egyet a metódus futása előtt, és commitál, amikor normálisan visszatér — vagy **rollbackel**, ha kivételt dob. A háttérben ez egy **AOP proxy**, ami a legtöbb gotcha forrása.

## Alap használat

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

## Az alapértelmezett rollback szabály (klasszikus csapda)

Alapból a Spring csak **unchecked** kivételekre (`RuntimeException`) és `Error`-ra rollbackel — **nem** checked kivételekre. Ha checked kivételt dobsz, a tranzakció *commitál*. Írd felül explicit módon:

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

## Propagáció

A propagáció dönti el, mi történik, amikor egy tranzakciós metódus egy másikat hív:

- **REQUIRED** (alapértelmezett): csatlakozik a hívó tranzakciójához, vagy indít egyet, ha nincs.
- **REQUIRES_NEW**: felfüggeszti a hívó tranzakcióját, és egy friss, független tranzakcióban fut — hasznos audit logokhoz, amelyeknek akkor is fenn kell maradniuk, ha a külső munka rollbackel.

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

## A self-invocation csapda

Mivel a `@Transactional` proxyn keresztül működik, ha egy `@Transactional` metódust egy másik, *ugyanabban az osztályban* lévő metódusból hívsz, az megkerüli a proxyt — az annotáció csendben figyelmen kívül marad. Hívj beanek között, vagy injektáld magadat.

## Miért fontos

A tranzakciók az adathelyesség otthona, ezért az interjúztatók keményen nyomulnak itt. A checked-kivétel rollback szabály és a self-invocation hiba az a két kérdés, amely megbízhatóan elválasztja azokat, akik *használták* a `@Transactional`-t, azoktól, akik *értik* is.

Alap használat

Az alapértelmezett rollback szabály (klasszikus csapda)

Propagáció

A self-invocation csapda

Miért fontos

Kapcsolódó kérdések