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 ?
- Une classe Java qui contient uniquement des getters et des setters
- Un objet dont la création et le cycle de vie sont gérés par le conteneur Spring ✓
- Un fichier de configuration XML
- 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` ?
- `@Configuration`, `@EnableWebMvc` et `@Transactional`
- `@SpringBootConfiguration`, `@EnableAutoConfiguration` et `@ComponentScan` ✓
- `@Component`, `@Service` et `@Repository`
- `@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()); }
}
- Aucune, les deux annotations sont équivalentes
- Avec `@Configuration`, un proxy CGLIB fait que `horloge()` renvoie le singleton existant ; avec `@Component`, chaque appel crée un nouvel objet ✓
- Les méthodes `@Bean` sont ignorées dans une classe `@Component`
- 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 ?
- Spring injecte la première classe trouvée par le scan
- Le démarrage échoue avec une `NoUniqueBeanDefinitionException` ✓
- Spring injecte `null` et l'erreur apparaît au premier appel
- 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 ?
- Oui, Spring synchronise automatiquement les appels aux singletons
- Non, pas automatiquement : il est partagé par tous les threads, il doit donc être sans état modifiable (ou gérer la concurrence) ✓
- Oui, car chaque thread reçoit sa propre copie
- 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