Injection de dépendance au printemps

L'injection de dépendance ou le CIO est un concept de base du cadre de ressort qui aide à gérer les objets Bean dans l'application. L'injection de dépendance, ou DI, comme le nom l'indique, gère les objets dépendants et rend notre code à coupler de manière lâche.

Par exemple, une application Spring peut créer plusieurs modules dépendants les uns des autres pour former une application pleinement fonctionnelle. Les objets dépendants doivent fournir leur instance pendant l'exécution sinon la demande peut se décomposer. Ainsi, en tant que cadre, Spring gère cette situation et fournit des objets de haricot lors de l'exécution.

Le CIO (inversion du contrôle) fait cette tâche, je.e., Injecte les dépendances pendant la création de haricots. Il s'agit d'un conteneur central qui crée, configure, gère des objets et gère même tout le cycle de vie d'un objet.

Spring DI est principalement classé comme un Constructeur injection de dépendance et un Setter injection de dépendance.

Dans cet article, nous allons Apprenez d'abord sur le constructeur Injection de dépendance et passage à la base du secteur dans le sujet suivant.

Commençons par une application de printemps basée sur Maven qui contient les fichiers Java et Config suivants.

// Employé.Java

Il s'agit d'une simple classe de bean qui contient deux propriétés et des méthodes de setter-getter.

Package com.linuxhint.haricots;
org d'importation.springframework.stéréotype.Composant;
@Composant
Employé de classe publique
INT PRIVÉ ID;
nom de chaîne privé;
public String getName ()
nom de retour;

public void setName (nom de chaîne)
ce.name = name;

public int getID ()
Retour ID;

public void setid (int id)
ce.id = id;

// Chef de projet.Java

Ici, nous avons créé un autre haricot contenant des méthodes Getter-Setter, et le point important est d'observer le constructeur ProjectManager () qui agit comme un DI basé sur le constructeur. Il crée un objet de haricot de la classe des employés tout en chargeant dans le contexte de l'application.

Package com.linuxhint.haricots;
org d'importation.springframework.stéréotype.Composant;
@Composant
classe publique ProjectManager
employé privé;
Public ProjectManager (employé employé)
ce.Employé = employé;

public void setInfo (int id, nom de chaîne)
employé.setID (id);
employé.setName (name);

String public getInfo ()
retourner «id =» + employé.getID () + ”\ nname =“ + Employé.getName ();

// Springapp.Java

C'est la classe principale qui charge SpringConfig. Ici, nous avons utilisé la méthode getbean () pour obtenir un objet de classe ProjectManager. Après cela, nous définissons et obtenons des valeurs pour cet objet.

Package com.Linuxhint;
org d'importation.springframework.contexte.annotation.AnnotationConfigApplicationContext;
Importer com.linuxhint.haricots.Chef de projet;
classe publique SpringApp
public static void main (String [] args)
AnnotationConfigApplicationContext AC = new AnnotationConfigApplicationContext (SpringConfig.classe);
ProjectManager PM = AC.Getbean (ProjectManager.classe);
PM.SetInfo (102, «Roman»);
Résultat de la chaîne = PM.getInfo ();
Système.dehors.println (résultat);
CA.fermer();

// SpringConfing.Java

Ceci est la classe de configuration qui aide à configurer l'application. Il est important lors de la configuration des applications en utilisant des annotations.

Package com.Linuxhint;
org d'importation.springframework.contexte.annotation.Composantscan;
org d'importation.springframework.contexte.annotation.Configuration;
@Configuration
@Componentscan («com.linuxhint.* ”)
classe publique SpringConfig

// pom.xml

Ce fichier contient des dépendances Maven pour le projet de printemps.

4.0.0
com.linuxhint
Springapp
0.0.1 snapshot
Springapp
Une application de printemps simple


org.springframework
printemps
$ printemps.version


org.springframework
contexte de printemps
$ printemps.version


javax.annotation
javax.annotation-api
1.3.2



5.2.8.LIBÉRER

Structure du projet

Après avoir créé tous les fichiers et le code, notre structure de projet est présentée ci-dessous:

Exécuter l'application

Maintenant, exécutez l'application et il doit afficher la sortie suivante dans la fenêtre de la console:

id = 102
Nom = romain

Configuration à l'aide du code XML

Vous pouvez le faire si vous souhaitez configurer votre application à l'aide du code XML. Cependant, la configuration XML est à l'ancienne. Vous avez le choix de configurer votre application en utilisant des annotations XML ou Java.

Dans le cas XML, nous avons juste besoin de créer un fichier applicationContext.xml et lisez-le dans le Springapp fichier de classe. Ton applicationContext.xml Le fichier doit contenir le code XML suivant:

// ApplicationContext.xml

xmlns: xsi = "http: // www.W3.org / 2001 / xmlschema-instance "
xmlns: p = "http: // www.springframework.org / schéma / p "
XSI: ScheMalation = "http: // www.springframework.org / schéma / haricots
http: // www.springframework.org / schéma / haricots / barils de ressort-3.0.xsd ">
class = "com.linuxhint.haricots.ProjectManager "/>

Ici, la balise est utilisée pour spécifier la classe de bean, et l'ID spécifie l'instance Bean. La balise spécifie la dépendance du constructeur et la balise pour injecter l'objet dans le constructeur.

Conclusion

Dans cet article, nous avons appris l'injection de dépendance au printemps basée sur le constructeur. Nous avons appris sa configuration en utilisant des annotations Java et XML. Puisqu'il s'agit d'un concept de base du framework Spring, vous devez l'apprendre avec l'exemple en cours d'exécution que nous avons expliqué.