Questions d'entretien Java / Spring Boot — Développeur Confirmé

Questions d'Entretien
Java / Spring Boot
Développeur Confirmé (Niveau Avancé)

98 questions • 16 thématiques

1. Java Core — Avancé

12 questions

Q1. Quelle est la différence entre == et equals() ?

▶ == compare les références (adresses mémoire). equals() compare le contenu logique des objets. Pour String,
equals() compare caractère par caractère.

Q2. Qu'est-ce que le contrat hashCode/equals ?

▶ Si deux objets sont equals(), ils DOIVENT avoir le même hashCode. L'inverse n'est pas obligatoire. Violer ce contrat
casse HashMap, HashSet, etc.

Q3. Expliquez la différence entre String, StringBuilder et StringBuffer.

▶ String est immuable. StringBuilder est mutable et non thread-safe (plus rapide). StringBuffer est mutable et thread-
safe (méthodes synchronized).

Q4. Qu'est-ce qu'un memory leak en Java ? Comment le détecter ?

▶ C'est quand des objets restent référencés alors qu'ils ne sont plus utilisés. Causes : caches non bornés, listeners non
désenregistrés. Détection : VisualVM, MAT (Memory Analyzer Tool), heap dumps.

Q5. Expliquez les différences entre Checked et Unchecked Exceptions.

▶ Checked (IOException, SQLException) : doivent être déclarées ou catchées, vérifiées à la compilation. Unchecked
(RuntimeException) : non obligatoires, indiquent des bugs de programmation.

Q6. Qu'est-ce que le principe de fail-fast en Java ?

▶ Un Iterator fail-fast lance ConcurrentModificationException si la collection est modifiée pendant l'itération. Les
iterators fail-safe (CopyOnWriteArrayList) travaillent sur une copie.

Q7. Qu'est-ce que la covariance et la contravariance en generics ?

▶ Covariance : List<? extends Animal> (lecture seule). Contravariance : List<? super Dog> (écriture seule). Principe
PECS : Producer Extends, Consumer Super.

Q8. Comment fonctionne le ClassLoader en Java ?

Page 1 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

▶ Hiérarchie : Bootstrap → Extension → Application ClassLoader. Délégation parent-first. Permet l'isolation de

classes, la hot-reload, les plugins OSGi.

Q9. Qu'est-ce que la réflexion (Reflection) et ses risques ?

▶ API permettant d'inspecter/modifier classes, méthodes, champs à l'exécution. Risques : contournement
d'encapsulation, performances dégradées, erreurs à runtime au lieu de compile-time.

Q10. Expliquez les différents types de références Java (Strong, Soft, Weak, Phantom).
▶ Strong : jamais GC. Soft : GC si mémoire faible (caches). Weak : GC au prochain cycle (WeakHashMap). Phantom :
GC effectué, pour nettoyage post-mortem.

Q11. Qu'est-ce que Optional et pourquoi l'utiliser ?

▶ Conteneur pouvant contenir ou non une valeur, élimine les NPE. Utiliser map(), flatMap(), orElse(), orElseThrow().
Ne jamais stocker Optional dans des champs ou l'utiliser comme paramètre.

Q12. Comment fonctionne le mécanisme de sérialisation Java ?

▶ Implémentation Serializable, serialVersionUID pour la compatibilité, transient pour exclure des champs. Préférer
JSON/Protobuf en production. Attention aux failles de sécurité (deserialization attacks).

2. Java Concurrence & Multithreading

8 questions

Q1. Expliquez le modèle mémoire Java (JMM).

▶ Définit la visibilité des variables entre threads. volatile garantit la visibilité et l'ordre. synchronized crée un
happens-before. Sans synchronisation, les modifications d'un thread peuvent être invisibles aux autres.

Q2. Quelle est la différence entre synchronized, volatile et AtomicInteger ?

▶ synchronized : exclusion mutuelle + visibilité. volatile : visibilité seule (pas atomicité composée). AtomicInteger :
opérations atomiques CAS (Compare-And-Swap), plus performant que synchronized.

Q3. Qu'est-ce qu'un deadlock ? Comment l'éviter ?

▶ Deux threads s'attendent mutuellement. Éviter : toujours acquérir les locks dans le même ordre, utiliser tryLock
avec timeout, réduire la granularité des locks.

