Formations — 1 037 leçons en français

Accueil › Spring Boot › Les fondamentaux — IoC et injection de dépendances

Les fondamentaux — IoC et injection de dépendances — entretien Spring Boot

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

IoC et injection de dépendances

Qu'est-ce qu'un bean Spring ?

  1. Une classe Java qui contient uniquement des getters et des setters
  2. Un objet dont la création et le cycle de vie sont gérés par le conteneur Spring ✓
  3. Un fichier de configuration XML
  4. N'importe quel objet créé dans une application Spring

Pourquoi : Un bean est un objet **géré par le conteneur**. Un objet créé avec `new` dans une application Spring n'est pas un bean. Ne pas confondre avec les « JavaBeans » (classes avec getters/setters).

Niveau junior

Déclaration des beans

Que regroupe l'annotation `@SpringBootApplication` ?

  1. `@Configuration`, `@EnableWebMvc` et `@Transactional`
  2. `@SpringBootConfiguration`, `@EnableAutoConfiguration` et `@ComponentScan` ✓
  3. `@Component`, `@Service` et `@Repository`
  4. `@EnableAutoConfiguration` uniquement

Pourquoi : `@SpringBootConfiguration` (une `@Configuration`), `@EnableAutoConfiguration` (l'auto-configuration de Spring Boot) et `@ComponentScan` (scan à partir du package de cette classe).

Niveau junior

Quelle différence y a-t-il entre déclarer des méthodes `@Bean` dans une classe `@Configuration` et dans une classe `@Component` ?

@Configuration // ou @Component ?
public class AppConfig {
    @Bean public Horloge horloge() { return new Horloge(); }
    @Bean public ServiceA serviceA() { return new ServiceA(horloge()); }
}
  1. Aucune, les deux annotations sont équivalentes
  2. Avec `@Configuration`, un proxy CGLIB fait que `horloge()` renvoie le singleton existant ; avec `@Component`, chaque appel crée un nouvel objet ✓
  3. Les méthodes `@Bean` sont ignorées dans une classe `@Component`
  4. Avec `@Component`, les beans sont automatiquement de scope prototype

Pourquoi : C'est le mode « full » (`@Configuration`) contre le mode « lite » (`@Component`, ou `@Configuration(proxyBeanMethods = false)`). En mode lite, l'appel direct `horloge()` est un simple appel Java : `ServiceA` reçoit une `Horloge` qui n'est pas le bean du conteneur. En mode lite, on reçoit plutôt la dépendance en paramètre : `serviceA(Horloge horloge)`.

Niveau senior

Injection de dépendances

Deux classes `@Service` implémentent `PaiementService`. Un contrôleur injecte `PaiementService` sans autre précision. Que se passe-t-il ?

  1. Spring injecte la première classe trouvée par le scan
  2. Le démarrage échoue avec une `NoUniqueBeanDefinitionException` ✓
  3. Spring injecte `null` et l'erreur apparaît au premier appel
  4. Spring crée un proxy qui appelle les deux implémentations

Pourquoi : Spring ne choisit pas au hasard : l'application ne démarre pas (« required a single bean, but 2 were found »). Solutions : `@Primary` sur l'implémentation par défaut, `@Qualifier("nomDuBean")` au point d'injection, ou injecter `List<PaiementService>`.

Niveau confirme

Scopes et cycle de vie

Un bean singleton Spring est-il thread-safe ?

  1. Oui, Spring synchronise automatiquement les appels aux singletons
  2. Non, pas automatiquement : il est partagé par tous les threads, il doit donc être sans état modifiable (ou gérer la concurrence) ✓
  3. Oui, car chaque thread reçoit sa propre copie
  4. Seulement s'il est annoté `@Service`

Pourquoi : Toutes les requêtes HTTP utilisent la même instance en parallèle. Un attribut modifiable dans un service (ex. `private Commande commandeEnCours`) mélange les données entre utilisateurs. Règle : des services **sans état**, les données passent par les paramètres des méthodes.

Niveau confirme

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