Qu'est-ce que les haricots de printemps ?

Question

Je n'ai pas encore trouvé de définition de haut niveau des Spring beans que je puisse comprendre. Je les vois souvent référencés dans la documentation et les livres sur Grails, mais je pense qu'il serait utile de comprendre ce qu'ils sont. Qu'est-ce que les Spring beans ? Comment peut-on les utiliser ? Ont-ils quelque chose à voir avec l'injection de dépendance ?

Answer 1

Les technologies de base de Spring documentation de référence décrit ce que sont les haricots.

Selon la Introduction au conteneur Spring IoC et aux beans section (où "IoC" signifie " inversion du contrôle ") :

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 géré par un conteneur Spring IoC. Autrement, un bean est simplement l'un des nombreux objets de votre application. Les beans, et les dépendances entre eux, sont reflétés dans les métadonnées de configuration utilisées par un conteneur.

Les haricots et les champs d'application sont décrits dans le document Pointes de haricot section :

Lorsque vous créez une définition de bean, vous créez une recette pour créer des instances réelles de la classe définie par cette définition de bean. L'idée qu'une définition de bean est une recette est importante, car elle signifie que, comme pour une classe, vous pouvez créer de nombreuses instances d'objets à partir d'une seule recette.

Vous pouvez contrôler non seulement les diverses dépendances et valeurs de configuration qui doivent être insérées dans un objet créé à partir d'une définition de haricot particulière, mais aussi la portée des objets créés à partir d'une définition de haricot particulière. Cette approche est puissante et flexible, car vous pouvez choisir la portée des objets que vous créez par le biais de la configuration au lieu de devoir intégrer la portée d'un objet au niveau de la classe Java. Les beans peuvent être définis pour être déployés dans l'un des nombreux domaines d'application.

Answer 2

Les Spring beans ne sont que des objets d'instance gérés par le conteneur Spring, c'est-à-dire qu'ils sont créés et câblés par le cadre et placés dans un "sac d'objets" (le conteneur) d'où vous pouvez les extraire ultérieurement.

La partie "câblage" est la raison d'être de l'injection de dépendances, ce qui signifie que vous pouvez simplement dire "J'ai besoin de cette chose" et le cadre suivra certaines règles pour vous fournir l'instance appropriée.

Pour quelqu'un qui n'est pas habitué au printemps, je pense que L'article de Wikipedia Spring contient une belle description :

L'inversion du conteneur de contrôle est au cœur du Spring Framework, qui fournit un moyen cohérent de configurer et de gérer les objets Java à l'aide de la réflexion. Le conteneur est responsable de la gestion le cycle de vie d'objets spécifiques : création de ces objets, appel de leur méthodes d'initialisation, et configurer ces objets en les reliant entre eux. en les reliant entre eux.

Les objets créés par le conteneur sont également appelés objets gérés o haricots . Le conteneur peut être configuré en chargeant des fichiers XML ou en en détectant des annotations Java spécifiques sur les classes de configuration. Ces sources de données contiennent les définitions des beans qui fournissent les informations nécessaires à la création des beans.

Les objets peuvent être obtenus au moyen de recherche de dépendances o l'injection de dépendance . Recherche de dépendances i demande à l'objet conteneur un objet portant un nom spécifique ou d'une type spécifique. Injection de dépendance est un modèle dans lequel le conteneur transmet des objets par leur nom à d'autres objets, par l'intermédiaire de constructeurs, des propriétés ou des méthodes d'usine.

Answer 3

Comprenons d'abord ce qu'est le printemps :

Spring est un cadre léger et flexible.

Analogie :

Les haricots Java sont des classes qui encapsulent de nombreux objets en un seul objet (le haricot). Le nom " Haricot "a été donné pour englober cette norme, qui vise à créer des composants logiciels réutilisables pour Java.

