Qu'est-ce que l'injection de dépendance et l'inversion de contrôle dans Spring Framework?
"Injection de dépendance" et "Inversion de contrôle" sont souvent mentionnés comme les principaux avantages de l'utilisation du framework Spring pour le développement de frameworks Web.
Quelqu'un pourrait-il expliquer ce que c'est en termes très simples avec un exemple si possible?
- Spring aide à la création d'applications à couplage lâche en raison de Injection de dépendance .
- Au printemps, les objets définissent leurs associations (dépendances) et ne s'inquiètent pas de la façon dont ils obtiendront ces dépendances . Spring a la responsabilité de fournir les dépendances requises pour la création d'objets.
Par exemple : Supposons que nous avons un objet Employee et qu'il dépend de l'objet Address. Nous définirions un bean correspondant à Employee qui définira sa dépendance à l’objet Address.
Lorsque Spring essaie de créer un objet Employee, il voit que Employee a une dépendance sur Address et crée donc d'abord l'objet Address (dépendant de objet) puis l’injecter dans l’objet Employee.
Inversion de contrôle ( [~ # ~] ioc [~ # ~] ) et injection de dépendance ( [~ # ~] di [~ # ~] ) sont utilisés de manière interchangeable. IOC est atteint par DI. DI est le processus de fourniture des dépendances et IOC est le résultat final de DI. ( Remarque: DI n’est pas le seul moyen d’obtenir le CIO, il existe aussi d’autres moyens .)
Par DI, la responsabilité de créer des objets est transférée de notre code d'application au conteneur Spring; ce phénomène s'appelle IOC.
- L'injection de dépendance peut être effectuée par injection de setter ou de constructeur.
J'écrirai ma compréhension simple de ces deux termes:
For quick understanding just read examples*
Injection de dépendance (DI):
L'injection de dépendance signifie généralement le passage d'un objet dépendant en tant que paramètre à une méthode, plutôt que de laisser la méthode créer l'objet dépendant .
En pratique, cela signifie que la méthode ne dépend pas directement d’une implémentation particulière; toute implémentation répondant aux exigences peut être transmise en tant que paramètre.
Cette implémentation d'objets définit leurs dépendances. Et le printemps le rend disponible.
Ceci conduit à un développement d’applications faiblement couplé.
Quick Example:EMPLOYEE OBJECT WHEN CREATED,IT WILL AUTOMATICALLY CREATE ADDRESS OBJECT (if address is defines as dependency by Employee object)*.<br>
Conteneur d'inversion de contrôle (IoC):
C’est une caractéristique commune aux frameworks, IOC gère Java objets
- de l’instanciation à la destruction en passant par son BeanFactory.
- Les composants Java instanciés par le conteneur IoC sont appelés des beans et le conteneur IoC gère la portée d'un bean, ses événements de cycle de vie et toutes les fonctions AOP pour lequel il a été configuré et codé.
QUICK EXAMPLE:Inversion of Control is about getting freedom, more flexibility, and less dependency. When you are using a desktop computer, you are slaved (or say, controlled). You have to sit before a screen and look at it. Using keyboard to type and using mouse to navigate. And a bad written software can slave you even more. If you replaced your desktop with a laptop, then you somewhat inverted control. You can easily take it and move around. So now you can control where you are with your computer, instead of computer controlling it.
En implémentant Inversion of Control, un consommateur de logiciels/objets obtient plus de contrôles/options sur les logiciels/objets au lieu d’être contrôlé ou d’avoir moins d’options.
L'inversion du contrôle en tant que directive de conception remplit les fonctions suivantes:
Il y a un découplage de l'exécution d'une tâche donnée de la mise en œuvre.
Chaque module peut se concentrer sur ce pour quoi il est conçu.
Les modules ne font aucune hypothèse sur ce que font les autres systèmes, mais reposent sur leurs contrats.
Le remplacement des modules n'a aucun effet secondaire sur les autres modules
Je vais garder les choses abstraites ici, vous pouvez visiter les liens suivants pour une compréhension détaillée du sujet.
ne bonne lecture avec exemple
Inversion de contrôle (IOC):
IoC est un modèle de conception qui décrit l'inversion du flux de contrôle dans un système. Par conséquent, le flux d'exécution n'est pas contrôlé par un élément de code central. Cela signifie que les composants ne doivent dépendre que des abstractions d'autres composants et ne sont pas responsables de la création d'objets dépendants. Au lieu de cela, les instances d'objet sont fournies au moment de l'exécution par un conteneur IoC via Dependency Injection (DI).
IoC permet une meilleure conception logicielle qui facilite la réutilisation, le couplage lâche et le test facile des composants logiciels.
Injection de dépendance (DI):
[~ # ~] di [~ # ~] est une technique permettant de passer des dépendances au constructeur d’un objet. Si l'objet a été chargé à partir du conteneur, ses dépendances seront automatiquement fournies par le conteneur. Cela vous permet de consommer une dépendance sans avoir à créer manuellement une instance. Cela réduit le couplage et vous donne un plus grand contrôle sur la durée de vie des instances d'objet.
Dans Spring, les objets sont faiblement couplés, c’est-à-dire que chaque classe est indépendante l’une de l’autre, de sorte que tout peut être testé individuellement. Mais lors de l'utilisation de ces classes, une classe peut dépendre d'autres classes qui doivent être instanciées en premier.
Nous disons donc à spring que la classe A dépend de la classe B. Ainsi, lors de la création d'un bean (comme la classe) pour la classe A, il instancie la classe B avant celle de la classe A et l'injecte en classe A à l'aide de méthodes de définition ou de définition de constructeur. C'est-à-dire que nous disons au printemps la dépendance au moment de l'exécution. Ceci est DI.
Comme nous attribuons la responsabilité de créer des objets (beans), de les maintenir et de leurs agrégations à Spring au lieu de les coder en dur, nous l'appelons Inversion Of Control (IOC).
Spring: Spring est le conteneur "Inversion of Control" pour la Java Platform.
Inversion of Control (IoC): Inversion of Control (IoC) est une pratique de programmation orientée objet dans laquelle le couplage d'objet est lié au moment de l'exécution par un objet "assembleur" et ne peut généralement pas être connu au moment de la compilation à l'aide d'une analyse statique.
Injection de dépendance (DI): "L'injection de dépendance est un modèle de conception logicielle qui permet de supprimer les dépendances codées en dur et de les modifier, que ce soit au moment de l'exécution ou de la compilation." -wiki.
Inversion de contrôle- Cela signifie donner le contrôle de la création et de l'instanciation des beans spring au conteneur Spring IOC) et le seul travail que le développeur effectue consiste à configurer les beans dans le fichier XML print.
Dépendance dépendance-
Considérons un employé de classe
class Employee {
private int id;
private String name;
private Address address;
Employee() {
id = 10;
name="name";
address = new Address();
}
}
et considérer l'adresse de la classe
class Address {
private String street;
private String city;
Address() {
street="test";
city="test1";
}
}
Dans le code ci-dessus, les valeurs de la classe d'adresse ne seront définies que lorsque la classe des employés sera instanciée, ce qui correspond à la dépendance de la classe d'adresse sur la classe des employés. Spring résout ce problème en utilisant le concept d’injection de dépendance en proposant deux manières d’injecter cette dépendance.
- Injection de poseur
Méthode Setter dans la classe Employee qui prend une référence à la classe Address
public void setAddress(Address addr) {
this.address = addr;
}
- Injection de constructeur
Constructeur dans la classe Employé qui accepte l'adresse
Employee(Address addr) {
this.address = addr;
}
De cette manière, les valeurs de la classe d’adresses peuvent être définies indépendamment à l’aide de l’injection de setter/constructeur.
Inversion of Control est un principe de conception générique de l’architecture logicielle qui permet de créer des cadres logiciels modulaires réutilisables et faciles à gérer.
C'est un principe de conception dans lequel le flux de contrôle est "reçu" à partir de la bibliothèque générique-écrite ou du code réutilisable.
Pour mieux le comprendre, voyons comment nous avions l'habitude de coder dans nos premiers jours de codage. Dans les langages procéduraux/traditionnels, la logique applicative contrôle généralement le flux de l'application et "appelle" le code/les fonctions génériques ou réutilisables. Par exemple, dans une application console simple, mon flux de contrôle est contrôlé par les instructions de mon programme, pouvant inclure les appels à certaines fonctions générales réutilisables.
print ("Please enter your name:");
scan (&name);
print ("Please enter your DOB:");
scan (&dob);
//More print and scan statements
<Do Something Interesting>
//Call a Library function to find the age (common code)
print Age
Dans Contrast, avec IoC, les Frameworks sont le code réutilisable qui "appelle" la logique applicative.
Par exemple, dans un système Windows, un framework sera déjà disponible pour créer des éléments d'interface utilisateur tels que des boutons, des menus, des fenêtres et des boîtes de dialogue. Lorsque j'écris la logique métier de mon application, ce sont les événements de framework qui appellent mon code de logique métier (lorsqu'un événement est déclenché) et NON l'inverse.
Bien que le code de la structure ne connaisse pas ma logique métier, il saura quand même appeler mon code. Ceci est réalisé en utilisant des événements/délégués, des rappels, etc. Ici, le contrôle du flux est "inversé".
Ainsi, au lieu de dépendre du flux de contrôle sur des objets liés de manière statique, le flux dépend du graphe d'objet global et des relations entre les différents objets.
L'injection de dépendance est un modèle de conception qui met en œuvre le principe IoC pour résoudre les dépendances des objets.
En termes plus simples, lorsque vous essayez d'écrire du code, vous allez créer et utiliser différentes classes. Une classe (classe A) peut utiliser d'autres classes (classes B et/ou D). Donc, les classes B et D sont des dépendances de la classe A.
Une simple analogie sera une voiture de classe. Une voiture peut dépendre d'autres classes comme le moteur, les pneus et plus encore.
L'injection de dépendance suggère qu'au lieu que les classes de dépendance (classe Car ici) créent ses dépendances (classe Engine et classe Tire), la classe devrait être injectée avec l'instance concrète de la dépendance.
Permet de comprendre avec un exemple plus pratique. Considérez que vous écrivez votre propre TextEditor. Entre autres choses, vous pouvez avoir un correcteur orthographique qui fournit à l’utilisateur une possibilité de vérifier les fautes de frappe dans son texte. Une implémentation simple d'un tel code peut être:
Class TextEditor
{
//Lot of rocket science to create the Editor goes here
EnglishSpellChecker objSpellCheck;
String text;
public void TextEditor()
{
objSpellCheck = new EnglishSpellChecker();
}
public ArrayList <typos> CheckSpellings()
{
//return Typos;
}
}
À première vue, tout semble rose. L'utilisateur va écrire du texte. Le développeur va capturer le texte et appeler la fonction CheckSpellings et trouver une liste de fautes de frappe qu'il montrera à l'utilisateur.
Tout semble bien fonctionner jusqu'au jour où un utilisateur commence à écrire le français dans l'éditeur.
Pour fournir un support pour plus de langues, nous avons besoin de plus de SpellCheckers. Probablement français, allemand, espagnol, etc.
Ici, nous avons créé un code étroitement associé, SpellChecker "anglais" étant étroitement associé à notre classe TextEditor, ce qui signifie que notre classe TextEditor dépend de EnglishSpellChecker ou en d'autres termes, EnglishSpellCheker est la dépendance de TextEditor. Nous devons supprimer cette dépendance. En outre, notre éditeur de texte a besoin d'un moyen de conserver la référence concrète de tout vérificateur orthographique en fonction de la discrétion du développeur au moment de l'exécution.
Ainsi, comme nous l’avons vu dans l’introduction de DI, cela suggère que la classe devrait être injectée avec ses dépendances. Ainsi, il devrait être de la responsabilité du code appelant d'injecter toutes les dépendances à la classe/code appelée. Afin que nous puissions restructurer notre code comme
interface ISpellChecker
{
Arraylist<typos> CheckSpelling(string Text);
}
Class EnglishSpellChecker : ISpellChecker
{
public override Arraylist<typos> CheckSpelling(string Text)
{
//All Magic goes here.
}
}
Class FrenchSpellChecker : ISpellChecker
{
public override Arraylist<typos> CheckSpelling(string Text)
{
//All Magic goes here.
}
}
Dans notre exemple, la classe TextEditor doit recevoir l'instance concrète de type ISpellChecker.
Maintenant, la dépendance peut être injectée dans Constructor, une propriété publique ou une méthode.
Essayons de changer notre classe en utilisant Constructor DI. La classe TextEditor modifiée ressemblera à quelque chose comme:
Class TextEditor
{
ISpellChecker objSpellChecker;
string Text;
public void TextEditor(ISpellChecker objSC)
{
objSpellChecker = objSC;
}
public ArrayList <typos> CheckSpellings()
{
return objSpellChecker.CheckSpelling();
}
}
Ainsi, lors de la création de l'éditeur de texte, le code appelant peut injecter le type SpellChecker approprié à l'instance de TextEditor.
Vous pouvez lire l'article complet ici
La méthode traditionnelle pour obtenir une instance d'adresse dans Employee consiste à créer une nouvelle instance de classe Address.
Donc, au printemps, nous dépendons simplement du conteneur de printemps qui nous fournit l'objet de dépendance.
CIO est une technique qui consiste à laisser quelqu'un d'autre créer l'objet à votre place. Et la personne d’autre en cas de ressort est IOC conteneur.
L'injection de dépendance est une technique dans laquelle un objet fournit la dépendance d'un autre objet.