Que sont les haricots de spring dans le monde?

Les objects qui constituent 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 object instancié, assemblé et géré par un conteneur Spring IoC. Ces beans sont créés avec les métadonnées de configuration que vous fournissez au conteneur, par exemple sous la forme de définitions XML.

En savoir plus sur les haricots et la scope de SpringSource :

Lorsque vous créez une définition de bean, ce que vous créez est 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 cela signifie que, tout comme une classe, vous pouvez potentiellement créer de nombreuses instances d’objects à partir d’une même recette.

Vous pouvez contrôler non seulement les différentes dépendances et valeurs de configuration à connecter à un object créé à partir d’une définition de bean particulière, mais également l’étendue des objects créés à partir d’une définition de bean particulière. Cette approche est très puissante et vous donne la possibilité de choisir l’étendue des objects que vous créez via la configuration, au lieu d’avoir à «cuire» la scope d’un object au niveau de la classe Java. Les haricots peuvent être définis pour être déployés dans l’une des nombreuses étendues

* IoC: Inversion de Contrôle

Les beans Spring ne sont que des instances d’objects gérées par le conteneur Spring, à savoir qu’ils sont créés et câblés par la structure et placés dans un “sac d’objects” (le conteneur) à partir duquel vous pouvez les obtenir ultérieurement.

La partie “Câblage”, il y a ce que l’dependency injection implique, ce que cela signifie, c’est que vous pouvez simplement dire “j’aurai besoin de cette chose” et que le framework suivra certaines règles pour vous procurer la bonne instance.

Pour quelqu’un qui n’est pas habitué au spring, je pense que l’article de Wikipedia a une belle description :

L’inversion du conteneur de contrôle, qui constitue un moyen cohérent de configurer et de gérer les objects Java à l’aide de la reflection, est au cœur de Spring Framework. Le conteneur est responsable de la gestion des cycles de vie des objects spécifiques: créer ces objects, appeler leurs méthodes d’initialisation et configurer ces objects en les connectant ensemble.

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

Les objects peuvent être obtenus au moyen d’une recherche de dépendance ou d’ une dependency injection . La recherche de dépendances est un modèle dans lequel un appelant demande à l’object conteneur un object portant un nom spécifique ou un type spécifique. L’dependency injections est un modèle dans lequel le conteneur transmet des objects par nom à d’autres objects, via des constructeurs, des propriétés ou des méthodes d’usine.

Eh bien, vous l’avez compris partiellement. Vous devez adapter les haricots en fonction de vos besoins et informer le conteneur de Spring de la gestion nécessaire, en utilisant une méthodologie connue sous le nom d’IoC ( Inversion of Control ) inventée par Martin Fowler , également connue sous le nom de Dependency Injection (DI).

Vous connectez les haricots de manière à ne pas avoir à vous soucier de l’instanciation ou à évaluer une dépendance au haricot. Ceci est populairement connu comme Hollywood Principe .

Google est le meilleur outil pour en savoir plus à ce sujet, en plus des liens qui vous envahiraient dans cette question. 🙂

Commençons par comprendre le spring:

Le spring est un cadre léger et flexible.

Analogie:

Bean: est un object créé, géré et détruit dans Spring Container. Nous pouvons injecter un object dans le conteneur Spring via les métadonnées (xml ou annotation), appelées inversion du contrôle.

Analogie: Supposons que l’agriculteur possède une terre agricole cultivée par graines (ou haricots). Ici, Farmer est un cadre de spring, les terres agricoles sont des conteneurs de spring, les haricots sont des haricots de spring, la culture est des processeurs de spring.

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

img source

Voici la séquence du cycle de vie d’un haricot au spring:

• Instanciation: le conteneur de spring trouve d’abord la définition du bean dans le fichier XML et instancie le bean.

• Remplissage des propriétés: À l’aide de l’dependency injections, Spring remplit toutes les propriétés comme spécifié dans la définition du bean.

