Comment implémenter la validation métier complexe (au-delà de Bean Validation) dans Spring Boot ?

Bonne réponse : Créer un validateur personnalisé implémentant org.springframework.validation.Validator, ou utiliser des annotations de validation custom. Implémentez l'interface Validator de Spring pour des validations complexes multi-champs. Ou créez des annotations de validation personnalisées avec @Constraint qui peuvent être réutilisées partout.

Entretien Spring Boot Junior : Security et JPA

Q: Quelle est la différence entre @Component, @Service, @Repository et @Controller ?

Bonne réponse : Ce sont tous des stéréotypes de @Component avec des sémantiques différentes ; @Repository ajoute la traduction des exceptions JPA. Tous sont des stéréotypes de @Component. @Repository ajoute la traduction automatique des exceptions JPA en DataAccessException. @Service et @Controller sont des spécialisations sémantiques pour la logique métier et la couche web.

Q: Comment fonctionne la traduction des exceptions dans @Repository ?

Bonne réponse : Spring traduit automatiquement les exceptions JPA (PersistenceException) en exceptions Spring (DataAccessException). Grâce à PersistenceExceptionTranslationPostProcessor, les repositories annotés @Repository voient leurs exceptions JPA/Hibernate traduites en exceptions Spring de la hiérarchie DataAccessException, cohérentes quel que soit le fournisseur.

Q: Expliquez le cycle de vie d'un bean Spring (singleton).

Bonne réponse : Instantiation → Populating Properties → BeanNameAware → BeanFactoryAware → PostProcessBeforeInitialization → InitializingBean/init-method → PostProcessAfterInitialization → Prêt → Destruction. Le cycle de vie complet : 1) Instantiation, 2) Injection des dépendances, 3) Appels Aware (BeanNameAware, BeanFactoryAware, ApplicationContextAware), 4) BeanPostProcessor.postProcessBeforeInitialization, 5) @PostConstruct / InitializingBean.afterPropertiesSet, 6) BeanPostProcessor.postProcessAfterInitialization, 7) Bean prêt, 8) @PreDestroy / DisposableBean.destroy.

Q: Quelle est la différence entre @RequestParam et @RequestBody ?

Bonne réponse : @RequestParam extrait les paramètres de requête (query string) ; @RequestBody désérialise le corps HTTP en objet Java. @RequestParam lie les paramètres de query string (?page=1&size=10) ou de formulaire. @RequestBody lit le corps de la requête HTTP (JSON, XML) et le convertit en objet Java via HttpMessageConverter (Jackson par défaut).

Q: Comment gérer les relations entre entités JPA (@OneToMany, @ManyToOne) sans tomber dans les pièges de performance ?

Bonne réponse : Utiliser fetch = FetchType.LAZY par défaut, éviter les boucles infinies avec @JsonIgnore ou @JsonManagedReference/@JsonBackReference. Les relations doivent être LAZY par défaut pour éviter de charger des données inutiles. Pour la sérialisation JSON, utilisez @JsonManagedReference/@JsonBackReference ou @JsonIgnore pour éviter les boucles infinies. Utilisez @EntityGraph pour les chargements spécifiques.

Q: Qu'est-ce que Spring AOP et comment l'utiliser pour le logging ?

Bonne réponse : La programmation orientée aspect ; utiliser @Aspect, @Before/@After/@Around pour ajouter du logging sans polluer le code métier. Spring AOP permet de séparer les préoccupations transversales (logging, sécurité, transactions). On crée une classe @Aspect avec des méthodes annotées @Before, @After, @Around et des pointcuts pour cibler les méthodes.

Q: Qu'est-ce que le pattern DTO et pourquoi l'utiliser dans Spring Boot ?

Bonne réponse : Data Transfer Object : un objet simple qui transporte les données entre les couches, évite d'exposer les entités JPA directement. Les DTOs sont des objets simples (sans logique) qui transportent les données. Ils évitent d'exposer les entités JPA (risque de lazy loading, sécurité, couplage). On les utilise entre le contrôleur et le service, ou en réponse/requête API.

Q: Comment configurer plusieurs sources de données (datasources) dans Spring Boot ?

