Qu'est-ce qu'un haricot printanier?

1. Vue d'ensemble

Bean est un concept clé du Spring Framework. En tant que tel, comprendre cette notion est crucial pour maîtriser le cadre et l'utiliser de manière efficace.

Malheureusement, il n'y a pas de réponses claires à une question simple: ce qu'est vraiment un haricot de printemps. Certaines explications vont à un niveau si bas qu'une vue d'ensemble est ratée, tandis que d'autres sont trop vagues.

Ce tutoriel tentera de faire la lumière sur le sujet, en commençant par une description dans la documentation officielle.

2. Définition du haricot

Voici une définition des beans dans la documentation Spring Framework:

Dans Spring, les objets qui forment l'épine dorsale de votre application et qui sont gérés par le conteneur Spring IoC sont appelés beans. Un bean est un objet qui est instancié, assemblé et autrement géré par un conteneur Spring IoC.

Cette définition est concise et va au point, mais manque une chose importante - le conteneur Spring IoC. Descendons dans le terrier du lapin pour voir ce que c'est et les avantages que cela apporte.

3. Inversion de contrôle

En termes simples, l'inversion de contrôle, ou IoC en abrégé, est un processus dans lequel un objet définit ses dépendances sans les créer. Cet objet délègue le travail de construction de telles dépendances à un conteneur IoC.

Commençons par la déclaration de quelques classes de domaine avant de plonger dans l'IoC.

3.1. Classes de domaine

Supposons que nous ayons une déclaration de classe:

public class Company { private Address address; public Company(Address address) { this.address = address; } // getter, setter and other properties }

Cette classe a besoin d'un collaborateur de type Adresse :

public class Address { private String street; private int number; public Address(String street, int number) { this.street = street; this.number = number; } // getters and setters }

3.2. Approche traditionnelle

Normalement, nous créons des objets avec les constructeurs de leurs classes:

Address address = new Address("High Street", 1000); Company company = new Company(address);

Il n'y a rien de mal avec cette approche, mais ne serait-il pas agréable de mieux gérer les dépendances?

Imaginez une application avec des dizaines, voire des centaines de classes. Parfois, nous voulons partager une seule instance d'une classe sur l'ensemble de l'application, d'autres fois, nous avons besoin d'un objet séparé pour chaque cas d'utilisation, et ainsi de suite.

Gérer un tel nombre d'objets n'est rien de moins qu'un cauchemar. C'est là que Inversion of Control vient à la rescousse.

Au lieu de construire des dépendances par lui-même, un objet peut récupérer ses dépendances à partir d'un conteneur IoC. Tout ce que nous devons faire est de fournir au conteneur les métadonnées de configuration appropriées.

3.3. Configuration du haricot

Tout d'abord, décorons la classe Company avec l' annotation @Component :

@Component public class Company { // this body is the same as before }

Voici une classe de configuration fournissant des métadonnées de bean à un conteneur IoC:

@Configuration @ComponentScan(basePackageClasses = Company.class) public class Config { @Bean public Address getAddress() { return new Address("High Street", 1000); } }

La classe de configuration produit un bean de type Address . Il contient également l' annotation @ComponentScan , qui demande au conteneur de rechercher des beans dans le package contenant la classe Company .

Lorsqu'un conteneur Spring IoC construit des objets de ces types, tous les objets sont appelés Spring beans car ils sont gérés par le conteneur IoC.

3.4. IoC en action

Puisque nous avons défini des beans dans une classe de configuration, nous aurons besoin d'une instance de la classe AnnotationConfigApplicationContext pour créer un conteneur:

ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

Un test rapide vérifie l'existence ainsi que les valeurs de propriété de nos beans:

Company company = context.getBean("company", Company.class); assertEquals("High Street", company.getAddress().getStreet()); assertEquals(1000, company.getAddress().getNumber());

Le résultat prouve que le conteneur IoC a créé et initialisé correctement les beans.

4. Conclusion

Ce didacticiel a donné une brève description des beans Spring et de leur relation avec un conteneur IoC.

Le code source complet de ce didacticiel se trouve à l'adresse over sur GitHub.