Q4. Expliquez ExecutorService et les différents thread pools.

▶ fixedThreadPool : N threads fixes. cachedThreadPool : threads créés à la demande. scheduledPool : tâches
planifiées. ForkJoinPool : work-stealing pour tâches récursives. Toujours shutdown() le pool.

Q5. Qu'est-ce que CompletableFuture ? Donnez des exemples.

▶ API asynchrone non-bloquante. thenApply() (transformation), thenCompose() (chaînage), thenCombine()
(combiner deux futures), exceptionally() (gestion erreurs), allOf() (attendre tous).

Page 2 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

Q6. Quelles sont les collections thread-safe et leurs différences ?

▶ ConcurrentHashMap : segmentation, haute concurrence. CopyOnWriteArrayList : copie à l'écriture, optimal si
lectures >> écritures. BlockingQueue : producteur/consommateur. [Link] : lock global (moins
performant).

Q7. Qu'est-ce que le pattern Producer-Consumer en Java ?

▶ BlockingQueue entre producers et consumers. put() bloque si pleine, take() bloque si vide. ArrayBlockingQueue
(borné), LinkedBlockingQueue (optionnellement borné). Utiliser avec ExecutorService.

Q8. Expliquez ThreadLocal et ses cas d'utilisation.

▶ Variable locale à chaque thread. Cas : contexte utilisateur dans une requête web, connexions DB par thread.
Attention aux memory leaks dans les thread pools (toujours remove() après usage).

3. Java 8+ — Streams, Lambdas, Fonctionnel

7 questions

Q1. Quelle est la différence entre map() et flatMap() ?

▶ map() : transforme chaque élément 1:1. flatMap() : transforme chaque élément en un Stream et les aplatit en un
seul Stream. Exemple : liste de listes → liste plate.

Q2. Quelle est la différence entre findFirst() et findAny() ?

▶ findFirst() retourne le premier élément (déterministe même en parallèle). findAny() peut retourner n'importe quel
élément, plus performant en parallèle.

Q3. Expliquez les Collectors les plus utiles.

▶ toList(), toSet(), toMap(), groupingBy() (regroupement), partitioningBy() (booléen), joining() (concaténation),
counting(), summarizingInt().

Q4. Qu'est-ce qu'une interface fonctionnelle ? Citez les principales.

▶ Interface avec une seule méthode abstraite (@FunctionalInterface). Principales : Function<T,R>, Predicate<T>,
Consumer<T>, Supplier<T>, BiFunction<T,U,R>, UnaryOperator<T>.

Q5. Qu'est-ce que le lazy evaluation dans les Streams ?

▶ Les opérations intermédiaires (filter, map) ne s'exécutent pas immédiatement, seulement à l'appel d'une opération
terminale (collect, forEach). Permet d'optimiser le traitement (court-circuit).

Q6. Expliquez les nouveautés de Java 11, 17 et 21.

▶ Java 11 : var en lambdas, HttpClient. Java 17 (LTS) : sealed classes, records, pattern matching instanceof, text
blocks. Java 21 (LTS) : virtual threads (Loom), pattern matching switch, sequenced collections.

Q7. Qu'est-ce que les Virtual Threads (Java 21) ?

Page 3 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

▶ Threads légers gérés par la JVM, non liés aux threads OS. Permettent des millions de threads concurrents. Idéaux
pour les applications I/O-bound. Remplacent les approches réactives pour la scalabilité.

4. Spring Core & IoC

8 questions

Q1. Expliquez le principe d'Inversion of Control (IoC) et Dependency Injection.

▶ IoC : le container gère la création et le cycle de vie des objets. DI : les dépendances sont injectées de l'extérieur
(constructor, setter, field injection). Favorise le découplage et la testabilité.

Q2. Quelle est la différence entre @Component, @Service, @Repository, @Controller ?

▶ Toutes sont des spécialisations de @Component pour la détection automatique. @Repository active la traduction
d'exceptions JPA. @Service marque la couche métier. @Controller marque la couche web MVC.

Q3. Expliquez les scopes de beans Spring.

▶ singleton (défaut) : une instance par contexte. prototype : nouvelle instance à chaque demande.
request/session/application : spécifiques au web. Attention aux dépendances singleton → prototype (utiliser
ObjectProvider).