• Set Bean Name: Si le bean implémente l’interface BeanNameAware , Spring transmet l’id du bean à la méthode setBeanName() .

• Set Bean factory: Si Bean implémente l’interface BeanFactoryAware , spring transmet la méthode beanfactory à la méthode setBeanFactory() .

• Pré-initialisation: également appelé post-traitement du haricot. Si des beanPostProcessors de bean sont associés au bean, Spring appelle la méthode postProcesserBeforeInitialization() .

• Initialiser les beans: Si le bean implémente IntializingBean , sa méthode 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: – Si des BeanPostProcessors associés au bean, leurs méthodes postProcessAfterInitialization() seront appelées.

• Prêt à l’emploi: le bean est maintenant prêt à être utilisé par l’application

• Destroy: Si le bean implémente DisposableBean , il appellera la méthode destroy()

Les haricots sont au cœur du spring. Ce sont des objects Java standard instanciés et gérés par Spring.

Les haricots sont principalement utilisés pour:

• Configurer Spring d’une manière ou d’une autre (parameters de connexion à la firebase database, sécurité, etc.)
• Évitez les dépendances de codage en dur en utilisant l’ dependency injection , afin que nos classes restnt autonomes et que l’unité soit testable

Le spring a le conteneur IoC qui porte le sac de haricot; La création et la suppression de la création sont les responsabilités de Spring Container. Nous pouvons mettre le haricot au spring par câblage et câblage automatique. Le câblage signifie que nous le configurons manuellement dans le fichier XML et que “Auto Wiring” signifie que nous mettons les annotations dans le fichier Java, puis que Spring parsing automatiquement le contexte racine où le fichier de configuration Java, le place et le place dans Spring.

Voici l’URI de détail où vous avez plus d’informations sur Beans

• Les beans Spring ne sont que des instances d’objects gérées par le conteneur Spring IOC.

• Spring Container porte le sac de Bean. La création, la maintenance et la suppression du Bean sont les responsabilités de Spring Container.

• Nous pouvons mettre le haricot au spring par câblage et câblage automatique.

• Le câblage signifie que nous le configurons manuellement dans le fichier XML.

• Le câblage automatique signifie que nous mettons les annotations dans le fichier Java, puis que Spring parsing automatiquement le contexte racine où se trouve le fichier de configuration Java, puis le place dans le sac de Spring.

Les haricots de spring sont des classes. Au lieu d’instancier une classe (à l’aide de new ), vous obtenez une instance en tant que bean convertie dans votre type de classe à partir du contexte d’application, où le bean correspond à celui que vous avez configuré dans la configuration du contexte d’application. De cette façon, l’application entière conserve l’instance singleton-scope dans toute l’application. Tous les beans sont initialisés après leur ordre de configuration juste après que le contexte de l’application est instancié. Event si vous n’obtenez aucun bean dans votre application, toutes les instances de beans sont déjà créées au moment où vous avez créé le contexte d’application.

Au spring, les objects qui constituent l’épine dorsale de votre application et qui sont gérés par le conteneur Spring IoC sont appelés beans. Un bean est simplement un object instancié, assemblé et géré par un conteneur Spring IoC;

Pour le spring, tous les objects sont des haricots! L’étape fondamentale de Spring Framework consiste à définir vos objects en tant que beans. Les beans ne sont que des instances d’objects qui seraient créées par la structure Spring en examinant leurs définitions de classes. Ces définitions forment essentiellement les métadonnées de configuration. Le framework crée ensuite un plan pour lequel les objects doivent être instanciés, quelles dépendances doivent être définies et injectées, la scope de l’instance nouvellement créée, etc., en fonction de ces métadonnées de configuration.

Les métadonnées peuvent être fournies dans un simple fichier XML, comme dans le premier chapitre. Alternativement, on pourrait fournir les métadonnées en tant qu’Annotation ou Configuration Java.

Livre: Just Spring