web-dev-qa-db-fra.com

Que sont les haricots de printemps dans le monde?

Je n'ai pas encore trouvé de définition de haut niveau des haricots de printemps que je puisse comprendre. Je les vois souvent référencés dans la documentation et les livres de Grails, mais je pense que comprendre ce qu’ils sont serait bénéfique. Alors, quels sont les haricots de printemps? Comment peuvent-ils être utilisés? Ont-ils quelque chose à voir avec l'injection de dépendance?

javaspringgrails
361
grantmcconnaughey

Les objets qui constituent le cœur de votre application et qui sont gérés par le conteneur Spring IoC * sont appelés des beans. Un bean est un objet instancié, assemblé et géré autrement 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.

Pour en savoir plus sur les haricots et la portée de SpringSource :

Lorsque vous créez une définition de bean, vous créez en réalité 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 avoir plusieurs instances d'objet créées à partir d'une seule recette.

Vous pouvez contrôler non seulement les différentes dépendances et les valeurs de configuration à connecter à un objet créé à partir d'une définition de bean particulière, mais également la portée des objets créés à partir d'une définition de bean particulière. Cette approche est très puissante et vous donne la possibilité de choisir la portée des objets que vous créez par le biais de la configuration au lieu de devoir "cuire" la portée d'un objet au niveau de la classe Java. Les haricots peuvent être définis pour être déployés dans un ou plusieurs domaines

* IoC: Inversion of Control

192
Juned Ahsan

Les beans Spring ne sont que des instances d'objet gérées par le conteneur Spring. En effet, ils sont créés et câblés par le framework, puis placés dans un "sac d'objets" (le conteneur) à partir duquel vous pourrez les récupérer ultérieurement.

La partie "câblage" de l’injection de dépendance consiste en ce que vous pouvez simplement dire "j’aurai besoin de cette chose" et que le cadre suivra certaines règles pour vous donner la bonne instance.

Pour ceux qui ne sont pas habitués au printemps, je pense que l'article de Wikipedia dans Spring a une description intéressante :

Le cadre central de Spring Framework est l’inversion du conteneur de contrôles, qui fournit un moyen cohérent de configuration et de gestion des objets Java à l’aide de la réflexion. Le conteneur est responsable de la gestion du cycle de vie des objets d'objets spécifiques: création de ces objets, appel de leurs méthodes d'initialisation et configuration de ces objets en les reliant entre eux.

Les objets créés par le conteneur sont également appelés des objets gérés ou des 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 objets peuvent être obtenus au moyen de recherche de dépendance ou de injection de dépendance . La recherche de dépendance est un modèle dans lequel un appelant demande à l'objet conteneur un objet avec un nom spécifique ou d'un type spécifique. L'injection de dépendance est un modèle dans lequel le conteneur transmet les objets par leur nom à d'autres objets, via des constructeurs, des propriétés ou des méthodes d'usine.

121
Elias Dorneles

D'abord laissez-nous comprendre le printemps:

Spring est un cadre léger et flexible.

Analogie:
enter image description here

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

Analogie: Supposons qu'un agriculteur cultive des terres cultivées avec des semences (ou des haricots). Ici, Farmer is Spring Framework, les terres agricoles sont Spring Container, les haricots sont des haricots de printemps, la culture est des processeurs de printemps.

enter image description here

Comme le cycle de vie d'un haricot, le haricot de printemps a aussi son propre cycle de vie.

enter image description here

enter image description here

source img

Voici la séquence du cycle de vie d'un haricot au printemps:

  • Instancier: le conteneur de printemps trouve la définition du bean à partir du fichier XML et instancie le bean.

  • Propriétés de peuplement: à l'aide de l'injection de dépendance, spring remplit toutes les propriétés spécifiées dans la définition du bean.

  • Définir le nom du bean: si le bean implémente l'interface BeanNameAware, spring transmet l'identifiant du bean à la méthode setBeanName().

  • Définir la fabrique de beans: Si Bean implémente l'interface BeanFactoryAware, spring transmet le beanfactory à la méthode setBeanFactory().

  • Pré-initialisation: Aussi appelé post-traitement du haricot. Si un bean BeanPostProcessors est associé 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: - S'il y a du BeanPostProcessors associé 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().

