Formations — 1 037 leçons en français

Accueil › Spring Boot › Les événements Spring

Les événements Spring

Événements et messagerieavance

Les événements Spring permettent à un bean de signaler qu'il s'est passé quelque chose, sans connaître qui va réagir. On injecte ApplicationEventPublisher, on publie un objet quelconque — un record fait très bien l'affaire, plus besoin d'étendre ApplicationEvent depuis Spring 4.2 :

public record ClientInscrit(Long clientId) { }

@Service
public class InscriptionService {
    private final ApplicationEventPublisher publisher;

    public InscriptionService(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    @Transactional
    public void inscrire(Client client) {
        repository.save(client);
        publisher.publishEvent(new ClientInscrit(client.getId()));
    }
}

N'importe quel bean peut écouter avec @EventListener :

@Component
public class StatistiquesListener {
    @EventListener
    public void surInscription(ClientInscrit evt) {
        compteur.incrementer();
    }
}

Par défaut, l'écoute est synchrone : publishEvent bloque jusqu'à ce que tous les écouteurs se terminent, sur le même thread, et — point important — dans la même transaction que le publieur. Une exception dans un écouteur remonte donc jusqu'au code qui publie. Pour réagir seulement si la transaction réussit, on utilise @TransactionalEventListener (phase AFTER_COMMIT par défaut) plutôt que @EventListener.

Les termes à connaître

ApplicationEventPublisher

Interface centrale pour publier un événement. Le contexte Spring l'implémente : il suffit de l'injecter comme n'importe quel bean et d'appeler publishEvent(...).

Événement applicatif

Depuis Spring 4.2, un événement peut être n'importe quel objet : plus besoin d'étendre ApplicationEvent. Un record est le choix naturel : immuable, concis, et il porte déjà equals/toString.

@EventListener

Annotée sur une méthode d'un bean, elle en fait un écouteur du type d'événement déclaré en paramètre. Plusieurs écouteurs peuvent réagir au même événement.

Écoute synchrone

Comportement par défaut : publishEvent(...) bloque jusqu'à ce que tous les écouteurs synchrones aient rendu la main, sur le même thread et, s'il y en a une, dans la même transaction que le code qui publie.

@TransactionalEventListener

Écouteur lié au cycle de vie de la transaction en cours plutôt qu'au moment précis de la publication. Sa phase par défaut est AFTER_COMMIT : il ne s'exécute qu'après le commit réussi de la transaction.

@Async sur un écouteur

Combiné à @EnableAsync, exécute l'écouteur sur un autre thread, dans un pool séparé de celui de la publication. L'écouteur n'a alors plus accès à la transaction ni au contexte de sécurité du publieur.

@Order

Fixe l'ordre d'exécution entre plusieurs écouteurs synchrones du même événement (valeur basse = exécuté en premier). Sans effet entre écouteurs asynchrones, qui s'exécutent indépendamment.

Spring Modulith

Projet qui aide à structurer une application en modules au sein d'un même déploiement, en s'appuyant notamment sur les événements Spring pour les faire communiquer sans dépendance directe entre leurs classes internes.

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.