Formations — 1 037 leçons en français

Accueil › Spring Boot › Auto-configuration en profondeur

Auto-configuration en profondeur — entretien Spring Boot

3 questions posées en entretien sur 3 sujets, avec la bonne réponse et son explication.

Conditions avancées

Que produit `@ConditionalOnProperty(prefix = "boutique.export", name = "active")` (sans `havingValue` ni `matchIfMissing`) si la propriété `boutique.export.active` est absente de la configuration ?

  1. La configuration s'active, car aucune valeur explicite n'est requise
  2. La configuration ne s'active pas : par défaut, une propriété absente ne satisfait pas la condition ✓
  3. Le démarrage échoue avec une exception
  4. Le comportement dépend du type de la propriété (String, boolean…)

Pourquoi : `matchIfMissing` vaut `false` par défaut : sans elle et sans la propriété présente, la condition n'est pas remplie. Sans `havingValue`, n'importe quelle valeur différente de `"false"` aurait suffi si la propriété avait été présente — mais son absence pure et simple désactive la configuration.

Niveau confirme

Créer un starter

Pourquoi préfère-t-on `ApplicationContextRunner` à un test `@SpringBootTest` complet pour tester une classe d'auto-configuration ?

  1. `ApplicationContextRunner` est plus rapide à écrire mais teste moins de cas
  2. Il construit un contexte minimal et isolé (sans serveur web ni auto-configurations superflues), ce qui permet de tester précisément une auto-configuration et ses conditions (classpath simulé, propriétés, bean utilisateur déjà présent…) ✓
  3. `@SpringBootTest` ne peut pas être utilisé en dehors d'une application Spring Boot complète
  4. `ApplicationContextRunner` remplace complètement le besoin d'écrire des tests d'intégration

Pourquoi : L'intérêt n'est pas la rapidité d'écriture mais l'isolation : `withClassLoader(new FilteredClassLoader(...))` simule l'absence d'une classe, `withUserConfiguration(...)` simule un bean déjà défini par l'utilisateur, `withPropertyValues(...)` simule la configuration — chacune de ces conditions se teste indépendamment, sans dépendre d'un contexte applicatif complet.

Niveau senior

Cycle de démarrage

Quel mécanisme est responsable de la création des proxies AOP (par exemple pour @Transactional) pendant le cycle de vie d'un bean ?

  1. Un `BeanFactoryPostProcessor`, qui modifie la définition du bean avant sa création
  2. Un `BeanPostProcessor`, dont `postProcessAfterInitialization` peut remplacer l'instance initialisée par un proxy ✓
  3. Un `EnvironmentPostProcessor`, exécuté avant la création du contexte
  4. Un `ApplicationContextInitializer`, exécuté juste après la création du contexte

Pourquoi : `BeanFactoryPostProcessor` agit sur les métadonnées (définitions), avant toute instanciation. `BeanPostProcessor` agit sur l'instance déjà construite et initialisée, et peut la remplacer par un autre objet — c'est exactement ce que fait Spring pour substituer un bean par son proxy AOP après l'étape d'initialisation (`@PostConstruct` compris).

Niveau senior

S'entraîner sur ces questions, chronométré →