Quiz personnalisé
Choisissez les thèmes que vous souhaitez réviser et lancez une session de QCM. Vous aurez les réponses et les explications à chaque question.
Quiz personnalisé
Sélectionnez les thèmes que vous souhaitez réviser, puis lancez le quiz.
Questions sélectionnées: 0
Question 1
Quelle est la différence fondamentale entre monitoring et alerting ?
Un dashboard se consulte quand on en a besoin ; une alerte interrompt quelqu'un, parfois en pleine nuit. C'est pourquoi les alertes doivent être rares, pertinentes et actionnables.
Question 2
Pourquoi recommande-t-on d'alerter sur les symptômes plutôt que sur les causes ?
Un CPU élevé sans impact sur la latence ni les erreurs n'est pas un incident ; à l'inverse, des erreurs 5xx méritent une intervention quelle qu'en soit la cause. Les métriques de causes restent utiles, mais dans les dashboards de diagnostic.
Question 3
Quels sont les quatre golden signals ?
Les golden signals du SRE book de Google sont des symptômes côté service : latence des requêtes, volume de trafic, taux d'erreurs et saturation de la ressource la plus contrainte. CPU/mémoire/disque sont des métriques de ressources, pas les golden signals.
Question 4
Dans cette règle Prometheus, à quoi sert la clause `for: 5m` ?
- alert: HighErrorRate
expr: rate(http_requests_total{status=~"5.."}[5m])
/ rate(http_requests_total[5m]) > 0.05
for: 5m
labels:
severity: criticalLa durée de persistance évite les faux positifs : un dépassement de seuil de 30 secondes pendant un déploiement ne réveille personne. Le compromis : plus la durée est longue, plus la détection des vrais incidents est tardive.
Question 5
Quand une alerte doit-elle « pager » l'astreinte plutôt que créer un ticket ?
La règle : si personne ne doit se lever à 3 h du matin pour cette alerte, elle ne doit pas pager. Un disque qui sera plein dans quatre jours mérite un ticket traité en heures ouvrées, pas une page.
Question 6
Votre équipe reçoit des dizaines d'alertes par jour et a pris l'habitude de les acquitter sans les lire. Quel est le problème et que faire ?
La fatigue d'alerte est le principal mode d'échec de l'alerting : à force de bruit, la vraie alerte passe inaperçue. Le remède : ne garder que des alertes actionnables, utiliser le regroupement et les inhibitions d'Alertmanager, documenter chaque alerte par un runbook et réviser régulièrement les règles.
Question 7
Quelle caractéristique est fondamentale dans une architecture microservices ?
L'autonomie est le cœur du modèle : déploiement indépendant, données privées par service et communication via APIs (REST, gRPC, messaging).
Question 8
Quelle stratégie de découpage des services est recommandée ?
La séparation fonctionnelle par domaine métier (DDD) donne des services cohésifs et faiblement couplés ; le découpage technique crée du couplage fort où chaque changement métier traverse plusieurs services.
Question 9
Qu'est-ce qu'un « distributed monolith » ?
C'est le piège classique : on paie la complexité opérationnelle des microservices (réseau, monitoring distribué) sans gagner l'indépendance de déploiement, à cause d'un couplage fort entre services.
Question 10
Que se passe-t-il quand un Circuit Breaker est à l'état Open ?
@CircuitBreaker(name = "userService")
public User getUser(String userId) {
return userServiceClient.getUser(userId);
}À l'état Open, le circuit court-circuite les appels pour éviter la cascade de pannes. Après un délai, il passe en Half-Open pour tester la récupération : CLOSED → OPEN → HALF_OPEN → CLOSED.
Question 11
Pourquoi le Saga Pattern est-il nécessaire en microservices ?
Chaque service ayant sa propre base, une opération métier traversant plusieurs services (inventaire, paiement, livraison) est gérée en transactions locales ; en cas d'échec, des actions de compensation annulent les étapes déjà réalisées.
Question 12
Dans quel cas privilégier la communication asynchrone (messaging, événements) entre services ?
L'asynchrone (RabbitMQ, Kafka…) découple les services et améliore la résilience : idéal pour les traitements différés et les événements métier. Le synchrone (REST, gRPC) reste adapté au temps réel et aux validations immédiates.
Question 13
Quelles responsabilités relèvent d'une API Gateway ?
L'API Gateway (Kong, Zuul, AWS API Gateway) centralise l'entrée des requêtes clients : routage vers les bons services, authentification/autorisation, rate limiting, logging et transformation de données.
Question 14
À quoi sert le header X-Correlation-ID propagé de service en service ?
Un identifiant unique est généré à l'entrée (gateway) puis propagé et loggé par chaque service : on peut ainsi reconstituer le parcours complet d'une requête dans le système distribué.
Question 15
Quel est le rôle de l'API Gateway (Kong, Zuul) dans une architecture microservices ?
L'API Gateway est la porte d'entrée unique du système : elle route les requêtes du frontend vers les bons microservices et centralise les préoccupations transverses comme l'authentification, au lieu de les dupliquer dans chaque service.
Question 16
Dans cette architecture, à quoi sert l'IDP (Keycloak, Auth0) ?
L'Identity Provider gère les identités des utilisateurs et émet les tokens (par exemple JWT via OpenID Connect) que l'API Gateway vérifie avant de laisser passer les requêtes vers les services.
Question 17
Quelle est la différence entre la communication synchrone et asynchrone entre services ?
En REST, l'appelant est bloqué jusqu'à la réponse et subit les pannes du destinataire ; avec Kafka, l'événement est publié dans un topic et consommé plus tard, ce qui découple les services dans le temps.
Question 18
Dans l'architecture de la fiche, comment la SCPI Invest API communique-t-elle avec le Partner Service ?
Le diagramme montre un échange asynchrone : SCPI Invest API → Kafka → Partner Service. Les événements métier transitent par le broker, pas par des appels REST directs.
Question 19
Quel est le rôle du Batch Service dans cette architecture ?
Le Batch Service consomme des fichiers déposés dans le bucket S3 et les ingère dans les différents datastores : PostgreSQL, MongoDB et Elasticsearch.
Question 20
Pourquoi utiliser un broker comme Kafka plutôt qu'un appel REST direct entre deux microservices ?
Le broker joue le rôle de tampon durable : le producteur publie sans dépendre de la disponibilité du consommateur, qui rattrape son retard en relisant le topic. Un appel REST direct échouerait si le service cible est en panne.
Question 21
Quel composant collecte et visualise les métriques de l'ensemble des services ?
Dans le diagramme, tous les services alimentent le bloc Monitoring : Prometheus collecte et stocke les métriques, Grafana les visualise sous forme de dashboards.
Question 22
Quel est l'objectif premier du BDD ?
Le BDD est avant tout une pratique de collaboration : les scénarios en langage naturel réduisent les malentendus entre équipes ; leur exécution automatisée n'en est que la conséquence.
Question 23
Dans un scénario Gherkin, que représente le mot-clé `Given` ?
Given pose le contexte initial (état du système), When décrit l'action de l'utilisateur, Then vérifie le résultat attendu.
Question 24
À quoi sert la section `Background` dans un fichier Gherkin ?
Le Background factorise les étapes Given communes : il est exécuté avant chaque scénario de la feature, évitant de répéter la même mise en place.
Question 25
Que permet un `Scenario Outline` accompagné d'une table `Examples` ?
Le Scenario Outline paramètre le scénario avec des placeholders (<email>, <password>…) ; chaque ligne de la table Examples produit une exécution avec ces valeurs.
Question 26
Quel mot-clé Gherkin manque à la place des ??? pour décrire l'action de l'utilisateur ?
Given je suis sur la page de connexion
??? je clique sur le bouton "Se connecter"
Then je suis redirigé vers le tableau de bordL'action déclenchée par l'utilisateur s'exprime avec When ; Given décrit l'état de départ et Then le résultat attendu.
Question 27
Dans une step definition Cucumber.js, que fait le placeholder `{string}` ?
When('je saisis {string} dans le champ email', async function (email) {
await this.page.fill('[data-testid="email-input"]', email);
});Les placeholders ({string}, {int}…) capturent les valeurs écrites dans la phrase Gherkin et les transmettent en arguments à la step definition, rendant la step réutilisable.
Question 28
Pourquoi parle-t-on de « spécifications vivantes » à propos du BDD ?
Les scénarios Gherkin sont à la fois documentation et tests exécutés : si le comportement de l'application diverge de la spécification, les tests échouent, ce qui force à garder la documentation à jour.
Question 29
Quelle est la convention Java pour nommer une constante ?
En Java : classes en PascalCase, méthodes et variables en camelCase, constantes en SNAKE_CASE majuscule, packages en minuscules.
Question 30
Que recommande le principe KISS ?
KISS (Keep It Simple, Stupid) : si une solution simple existe, l'utiliser. La suroptimisation prématurée (ex. bitwise pour tester le week-end) complexifie sans bénéfice réel.
Question 31
Quel est le principal risque d'une logique de validation dupliquée dans plusieurs méthodes ou classes ?
C'est le cœur de DRY : une règle dupliquée doit être corrigée partout à la fois. Extraire la logique commune (méthode privée, classe utilitaire) garantit un point de modification unique.
Question 32
Quel problème ce code pose-t-il ?
try {
FileInputStream file = new FileInputStream(path);
// Traitement...
} catch (Exception e) {
// rien
}Un catch vide masque l'erreur réelle et le flux n'est jamais fermé (fuite de ressource). Il faut un try-with-resources, des catch spécifiques, une journalisation avec contexte et une ré-encapsulation en exception métier.
Question 33
À quoi sert le try-with-resources en Java ?
Toute ressource AutoCloseable déclarée dans les parenthèses du try est fermée automatiquement, y compris quand une exception est levée — fini les finally oubliés.
Question 34
Dans un bloc try, dans quel ordre déclarer les catch ?
Un catch générique placé en premier capterait tout : les catch spécifiques (FileNotFoundException avant IOException) deviendraient du code mort — le compilateur le refuse d'ailleurs.
Question 35
Pourquoi remplacer `timer.schedule(task, 86400000)` par `timer.schedule(task, ONE_DAY_IN_MILLIS)` ?
86400000 est un magic number : personne ne devine qu'il s'agit d'un jour en millisecondes. Une constante nommée rend le code auto-documenté et évite les recopies erronées.
Question 36
Quel outil ou pratique aide à garantir un formatage cohérent dans une équipe ?
Un outil de formatage automatique, appliqué via hooks pre-commit et un `.editorconfig` partagé, élimine les débats de style et les diffs parasites dans les PR.
Question 37
En quelles deux parties se divise le Sprint Planning ?
La partie 1 répond au « Quoi ? » (review du backlog, Sprint Goal, sélection des stories) et la partie 2 au « Comment ? » (décomposition en tâches, estimation détaillée, planification).
Question 38
Quelle est la durée maximale du Sprint Planning pour un sprint de 4 semaines ?
Le Sprint Planning est timeboxé à 8h pour un sprint de 4 semaines, 4h pour un sprint de 2 semaines — la durée est proportionnelle à la longueur du sprint.
Question 39
Quelle règle s'applique au Daily Scrum ?
Le daily est timeboxé à 15 minutes, à heure et lieu fixes, focalisé sur le Sprint Goal. Les problèmes identifiés se traitent après, pas en séance.
Question 40
Lequel de ces comportements est un anti-pattern du Daily Scrum ?
Le daily appartient à l'équipe de développement : en faire un reporting au manager (ou y résoudre les problèmes, dépasser 15 min, parler hors sprint) est un anti-pattern classique.
Question 41
Quels sont les objectifs de la Sprint Review ?
La review inspecte le produit : démonstration interactive, feedback des stakeholders et adaptation du backlog. L'amélioration du processus relève de la rétrospective.
Question 42
Dans une rétrospective au format Keep / Stop / Start, où classer « les obstacles récurrents qui nous font perdre du temps » ?
Keep = ce qui a bien fonctionné, Stop = ce qui pose problème (pratiques inefficaces, obstacles récurrents, perte de temps), Start = nouvelles idées à tester.
Question 43
Quelle technique d'animation de rétrospective sert à identifier les causes racines d'un problème ?
Les 5 Whys consistent à demander « pourquoi ? » en cascade pour remonter à la cause racine. Mad/Sad/Glad explore les émotions, Starfish nuance (Start, Stop, Continue, More, Less), Timeline retrace les événements.
Question 44
Qui participe obligatoirement au Sprint Planning ?
PO et Development Team sont obligatoires (le PO présente les priorités, l'équipe s'engage), le Scrum Master facilite ; les stakeholders sont optionnels sur la partie 1.
Question 45
Quels sont les 4 piliers d'un code de qualité ?
Un code de qualité est maintenable (facile à faire évoluer), testable (isolable), lisible (compréhensible par tous) et extensible (on peut l'étendre sans le modifier).
Question 46
Pourquoi une classe `OrderManager` qui valide, calcule le prix, envoie l'email et sauvegarde en base est-elle difficile à maintenir ?
Une classe « qui fait tout » a plusieurs raisons de changer. Séparer les responsabilités (validator, calculator, notification, repository) permet de modifier chaque partie sans risque pour les autres.
Question 47
Qu'est-ce qui rend un code difficilement testable ?
Quand la classe crée elle-même ses dépendances vers le monde extérieur (base, API, horloge), impossible de les remplacer par des mocks : le test devient un test d'intégration fragile.
Question 48
Quel pilier de la qualité ce code viole-t-il principalement ?
public class Calc {
public double calc(List<Item> items, User u) {
double t = 0;
for (Item i : items) {
double p = i.getP();
if (u.getT() == 1 && i.getC().equals("FOOD")) p *= 0.9;
t += p * i.getQ();
}
return t > 100 ? t * 0.98 : t;
}
}`t`, `p`, `getT()`, `0.9`, `0.98`… le code fonctionne mais personne ne peut deviner l'intention. Des noms explicites et des constantes nommées (FOOD_DISCOUNT, BULK_THRESHOLD) le rendraient auto-documenté.
Question 49
Comment rendre testable une règle métier qui dépend de l'heure système (ex. « pas de connexion après 22 h ») ?
En injectant un `TimeProvider`, le test fournit une horloge factice et peut vérifier le comportement à 21 h comme à 23 h, de façon déterministe.
Question 50
Dans le `PaymentProcessor` extensible, comment ajoute-t-on le support d'Apple Pay ?
C'est le principe Open/Closed : le processeur dépend de l'abstraction `PaymentMethod` et d'une Map d'implémentations. Un nouveau moyen de paiement = une nouvelle classe, zéro modification du code en place.
Question 51
Quel est le signe classique d'une violation du principe Open/Closed dans un code existant ?
Chaque nouveau type impose de rouvrir et modifier la même méthode. Le remède : une abstraction (interface) et le polymorphisme, pour étendre sans modifier.
Question 52
Parmi ces points, lequel fait partie de la checklist d'une code review ?
La checklist porte sur le code lui-même : nommage, fonctions courtes, tests, documentation, gestion d'erreurs, sécurité, SOLID, DRY — jamais sur la personne ou des critères arbitraires.
Question 53
Vous repérez un bloc de code commenté (ancienne implémentation) dans une PR. Que faire ?
« Pas de code mort ou commenté » fait partie de la checklist : l'historique Git rend ces reliquats inutiles, et ils sèment le doute chez le prochain lecteur.
Question 54
Quelle formulation de commentaire de review est la plus constructive ?
Un feedback constructif est formulé comme une suggestion ou une question sur le code, jamais comme un jugement sur la personne ; il explique le bénéfice attendu (ici la lisibilité).
Question 55
Pourquoi laisser aussi des commentaires positifs (« Excellente utilisation du pattern Strategy ici ! ») lors d'une review ?
Valoriser un bon choix de conception encourage sa réutilisation et rappelle que la review est un échange bienveillant, pas un tribunal.
Question 56
Sur le plan de la sécurité, que doit vérifier en priorité un reviewer ?
La checklist cite explicitement la validation des entrées utilisateur : c'est la première ligne de défense contre les injections et les données corrompues.
Question 57
Au-delà de la détection de bugs, quel est l'autre grand bénéfice d'une code review ?
La review diffuse la connaissance du code et des bonnes pratiques : chaque PR relue est une occasion d'apprendre, pour l'auteur comme pour le reviewer.
Question 58
Quelle est la différence fondamentale entre List et Set ?
Une List est une collection ordonnée avec doublons et accès par index ; un Set garantit l'unicité des éléments, avec des stratégies d'ordre variables selon l'implémentation.
Question 59
Dans quel cas préférer LinkedList à ArrayList ?
LinkedList insère et supprime en O(1) aux extrémités, mais accède en O(n) et consomme plus de mémoire. ArrayList reste meilleure pour l'accès par index (O(1)).
Question 60
Que se passe-t-il à la troisième ligne d'ajout ?
Set<String> set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("Java");Un Set n'accepte pas les doublons : add() renvoie simplement false et le set reste inchangé, sans exception.
Question 61
Quelle implémentation de Set conserve l'ordre d'insertion des éléments ?
LinkedHashSet double la table de hachage d'une liste chaînée qui mémorise l'ordre d'insertion. HashSet n'a aucun ordre garanti et TreeSet trie selon l'ordre naturel (ou un Comparator).
Question 62
Qu'affiche cette boucle ?
Set<String> set = new TreeSet<>();
set.add("Python");
set.add("Java");
set.add("C++");
for (String lang : set) {
System.out.println(lang);
}TreeSet maintient les éléments triés selon leur ordre naturel (ici alphabétique pour des String), quel que soit l'ordre d'insertion. Les opérations coûtent O(log n).
Question 63
Que vaut la valeur associée à "Alice" après ce code ?
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.merge("Alice", 1, Integer::sum);merge() applique la fonction de fusion quand la clé existe déjà : Integer::sum additionne l'ancienne valeur (25) et celle fournie (1), donc 26. Si la clé était absente, la valeur 1 serait simplement insérée.
Question 64
Quelle est la complexité moyenne d'une recherche dans un HashMap et dans un TreeMap ?
HashMap s'appuie sur le hachage : O(1) en moyenne mais aucun ordre. TreeMap s'appuie sur un arbre trié : O(log n), en échange de clés maintenues triées (firstKey, subMap…).
Question 65
Vous devez itérer sur des paires clé-valeur en obtenant les clés par ordre alphabétique. Quelle structure choisir ?
TreeMap maintient les clés triées selon leur ordre naturel : l'itération sur keySet() les renvoie en ordre alphabétique. LinkedHashMap conserve l'ordre d'insertion, pas l'ordre trié.
Question 66
Quels sont les trois cycles de vie principaux de Maven ?
Maven définit trois cycles de vie : default (construction du projet), clean (nettoyage) et site (documentation). compile, package et deploy sont des phases du cycle default, pas des cycles.
Question 67
Que se passe-t-il quand vous lancez `mvn package` ?
mvn packageExécuter une phase déclenche toutes les phases qui la précèdent dans le cycle : mvn package valide, compile et teste avant de créer le JAR/WAR. install et deploy viennent après package.
Question 68
Quelle est la différence entre les phases `install` et `deploy` ?
install copie l'artefact dans le repository local (~/.m2) pour les autres projets de la machine ; deploy le publie vers un repository distant partagé (Nexus, Artifactory…).
Question 69
Dans quel ordre s'exécutent ces phases du cycle default ?
L'ordre du cycle default est fixe : validate (le projet est correct) → compile (code source) → test (tests unitaires) → package (JAR/WAR) → verify → install → deploy.
Question 70
À quoi sert le cycle de vie `clean` ?
Le cycle clean (pre-clean, clean, post-clean) supprime les artefacts du build précédent, typiquement le répertoire target/. Il ne touche ni au POM ni au repository local.
Question 71
Quelle phase exécute les tests d'intégration dans le cycle default ?
Les tests unitaires tournent en phase test (avant package) ; les tests d'intégration en phase integration-test, encadrée par pre/post-integration-test, après le packaging.
Question 72
Quel cycle de vie contient la phase `site-deploy` ?
Le cycle site (pre-site, site, post-site, site-deploy) génère et publie la documentation du projet — à ne pas confondre avec deploy du cycle default qui publie l'artefact.
Question 73
Qu'est-ce que l'Ubiquitous Language en DDD ?
L'Ubiquitous Language est le langage commun de l'équipe et du métier : les mêmes termes se retrouvent dans les conversations, la documentation et le code (classes, méthodes).
Question 74
Quelle est la différence fondamentale entre une Entity et un Value Object ?
Une Entity reste « la même » quand ses attributs changent, grâce à son identité. Un Value Object comme Money est immuable et deux instances de mêmes valeurs sont égales.
Question 75
Que garantit ce constructeur du Value Object Money ?
public Money(BigDecimal amount, Currency currency) {
if (amount.compareTo(BigDecimal.ZERO) < 0) {
throw new IllegalArgumentException("Amount cannot be negative");
}
this.amount = amount;
this.currency = currency;
}Le Value Object protège ses invariants dès la construction : il est impossible de créer un Money négatif, la règle métier est encapsulée dans le modèle.
Question 76
En architecture hexagonale, qu'est-ce qu'un port et qu'est-ce qu'un adapter ?
Le domaine définit ses besoins sous forme d'interfaces (ports, ex. OrderRepository) ; les adapters (JPA, REST, email…) les implémentent côté infrastructure, ce qui isole le métier des détails techniques.
Question 77
Quelle est la « règle de dépendance » de la Clean Architecture ?
Les dépendances vont des couches externes (frameworks, adapters) vers les couches internes (use cases, entités). Le domaine ne connaît ni la base de données ni le web.
Question 78
L'interface `OrderRepository` est définie dans le domaine mais implémentée par `JpaOrderRepository` dans l'infrastructure. Quel principe est appliqué ?
C'est l'inversion de contrôle/dépendance : le domaine définit le contrat dont il a besoin, l'infrastructure s'y conforme. Le sens de la dépendance du code pointe ainsi vers le domaine.
Question 79
Quel est le rôle d'un Aggregate Root en DDD ?
L'Aggregate Root (ex. Order avec ses OrderLine) est le gardien des invariants de l'agrégat : toutes les modifications passent par lui, comme addOrderLine qui refuse de modifier une commande confirmée.
Question 80
Dans quel cas est-il raisonnable de NE PAS appliquer ces architectures (hexagonale, clean) ?
Conseil clé : commencer simple. Ces patterns ajoutent de la structure et du code ; ils ne se justifient que si la complexité du domaine ou du projet le demande, et on peut y refactorer progressivement.
Question 81
Que désignent les coordonnées GAV d'un artefact Maven ?
GAV = GroupId (organisation, ex : org.springframework), ArtifactId (nom du module, ex : spring-boot-starter-web) et Version (ex : 3.2.0) — le triplet qui identifie un artefact de façon unique.
Question 82
Que signifie une version `1.0-SNAPSHOT` ?
Le suffixe -SNAPSHOT marque une version de développement, mutable : Maven peut en re-télécharger une version plus récente, contrairement à une release qui est immuable.
Question 83
Quel scope faut-il donner à JUnit pour qu'il ne soit pas embarqué dans l'artefact final ?
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>???</scope>
</dependency>Le scope test limite la dépendance à la compilation et à l'exécution des tests : elle n'est ni exposée au code principal ni embarquée dans le livrable.
Question 84
À quoi sert le bloc `<exclusions>` dans une dépendance ?
Une exclusion retire une dépendance transitive indésirable — par exemple exclure spring-boot-starter-logging de spring-boot-starter-web pour utiliser un autre framework de logging.
Question 85
Quels éléments suffisent pour déclarer une dépendance minimale ?
Le GAV suffit : scope (compile par défaut), type (jar par défaut), classifier et optional ont des valeurs par défaut et ne sont précisés qu'au besoin.
Question 86
Que fait la déclaration `<version>${jackson.version}</version>` ?
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>${jackson.version}</version>
</dependency>${jackson.version} est une propriété Maven, généralement définie dans <properties> du POM (ou d'un parent) : on centralise la version pour tous les modules Jackson.
Question 87
À quoi sert le `<classifier>` (ex : `sources`) dans une dépendance ?
Le classifier distingue plusieurs artefacts produits sous le même GAV : le JAR principal, mais aussi -sources.jar, -javadoc.jar ou des variantes par plateforme.
Question 88
Quel est le principe fondamental du GitOps ?
En GitOps, l'état désiré (manifests) vit dans Git. Un contrôleur comme ArgoCD compare en continu cet état avec l'état réel du cluster et applique les différences — plus personne ne pousse de changements à la main.
Question 89
Comment ArgoCD détecte-t-il qu'un déploiement doit être mis à jour ?
ArgoCD fonctionne en mode pull : il scrute le dépôt Git (poll ou webhook), détecte les dérives entre l'état désiré et l'état réel, puis applique les changements dans le cluster.
Question 90
Que provoque cette syncPolicy dans une Application ArgoCD ?
syncPolicy:
automated:
prune: true
selfHeal: true`automated` active la synchronisation sans intervention, `prune` supprime les ressources qui n'existent plus dans Git, et `selfHeal` reverte toute modification faite directement sur le cluster : Git reste la seule source de vérité.
Question 91
Un opérateur modifie à la main le nombre de replicas d'un deployment géré par ArgoCD avec selfHeal activé. Que se passe-t-il ?
C'est l'auto-healing : toute dérive entre le cluster et Git est corrigée dans le sens Git → cluster. Pour changer les replicas durablement, il faut modifier le manifest dans le dépôt.
Question 92
Comment effectue-t-on un rollback avec une approche GitOps ?
Puisque Git décrit l'état désiré, revenir en arrière consiste à reverter le commit fautif : ArgoCD détecte le changement et ramène le cluster à l'état précédent. Un `kubectl rollout undo` manuel serait annulé par le selfHeal.
Question 93
Pourquoi le GitOps améliore-t-il la sécurité des déploiements ?
Le modèle pull supprime le besoin de distribuer des credentials kubectl au pipeline ou aux développeurs ; chaque changement est un commit versionné, revu et traçable.
Question 94
Dans le manifest Deployment de la fiche, à quoi servent les blocs resources.requests et resources.limits ?
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"Les requests servent au scheduler Kubernetes pour placer le pod sur un nœud disposant des ressources demandées ; les limits plafonnent la consommation (throttling CPU, OOMKill si la mémoire dépasse la limite).
Question 95
Quelles sont les 3 grandes familles de design patterns ?
Les patterns de création gèrent l'instanciation (Builder, Singleton, Factory), les structurels organisent classes et objets (Adapter, Decorator), les comportementaux gèrent les interactions (Chain of Responsibility).
Question 96
Dans quel cas le pattern Builder est-il particulièrement adapté ?
Le Builder assemble l'objet par appels chaînés (addCheese().addTomato().build()) : idéal quand un constructeur à multiples paramètres optionnels deviendrait illisible.
Question 97
Qu'affiche ce programme ?
Database db1 = Database.getInstance();
Database db2 = Database.getInstance();
System.out.println(db1 == db2);Le Singleton stocke l'unique instance dans un champ statique : le premier appel la crée, les suivants renvoient la même référence, donc db1 == db2 vaut true.
Question 98
Quelle est la faiblesse classique du Singleton « lazy » à base de `if (instance == null)` ?
Sans synchronisation, deux threads peuvent passer le test null en même temps. Les parades : méthode synchronisée, double-checked locking avec volatile, ou l'enum singleton.
Question 99
Quel est le rôle du pattern Factory ?
Le client demande `factory.getShape("CIRCLE")` et reçoit un Shape : il ne connaît ni les classes concrètes ni la logique d'instanciation, centralisées dans la factory.
Question 100
Vous devez faire fonctionner une classe legacy `OldPrinter.printText()` derrière une nouvelle interface `NewPrinter.print()`. Quel pattern utiliser ?
L'Adapter enveloppe l'objet existant et traduit les appels de la nouvelle interface vers l'ancienne API, sans modifier la classe legacy.
Question 101
Dans l'exemple Decorator, que renvoie `logged.send()` pour `new LoggedMessage(new EncryptedMessage(new SimpleMessage()))` ?
Message message = new SimpleMessage();
Message encrypted = new EncryptedMessage(message);
Message logged = new LoggedMessage(encrypted);
System.out.println(logged.send());Chaque décorateur enveloppe le précédent : LoggedMessage affiche le log puis délègue à EncryptedMessage, qui entoure le résultat de SimpleMessage. Les décorateurs s'empilent librement, c'est leur force.
Question 102
Dans une Chain of Responsibility, que se passe-t-il quand un handler ne sait pas traiter la requête ?
Chaque handler traite la requête ou la passe à `next`. Si toute la chaîne échoue, le dernier maillon peut signaler « Request not handled » — l'émetteur ignore qui a finalement traité sa requête.
Question 103
Qui est responsable de la gestion et de la priorisation du Product Backlog ?
Le PO définit la vision produit, gère le Product Backlog, priorise les fonctionnalités et fait l'interface avec les stakeholders.
Question 104
Quel est le rôle principal du Scrum Master ?
Le Scrum Master est un « servant leader » : il facilite, coache et lève les obstacles. Il ne dirige pas l'équipe — c'est un piège d'entretien classique.
Question 105
Quelle est la taille recommandée d'une Development Team Scrum ?
Une équipe de 3 à 9 personnes, pluridisciplinaire et auto-organisée, reste assez petite pour communiquer efficacement et assez grande pour livrer un incrément.
Question 106
Quelles sont les 3 questions traitées lors du Daily Scrum ?
Le daily (15 min) synchronise l'équipe autour de trois questions : fait hier, prévu aujourd'hui, obstacles. Keep/Stop/Start relève de la rétrospective.
Question 107
Quelle est la durée maximale recommandée du Sprint Planning pour un sprint de 2 semaines ?
Pour un sprint de 2 semaines, le Sprint Planning est limité à 4 heures (8 heures pour un sprint de 4 semaines). On y sélectionne les stories et on définit le Sprint Goal.
Question 108
Quelle différence entre Sprint Review et Sprint Retrospective ?
La Sprint Review porte sur l'incrément produit (démonstration, feedback des stakeholders, adaptation du backlog) ; la rétrospective porte sur la façon de travailler de l'équipe.
Question 109
Une équipe a terminé 23, 27 et 25 story points sur ses trois derniers sprints. Comment utiliser cette information ?
Sprint 1 : 23 points
Sprint 2 : 27 points
Sprint 3 : 25 pointsLa vélocité (moyenne des points terminés sur 3-5 sprints, ici 25) sert à planifier des sprints réalistes et à prévoir les livraisons — pas à mettre la pression ni à comparer des équipes.
Question 110
Pourquoi utilise-t-on l'échelle de Fibonacci (1, 2, 3, 5, 8, 13, 21…) pour les story points ?
Plus une story est grosse, moins l'estimation est précise : inutile de débattre entre 12 et 13 points. L'écart croissant de Fibonacci matérialise cette incertitude.
Question 111
Que mesure un story point ?
Le story point est relatif, pas absolu : on compare les stories entre elles selon la complexité, l'effort, l'incertitude et les dépendances — sans conversion en heures.
Question 112
Une story est estimée à 21 points ou plus. Que recommandent les bonnes pratiques ?
Au-delà de 13-21 points, l'incertitude est trop grande : la story doit être découpée en éléments plus petits, estimables et livrables dans un sprint.
Question 113
Au Planning Poker, pourquoi les cartes sont-elles révélées simultanément ?
Chacun choisit sa carte en secret puis révélation simultanée : personne n'est influencé par l'estimation d'un collègue (effet d'ancrage), et les écarts déclenchent une discussion.
Question 114
Lors d'un Planning Poker, les votes divergent fortement. Que fait l'équipe ?
Story : "Ajouter un système de notation produit"
Alice : 5 Bob : 8 Carol : 3 Dave : 5Les écarts révèlent des incompréhensions : Bob pensait à l'intégration des avis clients, Carol à une UI simple. Après clarification, l'équipe revote et converge (ici sur 5).
Question 115
Quel usage de la vélocité est un piège à éviter ?
Les points sont relatifs à chaque équipe : 25 points chez l'une ne valent pas 25 points chez l'autre. Comparer les équipes (ou mettre la pression sur la vélocité) pervertit l'outil.
Question 116
Combien de sprints faut-il généralement pour qu'une vélocité se stabilise et devienne fiable ?
On calcule la moyenne des points terminés sur 3 à 5 sprints : c'est le temps nécessaire pour lisser les variations (composition d'équipe, obstacles, apprentissage).
Question 117
Quelle technique est idéale pour estimer rapidement de gros epics sans entrer dans le détail ?
Le T-Shirt Sizing classe grossièrement par tailles (XS à XL) : parfait pour dégrossir des epics. Le Dot Voting sert plutôt à prioriser, et l'Affinity Estimation à traiter de gros backlogs par regroupement.
Question 118
Quelle est la différence entre une checked et une unchecked exception ?
Le compilateur impose de gérer (try-catch) ou de déclarer (throws) les checked exceptions comme IOException. Les RuntimeException et leurs sous-classes sont unchecked : leur gestion est optionnelle.
Question 119
NullPointerException est-elle une checked ou une unchecked exception ?
NullPointerException, comme IllegalArgumentException ou ClassCastException, hérite de RuntimeException : elle est unchecked et signale généralement une erreur de programmation.
Question 120
Quelle affirmation sur le bloc `finally` est correcte ?
finally est garanti de s'exécuter que le try réussisse, échoue ou fasse un return : c'est historiquement l'endroit du nettoyage (fermeture de ressources) avant le try-with-resources.
Question 121
Quelle condition doit remplir une classe pour être utilisée dans un try-with-resources ?
Le try-with-resources (Java 7+) appelle automatiquement close() à la sortie du bloc, y compris en cas d'exception : la ressource doit donc implémenter AutoCloseable.
Question 122
Ce code compile-t-il, et pourquoi ?
try {
riskyOperation();
} catch (Exception e) {
System.err.println("Erreur générale");
} catch (IOException e) {
System.err.println("Erreur I/O");
}Les catch sont évalués dans l'ordre : un catch (Exception) en premier rend le catch (IOException) inaccessible et le compilateur refuse (« exception has already been caught »). Il faut mettre les plus spécifiques d'abord.
Question 123
Que permet la syntaxe multi-catch `catch (NullPointerException | ArrayIndexOutOfBoundsException e)` ?
Le multi-catch (Java 7+) factorise la gestion commune de plusieurs exceptions sans lien d'héritage direct, en évitant les blocs catch dupliqués.
Question 124
Pourquoi ce code est-il considéré comme une mauvaise pratique ?
try {
return array[index];
} catch (ArrayIndexOutOfBoundsException e) {
return null;
}Les exceptions signalent des situations exceptionnelles. Un cas prévisible comme un index hors bornes se teste avec if (index < array.length) : c'est plus lisible et évite le coût de construction de l'exception.
Question 125
Comment choisir entre Exception et RuntimeException pour une exception personnalisée ?
Une checked exception (extends Exception, ex. InsufficientFundsException) force l'appelant à traiter un cas métier attendu ; une unchecked (extends RuntimeException, ex. InvalidEmailException) convient aux violations de contrat qu'on ne veut pas imposer dans chaque signature.
Question 126
Quelle est la différence fondamentale entre `git fetch` et `git pull` ?
Fetch met à jour les références distantes (origin/main) sans modifier votre branche locale ; pull enchaîne fetch puis merge (ou rebase), ce qui modifie la branche et le working directory.
Question 127
Après un `git fetch origin`, qu'est-ce qui a changé dans votre dépôt local ?
Fetch télécharge les nouveaux commits et avance les références remote (origin/main), mais n'affecte ni votre branche locale ni votre working directory : c'est ce qui le rend sans risque.
Question 128
À quelle séquence de commandes `git pull origin main` est-il équivalent ?
git pull origin main
# Équivalent à :
???Pull n'est qu'un raccourci : un fetch pour télécharger les commits, suivi d'un merge de origin/main dans la branche courante (ou d'un rebase avec `git pull --rebase`).
Question 129
Vous avez fait un `git fetch origin`. Quelle commande permet de voir les commits reçus du remote avant de les intégrer ?
La plage `main..origin/main` liste les commits présents sur origin/main mais pas encore dans main : exactement ce qui serait intégré par un merge. C'est le grand intérêt du fetch : inspecter avant d'intégrer.
Question 130
Dans quel cas fetch est-il préférable à pull ?
Fetch donne un contrôle total : on voit d'abord ce qui arrive, puis on choisit quand et comment intégrer. Pull convient plutôt aux synchronisations rapides sans risque de conflit.
Question 131
Quel est le principal risque d'un `git pull` lancé sans précaution ?
Comme pull enchaîne fetch + merge sans étape d'inspection, il peut déclencher des conflits (ou un commit de merge non désiré) au milieu de votre travail — d'où la recommandation de fetch d'abord sur les features importantes.
Question 132
Que fait `git pull --rebase` par rapport à un `git pull` classique ?
Avec --rebase, l'étape d'intégration est un rebase au lieu d'un merge : vos commits locaux sont rejoués au-dessus de ceux du remote, ce qui évite les commits de merge et garde un historique linéaire.
Question 133
Que signifie la valeur « Les individus et leurs interactions plus que les processus et les outils » du Manifeste Agile ?
Le manifeste ne rejette pas les éléments de droite (processus, outils, documentation, plans) : il indique simplement que ceux de gauche ont davantage de valeur.
Question 134
Combien de valeurs fondamentales compte le Manifeste Agile ?
Le Manifeste Agile repose sur 4 valeurs (individus, logiciels opérationnels, collaboration client, adaptation au changement). Les 12, ce sont ses principes — un piège classique.
Question 135
Quel est le principal problème du cycle en V pointé par l'approche agile ?
Avec des phases séquentielles, des spécifications figées et des tests en fin de cycle, les problèmes et le retour client arrivent tard — d'où un risque de non-adéquation au besoin.
Question 136
Quelle caractéristique distingue Kanban de Scrum ?
Kanban organise le travail en flux continu : on visualise le flux et on limite le travail en cours (WIP), sans itérations fixes, contrairement aux sprints de Scrum.
Question 137
Quelles pratiques sont au cœur d'eXtreme Programming (XP) ?
XP se concentre sur les pratiques techniques : pair programming, TDD, intégration continue et refactoring. Les cérémonies relèvent de Scrum, le WIP de Kanban.
Question 138
En agilité, comment les exigences sont-elles traitées par rapport au cycle en V ?
Là où le cycle en V fige les spécifications au départ, l'agilité accepte l'évolution continue des exigences et s'adapte rapidement aux changements grâce aux itérations courtes.
Question 139
Quel avantage l'approche agile tire-t-elle de ses livraisons fréquentes ?
Livrer fréquemment permet d'obtenir un retour rapide du client, de corriger le tir tôt et donc de réduire le risque de construire un produit inadapté.
Question 140
Quel est le principal avantage des génériques introduits en Java 5 ?
Sans génériques, un mauvais cast provoquait une ClassCastException à l'exécution. Avec List<String>, ajouter un Integer est refusé dès la compilation et les casts deviennent inutiles.
Question 141
Que signifie la contrainte dans `public static <T extends Comparable<T>> T max(T a, T b)` ?
Le bounded type parameter <T extends Comparable<T>> restreint T aux types comparables entre eux : le compilateur autorise alors l'appel a.compareTo(b) dans le corps de la méthode.
Question 142
Selon la règle PECS, quand utiliser `? extends T` ?
PECS : Producer Extends, Consumer Super. Une List<? extends Number> produit des Number qu'on peut lire, mais on ne peut rien y écrire car son type exact est inconnu.
Question 143
Pourquoi cette ligne ne compile-t-elle pas ?
public static double sum(List<? extends Number> numbers) {
numbers.add(Integer.valueOf(5)); // ERREUR
...
}Avec ? extends Number, le type réel de la liste est inconnu (Integer ? Double ?). Pour préserver la type safety, le compilateur interdit toute écriture (sauf null).
Question 144
Que peut-on faire avec un paramètre `List<? super Integer> list` ?
Consumer Super : la liste est typée Integer, Number ou Object, donc y écrire un Integer est toujours sûr. En lecture, on ne peut garantir que le type Object.
Question 145
Qu'affiche ce code, et pourquoi ?
List<String> stringList = new ArrayList<String>();
List<Integer> intList = new ArrayList<Integer>();
System.out.println(stringList.getClass() == intList.getClass());Par type erasure, les paramètres génériques n'existent que pour le compilateur. Dans le bytecode, List<String> et List<Integer> deviennent le même type brut ArrayList : les deux getClass() sont identiques.
Question 146
Pourquoi ne peut-on pas écrire `new T()` dans une classe générique, et quelle est la solution classique ?
À l'exécution, T n'existe plus (type erasure) : la JVM ne sait pas quel constructeur appeler. La solution est de fournir explicitement un Class<T> (ex : Factory(Class<T> type)) et d'instancier par réflexion.
Question 147
Quel est le rôle de l'environnement de staging par rapport à la production ?
Le staging est l'antichambre de la production : tests d'intégration, validation métier et tests de performance, sur des données proches de la prod mais sans utilisateurs réels.
Question 148
Dans la stratégie « branches par environnement », quel est le flux de promotion du code ?
Le code monte par merges successifs : la feature est intégrée dans develop (DEV), promue vers staging (STAGING), puis vers main (PRODUCTION), chaque branche étant liée à un déploiement.
Question 149
Quel est un inconvénient connu de la stratégie « branches par environnement » ?
Multiplier les branches longue durée impose de les maintenir synchronisées : conflits lors des promotions, hotfixes à propager dans plusieurs branches, risque de divergence entre environnements.
Question 150
Dans la stratégie par tags, que déclenche cette séquence ?
git tag v1.3.0-rc.1
git push origin v1.3.0-rc.1Le format `-rc.N` (release candidate) est réservé au staging : la CI détecte le tag poussé et déploie cette version en staging pour les tests d'intégration. Le tag final `v1.3.0` ira, lui, en production.
Question 151
Dans la stratégie par tags, comment gérer un hotfix sur la version v1.3.0 en production ?
On se positionne sur l'état exact de la prod (`git checkout v1.3.0`), on corrige sur une branche hotfix, puis on publie un nouveau tag `v1.3.1` : les tags restent immuables et traçables.
Question 152
Avec des feature flags configurés par environnement, quel est le grand avantage en cas de problème en production ?
Le code problématique reste déployé mais inactif : basculer le flag à false le désactive immédiatement, sans pipeline de redéploiement ni revert. C'est aussi ce qui permet l'A/B testing et les tests sur un public limité.
Question 153
D'après cette configuration, que renvoie `featureService.isEnabled('BETA_UI', 'staging')` ?
const config = {
development: { NEW_FEATURE: true, BETA_UI: true },
staging: { NEW_FEATURE: true, BETA_UI: false },
production: { NEW_FEATURE: false, BETA_UI: false }
};
return config[environment][feature] || false;La configuration est lue par environnement : en staging, BETA_UI vaut false. Chaque environnement active progressivement moins de flags à mesure qu'on s'approche de la production.
Question 154
Quelle stratégie de gestion des environnements recommander à une équipe junior ?
Les branches par environnement offrent un cadre visuel et strict (une branche = un environnement) plus facile à suivre pour une équipe junior ; tags + flags et l'automatisation poussée conviennent aux équipes expérimentées.
Question 155
Pourquoi centraliser les secrets dans un outil comme HashiCorp Vault plutôt que dans des variables d'environnement ou le code ?
Un coffre central chiffre les secrets, limite qui peut lire quoi via des politiques, journalise chaque accès et facilite la rotation — autant de choses impossibles avec des secrets copiés dans le code ou des fichiers .env.
Question 156
Que permet cette politique Vault ?
path "secret/data/scpi-invest/*" {
capabilities = ["read"]
}Les politiques Vault suivent le principe du moindre privilège : ici, le porteur du token ne peut que lire (`read`) les secrets sous ce chemin précis, rien d'autre.
Question 157
Quelle méthode d'authentification Vault est adaptée à un pod tournant dans un cluster Kubernetes ?
Kubernetes Auth permet au pod de prouver son identité avec le token de son Service Account : pas de credential à provisionner à la main. LDAP/OIDC sont pour les humains, AppRole pour les applications et la CI/CD.
Question 158
Comment fonctionne le Vault Agent Injector ?
Grâce aux annotations `vault.hashicorp.com/agent-inject`, un sidecar s'authentifie auprès de Vault, rend le template et écrit le résultat dans un volume partagé ; l'application le lit au démarrage (`source /vault/secrets/db`).
Question 159
Quel est le rôle de l'External Secrets Operator par rapport à Vault ?
L'ExternalSecret référence un SecretStore (Vault) et crée/actualise un Secret Kubernetes (ici `db-credentials`) selon le `refreshInterval` : les applications consomment des Secrets natifs sans parler directement à Vault.
Question 160
Dans l'ExternalSecret de la fiche, que signifie `refreshInterval: 15s` ?
spec:
refreshInterval: 15s
secretStoreRef:
name: vault-backend
kind: SecretStore
target:
name: db-credentialsLe `refreshInterval` est la fréquence de resynchronisation : une rotation du secret dans Vault est répercutée dans le Secret Kubernetes cible en au plus 15 secondes.
Question 161
Quel est le risque si une clé d'API est commitée dans un dépôt Git, même supprimée ensuite ?
Supprimer un fichier ne retire pas le contenu des commits passés : quiconque clone le dépôt peut retrouver la clé. La seule réponse correcte est la rotation immédiate du secret — d'où l'intérêt de ne jamais les mettre dans Git.
Question 162
Quelle est la différence fondamentale entre merge et rebase ?
Merge crée un commit de fusion qui relie les deux branches et préserve l'historique réel ; rebase rejoue les commits au-dessus de la cible et produit un historique linéaire, mais réécrit.
Question 163
Que se passe-t-il exactement lors d'un `git rebase main` depuis une branche feature ?
Le rebase « rejoue » chaque commit de la branche au-dessus de la cible : les commits D et E deviennent D' et E', de nouveaux commits avec le même contenu mais un autre parent (et un autre SHA).
Question 164
Pourquoi dit-on que le rebase est « dangereux » ?
Les commits rejoués ont de nouveaux SHA. Si la branche était déjà poussée, l'historique distant et les copies locales des collègues divergent — d'où la règle d'or : ne jamais rebaser une branche partagée.
Question 165
Dans quel cas le merge est-il préférable au rebase ?
Le merge est non destructif et conserve la trace réelle du travail : c'est le bon choix pour les branches partagées, les releases, et les équipes hétérogènes.
Question 166
Quelle séquence de commandes intègre proprement main dans votre feature avec un rebase ?
git checkout ???
git rebase ???On se place sur la branche à rebaser (la feature), puis on la rejoue au-dessus de la cible : `git rebase main` depuis la feature.
Question 167
Après un rebase, les commits D et E deviennent D' et E'. Qu'ont-ils de différent ?
Un commit est identifié par un SHA calculé notamment à partir de son parent : rejoué sur un nouveau parent, le « même » commit devient un nouveau commit avec un nouveau SHA.
Question 168
Votre équipe veut un historique linéaire sur main tout en travaillant sur des branches de feature. Quelle pratique est cohérente ?
Le pattern courant « rebase then merge » : on rebase sa feature personnelle sur main juste avant l'intégration, ce qui permet un merge fast-forward et un historique linéaire.
Question 169
Quelles sont les trois phases d'une stratégie de migration Java ?
On commence par analyser le code existant (dépendances, APIs dépréciées), puis on planifie (roadmap, risques), et enfin on exécute une migration progressive avec tests et validation.
Question 170
Quel outil du JDK permet de détecter les APIs dépréciées destinées à être supprimées ?
`jdeprscan --for-removal myapp.jar` liste les usages d'APIs dépréciées marquées pour suppression ; jdeps, lui, analyse les dépendances.
Question 171
Que fait cette commande ?
jdeps --list-deps myapp.jarjdeps est l'outil d'analyse statique des dépendances du JDK : il liste les modules et packages requis par l'application, une étape clé de l'audit avant migration.
Question 172
Votre application utilise `javax.xml.bind` et casse en passant à Java 11. Quelle est la solution ?
Les modules Java EE (JAXB, activation…) ont été retirés du JDK en Java 11 : il faut les ajouter comme dépendances Maven/Gradle explicites.
Question 173
À quoi sert l'option `--add-opens` lors d'une migration ?
java --add-opens java.base/java.lang=ALL-UNNAMED MyAppLe système de modules (Java 9+) restreint l'accès par réflexion aux internals du JDK ; --add-opens ouvre un package d'un module aux classes du classpath (ALL-UNNAMED).
Question 174
Quel garbage collector est devenu le GC par défaut depuis Java 9 ?
G1GC est le GC par défaut depuis Java 9. On peut revenir à l'ancien avec -XX:+UseParallelGC, ou adopter les GC à faible latence comme ZGC (Java 11+) ou Shenandoah.
Question 175
Quel élément fait partie de la checklist AVANT la migration ?
Avant de migrer : audit du code, tests de régression, backup et plan de rollback. Les tests de performance, le monitoring renforcé et la formation viennent après la migration.
Question 176
Quel est le rôle de chaque composant dans la stack Prometheus/Grafana/Alert Manager ?
Prometheus scrape les métriques et les stocke dans sa TSDB ; Grafana interroge Prometheus via son API pour tracer les dashboards ; Alert Manager reçoit les alertes déclenchées par les règles Prometheus et les route vers email/SMS/Teams.
Question 177
Comment Prometheus récupère-t-il les métriques des applications ?
Prometheus fonctionne en pull : selon le `scrape_interval` (10 s dans la fiche), il appelle l'endpoint de métriques de chaque cible déclarée dans `scrape_configs` — `/actuator/prometheus` pour une app Spring Boot.
Question 178
Que calcule cette requête PromQL ?
rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m]) * 100On divise le débit des requêtes dont le status matche 5.. (500, 502, 503…) par le débit total sur une fenêtre de 5 minutes, multiplié par 100 : c'est le taux d'erreur serveur en pourcentage.
Question 179
Pourquoi utiliser `histogram_quantile(0.95, ...)` plutôt qu'une moyenne pour suivre le temps de réponse ?
Une moyenne peut rester bonne alors que 5 % des utilisateurs subissent des temps de réponse catastrophiques. Le p95 dit : « 95 % des requêtes sont plus rapides que cette valeur » — bien plus représentatif de l'expérience réelle.
Question 180
À quoi sert le Node Exporter dans cette architecture ?
Le Node Exporter tourne sur chaque nœud et expose les métriques système (node_cpu_seconds_total, node_memory_MemAvailable_bytes…) sur le port 9100, que Prometheus scrape comme n'importe quelle cible.
Question 181
Dans la configuration de la fiche, à quoi sert le bloc `kubernetes_sd_configs` avec `role: node` ?
- job_name: 'kubernetes-nodes'
kubernetes_sd_configs:
- role: node
relabel_configs:
- source_labels: [__address__]
regex: '(.*):10250'
target_label: __address__
replacement: '${1}:9100'La service discovery Kubernetes énumère dynamiquement les nœuds (inutile de maintenir une liste statique), et le relabeling réécrit l'adresse découverte (port kubelet 10250) vers le port 9100 où écoute le Node Exporter.
Question 182
Quelles sont les quatre familles de métriques citées dans la fiche ?
Un monitoring complet couvre plusieurs niveaux : les métriques applicatives et système pour la santé technique, les métriques base de données pour les dépendances, et les métriques business pour vérifier que le service rend réellement service.
Question 183
Quelle est la visibilité d'un membre déclaré `protected` ?
protected combine la visibilité package-private (tout le package) et l'accès depuis les sous-classes, même situées dans un autre package.
Question 184
Qu'affiche ce code ?
public class Counter {
private static int count = 0;
public Counter() { count++; }
public static int getCount() { return count; }
}
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.getCount());count est une variable de classe (static) partagée par toutes les instances : chaque constructeur l'incrémente, et la méthode statique s'appelle directement sur la classe, sans instance.
Question 185
Que se passe-t-il avec `final List<String> list = new ArrayList<>();` si on appelle ensuite `list.add("item")` ?
final interdit seulement la réassignation de la référence (list = new ArrayList<>() échouerait). L'objet pointé reste modifiable : add() est parfaitement légal.
Question 186
Depuis Java 8, que peut contenir une interface en plus des méthodes abstraites ?
Java 8 introduit les méthodes default (implémentation héritée par les classes qui implémentent l'interface) et les méthodes static. Une interface n'a en revanche ni constructeur ni état d'instance.
Question 187
Que garantit le mot-clé `synchronized` sur une méthode ?
synchronized pose un verrou (sur this pour une méthode d'instance) : les autres threads attendent que le verrou soit libéré, ce qui garantit l'exclusion mutuelle.
Question 188
Un champ `volatile int count` est incrémenté avec `count++` par plusieurs threads. Est-ce thread-safe ?
volatile assure que chaque thread voit la dernière valeur écrite, mais count++ reste trois opérations distinctes : deux threads peuvent lire la même valeur et écraser mutuellement leur incrément. Il faut synchronized ou AtomicInteger.
Question 189
Pourquoi une méthode static ne peut-elle pas accéder directement à une variable d'instance ?
Une méthode static s'exécute au niveau de la classe : il n'y a pas de this, donc pas d'instance dont lire les champs. Elle ne peut accéder qu'aux membres static.
Question 190
Quel est le rôle du Navigator en pair programming ?
Le Driver tient le clavier et gère les détails tactiques ; le Navigator prend du recul : direction, stratégie, détection des problèmes et suggestions.
Question 191
À quelle fréquence les rôles Driver et Navigator doivent-ils tourner ?
La rotation régulière (15-30 min) maintient l'engagement des deux partenaires et évite qu'une personne domine la session.
Question 192
Qu'est-ce que le Ping-Pong Pairing ?
Le Ping-Pong Pairing combine pair programming et TDD : l'un écrit un test qui échoue, l'autre le fait passer, et les rôles alternent naturellement.
Question 193
En quoi consiste le Strong-Style Pairing ?
Dans le Strong-Style, toute idée doit passer par les mains de l'autre : le Navigator dirige la réflexion, le Driver traduit au clavier sans initiative propre — très utile pour le transfert de connaissances.
Question 194
Que répondre à un manager qui objecte que le pair programming « coûte deux développeurs pour une tâche » ?
Le coût n'est qu'apparent : la qualité du code, la détection immédiate des erreurs, le partage de connaissances et la vitesse sur les tâches complexes produisent un retour sur investissement positif.
Question 195
Comment prévenir la fatigue mentale liée au pair programming ?
Le pairing demande une concentration intense : sessions courtes (2-4 h max), rotation des rôles toutes les 15-30 min et pauses de 10-15 minutes toutes les heures.
Question 196
Pour quel type de tâche le pair programming apporte-t-il le PLUS de valeur ?
Le pairing brille sur les tâches complexes ou à fort enjeu : algorithmes, architecture critique, bugs difficiles, sécurité et paiements — ainsi que pour l'onboarding et le transfert de connaissances.
Question 197
Dans quel ordre s'enchaînent les stages essentiels d'un pipeline CI/CD ?
On récupère d'abord le code, on le valide (tests unitaires puis intégration), et seulement ensuite on construit l'image, on la publie sur le registry et on déploie. Tester avant de builder évite de publier des images cassées.
Question 198
Pourquoi les tests unitaires s'exécutent-ils avant les tests d'intégration dans le pipeline ?
Principe du « fail fast » : les tests unitaires ne demandent aucune infrastructure et détectent la majorité des régressions en quelques secondes, alors que les tests d'intégration démarrent des services (PostgreSQL, Redis, docker-compose).
Question 199
Que fait cette étape du pipeline ?
docker build -t app:${{ github.sha }} .
docker tag app:${{ github.sha }} app:latestUne seule image est construite, identifiée de manière unique par le SHA du commit ; `docker tag` lui ajoute un alias `latest`. Le tag SHA garantit la traçabilité et permet de rollbacker vers une version précise.
Question 200
Dans la configuration GitLab CI de la fiche, quelle différence y a-t-il entre le déploiement staging et le déploiement production ?
`only: develop` vs `only: main` sélectionnent la branche déclencheuse, et `when: manual` sur la production impose une validation humaine avant la mise en production — un garde-fou classique.
Question 201
À quoi sert la commande `kubectl rollout status deployment/app` après un `kubectl set image` ?
`rollout status` bloque jusqu'à ce que le rollout aboutisse (ou échoue). Sans elle, le job du pipeline passerait au vert même si les nouveaux pods ne démarrent jamais.
Question 202
Quel est l'intérêt de déclarer `services: postgres:13, redis:6` dans le job de tests d'intégration GitLab CI ?
Les `services` GitLab CI démarrent des conteneurs jetables à côté du job : les tests d'intégration s'exécutent contre une vraie base et un vrai cache, puis tout est détruit à la fin du job.
Question 203
Où l'image Docker est-elle publiée à l'étape « Push Registry » ?
Le registry (Docker Hub, Harbor, ECR…) est le dépôt central des images : Kubernetes viendra y télécharger l'image référencée par le deployment au moment du déploiement.
Question 204
Qu'est-ce qu'un plugin Maven ?
Les plugins ajoutent des fonctionnalités à Maven : chacun expose des goals rattachés aux phases du cycle de vie et se configure dans le POM. Tout le travail réel de Maven est fait par des plugins.
Question 205
Quel plugin core exécute les tests unitaires ?
maven-surefire-plugin est lié à la phase test et exécute les tests unitaires (par défaut les classes *Test / *Tests). maven-test-plugin et maven-junit-plugin n'existent pas — distracteurs classiques.
Question 206
Que configure ce bloc XML ?
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.11.0</version>
<configuration>
<source>17</source>
<target>17</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>Le maven-compiler-plugin compile le code : source = version du langage acceptée, target = version du bytecode produit, encoding = encodage des fichiers. 3.11.0 est la version du plugin, pas de Maven.
Question 207
Quelle est la différence entre un build plugin et un reporting plugin ?
On distingue les build plugins (exécutés pendant le build, déclarés dans <build>) des reporting plugins (génération de rapports, typiquement pour le site du projet).
Question 208
Quel plugin permet de définir la classe principale (Main-Class) du manifeste d'un JAR exécutable ?
maven-jar-plugin crée l'archive JAR et permet de configurer le manifeste, notamment la mainClass. install et deploy ne font que copier l'artefact vers les repositories.
Question 209
Avec la configuration Surefire ci-dessous, quelles classes de test seront exécutées ?
<configuration>
<includes>
<include>**/*Test.java</include>
<include>**/*Tests.java</include>
</includes>
</configuration>Les patterns includes filtrent par nom de fichier : ici les classes se terminant par Test.java ou Tests.java, quel que soit leur package (**/).
Question 210
À quelle phase du cycle de vie le goal du maven-clean-plugin est-il naturellement lié ?
Chaque plugin core est rattaché à une phase : clean pour maven-clean-plugin, compile pour le compiler, test pour Surefire, jar pour package, install et deploy pour les plugins du même nom.
Question 211
Quels sont les 4 piliers de la POO ?
Les 4 piliers sont l'encapsulation (masquer l'implémentation), l'héritage (réutiliser le code), le polymorphisme (une interface, plusieurs implémentations) et l'abstraction (simplifier la complexité).
Question 212
Pourquoi déclarer `balance` en private et n'y accéder que via des méthodes ?
public class BankAccount {
private double balance;
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
}C'est l'encapsulation : l'état interne est masqué et tout accès passe par des méthodes qui peuvent valider (ici, refuser un montant négatif) — l'invariant de la classe est protégé.
Question 213
Qu'illustre ce code ?
Shape shape = new Circle(5);
double area = shape.area();La variable est typée Shape mais référence un Circle : à l'exécution, c'est le area() de Circle qui est appelé. C'est le polymorphisme (dispatch dynamique), à ne pas confondre avec la surcharge.
Question 214
Quelle est la différence clé entre une classe abstraite et une interface en Java ?
La classe abstraite porte de l'état (attributs, constructeur) et du code concret, mais une classe ne peut en étendre qu'une seule. L'interface est un contrat : implémentation multiple possible, et méthodes default depuis Java 8.
Question 215
Qu'est-ce qu'une méthode `default` dans une interface ?
public interface Electric {
void charge();
default void showBatteryLevel() {
System.out.println("Battery: 80%");
}
}Depuis Java 8, une interface peut fournir une implémentation par défaut : les classes implémentantes en héritent sans être obligées de la redéfinir.
Question 216
Pourquoi préférer la composition à l'héritage ?
La composition assemble des comportements par délégation (Car possède un Engine) sans figer une hiérarchie : moins de couplage, plus de flexibilité. L'héritage se réserve aux vraies relations « is-a ».
Question 217
Dans ce code, que fait l'appel `super.start()` ?
public class SportsCar extends Car {
@Override
public void start() {
super.start();
System.out.println("Turbo activated!");
}
}`super.start()` invoque l'implémentation héritée de la classe mère : la méthode redéfinie étend le comportement du parent au lieu de le remplacer entièrement.
Question 218
Que renvoie `car1.equals(car2)` pour deux objets Car créés séparément, sans redéfinition de equals ?
Car car1 = new Car("Toyota", "Camry", 2023);
Car car2 = new Car("Honda", "Civic", 2022);
System.out.println(car1.equals(car2));Sans redéfinition, equals() hérite du comportement d'Object : comparaison de références (comme ==). Deux instances distinctes renvoient donc false, même à contenu identique.
Question 219
Que signifie le S de SOLID (Single Responsibility Principle) ?
SRP ne compte pas les méthodes mais les responsabilités : si une classe gère données, validation, persistance et notification, quatre raisons différentes peuvent la faire changer.
Question 220
Une classe User contient setName(), isValidEmail(), saveToDatabase() et sendWelcomeEmail(). Quel principe est violé et comment corriger ?
Quatre responsabilités cohabitent (données, validation, persistance, notification). On les sépare en classes dédiées : chacune n'a plus qu'une raison de changer.
Question 221
Comment le pattern Strategy aide-t-il à respecter le principe Open/Closed ?
Avec une interface DiscountStrategy et une classe par type de remise, ajouter GOLD = créer GoldCustomerDiscount. La chaîne de if/else, elle, obligeait à modifier la méthode à chaque nouveau type.
Question 222
Quel principe SOLID ce code viole-t-il ?
class Penguin extends Bird {
@Override
public void fly() {
throw new UnsupportedOperationException("Penguins cannot fly!");
}
}Tout code qui appelle bird.fly() explose si on lui passe un Penguin : la sous-classe ne respecte pas le contrat de la classe de base. La solution : restructurer la hiérarchie (FlyingBird / SwimmingBird avec move()).
Question 223
Quel est le signe d'alerte typique d'une violation de l'Interface Segregation Principle ?
Quand Designer doit implémenter code() et test() qu'il ne supporte pas, l'interface Worker est trop large : il faut la découper en interfaces fines (Workable, Codable, Designable…).
Question 224
Que recommande le Dependency Inversion Principle ?
NotificationManager ne doit pas faire `new EmailService()` : il reçoit des implémentations de l'interface NotificationService par injection, ce qui permet d'en changer et de tester avec des mocks.
Question 225
Pourquoi l'injection de dépendances facilite-t-elle les tests unitaires ?
Puisque la classe reçoit ses dépendances (au lieu de les créer), le test peut lui fournir des doublures contrôlées et vérifier le comportement en isolation.
Question 226
Vous voyez une longue chaîne de if/else sur un champ `customerType` pour calculer une remise. Quels principes sont menacés ?
La méthode doit être rouverte à chaque nouveau type (violation OCP) et concentre toutes les règles de remise (SRP fragilisé). Le duo interface + implémentations par type corrige les deux.
Question 227
Quelle est la définition du refactoring selon Martin Fowler ?
Le refactoring change la structure interne (lisibilité, conception) mais jamais le comportement externe : le code fait exactement la même chose après qu'avant.
Question 228
Que dit la « règle des 3 » ?
La règle des 3 tolère une duplication ponctuelle : c'est à la troisième occurrence du même code ou du même irritant qu'il faut refactoriser.
Question 229
Quelle est la règle d'or avant tout refactoring ?
Ne jamais refactoriser sans tests automatisés : ils détectent immédiatement toute régression et garantissent que le comportement externe reste inchangé.
Question 230
Vous devez refactoriser du code legacy qui n'a aucun test. Quelle est la première étape recommandée ?
Les tests de caractérisation figent le comportement existant (même s'il est imparfait) et créent le filet de sécurité indispensable avant de toucher au code.
Question 231
Cette méthode enchaîne validation, calcul et sauvegarde dans un seul bloc. Quelle technique de refactoring s'applique en premier ?
public void processOrder(Order order) {
// Validation
if (order.getItems().isEmpty()) { throw new IllegalArgumentException("Order is empty"); }
// Calcul du total
double total = 0;
for (OrderItem item : order.getItems()) {
total += item.getPrice() * item.getQuantity();
}
order.setTotal(total);
// Sauvegarde
orderRepository.save(order);
}Les commentaires « Validation », « Calcul », « Sauvegarde » signalent des blocs à extraire : validateOrder(), calculateTotal() et saveAndNotify() rendent la méthode principale lisible.
Question 232
Quel problème résout la technique « Replace Conditional with Polymorphism » ?
Au lieu de tester le type (PREMIUM, GOLD, SILVER…) dans une cascade de conditions, chaque type implémente l'interface et porte sa propre règle : ajouter un type n'exige plus de modifier la condition.
Question 233
Lequel de ces comportements est un piège classique du refactoring ?
Une chose à la fois : mélanger refactoring et features rend impossible de savoir si une régression vient de la restructuration ou du nouveau comportement, et complique la revue.
Question 234
Quelle est la différence fondamentale entre `git reset` et `git revert` ?
Reset fait « disparaître » des commits en déplaçant HEAD (historique réécrit) ; revert ajoute un commit C' qui inverse les changements de C, sans toucher à l'historique existant.
Question 235
Que se passe-t-il après cette commande si le dernier commit contenait des modifications ?
git reset --soft HEAD~1--soft déplace HEAD en arrière mais conserve l'index : les fichiers du commit annulé restent « staged », ce qui est pratique pour recommitter différemment (squash manuel, correction de message).
Question 236
Quel mode de reset est utilisé par défaut si aucune option n'est précisée ?
Sans option, `git reset` est en mode --mixed : le commit est annulé et les fichiers reviennent dans le working directory, mais retirés de la staging area.
Question 237
Pourquoi `git reset --hard HEAD~1` est-il considéré comme dangereux ?
--hard écrase l'index et le working directory : les modifications non sauvegardées ailleurs sont perdues. Sur une branche partagée, la réécriture d'historique pose en plus un problème de synchronisation.
Question 238
Un bug a été introduit par le commit C, déjà poussé sur la branche partagée main. Quelle est la bonne façon de l'annuler ?
Sur une branche partagée, on ne réécrit pas l'historique : revert crée un nouveau commit qui inverse les changements, solution sécurisée et traçable.
Question 239
Que fait `git cherry-pick <commit-hash>` ?
Cherry-pick copie un commit précis (par exemple E d'une feature) sur la branche courante sous forme d'un nouveau commit E'. Utile pour les hotfixes, mais attention aux doublons si la branche est mergée ensuite.
Question 240
Vous devez changer de branche en urgence mais vous avez des modifications non commitées, y compris un fichier nouvellement créé non tracké. Que faire ?
Le stash met de côté les modifications trackées ; l'option -u (--include-untracked) est nécessaire pour embarquer aussi les nouveaux fichiers non suivis.
Question 241
Quelle est la différence entre `git stash pop` et `git stash apply` ?
pop = apply + drop : les changements sont restaurés puis l'entrée est retirée du stash. apply (par exemple `git stash apply stash@{0}`) restaure sans supprimer, ce qui permet de réappliquer le même stash ailleurs.
Question 242
À quoi sert Spring Boot Actuator ?
Actuator expose des endpoints de monitoring et de gestion (santé, métriques, environnement, loggers…) sans code supplémentaire : c'est l'outillage de production de Spring Boot.
Question 243
Que renvoie l'endpoint `/actuator/health` ?
/actuator/health agrège des indicateurs de santé (UP/DOWN) de l'application et de ses dépendances. C'est typiquement l'endpoint utilisé par les load balancers et Kubernetes pour les probes.
Question 244
Quel endpoint consultez-vous pour analyser un blocage de threads (deadlock suspecté) en production ?
/actuator/threaddump renvoie l'état de tous les threads de la JVM (stack traces, verrous), ce qui permet de diagnostiquer blocages et deadlocks. /actuator/heapdump joue le même rôle pour la mémoire.
Question 245
Que fait cette configuration ?
management:
endpoints:
web:
exposure:
include: prometheusexposure.include contrôle quels endpoints Actuator sont exposés en HTTP. Avec la dépendance micrometer-registry-prometheus, /actuator/prometheus publie les métriques au format attendu par le scraping Prometheus.
Question 246
Pourquoi ne faut-il pas exposer tous les endpoints Actuator publiquement en production ?
/actuator/env peut exposer variables d'environnement et secrets, et /actuator/shutdown (POST) arrête l'application. On n'expose que le nécessaire via exposure.include et on protège le reste (réseau, authentification).
Question 247
Quelle particularité a l'endpoint `/actuator/shutdown` par rapport aux autres ?
C'est un endpoint d'action, pas de lecture : on l'appelle en POST et il arrête proprement l'application. Vu sa dangerosité, il est désactivé par défaut et doit rester strictement protégé.
Question 248
Quel est le rôle de l'encoder Logstash dans la configuration Logback pour la stack ELK ?
La stack ELK (Elasticsearch, Logstash, Kibana) exploite des logs structurés : l'encoder LoggingEventCompositeJsonEncoder produit du JSON avec des champs normalisés, bien plus facile à indexer et à requêter que du texte brut.
Question 249
Vous voulez passer un logger en DEBUG en production sans redémarrer l'application. Quel endpoint le permet ?
/actuator/loggers est en lecture ET écriture : un POST sur /actuator/loggers/{nom} change le niveau du logger à chaud, sans redéploiement — précieux pour diagnostiquer un incident en production.
Question 250
Quel problème la programmation orientée aspect (AOP) résout-elle ?
L'AOP isole les préoccupations transversales dans des aspects : au lieu de répéter le code de logging ou de gestion de transaction dans chaque méthode, on le déclare une fois et il s'applique aux points sélectionnés.
Question 251
Quelle est la différence entre un Join Point, un Pointcut et un Advice ?
Le join point est un endroit possible d'interception (exécution d'une méthode), le pointcut est l'expression qui dit LESQUELS intercepter, et l'advice est le code QUI s'exécute (avant, après, autour).
Question 252
Que sélectionne cette expression de pointcut ?
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}Dans execution(* com.example.service.*.*(..)), le premier * est le type de retour (n'importe lequel), le deuxième la classe, le troisième la méthode, et (..) accepte tout nombre d'arguments. Le pointcut couvre donc toute la couche service.
Question 253
Quel type d'advice choisir pour mesurer le temps d'exécution d'une méthode ?
@Around est le seul advice qui entoure l'appel : on capture le temps avant et après joinPoint.proceed(), et on peut même modifier le résultat ou intercepter l'exception. @Before et @After seuls ne partagent pas d'état entre eux.
Question 254
Dans un advice @Around, que se passe-t-il si vous oubliez d'appeler `joinPoint.proceed()` ?
@Around("serviceLayer()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
logger.info("Method started");
return null; // proceed() jamais appelé
}C'est proceed() qui déclenche l'exécution de la méthode interceptée. Sans cet appel, l'appelant reçoit la valeur retournée par l'advice (ici null) et le code métier ne tourne jamais — un bug silencieux classique.
Question 255
Quelle est la différence entre @After et @AfterReturning ?
@After est comme un finally : il s'exécute que la méthode réussisse ou lève une exception. @AfterReturning ne s'exécute qu'en cas de retour normal (et peut accéder à la valeur retournée) ; @AfterThrowing couvre le cas de l'exception.
Question 256
À quoi sert l'annotation @EnableAspectJAutoProxy sur une classe de configuration ?
Spring AOP fonctionne par proxys : @EnableAspectJAutoProxy demande à Spring de détecter les @Aspect et d'envelopper les beans correspondants dans des proxys qui exécutent les advices autour des méthodes interceptées.
Question 257
Quelle est la hiérarchie des concepts dans Spring Batch ?
Le Job est l'unité de traitement complète, composée de Steps enchaînés (start/next). Au sein d'un Step, les données sont traitées par blocs (chunks) pour optimiser les performances.
Question 258
Que signifie `chunk(10)` dans cette définition de step ?
stepBuilderFactory.get("step1")
.<UserCsv, User>chunk(10)
.reader(reader())
.processor(processor())
.writer(writer())
.build();Le chunk définit la taille du bloc : read et process s'appliquent élément par élément, puis le writer reçoit les 10 éléments d'un coup et la transaction est validée. Cela réduit le coût des écritures et des commits.
Question 259
Quels sont les trois composants d'un step orienté chunk ?
Le pattern de Spring Batch : l'ItemReader lit la source (fichier, base…), l'ItemProcessor transforme ou filtre chaque élément, l'ItemWriter écrit le bloc vers la destination.
Question 260
À quoi sert le `RunIdIncrementer` ajouté au job ?
Spring Batch identifie une instance de job par son nom + ses paramètres, et refuse de relancer une instance déjà terminée. Le RunIdIncrementer ajoute un run.id incrémenté qui rend chaque lancement unique.
Question 261
Quel composant utilise-t-on pour lire un fichier CSV ligne à ligne et le mapper vers des objets ?
FlatFileItemReader lit les fichiers plats (CSV) : on déclare les colonnes (names) et un FieldSetMapper (ici BeanWrapperFieldSetMapper) qui convertit chaque ligne en objet UserCsv.
Question 262
Quel est le rôle de l'ItemProcessor dans l'exemple d'import d'utilisateurs ?
L'ItemProcessor<UserCsv, User> reçoit chaque élément lu et retourne l'élément transformé destiné au writer. C'est là qu'on place la logique de transformation, de validation ou de filtrage.
Question 263
Quand la méthode `afterJob(JobExecution jobExecution)` du listener est-elle appelée, et que vérifie l'exemple ?
Un JobExecutionListener est notifié au début (beforeJob) et à la fin (afterJob) du job. L'exemple ne vérifie les résultats en base que si jobExecution.getStatus() == BatchStatus.COMPLETED, c'est-à-dire si le job s'est terminé avec succès.
Question 264
Quel est l'apport principal de Spring Boot par rapport à Spring « classique » ?
Spring Boot s'appuie sur Spring et le rend immédiatement productif : auto-configuration basée sur le classpath, starters de dépendances et configuration par défaut sensée, sans XML.
Question 265
Sur quoi se base l'auto-configuration de Spring Boot pour décider quels beans créer ?
L'auto-configuration est conditionnelle (@ConditionalOnClass, @ConditionalOnMissingBean…) : un bean n'est configuré que si la classe correspondante est sur le classpath et qu'aucun bean équivalent n'existe déjà.
Question 266
Qu'est-ce qu'un « starter » Spring Boot ?
Un starter (ex. spring-boot-starter-web) est une dépendance « parapluie » : en l'ajoutant, on récupère un ensemble cohérent et compatible de bibliothèques, sans gérer chaque version soi-même.
Question 267
Quel starter faut-il ajouter pour développer une API web avec Spring MVC ?
spring-boot-starter-web apporte Spring MVC, Jackson pour le JSON et un Tomcat embarqué : tout le nécessaire pour une application ou API web.
Question 268
Quel avantage apporte le serveur embarqué de Spring Boot ?
java -jar mon-application.jarTomcat (ou Jetty/Undertow) est intégré dans l'application : le déploiement se réduit à lancer le JAR, sans installer ni configurer de serveur d'applications externe.
Question 269
Quel starter fournit des endpoints de monitoring (santé, métriques) prêts à l'emploi ?
Actuator expose des endpoints comme /actuator/health ou /actuator/metrics, très utilisés en production pour la supervision et les sondes Kubernetes.
Question 270
Vous définissez votre propre bean DataSource dans votre configuration. Que fait l'auto-configuration de Spring Boot ?
L'auto-configuration est conçue pour s'effacer devant la configuration explicite : grâce à @ConditionalOnMissingBean, Spring Boot ne crée son bean par défaut que si le développeur n'en a pas déjà fourni un.
Question 271
À quoi sert le Service Discovery (Eureka, Consul) dans une architecture microservices ?
Le Service Discovery est un annuaire : chaque service s'y enregistre au démarrage, et les autres le consultent pour résoudre un nom logique en adresse réelle, sans coder les adresses en dur.
Question 272
Quel composant Spring Cloud protège l'application contre les pannes en cascade quand un service distant ne répond plus ?
Le circuit breaker « ouvre le circuit » après un certain nombre d'échecs : les appels suivants échouent immédiatement (ou basculent sur un fallback) au lieu de saturer le service défaillant et de propager la panne.
Question 273
Pourquoi la configuration d'un serveur Eureka contient-elle `register-with-eureka: false` et `fetch-registry: false` ?
eureka:
client:
register-with-eureka: false
fetch-registry: falseCes deux propriétés indiquent que l'application est le registre lui-même : elle ne doit pas se comporter comme un client qui s'enregistre auprès d'un autre serveur ou télécharge l'annuaire.
Question 274
Que fait cette interface annotée `@FeignClient` ?
@FeignClient(name = "order-service")
public interface OrderServiceClient {
@GetMapping("/api/orders/user/{userId}")
List<Order> getOrdersByUserId(@PathVariable Long userId);
}Feign génère l'implémentation HTTP à partir de l'interface : appeler getOrdersByUserId déclenche un GET vers l'instance d'order-service résolue via le service discovery. Ce n'est pas un contrôleur, c'est un client.
Question 275
Quel est le rôle d'une API Gateway (Spring Cloud Gateway, Zuul) ?
La gateway est la porte d'entrée du système : elle route chaque requête vers le bon service et centralise les préoccupations transversales (authentification, rate limiting, logs) au lieu de les dupliquer dans chaque service.
Question 276
Quel problème le Spring Cloud Config Server résout-il ?
Avec des dizaines de services, gérer un application.yml par service devient ingérable. Le Config Server centralise la configuration et la sert à chaque service au démarrage ; Vault joue le même rôle pour les secrets.
Question 277
Une requête traverse 5 microservices et vous voulez suivre son parcours de bout en bout. Quels outils Spring Cloud utilisez-vous ?
Sleuth ajoute des identifiants de corrélation (trace ID, span ID) propagés d'un service à l'autre, et Zipkin collecte et visualise ces traces : c'est le tracing distribué.
Question 278
Que signifie l'Inversion de Contrôle (IoC) dans Spring ?
Avec l'IoC, ce n'est plus la classe qui instancie ses dépendances avec `new` : c'est le conteneur Spring qui crée les beans, gère leur cycle de vie et les fournit là où ils sont nécessaires.
Question 279
Quel mode d'injection de dépendances est recommandé et pourquoi ?
L'injection par constructeur garantit que l'objet est créé avec toutes ses dépendances obligatoires, autorise les champs `final` et permet d'instancier la classe en test sans conteneur Spring.
Question 280
Quel est le principal bénéfice de l'injection de dépendances sur la conception du code ?
Une classe ne connaît plus l'implémentation concrète de ses dépendances : elle déclare ce dont elle a besoin et le conteneur fournit le bean, ce qui découple les classes et facilite le remplacement des implémentations.
Question 281
Quelle est la différence entre @Component et @Service ?
@Service, @Repository et @Controller sont des spécialisations de @Component : techniquement ce sont tous des beans, mais l'annotation précise le rôle de la classe dans l'architecture en couches.
Question 282
À quoi sert l'annotation @Qualifier ?
@Autowired
@Qualifier("emailNotifier")
private Notifier notifier;Si plusieurs implémentations de `Notifier` sont des beans, @Autowired seul est ambigu : @Qualifier désigne le bean à injecter par son nom.
Question 283
Quelle annotation choisir pour une classe d'accès aux données, et quel avantage spécifique apporte-t-elle ?
@Repository marque la couche d'accès aux données et active la traduction des exceptions techniques (JDBC, JPA) en exceptions Spring unifiées (DataAccessException).
Question 284
Pourquoi la Field Injection est-elle déconseillée par rapport à la Constructor Injection ?
@Autowired
private UserService userService;Avec l'injection de champ, impossible d'instancier la classe avec ses dépendances sans réflexion ou conteneur : les dépendances sont invisibles dans l'API de la classe et le champ ne peut pas être `final`.
Question 285
Quel est l'objectif principal de Spring Data ?
Spring Data fournit une abstraction repository commune : on déclare une interface, et les opérations CRUD ainsi que les requêtes dérivées du nom des méthodes sont implémentées automatiquement.
Question 286
Que faut-il écrire pour implémenter la méthode findByEmail de ce repository ?
public interface UserRepository extends JpaRepository<User, Long> {
Optional<User> findByEmail(String email);
}C'est le principe des requêtes dérivées : Spring Data analyse le nom de la méthode (findBy + propriété Email) et génère la requête au démarrage, sans aucune implémentation manuelle.
Question 287
Quel couple d'annotations rend une classe persistable par JPA avec une clé primaire auto-générée ?
@Entity déclare la classe comme entité JPA ; @Id marque la clé primaire et @GeneratedValue (ex. strategy = IDENTITY) délègue sa génération à la base.
Question 288
Quelles méthodes obtient-on gratuitement en étendant JpaRepository<User, Long> ?
JpaRepository fournit tout le CRUD standard hérité : save, findById, findAll, deleteById, count, existsById… sans une ligne d'implémentation.
Question 289
Que retourne l'appel suivant ?
Pageable pageable = PageRequest.of(0, 20, Sort.by("createdAt").descending());
Page<User> page = userRepository.findByStatus(UserStatus.ACTIVE, pageable);PageRequest.of(0, 20, sort) demande la page 0 de taille 20 ; l'objet Page contient les éléments et les métadonnées (nombre total d'éléments, de pages, etc.).
Question 290
À quoi sert @Enumerated(EnumType.STRING) sur un champ enum d'une entité ?
Par défaut JPA stocke l'ordinal (position numérique), fragile si l'ordre des constantes change ; EnumType.STRING stocke le nom (ex. "ACTIVE"), plus robuste et lisible.
Question 291
Pourquoi annoter le service (et non le repository) avec @Transactional ?
La frontière transactionnelle se place au niveau du cas d'usage : dans createUser, la vérification existsByEmail et le save doivent s'exécuter dans la même transaction pour rester cohérents.
Question 292
Que se passe-t-il au démarrage si une méthode de repository référence une propriété inexistante (ex. findByEmial) ?
Les requêtes dérivées sont construites au démarrage lors de la création des repositories : une propriété introuvable dans l'entité provoque une exception immédiate, ce qui détecte l'erreur très tôt.
Question 293
Dans le pattern MVC de Spring, quel est le rôle du Controller ?
Le Controller est le point d'entrée des requêtes : il les reçoit, appelle les services (Model) et retourne soit un nom de vue, soit directement des données (REST).
Question 294
Quelle est la différence entre @Controller et @RestController ?
Avec @Controller, un String retourné est interprété comme un nom de vue à rendre ; avec @RestController, chaque méthode se comporte comme si elle était annotée @ResponseBody et retourne directement les données sérialisées.
Question 295
Que retourne cette méthode au client HTTP ?
@Controller
@RequestMapping("/users")
public class UserController {
@GetMapping
public String listUsers(Model model) {
model.addAttribute("users", userService.findAll());
return "users/list";
}
}Dans un @Controller, le String retourné est un nom logique de vue : le ViewResolver localise le template users/list et le rend avec les attributs du Model.
Question 296
À quoi sert l'annotation @PathVariable ?
@GetMapping("/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) { ... }@PathVariable lie un segment dynamique de l'URL (déclaré entre accolades dans le mapping) au paramètre de la méthode ; pour la query string on utiliserait @RequestParam.
Question 297
Quel est le rôle de @RequestBody dans une méthode de contrôleur REST ?
@RequestBody demande à Spring de convertir le corps de la requête HTTP (typiquement du JSON, via Jackson) en objet Java ; la validation, elle, est déclenchée par @Valid.
Question 298
Quel code HTTP est le plus approprié en réponse à la création réussie d'une ressource via POST ?
@PostMapping
public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
User savedUser = userService.save(user);
return ResponseEntity.status(???).body(savedUser);
}Par convention REST, la création d'une ressource répond 201 Created (HttpStatus.CREATED), idéalement avec la ressource créée dans le corps et/ou son URL dans l'en-tête Location.
Question 299
À quoi sert l'annotation @CrossOrigin(origins = "http://localhost:3000") ?
Les navigateurs bloquent par défaut les appels AJAX entre origines différentes ; @CrossOrigin ajoute les en-têtes CORS qui autorisent le front (ici servi sur le port 3000) à appeler l'API.
Question 300
Que se passe-t-il si findById ne trouve pas l'utilisateur dans ce REST controller ?
@GetMapping("/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
return userService.findById(id)
.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}findById retourne un Optional : s'il est vide, orElse fournit ResponseEntity.notFound().build(), soit une réponse HTTP 404 propre — le pattern idiomatique pour une ressource absente.
Question 301
Quelle est la différence entre authentification et autorisation ?
L'authentification répond à « qui êtes-vous ? » (login, JWT, OAuth2…) ; l'autorisation répond à « qu'avez-vous le droit de faire ? » (rôles, permissions). La première précède toujours la seconde.
Question 302
Comment configure-t-on la sécurité web dans Spring Security moderne (Spring Security 6) ?
WebSecurityConfigurerAdapter a été supprimé : la configuration moderne expose un bean SecurityFilterChain construit via http.authorizeHttpRequests(...), http.formLogin(...), etc.
Question 303
Avec cette configuration, qui peut accéder à un endpoint sous /api/admin/ ?
.authorizeHttpRequests(authz -> authz
.requestMatchers("/api/auth/**").permitAll()
.requestMatchers("/api/admin/**").hasRole("ADMIN")
.requestMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
.anyRequest().authenticated()
)hasRole("ADMIN") exige l'autorité ROLE_ADMIN. Les règles sont évaluées dans l'ordre de déclaration : /api/admin/** est réservé aux ADMIN, tandis que /api/user/** accepte USER et ADMIN.
Question 304
Pourquoi désactive-t-on souvent CSRF et passe-t-on la session en STATELESS pour une API REST à JWT ?
.csrf(csrf -> csrf.disable())
.sessionManagement(session ->
session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))L'attaque CSRF exploite les cookies de session envoyés automatiquement par le navigateur. Une API stateless authentifiée par JWT dans un header n'utilise pas ce mécanisme : la protection CSRF devient inutile.
Question 305
Quel est le rôle du PasswordEncoder (ex. BCryptPasswordEncoder) ?
BCrypt applique un hachage à sens unique avec sel intégré : on stocke le hash, jamais le mot de passe, et matches() compare le mot de passe saisi au hash. Base64 n'est pas de la sécurité.
Question 306
À quoi sert l'interface UserDetailsService ?
loadUserByUsername est le point d'extension par lequel Spring Security récupère l'utilisateur (souvent en base via un repository) et le convertit en UserDetails pour vérifier les identifiants et les rôles.
Question 307
Dans le code suivant, pourquoi préfixer le nom du rôle par « ROLE_ » ?
return roles.stream()
.map(role -> new SimpleGrantedAuthority("ROLE_" + role.getName()))
.collect(Collectors.toList());Convention Spring Security : hasRole("ADMIN") ajoute automatiquement le préfixe et compare à l'autorité ROLE_ADMIN. Sans ce préfixe côté autorités, il faudrait utiliser hasAuthority("ADMIN").
Question 308
Que permet @EnableMethodSecurity(prePostEnabled = true) ?
Cette annotation active la sécurité au niveau méthode : on peut alors poser @PreAuthorize("hasRole('ADMIN')") sur une méthode de service pour contrôler l'accès au-delà du seul filtrage des URLs.
Question 309
Quelle est la différence entre `@Mock` et `@MockBean` ?
@Mock est du Mockito pur, utilisé dans les tests unitaires sans contexte. @MockBean s'utilise dans les tests Spring (@SpringBootTest, @WebMvcTest) : il enregistre le mock comme bean du contexte à la place du vrai.
Question 310
Que fait `@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)` ?
C'est le test d'intégration le plus complet : toute l'application démarre avec un serveur réel sur un port libre choisi au hasard, et on la teste via de vraies requêtes HTTP (TestRestTemplate).
Question 311
Dans un test `@WebMvcTest(UserController.class)`, pourquoi doit-on déclarer `@MockBean private UserService userService` ?
Un slice test ne charge qu'une tranche du contexte. @WebMvcTest instancie le contrôleur et l'infrastructure MVC, mais pas les services : sans @MockBean, l'injection échoue au démarrage du test.
Question 312
Que teste ce code et avec quel outil ?
mockMvc.perform(get("/api/users/1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.email").value("john@example.com"));MockMvc simule la requête à travers la couche MVC sans démarrer de serveur HTTP. jsonPath permet d'asserter le contenu du corps JSON de la réponse ($.email = champ email à la racine).
Question 313
Quel est le rôle de `@InjectMocks` dans un test unitaire Mockito ?
@InjectMocks crée une vraie instance de la classe testée (ex. UserService) et y injecte les mocks déclarés (@Mock UserRepository, @Mock EmailService) : on teste le vrai code du service avec des dépendances factices.
Question 314
Que fournit `@DataJpaTest` par défaut ?
@DataJpaTest est un slice test de la couche de persistance : il configure une base embarquée, ne charge que les composants JPA et fournit TestEntityManager pour préparer les données (persistAndFlush).
Question 315
Quand préférer un slice test (@WebMvcTest, @DataJpaTest) à un @SpringBootTest complet ?
Les slice tests ne chargent qu'une tranche du contexte : ils démarrent bien plus vite et isolent la couche testée. @SpringBootTest reste utile pour les scénarios de bout en bout, mais en abuser rend la suite de tests lente.
Question 316
Dans le test unitaire de UserService, à quoi sert `verify(emailService).sendWelcomeEmail(user.getEmail())` ?
verify() contrôle les interactions : le test échoue si la méthode n'a pas été appelée (ou pas avec les bons arguments). C'est complémentaire de when()/thenReturn() qui, lui, définit le comportement du mock.
Question 317
Que fait un squash sur une branche feature contenant les commits D, E et F ?
Le squash combine plusieurs commits en un seul : le code final est identique, mais l'historique ne contient plus qu'un commit X regroupant les changements de D, E et F.
Question 318
Dans un rebase interactif, que signifie ce contenu d'éditeur ?
pick d1f2e3a Premier commit
squash a4b5c6d Deuxième commit
squash e7f8g9h Troisième commit`pick` conserve le commit de base ; chaque ligne `squash` fusionne le commit dans le précédent. Résultat : un seul commit combinant les trois.
Question 319
Quelle particularité a `git merge --squash feature-branch` par rapport à un merge classique ?
--squash ramène l'ensemble des changements de la branche dans l'index de main, sans lien d'historique ni commit automatique : on committe ensuite soi-même un commit unique.
Question 320
Quelle séquence réalise un squash « manuel » des 3 derniers commits ?
reset --soft recule HEAD de 3 commits en gardant tous les changements stagés ; un seul commit suffit alors pour les regrouper. --hard perdrait les changements.
Question 321
Vous venez de committer mais vous avez oublié un fichier. Comment l'ajouter au dernier commit sans changer son message ?
--amend remplace le dernier commit en y intégrant ce qui est stagé ; --no-edit conserve le message existant. Le fichier oublié rejoint ainsi le commit initial.
Question 322
Pourquoi ne faut-il jamais squasher ou amender des commits déjà poussés sur une branche partagée ?
Squash et amend créent de nouveaux commits (nouveaux SHA) à la place des anciens. Si l'historique était déjà partagé, les copies des autres développeurs divergent — même règle d'or que pour le rebase.
Question 323
Quelle commande permet de corriger uniquement le message du dernier commit ?
Avec --amend et -m, le dernier commit est remplacé par un commit identique portant le nouveau message. Pour un commit plus ancien, il faudrait passer par un rebase interactif (reword).
Question 324
Quelle pratique est cohérente avec un bon usage du squash en équipe ?
Le squash s'utilise sur ses commits locaux, avant l'intégration : on présente à main un historique propre (un commit logique par feature), sans jamais réécrire ce qui est déjà partagé.
Question 325
Que signifie l'immutabilité d'une String en Java ?
Le contenu d'une String est figé à sa création. str = str + " World" ne modifie pas l'originale : une nouvelle String est créée et la variable pointe dessus (son hashCode change d'ailleurs).
Question 326
Qu'affiche ce code ?
String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");
System.out.println(s1 == s2);
System.out.println(s1 == s3);Les littéraux identiques partagent la même référence du String Pool (s1 == s2 est true), alors que new String() crée toujours un nouvel objet hors du pool (s1 == s3 est false, même si equals() renverrait true).
Question 327
Quelle est la différence entre StringBuilder et StringBuffer ?
Les deux offrent la même API mutable, mais StringBuffer synchronise ses méthodes, ce qui le rend thread-safe au prix de la performance. En mono-thread, StringBuilder est le choix recommandé.
Question 328
Pourquoi la concaténation avec + dans une boucle est-elle une mauvaise pratique ?
String result = "";
for (String item : items) {
result += item + ", ";
}String étant immuable, chaque += recopie tout le contenu accumulé dans une nouvelle String. Avec un StringBuilder, on réutilise un buffer interne et on reste en O(n).
Question 329
Pourquoi écrire `"expected".equals(userInput)` plutôt que `userInput.equals("expected")` ?
Si userInput est null, userInput.equals(...) lève une NullPointerException. En appelant equals() sur le littéral (jamais null), la comparaison renvoie simplement false.
Question 330
Que fait la méthode `intern()` sur une String ?
intern() garantit une référence unique par contenu via le pool : après s4 = s3.intern(), s4 == "Hello" est true. À utiliser avec parcimonie, un usage massif peut causer des fuites.
Question 331
Quel est le résultat de ce code ?
String data = "Java,Python,JavaScript";
System.out.println(data.substring(5, 11));substring(debut, fin) inclut l'index de début et exclut l'index de fin : les caractères 5 à 10 de "Java,Python,JavaScript" forment "Python".
Question 332
Quel est l'ordre correct du cycle TDD ?
TDD commence toujours par un test qui échoue (rouge), puis le minimum de code pour le faire passer (vert), et enfin l'amélioration du code à tests constants (refactor).
Question 333
Pourquoi écrit-on le test AVANT le code en TDD ?
Écrire le test d'abord oblige à clarifier ce que le code doit faire (API, entrées, sorties) avant de se demander comment le faire.
Question 334
En phase verte, quelle quantité de code faut-il écrire ?
L'objectif de la phase verte est de valider rapidement que le test est correct : on écrit le strict minimum, les améliorations viennent en phase de refactor.
Question 335
Vous lancez ce test alors qu'aucune classe Calculator n'existe encore. Que se passe-t-il, et est-ce normal en TDD ?
test('should add two numbers', () => {
const calculator = new Calculator();
const result = calculator.add(2, 3);
expect(result).toBe(5);
});C'est exactement la phase rouge : le test échoue parce que le code n'existe pas encore. Cet échec initial prouve que le test vérifie réellement quelque chose.
Question 336
Que signifie « refactorer » dans le cycle TDD ?
Le refactor améliore la structure interne (ex. ajouter la validation des arguments de add) à comportement constant : les tests existants doivent rester verts et servent de filet de sécurité.
Question 337
Quel est le risque si on saute la phase rouge (on écrit le code puis le test) ?
Un test jamais vu rouge n'a pas prouvé sa valeur : une assertion mal écrite ou un mauvais câblage peut le faire passer en permanence, donnant une fausse confiance.
Question 338
Quel est le format standard d'une User Story ?
Le template « En tant que… je veux… afin de… » centre l'exigence sur l'utilisateur et sa valeur. « Étant donné / quand / alors » est le format Gherkin des critères d'acceptation en BDD.
Question 339
Pourquoi cette User Story est-elle mal rédigée ?
En tant que développeur,
Je veux créer une API REST,
Afin d'avoir une architecture propre.Une bonne story part de l'utilisateur final et de la valeur métier. Ici la perspective est technique (développeur), vague, sans bénéfice utilisateur ni critères mesurables.
Question 340
Dans l'acronyme INVEST, que signifie le « I » ?
Independent : une story doit pouvoir être développée dans n'importe quel ordre. Les cinq autres critères sont Negotiable, Valuable, Estimable, Small, Testable.
Question 341
Selon le critère « Small » d'INVEST, quelle taille doit avoir une User Story ?
Une story doit pouvoir être terminée dans un sprint (généralement 1-8 points). Au-delà (13, 21+), on la découpe en stories plus petites.
Question 342
Quelle est la hiérarchie correcte des exigences, du plus large au plus précis ?
Le Thème porte la vision globale (ex : améliorer l'expérience d'achat), l'Epic une grande fonctionnalité (ex : gestion du panier), la User Story une fonctionnalité spécifique (ex : ajouter un produit au panier).
Question 343
À quoi servent les critères d'acceptation d'une User Story ?
Les critères d'acceptation (ex : « le filtre peut être réinitialisé ») rendent la story vérifiable — c'est le « T » de Testable dans INVEST.
Question 344
« Système de recommandations » regroupant plusieurs stories comme « Recommander des produits similaires » : de quoi s'agit-il ?
Un Epic est une grande fonctionnalité trop volumineuse pour un sprint, qu'on décompose en User Stories spécifiques. Le Thème est encore au-dessus (vision globale).
Question 345
Quelles sont les versions LTS de Java citées dans la fiche ?
Les versions Long Term Support sont Java 8 (2014), 11 (2018), 17 (2021) et 21 (2023). Les autres versions sont des releases intermédiaires au support court.
Question 346
Quelle version de Java a introduit les expressions lambda et la Stream API ?
Java 8 (2014) est la « révolution des lambdas » : expressions lambda, Stream API, interfaces fonctionnelles, Optional et nouvelle API Date/Time.
Question 347
Que permet le mot-clé `var` introduit pour les variables locales ?
var list = List.of("Java", "11", "LTS");
var map = Map.of("version", 11);`var` (utilisable en LTS depuis Java 11) délègue l'inférence du type au compilateur : la variable reste typée statiquement, seul le type explicite disparaît du code.
Question 348
Quel est l'apport principal des Records introduits avec Java 17 LTS ?
public record Person(String name, int age) {}Un record est une classe de données concise : le compilateur génère le constructeur, les accesseurs (name(), age()), equals, hashCode et toString.
Question 349
Quelle nouveauté majeure de Java 21 est issue du Project Loom ?
Java 21 introduit les Virtual Threads (Project Loom) : des threads légers gérés par la JVM qui permettent de lancer des milliers de tâches concurrentes à faible coût.
Question 350
Que renvoie ce switch de Java 21 si `obj` vaut null ?
String result = switch (obj) {
case Integer i -> "Integer: " + i;
case String s -> "String: " + s;
case null -> "null value";
default -> "Unknown type";
};Le pattern matching pour switch de Java 21 accepte un case null explicite ; sans ce case, un switch sur null lancerait une NullPointerException.
Question 351
Qu'a supprimé Java 11 qui casse fréquemment les applications lors d'une montée de version depuis Java 8 ?
Java 11 a retiré les modules Java EE du JDK (JAXB, activation…) : les applications qui les utilisaient doivent désormais les ajouter comme dépendances externes.
Question 352
Quelle recommandation la fiche donne-t-elle pour le choix de version ?
La recommandation : démarrer les nouveaux projets sur Java 21 LTS et planifier la migration des projets existants vers au moins Java 17, les deux LTS les plus récentes.
Question 353
Dans GitFlow, quel est le rôle respectif des branches main et develop ?
GitFlow sépare strictement : main contient uniquement le code en production (taggé par release), develop agrège le travail des branches feature en continu.
Question 354
Dans GitFlow, d'où part une branche hotfix et où doit-elle être mergée ?
Le hotfix part de main pour corriger la production au plus vite, puis est mergé dans main ET dans develop — sinon le bug corrigé réapparaît à la prochaine release.
Question 355
Pourquoi GitFlow utilise-t-il `git merge --no-ff` pour intégrer les features ?
git checkout develop
git merge --no-ff feature/nouvelle-fonctionnalite--no-ff interdit le fast-forward : même si develop pouvait simplement avancer, un commit de merge est créé, ce qui matérialise la feature dans l'historique et facilite la traçabilité.
Question 356
Quel est le principe central du Trunk-based Development ?
En trunk-based, tout le monde intègre très fréquemment sur main/trunk : les branches vivent au maximum 2-3 jours, ce qui rend l'intégration continue réelle et limite les conflits.
Question 357
En Trunk-based Development, comment livrer sur main une fonctionnalité encore incomplète sans la montrer aux utilisateurs ?
Les feature flags permettent de merger et déployer du code incomplet mais inactif : `if (featureFlag.isEnabled('NEW_FEATURE'))` route vers l'ancienne implémentation tant que le flag est éteint.
Question 358
Quel contexte plaide pour GitFlow plutôt que pour le Trunk-based ?
GitFlow apporte une structure prévisible (release, hotfix, develop) qui paie dans les grandes équipes, les releases espacées et les contextes réglementés ; son overhead pénalise les petites équipes en déploiement continu.
Question 359
Quel est un inconvénient reconnu de GitFlow ?
Avec des branches feature et release qui vivent longtemps, l'intégration arrive tard : les divergences s'accumulent et les conflits de merge deviennent fréquents — exactement ce que le trunk-based cherche à éviter.
Question 360
Quel prérequis rend le Trunk-based Development viable ?
Comme tout le monde pousse fréquemment vers main, seuls des tests automatisés solides et une CI obligatoire empêchent de casser la branche principale — c'est une question de discipline d'équipe.
Résultats du quiz
Comment ça marche
- Sélectionnez des thèmes – Choisissez parmi Java, Spring, Git, DevOps, etc.
- Lancez le quiz – Les questions s'enchaînent une par une
- Recevez un feedback immédiat – Explication après chaque réponse
- Consultez votre score – Global et par thème
Vous pouvez recommencer autant de fois que vous le souhaitez. Les quiz sont générés dynamiquement à partir des fiches.