Qu’est-ce qu’un haricot printanier?

Qu'est-ce qu'un haricot de printemps?

1. Vue d'ensemble

Le haricot est un concept clé du cadre de printemps. En tant que telle, la compréhension de cette notion est cruciale pour comprendre le cadre et l’utiliser efficacement.

Malheureusement,there aren’t clear answers to a simple question – what a Spring bean really is. Certaines explications vont à un niveau si bas qu'une vue d'ensemble est ratée, alors que certaines sont trop vagues.

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

Lectures complémentaires:

Pourquoi choisir Spring comme framework Java?

Un aperçu rapide et pratique de la proposition de valeur principale du cadre Spring.

Comprendre getBean () au printemps

Découvrez les différentes variantes de la méthode BeanFactory.getBean () de Spring pour récupérer une instance de bean à partir du conteneur Spring

2. Définition du haricot

Voici une définition des beans enthe Spring Framework documentation:

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,but misses an important thing – Spring IoC container. Allons 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,Ihttps: //www.example.com/inversion-control-and-dependency-injection-in-spring [nversion of Control], ou IoC en abrégé, esta process in which an object defines its dependencies without creating them. Cet objet délègue le travail de construction de telles dépendances vers 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 typeAddress:

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 à cette approche, mais ne serait-il pas bien de gérer les dépendances d'une meilleure manière?

Imaginez une application avec des dizaines voire des centaines de classes. Parfois, nous souhaitons partager une instance unique d'une classe dans l'ensemble de l'application. D'autres fois, nous avons besoin d'un objet distinct pour chaque cas d'utilisation, etc.

Gérer un tel nombre d'objets n'est rien de moins qu'un cauchemar. This is where Inversion of Control comes to the rescue.

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. All we need to do is to provide the container with appropriate configuration metadata.

3.3. Configuration du bean

Tout d'abord, décorons la classeCompany 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 typeAddress. Il porte également l'annotation@ComponentScan, qui demande au conteneur de rechercher des beans dans le package contenant la classeCompany.

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,we’ll need an instance of the AnnotationConfigApplicationContext class to build up a container:

ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

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

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 tutoriel a donné une brève description des haricots Spring et de leur relation avec un conteneur IoC.

Le code source complet de ce didacticiel se trouve àover on GitHub.

TOC