Bonne réponse : Définir plusieurs beans DataSource avec @Primary et @Qualifier, et configurer des packages séparés pour chaque source. Pour des datasources multiples : créez des classes @Configuration séparées, définissez les propriétés (spring.datasource.primary, spring.datasource.secondary), marquez-en une @Primary, et utilisez @Qualifier pour choisir.

Q: Comment implémenter un cache dans Spring Boot ?

Bonne réponse : Avec @EnableCaching, @Cacheable, @CacheEvict et @CachePut ; Spring Boot auto-configure un CacheManager. Activez le cache avec @EnableCaching. Annoter une méthode @Cacheable("users") pour mettre en cache son résultat. @CacheEvict vide le cache, @CachePut met à jour. Spring Boot fournit des implémentations (ConcurrentHashMap, EhCache, Redis).

Q: Qu'est-ce que le "N+1 problem" dans JPA et comment le résoudre ?

Bonne réponse : Problème de performance où une requête principale + N requêtes enfants sont exécutées ; solution : @EntityGraph, JOIN FETCH, ou @BatchSize. Le N+1 se produit quand JPA exécute 1 requête pour l'entité principale, puis N requêtes pour chaque entité liée (lazy loading). Solutions : JOIN FETCH dans JPQL, @EntityGraph pour définir ce qui doit être chargé, ou @BatchSize pour grouper les requêtes.

Spring-Boot Junior Quiz-Springboot-Junior Spring-Security Jwt Spring-Data-Jpa Hibernate Validation Exception-Handling Junit Questions-Entretien-Spring-Junior Qcm-Springboot-Junior Java Back-End

Junior 🔀 Mixte 20 questions ⏱ 15 min

📝

Entretien Spring Boot Junior : Security et JPA

20 questions Spring Boot niveau junior : Spring Security, JWT, Spring Data JPA avancé, Hibernate, validation, exception handling et tests JUnit pour entretien.

20 questions ⏱ ~15 min Niveau Junior

Publié/Développé par Mezgani Said

Développeur web full‑stack et formateur spécialisé en Angular, TypeScript et Node.js, il partage sur AngularForAll des ressources complètes pour les développeurs : tutoriels pratiques, guides pas‑à‑pas, outils gratuits, exercices, QCM techniques et retours d’expérience issus de projets réels (SaaS, micro‑frontends, architectures modulaires, applications d’entreprise).
Le site couvre l’ensemble de l’écosystème web : front‑end, intégration HTML/CSS, Composants réutilisables, SEO, back‑end, cloud, IA, CLI, productivité, bien‑être, outils web et métiers du digital.
Un espace pensé pour générer, apprendre, progresser et développer des projets modernes avec des bonnes pratiques professionnelles.

Banque de révision : les 30 questions corrigées

Voici l'intégralité des 30 questions de « Entretien Spring Boot Junior : Security et JPA », chacune avec sa bonne réponse et son explication. Le quiz interactif ci-dessus en tire une sélection aléatoire à chaque tentative — utilisez cette liste complète pour réviser.

Ce sont tous des stéréotypes de @Component avec des sémantiques différentes ; @Repository ajoute la traduction des exceptions JPA (bonne réponse)
@Service est plus rapide que @Component
Il n'y a aucune différence technique
@Controller ne peut être utilisé que pour les API REST

Explication : Tous sont des stéréotypes de @Component. @Repository ajoute la traduction automatique des exceptions JPA en DataAccessException. @Service et @Controller sont des spécialisations sémantiques pour la logique métier et la couche web.

Utilisez le stéréotype le plus spécifique. Cela améliore la lisibilité et permet à Spring d'appliquer des comportements supplémentaires (ex: traduction d'exceptions pour @Repository).

Spring traduit automatiquement les exceptions JPA (PersistenceException) en exceptions Spring (DataAccessException) (bonne réponse)
Les exceptions sont supprimées
Les exceptions sont loggées sans être relancées
La traduction doit être codée manuellement

Explication : Grâce à PersistenceExceptionTranslationPostProcessor, les repositories annotés @Repository voient leurs exceptions JPA/Hibernate traduites en exceptions Spring de la hiérarchie DataAccessException, cohérentes quel que soit le fournisseur.

Cette traduction rend votre couche service indépendante de l'implémentation JPA sous-jacente.