Haricot de printemps : est un objet qui est créé, géré et détruit dans le Spring Container. Nous pouvons injecter un objet dans le conteneur Spring par le biais des métadonnées (xml ou annotation), ce qui s'appelle l'inversion du contrôle.

Analogie : Supposons que l'agriculteur dispose d'une terre cultivée en semences (ou en haricots). Ici, l'agriculteur est Spring Framework, la terre agricole est Spring Container, les haricots sont Spring Beans, la culture est Spring Processors.

Comme le cycle de vie des haricots, les haricots de printemps ont aussi leur propre cycle de vie.

Source de l'image

Voici la séquence du cycle de vie d'un bean dans Spring :

• Instancier : Tout d'abord, le conteneur Spring trouve la définition du bean dans le fichier XML et instancie le bean.

• Remplir les propriétés : En utilisant l'injection de dépendance, Spring remplit toutes les propriétés spécifiées dans la définition du bean.

• Set Bean Name : Si le bean implémente BeanNameAware spring transmet l'identifiant du bean à l'interface setBeanName() método.

• Régler l'usine de haricots : Si le Bean implémente BeanFactoryAware spring transmet la beanfactory à l'interface setBeanFactory() método.

• Pré-initialisation : Également appelé post-processus du bean. S'il existe des BeanPostProcessors associés au bean, Spring appelle postProcesserBeforeInitialization() método.

• Initialiser les haricots : Si le bean implémente IntializingBean ,son afterPropertySet() est appelée. Si le bean a une déclaration de méthode init, la méthode d'initialisation spécifiée est appelée.

• Post-initialisation : - S'il y a des BeanPostProcessors associés au haricot, leur postProcessAfterInitialization() seront appelées.

• Prêt à l'emploi : Le bean est maintenant prêt à être utilisé par l'application.

• Destruction : si le bean implémente la norme DisposableBean il appellera la fonction destroy() méthode

Answer 4

Vous l'avez compris en partie. Vous devez adapter les haricots en fonction de vos besoins et informer le conteneur Spring de les gérer lorsque cela est nécessaire, en utilisant une méthodologie populairement connue sous le nom de IoC ( Inversion de contrôle ) inventé par Martin Fowler également connu sous le nom de Injection de dépendance (DI).

Vous câblez les haricots de manière à ne pas avoir à vous occuper de l'instanciation ou de l'évaluation d'une dépendance à l'égard du haricot. C'est ce que l'on appelle communément Le principe d'Hollywood .

Google est le meilleur outil pour en savoir plus à ce sujet, en plus des liens dont vous serez inondés dans cette question :)

Answer 5

Un Bean est un POJO (Plain Old Java Object), qui est géré par le conteneur Spring.

Les conteneurs Spring ne créent par défaut qu'une seule instance du bean. 
Ce bean est mis en cache dans la mémoire, de sorte que toutes les requêtes pour le bean renverront une référence partagée vers le même bean.

L'annotation @Bean renvoie un objet que Spring enregistre en tant que bean dans le contexte de l'application.
La logique à l'intérieur de la méthode est responsable de la création de l'instance.

Quand utiliser l'annotation @Bean ?

Lorsque la configuration automatique n'est pas possible. Par exemple, lorsque nous voulons connecter des composants provenant d'une bibliothèque tierce, parce que le code source n'est pas disponible et que nous ne pouvons donc pas annoter les classes avec @Component.

Un scénario en temps réel pourrait être que quelqu'un veuille se connecter à la base de données Amazon S3. La source n'étant pas disponible, il devrait créer un @bean.

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

Source du code ci-dessus -> https://www.devglan.com/spring-mvc/aws-s3-java

Parce que j'ai mentionné l'annotation @Component ci-dessus.

@Component Indique qu'une classe annotée est un "composant". Ces classes sont considérées comme des candidates à l'autodétection lors de l'utilisation de la configuration basée sur les annotations et de l'analyse du chemin des classes.

L'annotation Component enregistre la classe en tant que bean unique.