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. Unrecordest 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
phasepar défaut estAFTER_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.
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.