Formations — 1 037 leçons en français

Accueil › Spring Boot › Programmation réactive

Programmation réactive — entretien Spring Boot

3 questions posées en entretien sur 3 sujets, avec la bonne réponse et son explication.

Reactor

Un repository réactif expose `Mono<Client> findById(Long id)`. Pour transformer un `Mono<Long>` en `Mono<Client>`, quel opérateur utiliser ?

  1. `map`, car il s'applique à toute fonction de transformation
  2. `flatMap`, car la fonction de transformation renvoie elle-même un `Mono` ✓
  3. `then`, car on enchaîne une nouvelle étape
  4. `zip`, car on combine un identifiant et un client

Pourquoi : `map` attend une fonction `T -> R` (synchrone). Ici la fonction renvoie un `Mono<Client>` : `map` produirait un `Mono<Mono<Client>>`. `flatMap` « aplatit » le résultat en `Mono<Client>`. Confusion très fréquente en début d'apprentissage de Reactor.

Niveau confirme

R2DBC

Pourquoi ne peut-on pas simplement changer le driver JDBC en driver R2DBC pour rendre une application Spring Data JPA réactive ?

  1. C'est possible : JPA détecte le type de driver et bascule automatiquement en mode non bloquant
  2. JPA/Hibernate repose sur JDBC et des concepts fondamentalement bloquants (session, proxies de chargement paresseux) ; passer au réactif exige une autre couche, Spring Data R2DBC ✓
  3. R2DBC est réservé aux bases NoSQL, incompatible avec les entités JPA
  4. Il suffit d'ajouter `@Async` sur les méthodes du repository

Pourquoi : JPA n'a pas de mode réactif : Hibernate est construit sur JDBC de bout en bout (session de persistance, cache de premier niveau, proxies). Le passage au réactif implique un changement complet de couche d'accès aux données, avec `ReactiveCrudRepository`, sans équivalent direct à `@OneToMany` ni au chargement paresseux.

Niveau confirme

Réactif, MVC ou virtual threads

Pourquoi un bloc `synchronized` contenant un appel bloquant est-il un piège avec les virtual threads ?

public synchronized InfosStock verifierStock(Long produitId) {
    return appelReseauBloquant(produitId); // opération lente
}
  1. `synchronized` provoque une erreur de compilation avec les virtual threads
  2. Le virtual thread reste « épinglé » (pinning) à son thread porteur pendant le blocage, empêchant la JVM de libérer ce thread porteur pour d'autres tâches ✓
  3. Les virtual threads ignorent silencieusement `synchronized`, créant un risque de concurrence non protégée
  4. Aucun piège : `synchronized` est spécifiquement optimisé pour les virtual threads

Pourquoi : Un virtual thread bloqué à l'intérieur d'un bloc `synchronized` ne peut pas être démonté (pinning) : le thread porteur reste immobilisé pendant toute la durée du blocage. Si ce motif est fréquent avec des opérations lentes, il réduit le gain de concurrence recherché. `java.util.concurrent.locks.ReentrantLock` n'a pas cette limitation.

Niveau senior

S'entraîner sur ces questions, chronométré →