Formations — 1 037 leçons en français

Accueil › Spring Boot › Les transactions avec @Transactional

Les transactions avec @Transactional

JPA avancéintermediaire

@Transactional délimite une transaction autour d'une méthode : si tout se passe bien, les modifications sont validées (commit) ensemble à la fin ; en cas d'erreur, elles sont toutes annulées (rollback).

@Service
public class CommandeService {
    private final CommandeRepository repo;
    private final StockService stockService;

    public CommandeService(CommandeRepository repo, StockService stockService) {
        this.repo = repo;
        this.stockService = stockService;
    }

    @Transactional
    public Commande valider(Commande commande) {
        stockService.decrementer(commande); // si ça échoue...
        return repo.save(commande);         // ...ceci est annulé aussi
    }
}

Points essentiels :

REQUIRED — le défaut commander() ouvre la transaction T1 debiterStock() rejoint T1 : aucune nouvelle transaction Un seul commit, un seul rollback : si debiterStock() échoue, la commande est annulée aussi. REQUIRES_NEW commander() T1 suspendue pendant l'appel journaliser() T2 : commit indépendant de T1 Deux transactions distinctes : le journal reste écrit même si la commande échoue ensuite. Le rollback par défaut ne couvre que RuntimeException et Error Une exception vérifiée laisse la transaction committer. Il faut @Transactional(rollbackFor = ...). Et tout cela passe par un proxy Un appel interne this.autreMethode() contourne le proxy : aucune transaction, et aucune erreur.
Deux questions à se poser devant un @Transactional : quelle propagation, et quelles exceptions provoquent le rollback. Ce sont les deux sources de surprise en production.

Les termes à connaître

@Transactional

Annotation (org.springframework.transaction.annotation.Transactional) qui délimite une transaction autour d'une méthode : tout se valide (commit) ensemble à la fin, ou tout est annulé (rollback) en cas d'erreur. Repose sur un proxy créé par Spring autour du bean.

Proxy transactionnel

Spring n'exécute jamais directement la méthode annotée : il enveloppe le bean dans un proxy (CGLIB ou proxy JDK dynamique) qui ouvre la transaction, appelle la vraie méthode, puis commite ou annule selon le résultat. Sans passer par ce proxy, l'annotation n'a aucun effet.

Rollback par défaut

Par défaut, Spring annule la transaction sur une RuntimeException (ou une Error), mais valide la transaction si la méthode lève une exception vérifiée (checked, qui étend Exception sans étendre RuntimeException). rollbackFor = MonException.class étend le rollback à une exception vérifiée précise.

readOnly

@Transactional(readOnly = true) indique que la méthode ne fait que lire. Permet à Hibernate d'optimiser (pas de vérification de modification à la fin) et, selon le pilote et la base, d'informer le SGBD. Ce n'est pas une protection stricte contre les écritures : une modification reste possible, elle n'est simplement pas garantie d'être détectée ou persistée correctement.

Propagation

Attribut propagation qui règle le comportement quand une méthode transactionnelle en appelle une autre, elle aussi transactionnelle : rejoindre la transaction existante, en suspendre une, en exiger une, en refuser une… REQUIRED est la valeur par défaut.

Isolation

Attribut isolation qui règle le niveau d'isolement entre transactions concurrentes (READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE…). Par défaut, Isolation.DEFAULT conserve le niveau configuré par la base de données ; à ne modifier qu'en connaissance de cause, l'attribut n'a d'effet qu'au démarrage d'une nouvelle transaction.

Auto-invocation

Le fait qu'une méthode d'un bean en appelle une autre du même bean via this.autreMethode(). Cet appel ne passe pas par le proxy Spring : si autreMethode() est annotée @Transactional, l'annotation est silencieusement ignorée.

jakarta.transaction.Transactional

Annotation standard JTA, elle aussi reconnue par Spring, mais avec moins d'attributs que celle de Spring (pas de readOnly, pas de propagation NESTED…). En pratique, dans un projet Spring Boot, on utilise l'annotation Spring org.springframework.transaction.annotation.Transactional.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.