Q4. Quelle est la différence entre @Autowired et @Inject ? @Qualifier vs @Primary ?

▶ @Autowired est Spring, @Inject est JSR-330 (standard). @Primary : bean préféré par défaut. @Qualifier : sélection
précise par nom. Préférer l'injection par constructeur pour l'immuabilité et la testabilité.

Q5. Qu'est-ce que le cycle de vie d'un bean Spring ?

▶ Instanciation → injection des dépendances → @PostConstruct / InitializingBean → utilisation → @PreDestroy /
DisposableBean → destruction. BeanPostProcessor permet d'intercepter chaque étape.

Q6. Expliquez @Conditional et les profils Spring.

▶ @Profile : active des beans selon l'environnement (dev, prod). @Conditional : activation basée sur une condition
personnalisée. @ConditionalOnProperty, @ConditionalOnClass sont des raccourcis Spring Boot.

Q7. Qu'est-ce qu'un BeanPostProcessor vs BeanFactoryPostProcessor ?

▶ BeanFactoryPostProcessor : modifie la définition des beans AVANT leur création (ex:
PropertySourcesPlaceholderConfigurer). BeanPostProcessor : intercepte chaque bean APRÈS création (ex: AOP
proxies).

Q8. Expliquez le mécanisme de proxy Spring (AOP proxies).

▶ Spring utilise JDK Dynamic Proxy (interfaces) ou CGLIB (classes concrètes). Les appels self-invocation ne passent pas
par le proxy, donc @Transactional et @Cacheable ne fonctionnent pas en auto-appel.

5. Spring Boot
6 questions

Page 4 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

Q1. Comment fonctionne l'auto-configuration Spring Boot ?

▶ @EnableAutoConfiguration scanne META-
INF/spring/[Link]. Chaque AutoConfiguration est
conditionnelle (@ConditionalOnClass, @ConditionalOnMissingBean). Utiliser --debug pour voir le rapport.

Q2. Expliquez le mécanisme des starters Spring Boot.

▶ Agrégats de dépendances (BOM) + auto-configuration. spring-boot-starter-web inclut Tomcat, Spring MVC,
Jackson. Créer un starter custom : module autoconfigure + module starter avec dépendance vers lui.

Q3. Comment externaliser la configuration dans Spring Boot ?

▶ Ordre de priorité : args CLI > variables d'env > application-{profile}.properties > [Link].
@ConfigurationProperties pour des classes de config typées. @Value pour des propriétés simples.

Q4. Qu'est-ce que Spring Boot Actuator ?

▶ Endpoints de monitoring : /health, /metrics, /env, /beans, /mappings, /loggers. Intégration Micrometer pour les
métriques. Sécuriser les endpoints sensibles en production avec Spring Security.

Q5. Comment personnaliser le serveur embarqué dans Spring Boot ?

▶ Via [Link] ([Link], [Link].*). Ou implémentation
WebServerFactoryCustomizer<TomcatServletWebServerFactory> pour une configuration programmatique avancée.

Q6. Expliquez @SpringBootTest et les slices de tests.

▶ @SpringBootTest charge tout le contexte. Slices : @WebMvcTest (MVC seul), @DataJpaTest (JPA + H2), @JsonTest
(Jackson), @RestClientTest. Les slices sont plus rapides car elles chargent moins de beans.

6. Spring MVC & REST

7 questions

Q1. Quelle est la différence entre @Controller et @RestController ?

▶ @RestController = @Controller + @ResponseBody sur toutes les méthodes. Les méthodes retournent directement
des données sérialisées (JSON/XML) au lieu de noms de vues.

Q2. Expliquez le cycle de traitement d'une requête dans Spring MVC.

▶ DispatcherServlet → HandlerMapping → HandlerAdapter → Controller → ViewResolver (ou HttpMessageConverter
pour REST). Les HandlerInterceptors s'intercalent avant/après le controller.

Q3. Quelle est la différence entre @RequestParam, @PathVariable, @RequestBody ?

▶ @PathVariable : extrait de l'URL (/users/{id}). @RequestParam : paramètre de query (?page=1). @RequestBody :
désérialise le corps de la requête (JSON→objet). @RequestHeader : valeur d'en-tête HTTP.