38
Premraj

Eh bien, vous l'avez compris partiellement. Vous devez adapter les haricots en fonction de vos besoins et informer le conteneur Spring de le gérer en cas de besoin, à l'aide d'une méthodologie connue sous le nom de IoC ( Inversion of Control ) forgé par Martin Fowler =, également appelé Injection de dépendance (DI).

Vous câblez les haricots de manière à ne pas avoir à vous occuper de l'instanciation ou à évaluer une éventuelle dépendance à l'égard du haricot. Ceci est communément appelé principe d'Hollywood .

Google est le meilleur outil pour explorer davantage ce sujet, en plus des liens qui vous envahiraient ici dans cette question. :)

22
dmahapatro

Spring a le conteneur IoC qui porte le sac de haricot; La création, la maintenance et la suppression sont les responsabilités de Spring Container. Nous pouvons mettre le haricot au printemps par câblage et câblage automatique. Câblage signifie que nous le configurons manuellement dans le fichier XML et "Câblage automatique" signifie que nous plaçons les annotations dans le fichier Java, puis que Spring scanne automatiquement le contexte racine où le fichier de configuration Java est et mis dans le sac de printemps.

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

8
Yasir Shabbir Choudhary

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

  • Le conteneur Spring IOC porte le sac de haricot. La création, la maintenance et la suppression de haricots sont la responsabilité de Spring Container.

  • Nous pouvons mettre le haricot au printemps 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 plaçons les annotations dans le fichier Java, puis que Spring analyse automatiquement le contexte racine dans lequel le fichier de configuration Java est créé et placé dans le sachet de Spring.

5
maniBrock

Les haricots de printemps sont des cours. Au lieu d'instancier une classe (à l'aide de new), vous obtenez une instance sous la forme d'un attribut bean vers votre type de classe à partir du contexte d'application, où le bean correspond à ce que vous avez configuré dans la configuration du contexte d'application. De cette façon, l’application entière conserve une instance singleton-scope dans l’application. Tous les beans sont initialisés en suivant l'ordre de configuration juste après l'instanciation du contexte de l'application. Même si vous n'obtenez pas de beans dans votre application, toutes les instances de beans sont déjà créées au moment de la création du contexte de l'application.

4
Downhillski

Au printemps, les objets constituant l’ossature de votre application et gérés par le conteneur Spring IoC sont appelés beans. Un haricot est simplement un objet instancié, assemblé et géré d'une autre manière par un conteneur Spring IoC;

2
user3472473

Pour le printemps, tous les objets sont des haricots! L'étape fondamentale dans Spring Framework consiste à définir vos objets en tant que haricots. Les haricots ne sont rien d'autre que des instances d'objet qui pourraient être créées par le framework spring en regardant leurs définitions de classe. Ces définitions constituent essentiellement les métadonnées de configuration. La structure crée ensuite un plan pour lequel les objets doivent être instanciés, les dépendances qui doivent être définies et injectées, la portée 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. Vous pouvez également fournir les métadonnées sous forme d'annotation ou de configuration Java.

Livre: Just Spring

1
BERGUIGA Mohamed Amine

La configuration XML de Spring est composée de Beans et les Beans sont essentiellement des classes. Ce ne sont que des POJO que nous utilisons dans notre ApplicationContext. Définir les haricots peut être considéré comme remplaçant le mot clé new. Donc, partout où vous utilisez le mot-clé new dans votre application, quelque chose comme:

MyRepository myRepository =new MyRepository ();

Si vous utilisez ce mot-clé nouvea, vous pouvez supprimer cette configuration et la placer dans un fichier XML. Nous allons donc coder comme ceci:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

Maintenant, nous pouvons simplement utiliser Setter Injection/Constructor Injection. J'utilise Setter Injection.

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}
0
Wiqi