Instantiation → Populating Properties → BeanNameAware → BeanFactoryAware → PostProcessBeforeInitialization → InitializingBean/init-method → PostProcessAfterInitialization → Prêt → Destruction (bonne réponse)
Création → Utilisation → Destruction uniquement
Constructor → Getter/Setter → Ready
Il n'y a pas de cycle de vie défini

Explication : Le cycle de vie complet : 1) Instantiation, 2) Injection des dépendances, 3) Appels Aware (BeanNameAware, BeanFactoryAware, ApplicationContextAware), 4) BeanPostProcessor.postProcessBeforeInitialization, 5) @PostConstruct / InitializingBean.afterPropertiesSet, 6) BeanPostProcessor.postProcessAfterInitialization, 7) Bean prêt, 8) @PreDestroy / DisposableBean.destroy.

Utilisez @PostConstruct pour la logique d'initialisation après injection des dépendances, et @PreDestroy pour le nettoyage.

@RequestParam extrait les paramètres de requête (query string) ; @RequestBody désérialise le corps HTTP en objet Java (bonne réponse)
@RequestParam est pour POST, @RequestBody pour GET
Il n'y a pas de différence
@RequestParam est obsolète

Explication : @RequestParam lie les paramètres de query string (?page=1&size=10) ou de formulaire. @RequestBody lit le corps de la requête HTTP (JSON, XML) et le convertit en objet Java via HttpMessageConverter (Jackson par défaut).

Pour une requête POST avec JSON, utilisez @RequestBody. Pour une requête GET avec des filtres, utilisez @RequestParam.

Utiliser fetch = FetchType.LAZY par défaut, éviter les boucles infinies avec @JsonIgnore ou @JsonManagedReference/@JsonBackReference (bonne réponse)
Toujours utiliser FetchType.EAGER
Ignorer les relations
Faire toutes les requêtes manuellement

Explication : Les relations doivent être LAZY par défaut pour éviter de charger des données inutiles. Pour la sérialisation JSON, utilisez @JsonManagedReference/@JsonBackReference ou @JsonIgnore pour éviter les boucles infinies. Utilisez @EntityGraph pour les chargements spécifiques.

Le piège classique : @OneToMany EAGER + sérialisation Jackson = requêtes SQL en cascade et réponse JSON infinie.

La programmation orientée aspect ; utiliser @Aspect, @Before/@After/@Around pour ajouter du logging sans polluer le code métier (bonne réponse)
Un type de base de données
Un framework de test
Un outil de build

Explication : Spring AOP permet de séparer les préoccupations transversales (logging, sécurité, transactions). On crée une classe @Aspect avec des méthodes annotées @Before, @After, @Around et des pointcuts pour cibler les méthodes.

Exemple de pointcut pour logger toutes les méthodes d'un package service : @Before("execution(* com.example.service.*.*(..))").

Data Transfer Object : un objet simple qui transporte les données entre les couches, évite d'exposer les entités JPA directement (bonne réponse)
Un type de base de données
Un framework de validation
Un outil de test

Explication : Les DTOs sont des objets simples (sans logique) qui transportent les données. Ils évitent d'exposer les entités JPA (risque de lazy loading, sécurité, couplage). On les utilise entre le contrôleur et le service, ou en réponse/requête API.

Utilisez MapStruct ou ModelMapper pour convertir automatiquement les entités en DTO et vice-versa.

Définir plusieurs beans DataSource avec @Primary et @Qualifier, et configurer des packages séparés pour chaque source (bonne réponse)
Spring Boot ne supporte qu'une seule datasource
Utiliser une base de données NoSQL
Fusionner toutes les bases en une seule

Explication : Pour des datasources multiples : créez des classes @Configuration séparées, définissez les propriétés (spring.datasource.primary, spring.datasource.secondary), marquez-en une @Primary, et utilisez @Qualifier pour choisir.

Utilisez @EnableJpaRepositories avec basePackages et entityManagerFactoryRef pour lier chaque datasource à ses repositories.

Avec @EnableCaching, @Cacheable, @CacheEvict et @CachePut ; Spring Boot auto-configure un CacheManager (bonne réponse)
Stocker les données dans des fichiers texte
Utiliser une base de données externe obligatoirement
Le cache n'est pas supporté

