Guide Entretien Java / Spring Boot
Guide de Preparation
Entretien Technique Java / Spring Boot
Concepts cles, definitions et pieges a eviter
Page 1
Guide Entretien Java / Spring Boot
1. Principes SOLID
Les principes SOLID sont les 5 fondements de la conception orientee objet. Maitriser ces principes
est indispensable pour tout entretien senior.
S - Single Responsibility Principle (SRP)
Definition Une classe ne doit avoir qu'une seule raison de changer. Elle encapsule une
responsabilite unique et coherente.
Objectif Reduire le couplage, faciliter la maintenance et les tests unitaires.
En pratique Separer Controller (HTTP), Service (logique metier) et Repository (acces
BDD).
Astuce entretien : Si je dois modifier la logique d'envoi d'email ET la validation dans la meme classe,
c'est une violation du SRP.
O - Open/Closed Principle (OCP)
Definition Une entite doit etre ouverte a l'extension mais fermee a la modification.
Objectif Ajouter du comportement sans toucher au code existant, limitant les
regressions.
En pratique Utiliser des interfaces et le polymorphisme plutot que des if/switch sur des
types.
Astuce entretien : Ajouter un nouveau type de paiement (PayPal, Stripe...) sans modifier la classe
PaymentProcessor existante.
L - Liskov Substitution Principle (LSP)
Definition Un objet d'une sous-classe doit pouvoir remplacer un objet de la classe
parente sans alterer le comportement du programme.
Objectif Garantir que l'heritage est utilise a bon escient.
Violation classique Square extends Rectangle : modifier la largeur d'un carre change aussi sa
hauteur, ce qui viole les postconditions de Rectangle.
Piege : Mefiez-vous de l'heritage quand les preconditions ou postconditions changent dans la sous-
classe.
I - Interface Segregation Principle (ISP)
Definition Mieux vaut plusieurs interfaces specifiques qu'une seule interface generaliste.
Objectif Les clients ne doivent pas dependre de methodes qu'ils n'utilisent pas.
Exemple Separer Printable, Scannable, Faxable plutot qu'une grosse interface
Machine.
Page 2
Guide Entretien Java / Spring Boot
D - Dependency Inversion Principle (DIP)
Definition Les modules de haut niveau ne doivent pas dependre des modules de bas
niveau. Les deux doivent dependre d'abstractions.
Objectif Reduire le couplage entre les couches de l'application.
Spring Le conteneur IoC de Spring applique ce principe nativement via l'injection de
dependances.
Exemple OrderService depend de IPaymentGateway (interface), pas de StripePayment
directement.
Page 3
Guide Entretien Java / Spring Boot
2. Design Patterns
Les Design Patterns sont des solutions reutilisables a des problemes recurrents. Connaitre les
plus courants et savoir les identifier dans Spring Boot est essentiel.
Patterns Creationnels
Singleton
Definition Garantit qu'une classe n'a qu'une seule instance et fournit un point d'acces
global.
Spring Les beans Spring sont des singletons par defaut (scope singleton). Le
conteneur gere l'unicite.
Thread-safety En Java pur, utiliser le double-checked locking ou l'enum pour un Singleton
thread-safe.
Factory / Factory Method
Definition Delegue la creation d'objets a une methode ou une classe dediee. Decouple
le code client du code de creation.
Spring BeanFactory et ApplicationContext sont des implementations de ce pattern
dans Spring.
Builder
Definition Construit un objet complexe etape par etape, separant construction et
representation.
Avantage Ideal pour les objets avec de nombreux parametres optionnels, evite les
telescoping constructors.
Spring Lombok @Builder, UriComponentsBuilder, MockMvcRequestBuilders...
Patterns Comportementaux
Strategy
Definition Definit une famille d'algorithmes interchangeables encapsules derriere une
interface commune.
Avantage Choix de l'algorithme a l'execution sans modifier le code client.
Exemple Differentes strategies de calcul de prix, de tri ou de validation selon le
contexte.
Observer
Definition Un sujet notifie automatiquement ses observateurs lors d'un changement
d'etat.
Spring ApplicationEventPublisher / @EventListener. Aussi base de la programmation
reactive (Reactor, RxJava).
Page 4
Guide Entretien Java / Spring Boot
Template Method
Definition Definit le squelette d'un algorithme dans une classe parente, en laissant les
sous-classes redefinir certaines etapes.
Spring JdbcTemplate, RestTemplate : Spring gere le boilerplate (ouverture
connexion, gestion erreurs) et laisse le developpeur fournir la logique metier.
Patterns Structurels
Proxy / Decorator
Proxy Controle l'acces a un objet (securite, lazy loading, logging). Spring AOP utilise
des proxies dynamiques JDK ou CGLIB.
Decorator Ajoute dynamiquement des responsabilites a un objet sans modifier sa classe
ni utiliser l'heritage.
Spring AOP @Transactional, @Cacheable, @Async : Spring genere un proxy qui
encapsule le comportement transverse autour de la methode.
Piege : @Transactional ne fonctionne pas sur les appels internes (self-invocation) car Spring passe par
le proxy. Si une methode @Transactional en appelle une autre dans la meme classe, la transaction n'est
pas creee.
Page 5
Guide Entretien Java / Spring Boot
3. Spring Boot - Concepts Cles
IoC et Injection de Dependances
IoC Inversion of Control : le conteneur Spring prend en charge la creation et le
cablage des objets (beans), pas le code metier.
DI Dependency Injection : les dependances sont injectees par le conteneur, pas
instanciees par la classe elle-meme.
Modes d'injection Par constructeur (recommande), par setter, par champ (@Autowired).
Astuce entretien : Preferer l'injection par constructeur : elle rend les dependances obligatoires
explicites et facilite les tests unitaires (pas besoin de Spring pour tester).
AOP - Aspect-Oriented Programming
Definition Permet de separer les preoccupations transversales (logging, securite,
transactions) de la logique metier.
Concepts cles Aspect : classe annotee @Aspect. Join Point : point d'execution (methode).
Pointcut : expression definissant les join points cibles. Advice : code execute
(@Before, @After, @Around, @AfterReturning, @AfterThrowing).
Mecanisme Spring cree un proxy (JDK dynamic proxy si interface, CGLIB sinon) qui
intercepte les appels et execute les advices.
Usages @Transactional, @Cacheable, @Async, @Secured, logging automatique,
metriques.
@Around("execution(* [Link].*.*(..))") public Object
logExecution(ProceedingJoinPoint pjp) throws Throwable { long start =
[Link](); Object result = [Link](); [Link]("Duree:
{}ms", [Link]() - start); return result; }
Cycle de vie d'un Bean Spring
Instanciation → Injection des dependances → @PostConstruct / afterPropertiesSet() → Utilisation
→ @PreDestroy / destroy()
singleton Une seule instance par conteneur (defaut). Partage entre tous les
composants.
prototype Nouvelle instance a chaque injection / getBean(). Spring ne gere pas sa
destruction.
request Une instance par requete HTTP (contexte web).
session Une instance par session HTTP (contexte web).
@Transactional - Details et Pieges
Page 6
Guide Entretien Java / Spring Boot
Propagation REQUIRED (defaut) : rejoint la transaction existante ou en cree une nouvelle.
REQUIRES_NEW : suspend la transaction courante et en cree une
independante.
Isolation Definit la visibilite des modifications non committees entre transactions
(READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE...).
Rollback Rollback automatique sur RuntimeException et Error. Pas de rollback sur les
checked exceptions (configurable avec rollbackFor).
readOnly readOnly = true : optimisation pour les requetes en lecture seule (Hibernate
ne fait pas de dirty checking).
Piege : Self-invocation : appeler une methode @Transactional depuis la meme classe ne cree pas de
nouvelle transaction, le proxy est contourne.
Piege : Checked exceptions ne declenchent pas de rollback par defaut. Utiliser
@Transactional(rollbackFor = [Link]) si necessaire.
Spring Security
Architecture Chaine de filtres (SecurityFilterChain). Chaque filtre traite un aspect
(authentification, CSRF, session...).
Authentification Qui es-tu ? Verification de l'identite via username/password, JWT, OAuth2,
certificat...
Autorisation Qu'as-tu le droit de faire ? Controle d'acces aux ressources (URLs,
methodes).
JWT JSON Web Token : token signe et stateless. Spring Security le valide a
chaque requete via un OncePerRequestFilter.
@PreAuthorize Controle fin au niveau methode : @PreAuthorize("hasRole('ADMIN')").
Necessite @EnableMethodSecurity.
Spring Data JPA
JpaRepository Fournit automatiquement les operations CRUD + paginiation + tri. Generation
des requetes SQL a partir des noms de methodes.
JPQL / Criteria API JPQL : SQL oriente objet. Criteria API : construction programmatique et type-
safe des requetes (utile pour les requetes dynamiques).
N+1 Problem Chargement de N entites genere N requetes supplementaires pour les
associations. Solution : FETCH JOIN, @EntityGraph, ou batch fetching.
Lazy vs Eager LAZY : associations chargees a la demande (defaut pour @OneToMany).
EAGER : chargees systematiquement (defaut pour @ManyToOne). Preferer
LAZY + fetch join explicite.
Piege : LazyInitializationException : acceder a une association LAZY hors d'une transaction ouverte.
Solution : open session in view (anti-pattern en prod) ou charger les donnees dans la transaction.
Page 7
Guide Entretien Java / Spring Boot
4. Java Core - Concepts Avances
Concurrence et Thread-Safety
synchronized Verrouille sur l'objet/classe cible. Garantit exclusion mutuelle et visibilite
memoire. Lourd si contentions frequentes.
volatile Garantit la visibilite memoire (pas de cache CPU) mais pas l'atomicite des
operations composees. Adequat pour des flags simples.
ReentrantLock Verrou explicite plus flexible : tryLock() avec timeout, lockInterruptibly(),
fairness policy.
AtomicInteger / Operations atomiques sans synchronisation explicite, basees sur CAS
AtomicReference (Compare-And-Swap).
[Link] Executors, CountDownLatch, CyclicBarrier, Semaphore, BlockingQueue pour
la coordination de threads.
Astuce entretien : Difference volatile vs synchronized : volatile garantit la visibilite mais check-then-act
n'est pas atomique. Exemple : i++ avec volatile n'est pas thread-safe.
Collections et Performance
ArrayList vs ArrayList : acces O(1), insertion/suppression milieu O(n). LinkedList : acces
LinkedList O(n), insertion/suppression O(1) si iterateur positionne. ArrayList prefere en
pratique (meilleure localite memoire).
HashMap Tableau de buckets + listes/arbres (Java 8+). Facteur de charge 0.75. Non
thread-safe. Cles : hashCode() + equals() coherents obligatoires.
ConcurrentHashMap Thread-safe par segmentation (pas de lock global). Remplace Hashtable
(obsolete). Pas de lock sur les lectures.
TreeMap / TreeMap : tries par cle (O(log n)). LinkedHashMap : ordre d'insertion ou
LinkedHashMap d'acces (base du LRU cache).
Stream API et Programmation Fonctionnelle
Lazy evaluation Les operations intermediaires (filter, map, flatMap) ne sont pas executees
jusqu'a une operation terminale (collect, forEach, count...).
Optional<T> Conteneur qui peut contenir ou non une valeur. Evite les NullPointerException
en forcant la gestion explicite de l'absence.
Interface Interface avec une seule methode abstraite (@FunctionalInterface). Cible des
fonctionnelle lambdas et methodes references. Exemples : Function, Predicate, Consumer,
Supplier.
Streams paralleles parallelStream() utilise le ForkJoinPool commun. Attention : ordre non garanti,
overhead pour les petits datasets.
// Eviter Optional<User> user = findUser(id); if ([Link]()) { return
[Link]().getName(); } // Preferer return
findUser(id).map(User::getName).orElse("Inconnu");
Page 8
Guide Entretien Java / Spring Boot
Gestion Memoire et GC
Heap Zone principale : Young Generation (Eden + Survivor S0/S1) + Old
Generation (Tenured). Les objets survivants au GC mineur migrent vers Old
Gen.
Metaspace Remplace PermGen depuis Java 8. Stocke les metadonnees des classes.
Taille dynamique (limite par la RAM systeme).
G1GC Garbage Collector par defaut depuis Java 9. Divise le heap en regions,
minimise les pauses. Adapte aux applications a faible latence.
ZGC / Shenandoah GC a pauses ultra-courtes (<1ms). Adapte aux services avec SLA stricts.
Disponibles en Java 11+.
Memory leaks References statiques vers des objets volumineux, listeners non desabonnes,
courants caches non bornes, ThreadLocal non nettoyes.
CompletableFuture et Async
CompletableFuture API de programmation asynchrone non-bloquante. Permet de chainer des
operations et de composer des Futures.
thenApply vs thenApply : transforme le resultat (Function). thenCompose : enchaine avec
thenCompose un autre CompletableFuture (flatMap).
handle vs handle : gere succes ET erreur. exceptionally : gere uniquement les erreurs.
exceptionally
@Async Spring Delegue l'execution a un thread pool configure. Attention : meme probleme
que @Transactional pour la self-invocation.
Page 9
Guide Entretien Java / Spring Boot
5. Architecture et Bonnes Pratiques
Architecture en Couches
Controller Couche presentation : recoit les requetes HTTP, valide les inputs (@Valid),
appelle le Service, retourne la reponse. Ne contient PAS de logique metier.
Service Couche metier : orchestre les traitements, applique les regles metier, gere les
transactions. C'est ici que reside la valeur ajoutee.
Repository Couche acces donnees : abstrait la persistance. N'expose pas les details
JPA/SQL au Service.
DTO / Mapper Data Transfer Objects : objects dedies a l'echange de donnees entre
couches. Evite d'exposer les entites JPA. Utiliser MapStruct pour la
conversion.
Conception d'API REST
Verbes HTTP GET (lecture), POST (creation), PUT (remplacement complet), PATCH
(modification partielle), DELETE (suppression). Respecter la semantique.
Codes HTTP 200 OK, 201 Created, 204 No Content, 400 Bad Request, 401 Unauthorized,
403 Forbidden, 404 Not Found, 409 Conflict, 422 Unprocessable Entity, 500
Internal Server Error.
Versioning Via le chemin (/api/v1/), le header (Accept: application/[Link].v1+json) ou le
query param. Le chemin est le plus simple.
HATEOAS Inclure les liens vers les ressources associees dans les reponses. Facilite la
navigation et reduit le couplage client/serveur.
Pagination Toujours paginer les listes. Parametres standards : page, size, sort.
Retourner les metadonnees (totalElements, totalPages).
Microservices
Definition Architecture decomposant l'application en services autonomes, deployes
independamment, communiquant via reseau.
Communication REST (Feign Client), gRPC (haute performance, schema type-safe avec
sync Protobuf).
Communication Kafka (event streaming, haute disponibilite), RabbitMQ (message broker,
async routage flexible). Favorise le decouplage temporel.
Circuit Breaker Evite les cascades de pannes. 3 etats : Closed (normal), Open (appels
bloques, fallback), Half-Open (test retablissement). Resilience4j dans Spring
Boot.
Saga Pattern Gestion des transactions distribuees via une sequence de transactions
locales compensatrices. Orchestration (un orchestrateur central) ou
Choreography (events).
Service Discovery Eureka (Netflix), Consul : les services s'enregistrent et se decouvrent
dynamiquement. Spring Cloud LoadBalancer cote client.
Page 10
Guide Entretien Java / Spring Boot
Tests
Tests unitaires Testent une classe isolee. Les dependances sont mockees (Mockito).
Rapides, nombreux. Pas de Spring context.
@WebMvcTest Charge uniquement la couche Web (Controller, Filter). Mock le Service avec
@MockBean. Teste les endpoints, la serialisation, la validation.
@DataJpaTest Charge uniquement JPA/Hibernate avec une BDD H2 en memoire. Teste les
requetes Repository.
@SpringBootTest Charge le contexte complet. Test d'integration de bout en bout. Plus lent. A
reserver pour les tests critiques.
TestContainers Lance de vrais conteneurs Docker (PostgreSQL, Kafka...) pendant les tests.
Tests d'integration realistes sans mocks.
Pyramide des tests Beaucoup de tests unitaires, moins de tests d'integration, peu de tests E2E.
L'inverse (anti-pattern) ralentit le feedback.
Observabilite
Logs Utiliser SLF4J + Logback/Log4j2. Logger en JSON pour l'agregation (ELK).
Inclure le correlationId/traceId dans les MDC pour tracer les requetes.
Metriques Micrometer (abstraction) + Prometheus + Grafana. Exposer les metriques via
/actuator/prometheus. Instrumenter les cas metier importants.
Traces distribues OpenTelemetry + Jaeger/Zipkin : suivre une requete a travers plusieurs
microservices. Spring Boot Actuator + Micrometer Tracing.
Health checks /actuator/health : indique si le service est operationnel. Configurer des
liveness et readiness probes (Kubernetes).
Page 11
Guide Entretien Java / Spring Boot
6. Questions Classiques d'Entretien
Questions sur Spring
Q : Quelle est la difference entre @Component, @Service, @Repository et @Controller ?
• Toutes sont des specialisations de @Component et declenchent la detection automatique
(component scanning).
• @Repository ajoute la traduction des exceptions de persistance en DataAccessException.
• @Service marque la couche metier semantiquement.
• @Controller indique a Spring MVC que la classe gere les requetes HTTP.
Q : Comment Spring gere-t-il les transactions imbriquees ?
• Par defaut ([Link]) : la methode appelee rejoint la transaction existante.
• Propagation.REQUIRES_NEW : suspend la transaction courante et en cree une independante.
• [Link] : point de sauvegarde dans la transaction courante (rollback partiel
possible).
Q : Quelle est la difference entre @Bean et @Component ?
• @Component : detection automatique, appliquee sur des classes que l'on contole.
• @Bean : declaration explicite dans une @Configuration, pour des classes tierces ou des
configurations complexes.
Questions sur Java
Q : Quelle est la difference entre String, StringBuilder et StringBuffer ?
• String : immutable. Chaque concatenation cree un nouvel objet.
• StringBuilder : mutable, non thread-safe. A preferer pour les concatenations en boucle.
• StringBuffer : mutable, thread-safe (methodes synchronisees). Plus lent que StringBuilder.
Q : Comment fonctionne le hashCode/equals en Java ?
• hashCode() determine le bucket dans une HashMap. equals() verifie l'egalite dans le bucket.
• Contrat : si [Link](b) alors [Link]() == [Link](). L'inverse n'est pas necessaire.
• Violation : hashCode() coherent mais equals() non override → doublons dans les Sets.
Q : Qu'est-ce qu'un deadlock ? Comment l'eviter ?
• Deadlock : deux threads s'attendent mutuellement (A attend B, B attend A).
• Prevention : toujours acquerir les locks dans le meme ordre, utiliser tryLock() avec timeout,
minimiser la granularite des locks.
Questions Architecture
Q : REST vs gRPC, quand choisir l'un ou l'autre ?
REST Simple, lisible, support universel (navigateurs), JSON. Ideal pour les APIs
publiques, la communication inter-domaines.
gRPC Protocole binaire (Protobuf), contrat type-safe, streaming bidirectionnel, haute
performance. Ideal pour la communication inter-microservices en interne.
Page 12
Guide Entretien Java / Spring Boot
Q : Comment garantir la coherence des donnees dans une architecture microservices ?
• Eviter les transactions distribuees (2PC) : trop couteuses et fragiles.
• Saga Pattern : sequence de transactions locales avec compensations en cas d'echec.
• Event Sourcing : stocker les evenements plutot que l'etat. Reconstitution de l'etat a partir des
evenements.
• Coherence eventuelle : accepter un delai de propagation et concevoir l'application en
consequence.
Bonne chance pour votre entretien !
Page 13