Q4. Comment gérer les erreurs globalement dans Spring Boot ?

Page 5 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

▶ @ControllerAdvice + @ExceptionHandler pour centraliser la gestion. ResponseEntityExceptionHandler comme

classe de base. ProblemDetail (RFC 7807) pour les réponses d'erreur standardisées (Spring 6+).

Q5. Qu'est-ce que le Content Negotiation dans Spring MVC ?

▶ Mécanisme permettant de retourner JSON, XML selon l'en-tête Accept. Configurer via
ContentNegotiationConfigurer. HttpMessageConverters convertissent les objets (Jackson pour JSON, JAXB pour XML).

Q6. Comment implémenter la pagination et le tri avec Spring MVC ?

▶ Ajouter Pageable comme paramètre de méthode (avec @PageableDefault). Spring Data crée automatiquement la
requête. Retourner Page<T> ou Slice<T>. Configurer SpringDataWebAutoConfiguration.

Q7. Qu'est-ce que HATEOAS dans une API REST ?

▶ Hypermedia As The Engine Of Application State. Les réponses incluent des liens vers les actions possibles. Spring
HATEOAS : EntityModel, CollectionModel, RepresentationModelAssembler. Niveau 3 du modèle de maturité
Richardson.

7. Spring Data JPA & Hibernate

8 questions

Q1. Expliquez les stratégies de fetch : EAGER vs LAZY.

▶ LAZY : chargement à la demande (défaut pour collections). EAGER : chargement immédiat (défaut pour
@ManyToOne/@OneToOne). Préférer LAZY + JOIN FETCH dans les requêtes pour éviter N+1.

Q2. Qu'est-ce que le problème N+1 et comment le résoudre ?

▶ Pour N entités, N requêtes supplémentaires sont émises pour charger les associations. Solutions : JOIN FETCH dans
JPQL, @EntityGraph, @BatchSize, ou projections DTO avec une seule requête.

Q3. Expliquez les stratégies d'héritage JPA.

▶ SINGLE_TABLE : tout dans une table (discriminator column, performant). TABLE_PER_CLASS : une table par classe
concrète (pas de polymorphisme). JOINED : une table par classe (normalisé, plus de jointures).

Q4. Qu'est-ce que le dirty checking dans Hibernate ?

▶ Hibernate détecte automatiquement les modifications des entités managées et génère les UPDATE au flush.
Fonctionnement : snapshots à l'instant du chargement, comparaison avant flush.

Q5. Quelle est la différence entre merge() et persist() ?

▶ persist() : attache une nouvelle entité transient au contexte (doit être détachée si ID présent). merge() :
synchronise un objet détaché avec le contexte, retourne l'entité managée (l'original reste détaché).

Q6. Expliquez les différents types de requêtes Spring Data.

▶ Méthodes dérivées (findByNameAndAge), @Query JPQL/@Query nativeQuery=true, Specifications (critères
dynamiques), Querydsl (type-safe), @NamedQuery sur l'entité.

Page 6 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

Q7. Qu'est-ce que le cache de premier et second niveau Hibernate ?

▶ L1 (session cache) : automatique par session, élimine les requêtes dupliquées dans une transaction. L2 (shared
cache) : entre sessions, configurer avec EhCache/Caffeine + @Cacheable sur les entités. Risque de stale data.

Q8. Comment optimiser les performances JPA en production ?

▶ Activer le logging SQL ([Link]-sql=true, format_sql). Analyser avec p6spy ou Datasource-proxy. Indices de
base de données. Projections DTO. Pagination. Connection pooling (HikariCP).

8. Spring Security
6 questions

Q1. Expliquez l'architecture de Spring Security.

▶ SecurityFilterChain : chaîne de filtres Servlet. AuthenticationManager → AuthenticationProvider →
UserDetailsService. SecurityContextHolder stocke l'authentification courante (thread-local par défaut).

Q2. Comment implémenter JWT avec Spring Security ?

▶ JwtAuthenticationFilter (OncePerRequestFilter) extrait et valide le token. Crée un
UsernamePasswordAuthenticationToken et le met dans le SecurityContextHolder. Pas de session HTTP (stateless).