Explication : Activez le cache avec @EnableCaching. Annoter une méthode @Cacheable("users") pour mettre en cache son résultat. @CacheEvict vide le cache, @CachePut met à jour. Spring Boot fournit des implémentations (ConcurrentHashMap, EhCache, Redis).

Pour le cache distribué en production, utilisez Redis avec spring-boot-starter-data-redis.

Problème de performance où une requête principale + N requêtes enfants sont exécutées ; solution : @EntityGraph, JOIN FETCH, ou @BatchSize (bonne réponse)
Un bug de Spring Boot
Un problème de configuration du serveur
Un problème de sécurité

Explication : Le N+1 se produit quand JPA exécute 1 requête pour l'entité principale, puis N requêtes pour chaque entité liée (lazy loading). Solutions : JOIN FETCH dans JPQL, @EntityGraph pour définir ce qui doit être chargé, ou @BatchSize pour grouper les requêtes.

Activez les logs SQL (spring.jpa.show-sql=true) pour détecter le N+1. Si vous voyez une avalanche de SELECT, vous avez un N+1.

Utiliser Flyway ou Liquibase qui s'intègrent nativement avec Spring Boot pour versionner et appliquer les changements de schéma (bonne réponse)
Modifier la base manuellement
Recréer la base à chaque déploiement
Utiliser Hibernate ddl-auto en production

Explication : Flyway et Liquibase sont les solutions standards. Elles versionnent les changements de schéma SQL, les appliquent automatiquement au démarrage, et assurent la cohérence entre les environnements.

Ne JAMAIS utiliser spring.jpa.hibernate.ddl-auto=create ou update en production. Préférez validate avec Flyway/Liquibase.

@ComponentScan scanne les beans Spring (@Component) ; @EntityScan scanne les entités JPA (@Entity) (bonne réponse)
Les deux font la même chose
@ComponentScan est pour le web, @EntityScan pour la BDD
@EntityScan n'existe pas

Explication : @ComponentScan scanne les packages pour trouver les composants Spring (@Component, @Service, etc.). @EntityScan (dans Spring Boot) scanne les packages pour trouver les entités JPA (@Entity).

Si vos entités sont dans un package différent de votre classe principale, utilisez @EntityScan("com.example.entities").

Utiliser Pageable de Spring Data ; le contrôleur accepte un paramètre Pageable et retourne une Page (bonne réponse)
Charger toutes les données et les paginer avec JavaScript
La pagination n'est pas supportée
Utiliser des LIMIT/OFFSET SQL manuellement

Explication : Spring Data fournit Pageable. Le contrôleur accepte @PageableDefault Pageable pageable, le repository retourne Page<T>. Les paramètres ?page=0&size=20&sort=name,asc sont automatiquement interprétés.

Pour personnaliser les noms des paramètres : @PageableDefault(size = 20, sort = "name").

Avec @WebMvcTest et MockMvc pour tester la couche web de manière isolée (bonne réponse)
Uniquement avec des tests manuels via Postman
En déployant l'application
Avec des tests unitaires simples sans Spring

Explication : @WebMvcTest(MonController.class) charge uniquement la couche web. MockMvc permet de simuler des requêtes HTTP et de vérifier les réponses. On mocke les services avec @MockBean.

Exemple : mockMvc.perform(get("/users/1")).andExpect(status().isOk()).andExpect(jsonPath("$.name").value("Alice"));.

Un framework d'authentification et d'autorisation ; s'intègre avec le starter spring-boot-starter-security (bonne réponse)
Un outil de chiffrement de base de données
Un firewall
Un générateur de mots de passe

Explication : Spring Security est le standard de sécurité pour Spring. Ajoutez spring-boot-starter-security, et il sécurise automatiquement les endpoints (authentification par défaut). Personnalisez avec une SecurityFilterChain.

Dès que vous ajoutez le starter, tous les endpoints sont protégés. Le mot de passe par défaut est généré dans les logs au démarrage.

Avec @CrossOrigin sur le contrôleur, ou globalement via un WebMvcConfigurer ou CorsFilter (bonne réponse)
Modifier le fichier web.xml
CORS n'est pas supporté
Désactiver la sécurité

Explication : @CrossOrigin(origins = "http://localhost:4200") sur un contrôleur ou méthode. Globalement : implémenter WebMvcConfigurer.addCorsMappings() ou définir un bean CorsFilter.

