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. Quels sont donc les haricots de printemps? Comment peuvent-ils être utilisés? Ont-ils quelque chose à voir avec l'injection de dépendance?

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. Ces beans sont créés avec les métadonnées de configuration que vous fournissez au conteneur, par exemple, sous la forme de <bean/>définitions XML .

En savoir plus sur les beans et la portée de SpringSource :

Lorsque vous créez une définition de bean, ce que vous créez réellement 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 elle signifie que, tout comme une classe, vous pouvez potentiellement créer de nombreuses instances d'objet à partir d'une seule recette.

Vous pouvez contrôler non seulement les diverses dépendances et valeurs de configuration qui doivent être connectées à 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 flexibilité de choisir la portée des objets que vous créez par le biais de la configuration au lieu d'avoir à «cuire» 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'une des nombreuses étendues

* IoC: inversion de contrôle

Les beans Spring ne sont que des objets d'instance qui sont gérés par le conteneur Spring, c'est-à-dire qu'ils sont créés et câblés par le framework et placés dans un "sac d'objets" (le conteneur) d'où vous pourrez les récupérer plus tard.

La partie "câblage", c'est ce qu'est l'injection de dépendances, ce que cela signifie, c'est que vous pouvez simplement dire "j'aurai besoin de cette chose" et le framework suivra quelques règles pour vous donner l'instance appropriée.

Pour quelqu'un qui n'est pas habitué à Spring, je pense que l'article de Wikipedia Spring a une belle description :

Au cœur de Spring Framework se trouve son inversion du conteneur de contrôle, qui fournit un moyen cohérent de configurer et de gérer les objets Java à l'aide de la réflexion. Le conteneur est chargé de gérer les cycles de vie des objets d'objets spécifiques: créer ces objets, appeler leurs méthodes d'initialisation et configurer ces objets en les câblant ensemble.

Les objets créés par le conteneur sont également appelés objets 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 bean qui fournissent les informations requises pour créer les beans.

Les objets peuvent être obtenus au moyen d'une recherche de dépendance ou d' une 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épendances est un modèle dans lequel le conteneur transmet des objets par leur nom à d'autres objets, via des constructeurs, des propriétés ou des méthodes d'usine.

Comprenons d'abord le printemps:

Le printemps est un cadre léger et flexible.

Analogie:

Bean: est un objet qui est 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), ce qui est appelé inversion de contrôle.

Analogie: Supposons que l'agriculteur possède une terre agricole cultivée par graines (ou haricots). Ici, Farmer est Spring Framework, les terres agricoles sont Spring Container, les haricots sont Spring Beans, la culture est Spring Processors.

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

source img

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

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

• Remplir les propriétés: à l'aide de l'injection de dépendances, spring remplit toutes les propriétés comme spécifié dans la définition du bean.

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

• Définir la fabrique de bean: si Bean implémente l' BeanFactoryAwareinterface, le ressort passe la beanfactory à la setBeanFactory()méthode.

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

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

• Prêt à l'emploi: le bean est maintenant prêt à l'emploi par l'application

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

Vous l'avez bien compris partiellement. Vous devez adapter les haricots en fonction de vos besoins et informer Spring Container de le gérer en cas de besoin, 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 câblez les beans de manière à ne pas avoir à vous soucier de l'instanciation ou à évaluer toute dépendance à l'égard du bean. Ceci est populairement connu comme le principe d'Hollywood .

Google est le meilleur outil pour en savoir plus à ce sujet en plus des liens qui vous submergeraient ici dans cette question. :)

Le printemps a le conteneur IoC qui porte le sac de haricots; la création, la maintenance et la suppression sont des responsabilités de Spring Container. Nous pouvons mettre le haricot dans Spring par câblage et câblage automatique. Le câblage signifie que nous le configurons manuellement dans le fichier XML et "Auto Wiring" signifie que nous mettons les annotations dans le fichier Java puis Spring scanne automatiquement le contexte racine où le fichier de configuration java, le fait et le met dans le sac de Spring.

Voici l'URI détaillé où vous avez obtenu plus d'informations sur Beans

Les haricots de printemps sont des classes. Au lieu d'instancier une classe (à l'aide new), vous obtenez une instance en tant que beantranstypage en votre type de classe à partir du contexte d'application, où le bean est ce que vous avez configuré dans la configuration du contexte d'application. De cette façon, l'application entière conserve une instance de portée singleton dans toute l'application. Tous les beans sont initialisés suivant leur ordre de configuration juste après l'instanciation du contexte d'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 où vous avez créé le contexte de l'application.

• 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 haricots. La création, la maintenance et la suppression des haricots incombent à Spring Container.

• Nous pouvons mettre le haricot dans 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 analyse automatiquement le contexte racine où se trouve le fichier de configuration java, le crée et le met dans le sac de Spring.

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

Les conteneurs Spring ne créent qu'une seule instance du bean par défaut. Ce bean est mis en cache en mémoire, donc toutes les requêtes pour le bean renverront une référence partagée au 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 utilisons-nous l'annotation @Bean?

Lorsque la configuration automatique n'est pas une option. Par exemple, lorsque nous voulons câbler des composants à partir d'une bibliothèque tierce, car le code source n'est pas disponible, nous ne pouvons donc pas annoter les classes avec @Component.

Un scénario en temps réel pourrait être que quelqu'un souhaite se connecter au compartiment Amazon S3. Parce que la source n'est 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 pour le code ci-dessus -> https://www.devglan.com/spring-mvc/aws-s3-java

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

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

L'annotation de composant enregistre la classe comme un bean unique.

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 simplement un objet qui est instancié, assemblé et autrement géré par un conteneur Spring IoC;

Pour le printemps, tous les objets sont des haricots! L'étape fondamentale du Spring Framework consiste à définir vos objets en tant que beans. Les beans ne sont rien d'autre que des instances d'objets qui seraient créées par le framework Spring en examinant leurs définitions de classe. Ces définitions forment essentiellement les métadonnées de configuration. Le cadre crée ensuite un plan pour lequel les objets doivent être instanciés, quelles dépendances 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. Alternativement, on pourrait fournir les métadonnées sous forme d'annotation ou de configuration Java.

Livre: Just Spring

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

MyRepository myRepository =new MyRepository ();

Lorsque vous utilisez ce mot clé nouveau, c'est quelque part, vous pouvez envisager de supprimer cette configuration et de 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();
    }
}