Q3. Quelle est la différence entre @Secured, @RolesAllowed et @PreAuthorize ?

▶ @Secured et @RolesAllowed : vérification basique de rôles. @PreAuthorize : SpEL expressions puissantes (hasRole,
hasPermission, #param == [Link]). Activer avec @EnableMethodSecurity.

Q4. Comment protéger contre CSRF dans Spring Security ?

▶ Protection CSRF activée par défaut pour les formulaires HTML (token synchronizer). Pour les API REST stateless
(JWT), désactiver : [Link]().disable(). La nature stateless protège naturellement contre CSRF.

Q5. Expliquez OAuth2 et OIDC dans Spring Security.

▶ OAuth2 : délégation d'autorisation (Access Token). OIDC : couche d'identité sur OAuth2 (ID Token JWT). Spring
Security OAuth2 Client gère le flow Authorization Code. @RegisteredOAuth2AuthorizedClient injecte le token.

Q6. Comment implémenter une autorisation basée sur les permissions (ABAC) ?
▶ Implémenter PermissionEvaluator et enregistrer dans MethodSecurityExpressionHandler. Utiliser
@PreAuthorize("hasPermission(#entity, 'WRITE')"). Logique métier dans l'évaluateur.

9. Spring Transaction
4 questions

Q1. Expliquez les niveaux d'isolation des transactions.

Page 7 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

▶ READ_UNCOMMITTED : dirty reads possibles. READ_COMMITTED (défaut PG) : évite dirty reads.
REPEATABLE_READ : évite non-repeatable reads. SERIALIZABLE : isolation totale (plus lent). Choisir selon le besoin de
cohérence.

Q2. Expliquez les modes de propagation @Transactional.

▶ REQUIRED (défaut) : rejoindre ou créer. REQUIRES_NEW : toujours nouvelle transaction. NESTED : savepoint.
SUPPORTS : rejoindre si existante. NOT_SUPPORTED : suspendre. NEVER : exception si active.

Q3. Pourquoi @Transactional ne fonctionne pas avec les auto-appels ?

▶ Spring crée un proxy autour du bean. Les self-invocations ([Link]()) contournent le proxy. Solutions : injecter
le bean lui-même, utiliser [Link](), ou déplacer dans un autre bean.

Q4. Comment tester les transactions dans Spring Boot ?

▶ @DataJpaTest crée un contexte JPA avec H2 et rollback automatique. @Transactional sur les tests provoque un
rollback. Utiliser @Commit pour persister. TestEntityManager pour les opérations JPA dans les tests.

10. Spring AOP

3 questions

Q1. Expliquez les concepts clés d'AOP : Advice, Pointcut, JoinPoint, Aspect.
▶ JoinPoint : point d'exécution du programme. Pointcut : expression qui sélectionne des JoinPoints. Advice : code à
exécuter (@Before, @After, @Around, @AfterReturning, @AfterThrowing). Aspect : classe contenant Pointcut +
Advices.

Q2. Quelle est la différence entre Spring AOP et AspectJ ?

▶ Spring AOP : proxy-based, uniquement méthodes de beans Spring, à l'exécution. AspectJ : compile-time ou load-
time weaving, toutes les classes Java, plus puissant (champs, constructeurs). Spring supporte la syntaxe AspectJ.

Q3. Donnez des exemples concrets d'utilisation d'AOP.

▶ Logging des temps d'exécution (@Around). Gestion des transactions (@Transactional). Mise en cache
(@Cacheable). Sécurité (@PreAuthorize). Retry (@Retryable). Audit. Métriques Micrometer.

11. Microservices & Architecture

6 questions

Q1. Quels sont les patterns clés des microservices ?

▶ Circuit Breaker (Resilience4j). API Gateway. Service Discovery (Eureka). Saga (transactions distribuées). CQRS. Event
Sourcing. Strangler Fig (migration). Sidecar. Outbox Pattern.

Q2. Expliquez le Circuit Breaker pattern.

▶ 3 états : CLOSED (normal), OPEN (tout rejette après X échecs), HALF_OPEN (teste quelques requêtes). Évite la
cascade de pannes. Resilience4j avec Spring Boot : @CircuitBreaker, @Retry, @RateLimiter, @Bulkhead.

Page 8 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

Q3. Qu'est-ce que le pattern Saga et ses deux variantes ?

▶ Transactions distribuées sans 2PC. Choreography : chaque service publie des événements (couplage faible, difficile
à tracer). Orchestration : un saga orchestrator pilote (plus de contrôle, couplage plus fort).

Q4. Expliquez CQRS et Event Sourcing.

▶ CQRS : Command (écriture) et Query (lecture) séparés, modèles différents. Event Sourcing : état reconstruit depuis
l'historique des événements (audit complet, replay possible). Souvent combinés avec Kafka/Axon.

Q5. Comment gérer la configuration dans les microservices ?

▶ Spring Cloud Config Server : dépôt Git centralisé. @RefreshScope pour la mise à jour sans redémarrage. Consul ou
Vault pour les secrets. Variables d'environnement (12-factor app). Kubernetes ConfigMap/Secret.

Q6. Qu'est-ce que le Service Mesh (Istio) ?

▶ Couche infrastructure pour la communication inter-services : mTLS automatique, load balancing, circuit breaking,
observabilité (traces, métriques) sans modification du code applicatif. Sidecars Envoy injectés dans les pods.

12. Messaging — Kafka & RabbitMQ

4 questions

Q1. Expliquez l'architecture d'Apache Kafka.

▶ Topics partitionnés et répliqués. Producers écrivent dans des partitions. Consumer Groups : chaque partition lue
par un seul consumer du groupe. Offsets pour le positionnement. Rétention configurable.

Q2. Quelle est la différence entre at-least-once, at-most-once, exactly-once ?

▶ At-most-once : peut perdre des messages. At-least-once : peut dupliquer (idempotence nécessaire). Exactly-once :
Kafka Transactions + idempotent producers, coût en performance.

Q3. Comment utiliser Spring Kafka dans Spring Boot ?

▶ @KafkaListener sur les méthodes consumers. KafkaTemplate pour la production.
ConcurrentKafkaListenerContainerFactory pour la configuration. ErrorHandler pour les erreurs.
DeadLetterPublishingRecoverer pour les DLQ.

Q4. Quelle est la différence entre Kafka et RabbitMQ ?

▶ Kafka : log distribué, haute volumétrie, rétention longue, replay, CQRS/Event Sourcing. RabbitMQ : message broker
traditionnel, routage flexible (exchanges), acquittements, idéal pour les tâches asynchrones simples.

13. Tests
5 questions

Q1. Expliquez la pyramide de tests dans le contexte Spring Boot.

Page 9 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

▶ Unit tests (Mockito, sans Spring) : rapides, nombreux. Integration tests (@SpringBootTest, slices) : plus lents. E2E
tests (Testcontainers, REST Assured) : rares, coûteux. Ratio conseillé : 70/20/10.

Q2. Comment mocker des dépendances avec Mockito ?

▶ @Mock crée un mock, @InjectMocks injecte. when().thenReturn() pour les stubs. verify() pour les interactions.
@MockBean dans Spring Boot remplace le bean dans le contexte. ArgumentCaptor pour capturer les arguments.

Q3. Qu'est-ce que Testcontainers et quand l'utiliser ?

▶ Lance des conteneurs Docker pendant les tests (PostgreSQL, Kafka, Redis...). Remplace les bases H2 pour des tests
plus réalistes. @Container + @ServiceConnection (Spring Boot 3.1) configure automatiquement la datasource.

Q4. Comment tester une API REST avec MockMvc ?

▶ [Link](get("/api/users")).andExpect(status().isOk()).andExpect(jsonPath("$.name").value("Alice")).
@WebMvcTest pour les tests MVC sans contexte complet. RestAssured pour les tests d'intégration.

Q5. Qu'est-ce que le Test-Driven Development (TDD) ?

▶ Red → Green → Refactor. Écrire le test qui échoue, puis le code minimal pour passer, puis refactorer. Avantages :
conception orientée usage, couverture naturelle, filet de sécurité pour le refactoring.

14. Performance & Scalabilité

5 questions

Q1. Comment profiler une application Spring Boot ?

▶ JVM : JFR (Java Flight Recorder), VisualVM, async-profiler. Application : Micrometer + Prometheus + Grafana. APM :
Datadog, New Relic, Elastic APM. Activer Actuator /metrics et /health.

Q2. Comment configurer HikariCP pour la production ?

▶ maximumPoolSize = nb_cores * 2 + nb_disques. minimumIdle = 0 (scale to zero). connectionTimeout = 30s.
idleTimeout = 10min. maxLifetime = 30min. Toujours valider la connexion (connectionTestQuery ou JDBC4).

Q3. Expliquez les stratégies de cache dans Spring.

▶ @Cacheable (read-through), @CachePut (toujours met à jour), @CacheEvict (invalide). Backends : Caffeine (local),
Redis (distribué). Clés composites avec SpEL. TTL configuré sur le CacheManager.

Q4. Comment optimiser les requêtes Hibernate/SQL ?

▶ Analyser le plan d'exécution (EXPLAIN ANALYZE). Index sur les colonnes de jointure et de filtrage. Éviter SELECT *
(projections). Pagination keyset > offset pour de grandes tables. Batch inserts/updates.

Q5. Qu'est-ce que la programmation réactive avec Spring WebFlux ?

▶ Modèle non-bloquant basé sur Reactor (Flux, Mono). Event loop au lieu de thread-par-requête. Idéal pour I/O-
bound et haute concurrence. Backpressure native. Courbe d'apprentissage plus élevée.

Page 10 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

15. DevOps & Cloud

5 questions

Q1. Comment créer une image Docker optimisée pour Spring Boot ?
▶ Multi-stage build. Utiliser des layers avec Buildpacks (./mvnw spring-boot:build-image). Séparer les dépendances
du code applicatif. Utiliser JRE et pas JDK. Limiter les droits (USER non-root). Ajouter HEALTHCHECK.

Q2. Expliquez les sondes Kubernetes pour Spring Boot.

▶ readinessProbe : /actuator/health/readiness — le pod est prêt à recevoir du trafic. livenessProbe :
/actuator/health/liveness — le pod doit être redémarré si KO. Configurer des startupProbes pour les apps lentes.

Q3. Qu'est-ce que GraalVM Native Image dans le contexte Spring Boot ?
▶ Compilation AOT (Ahead-Of-Time) : exécutable natif sans JVM. Avantages : démarrage instantané (<100ms),
consommation mémoire réduite. Contraintes : pas de réflexion dynamique, classes connues à la compilation.

Q4. Comment implémenter le health check dans Spring Boot ?

▶ Actuator /health : DOWN si DB, Redis, Kafka indisponibles. Implémenter HealthIndicator pour des checks custom.
Séparer liveness (JVM alive) et readiness (dépendances prêtes) depuis Spring Boot 2.3.

Q5. Qu'est-ce que le 12-Factor App ?

▶ 12 principes : codebase, dépendances explicites, config dans l'environnement, services tiers, build/release/run
séparés, processus stateless, port binding, concurrence, disposabilité, parité dev/prod, logs comme streams, admin
processes.

16. Patterns de Conception

4 questions

Q1. Quels patterns GoF utilise Spring massivement ?

▶ Factory (BeanFactory). Singleton (beans). Proxy (AOP, @Transactional). Template Method (JdbcTemplate,
RestTemplate). Observer (@EventListener). Decorator (HttpMessageConverter). Strategy (SortStrategy).

Q2. Expliquez le pattern Repository vs DAO.

▶ DAO (Data Access Object) : abstraction bas niveau liée à une table. Repository : abstraction orientée domaine,
collection d'agrégats. Spring Data JPA implémente le pattern Repository.

Q3. Qu'est-ce que le pattern Builder et pourquoi l'utiliser en Java ?

▶ Construit des objets complexes étape par étape. Résout le problème des constructeurs télescopiques. Lombok
@Builder génère automatiquement. Assure l'immuabilité si les champs sont final.

Q4. Expliquez les principes SOLID en Java.

▶ S : Single Responsibility. O : Open/Closed (extension sans modification). L : Liskov Substitution. I : Interface
Segregation (petites interfaces ciblées). D : Dependency Inversion (dépendre d'abstractions). Spring les applique
nativement.

Page 11 / 12
Questions d'entretien Java / Spring Boot — Développeur Confirmé

Page 12 / 12