En production, soyez restrictif sur les origines autorisées. Évitez allowedOrigins("*").

Créer une classe annotée @ConfigurationProperties(prefix = "app") avec des champs correspondant aux propriétés (bonne réponse)
Utiliser uniquement @Value pour chaque propriété
Stocker les propriétés dans une base de données
Les propriétés complexes ne sont pas supportées

Explication : @ConfigurationProperties mappe un groupe de propriétés vers un objet Java structuré. Exemple : @ConfigurationProperties(prefix = "app.mail") mappe app.mail.host, app.mail.port vers les champs d'une classe.

Ajoutez spring-boot-configuration-processor pour avoir l'auto-complétion dans l'IDE lors de l'édition du application.properties.

Un mécanisme de publication/souscription d'événements avec ApplicationEventPublisher et @EventListener (bonne réponse)
Un type de calendrier
Un outil de logging
Un framework de test

Explication : Spring Events permettent une communication découplée. Un composant publie un événement via ApplicationEventPublisher.publishEvent(). D'autres composants le reçoivent via @EventListener, sans dépendance directe.

Pour les événements asynchrones, ajoutez @Async sur le listener et @EnableAsync sur la configuration.

Créer un validateur personnalisé implémentant org.springframework.validation.Validator, ou utiliser des annotations de validation custom (bonne réponse)
Faire la validation dans le contrôleur avec des if/else
Ignorer la validation métier
Utiliser uniquement les contraintes de base de données

Explication : Implémentez l'interface Validator de Spring pour des validations complexes multi-champs. Ou créez des annotations de validation personnalisées avec @Constraint qui peuvent être réutilisées partout.

Pour une validation qui nécessite l'accès à la base de données, injectez un repository dans votre Validator personnalisé.

RestTemplate (synchrone, déprécié mais encore utilisé) ; WebClient (réactif, recommandé) avec spring-boot-starter-webflux (bonne réponse)
Uniquement avec des requêtes SQL
En écrivant des appels HTTP manuellement
Spring Boot ne supporte pas les appels externes

Explication : RestTemplate est l'ancien client synchrone (déprécié, en maintenance). WebClient (Spring WebFlux) est le client moderne, supportant le synchrone et le réactif. Créez un bean WebClient.Builder et injectez-le.

WebClient peut être utilisé même sans WebFlux. Ajoutez spring-boot-starter-webflux et utilisez .block() pour des appels synchrones.

Un pattern qui empêche les appels en cascade vers un service défaillant ; Resilience4j fournit @CircuitBreaker (bonne réponse)
Un type de disjoncteur électrique
Un pattern de base de données
Un outil de monitoring

Explication : Le Circuit Breaker détecte les échecs répétés vers un service externe et "ouvre le circuit" pour éviter des appels inutiles. Resilience4j (successeur de Hystrix) s'intègre avec Spring Boot et fournit @CircuitBreaker.

