Guide de préparation aux entretiens techniques – Développeur Java
Senior
1. Langages : Java (21), PL/pgSQL, SQL, TypeScript
Cette section couvre les fondamentaux et nouveautés des langages utilisés par un
développeur Java senior.
• Nouveautés de Java 21 :
Java 21 introduit plusieurs fonctionnalités majeures : les Virtual Threads (Project Loom)
pour le parallélisme léger,
les Record Patterns, le Pattern Matching pour switch, les Sequenced Collections et les
Scoped Values. Ces évolutions améliorent la lisibilité et la performance du code.
• CompletableFuture vs Threads classiques :
`CompletableFuture` permet une programmation asynchrone non bloquante. Contrairement
aux threads classiques, il simplifie la composition de tâches grâce à des méthodes comme
`thenCompose` et `thenCombine`.
• Garbage Collectors : G1 vs ZGC :
G1 divise le tas mémoire en régions pour mieux gérer les pauses, tandis que ZGC offre des
pauses ultra-courtes (<10ms) idéales pour les applications à faible latence.
2. Paradigmes : Clean Architecture, Clean Code, TDD
Ces concepts garantissent la maintenabilité, la testabilité et la qualité du code sur le long
terme.
• Clean Architecture :
Elle repose sur une séparation claire des couches : Domaine (Entités, Use Cases),
Application (Règles métier), Infrastructure (Base de données, API externes) et Interface
(API REST, UI).
Les dépendances pointent toujours vers le centre (le domaine).
• Clean Code :
Principes SOLID, code lisible, fonctions courtes, nommage clair, suppression des
duplications et application du principe KISS (Keep It Simple, Stupid).
• TDD (Test Driven Development) :
Cycle “Red-Green-Refactor” : écrire un test qui échoue, implémenter le code minimal pour le
faire passer, puis refactoriser pour améliorer la qualité du code.
3. Frameworks Java : Spring Boot, Quarkus
Les frameworks modernes comme Spring Boot et Quarkus facilitent le développement
d’applications d’entreprise robustes et performantes.
• Spring Boot :
Basé sur le principe de configuration par convention, Spring Boot simplifie la création
d'applications Spring prêtes à l'emploi.
Il gère automatiquement l’injection de dépendances via le conteneur IoC, les annotations
(`@Autowired`, `@Component`, `@Service`) et la configuration auto-magique.
• Sécurité :
Spring Security permet de gérer l’authentification (souvent via JWT) et l’autorisation, avec
la configuration des filtres (`SecurityFilterChain`) et des politiques CORS/CSRF.
• Quarkus :
Quarkus est optimisé pour le cloud et GraalVM. Il démarre plus vite, consomme moins de
mémoire et supporte Panache pour simplifier l’accès aux données.
Contrairement à Spring Boot, il cible les architectures serverless et les conteneurs légers.
4. Front-End : Vue 3, Pinia, Angular
La maîtrise des frameworks front-end permet une meilleure collaboration avec les équipes
UI et le développement d’interfaces modernes.
• Vue 3 et Pinia :
Vue 3 introduit la Composition API, plus flexible et performante. Pinia remplace Vuex
comme store global : typé, réactif et simple à tester.
• Angular :
Framework complet avec DI, RxJS et liaison bidirectionnelle via `[(ngModel)]`. Idéal pour les
grandes applications structurées.
5. Web & API : REST, OpenAPI (Swagger)
La conception d’APIs robustes et bien documentées est essentielle pour la communication
entre services.
• Bonnes pratiques REST :
Respect des verbes HTTP, URIs cohérentes, réponses stateless, gestion correcte des codes
de statut et pagination.
• OpenAPI / Swagger :
Permet de documenter et tester les endpoints REST automatiquement. Avec `springdoc-
openapi`, la documentation se génère via annotations `@Operation` et `@Schema`.
6. Tests & Qualité : JUnit, Mockito, Karate, SonarQube
Les tests garantissent la fiabilité et la maintenabilité du code dans le temps.
• Tests unitaires et d’intégration :
Les tests unitaires isolent une méthode ou une classe. Les tests d’intégration valident
plusieurs composants ensemble (ex : contrôleur + service + base).
• Mockito :
Permet de simuler des dépendances avec `@Mock` et `when(...).thenReturn(...)` pour isoler
le code testé.
• Karate :
Framework BDD pour tester les APIs REST en bout en bout. Permet des scénarios lisibles
(Given / When / Then) pour la QA.
• SonarQube :
Analyse statique du code : détecte les bugs, vulnérabilités, duplications et mesure la
couverture de tests.
7. Bases de données : PostgreSQL, Talend, Oracle
Une bonne compréhension des bases et de l’optimisation SQL est indispensable.
• Optimisation SQL :
Utilisation d’index, analyse avec EXPLAIN PLAN, éviter les sous-requêtes inutiles, limiter les
SELECT *.
• Talend Studio :
Outil ETL pour automatiser les flux de données (extraction, transformation, chargement).
Utilisé pour la migration et l’intégration.
8. Outils de gestion de projets : Jira, Confluence, Git, Maven, Nexus, Jenkins
La maîtrise de ces outils améliore la productivité et la qualité des livrables.
• Jira & Confluence : gestion agile, suivi des tickets, documentation partagée.
• Git & GitLab : contrôle de version et pipelines CI/CD.
• Maven & Nexus : gestion des dépendances et artifacts internes.
• Jenkins : automatisation du build, des tests et du déploiement via Jenkinsfile.
9. Déploiement : Docker, Kubernetes, Rancher
Ces outils facilitent la conteneurisation et l’orchestration d’applications modernes.
• Docker : conteneurisation des applications via Dockerfile (`FROM`, `RUN`, `COPY`, `CMD`).
• Kubernetes : orchestration, scalabilité, gestion de Pods, Services, Deployments.
• Rancher : interface de gestion multi-clusters Kubernetes.
10. Environnements de développement : Eclipse, IntelliJ IDEA, VS Code
Les environnements de développement modernes améliorent la productivité grâce à
l’intégration d’outils et plugins.
• IntelliJ IDEA : refactorings puissants, inspection de code, intégration Maven/Gradle fluide.
• Eclipse : plus configurable, adapté aux projets legacy.
• Plugins utiles : Lombok, SonarLint, Docker, Spring Assistant.
11. Questions transversales & comportementales (profil senior)
Les recruteurs évaluent aussi la communication, la gestion d’équipe et la capacité à
résoudre des problèmes complexes.
• Comment gérez-vous un conflit technique dans une équipe ?
→ Chercher le consensus sur des critères techniques, argumenter avec des faits
(benchmarks, code review), et favoriser la décision collective.
• Comment gérez-vous une deadline serrée ?
→ Priorisation, communication avec le management, découpage en MVP, et maintien de la
qualité minimale.
• Exemple d’incident critique résolu :
→ (Donner un cas concret : fuite mémoire, lenteur API, déploiement bloqué, etc.) Mettre en
avant la méthodologie de diagnostic et la résolution.
• Comment partagez-vous la connaissance dans l’équipe ?
→ Pair programming, code reviews, documentation Confluence, présentations techniques.