Combinez CircuitBreaker avec @Retry (réessayer avant d'ouvrir) et @TimeLimiter (timeout) pour une stratégie de résilience complète.

Avec MultipartFile comme paramètre de méthode, et configurer spring.servlet.multipart.* dans application.properties (bonne réponse)
Uniquement via FTP
Spring Boot ne supporte pas l'upload
En utilisant une base de données uniquement

Explication : Spring Boot supporte l'upload via MultipartFile. Utilisez @RequestParam("file") MultipartFile file dans le contrôleur. Configurez la taille max avec spring.servlet.multipart.max-file-size et max-request-size.

Ne stockez pas les fichiers dans la base de données. Stockez-les sur le système de fichiers ou un service cloud (S3), et gardez le chemin en base.

Un framework pour le traitement par lots (batch processing) : lecture, transformation, écriture de gros volumes de données (bonne réponse)
Un outil de build
Un framework de test
Un type de base de données

Explication : Spring Batch structure les traitements batch en Jobs composés de Steps (ItemReader → ItemProcessor → ItemWriter). Il gère les transactions, les reprises sur erreur, et le chunk processing pour de gros volumes.

Utilisez Spring Batch pour les imports/exports massifs, la génération de rapports, ou le nettoyage de données.

Avec @Scheduled sur une méthode et @EnableScheduling sur la configuration (bonne réponse)
Uniquement avec des cron jobs systèmes
Avec un serveur externe
Le scheduling n'est pas supporté

Explication : @EnableScheduling active le support. @Scheduled(fixedRate = 5000) exécute toutes les 5 secondes. @Scheduled(cron = "0 0 * * * *") utilise une expression cron.

Pour les environnements distribués, utilisez un scheduler distribué (ShedLock) pour éviter que la tâche ne s'exécute sur plusieurs instances.

Définir des fichiers messages_xx.properties, configurer un MessageSource et utiliser LocaleResolver pour détecter la langue (bonne réponse)
Traduire manuellement dans le code
Utiliser une API de traduction externe obligatoirement
L'i18n n'est pas supporté

Explication : Créez des fichiers messages.properties (défaut), messages_fr.properties, messages_en.properties. Utilisez MessageSource pour récupérer les messages. AcceptHeaderLocaleResolver détecte la langue du navigateur.

Dans un contrôleur REST, injectez le MessageSource ou utilisez LocaleContextHolder.getLocale().

Un starter qui inclut JUnit 5, Mockito, AssertJ, Hamcrest, JSONassert et Spring Test pour les tests (bonne réponse)
Un serveur de test
Une base de données de test
Un outil de build

Explication : spring-boot-starter-test regroupe les dépendances de test essentielles : JUnit 5 (framework de test), Mockito (mocks), AssertJ (assertions fluides), Hamcrest (matchers), JSONassert (assertions JSON), et Spring Test.

Utilisez @SpringBootTest pour les tests d'intégration (charge tout le contexte). Pour des tests plus légers, utilisez des slices comme @WebMvcTest ou @DataJpaTest.

Avec @ControllerAdvice et un @ExceptionHandler pour MethodArgumentNotValidException, construire une réponse d'erreur cohérente (bonne réponse)
Laisser Spring retourner l'erreur par défaut
Utiliser des try/catch dans chaque contrôleur
Ignorer les erreurs de validation

Explication : Créez une classe @RestControllerAdvice avec @ExceptionHandler(MethodArgumentNotValidException.class). Extrayez les erreurs de champ, construisez un DTO d'erreur structuré (code, message, détails), et retournez-le avec un statut HTTP approprié.

Structure recommandée pour l'erreur : { "status": 400, "message": "Validation failed", "errors": [{ "field": "email", "message": "Invalid email" }] }.

Un ensemble d'outils pour construire des microservices : service discovery, configuration centralisée, gateway, circuit breaker (bonne réponse)
Un service de cloud computing
Une base de données cloud
Un framework concurrent de Spring Boot

Explication : Spring Cloud fournit des solutions pour les architectures microservices : Service Discovery (Eureka, Consul), Configuration centralisée (Config Server), API Gateway (Spring Cloud Gateway), Circuit Breaker (Resilience4j), Distributed Tracing (Sleuth/Micrometer).

Commencez par Spring Cloud Netflix Eureka pour le service discovery et Spring Cloud Gateway pour le routage.

Activer la compression GZIP, utiliser le cache, optimiser les requêtes JPA (N+1, lazy loading), et configurer le pool de connexions (bonne réponse)
Ajouter plus de RAM uniquement
Désactiver tous les logs
Réécrire l'application dans un autre langage

Explication : Optimisations clés : compression GZIP (server.compression.enabled=true), cache (@Cacheable, Redis), optimisation JPA (lazy loading, batch size, éviter N+1), pool de connexions (HikariCP par défaut, ajuster pool-size), et monitoring (Actuator + Micrometer).

Utilisez un APM (Application Performance Monitoring) comme Prometheus + Grafana, ou Spring Boot Admin pour surveiller la production.

Utiliser le plugin spring-boot-maven-plugin avec build-image, ou écrire un Dockerfile multi-stage (bonne réponse)
Copier le JAR manuellement sur le serveur
Spring Boot n'est pas compatible avec Docker
Utiliser une machine virtuelle

Explication : Deux approches : 1) mvn spring-boot:build-image (Cloud Native Buildpacks, sans Dockerfile). 2) Dockerfile multi-stage (builder avec Maven/Gradle + runtime avec JRE). Les deux produisent une image Docker optimisée.

Les Buildpacks sont recommandés : ils créent des images optimisées, sécurisées, avec une JRE adaptée, sans avoir à écrire de Dockerfile.