Le modèle d’injection de dépendance a toujours été l’un des concepts qu’il en coûte pour comprendre dans le monde du développement logiciel, en particulier pour les personnes qui commencent. Quel est ce modèle de conception pour quelle est votre utilisation? Normalement, lorsque nous prenons au jour le jour avec la programmation orientée objet, nous trouvons les objets de construction d’objets et reliant des objets à l’aide de dépendances.
Par exemple, nous pouvons avoir un programme principal qui utilise un simple service d’impression pour imprimer un document.
package com.arquitecturajava;public class ServicioImpresion {public void imprimir() {System.out.println("enviando el documento a imprimir");System.out.println("imprimiendo el documento en formato pdf");}}
Nous utilisons un programme de programme E principal:
package com.arquitecturajava;public class Principal {public static void main(String args) {ServicioImpresion miServicio= new ServicioImpresion();miServicio.imprimir();}}
up gratuit et nous verrons Le résultat imprimé sur la console:
<6D4E9D9F5C "> Aucune injection de dépendance
Injection de dépendance
Cependant, la chose logique est que ce programme divise ses responsabilités un peu plus et ce composé de plusieurs services comme les suivants:
Jusqu’à présent, tout est assez raisonnable et ce que nous obtenons est que notre service d’impression dépend d’autres services et responsabilités sont plus claires. Nous venons de générer des dépendances au service d’impression. Le code serait quelque chose comme ce qui suit.
public class ServicioImpresion {ServicioEnvio servicioA;ServicioPDF servicioB; public ServicioImpresion() {this.servicioA= new ServicioEnvio();this.servicioB= new ServicioPDF();}public void imprimir() {servicioA.enviar();servicioB.pdf();}}
public class ServicioEnvio {public void enviar() {System.out.println("enviando el documento a imprimir");}}
Le résultat dans la console sera le même que nous avons mieux divisé.
La même opération peut être effectuée en injectant les dépendances au service de service et qui n’est pas celui qui doit les définir dans le constructeur.
Ceci semble Principe un changement sans importance, le code serait:
package com.arquitecturajava.parte3;public class ServicioImpresion {ServicioEnvio servicioA;ServicioPDF servicioB;public ServicioImpresion(ServicioEnvio servicioA,ServicioPDF servicioB) {this.servicioA= servicioA;this.servicioB= servicioB;}public void imprimir() {servicioA.enviar();servicioB.pdf();}}
<667ec1025e ">
Le résultat est toujours le même. Nous venons de injecter les dépendances au service de notre programme principal. Quels avantages cela contribuent-il? . La réalité est que, en principe, il semble qu’aucun. Mais il y a quelque chose qui a changé n’est plus le service lui-même responsable de la définition de ses dépendances, mais c’est le programme principal. Cela ouvre les portes à l’extensibilité. C’est-à-dire que nous devons-nous toujours injecter les mêmes dépendances en service? La réponse semble évidente … bien sûr, ils sont déjà définis. Cependant, la réponse est non, nous pouvons changer le type de dépendance que nous injectons, en prolongeant simplement l’une de nos classes et modifier le comportement, voyons-le.
public class ServicioEnvioAspecto extends ServicioEnvio {@Overridepublic void enviar() {System.out.println("haciendo log del correo que vamos a enviar");super.enviar();}}
Nous venons de créer une classe qui étend Serviceenvius et ajoute une fonctionnalité de journal supplémentaire qui fait un « journal » de l’e-mail que nous envoyons. Maintenant, c’est aussi simple que de dire le programme principal que lors de l’injection de la dépendance n’injecte pas le formulaire Serviceenvi. aura beaucoup changé de comportement.
public class Principal {public static void main(String args) {ServicioImpresion miServicio= new ServicioImpresion(new ServicioEnvioAspecto(),new ServicioPDF());miServicio.imprimir();}}
Le résultat dans la console sera:
« 16b241céaa »> Injection de dépendance
Nous venons de modifier le comportement de notre programme de manière significative grâce à l’utilisation du concept Injection de dépendance.
Dépendance d’injection du patrimoine
L’injection de dépendance nous permet d’injecter d’autres classes et d’ajouter des fonctionnalités transversales personnalisées. Ce modèle de conception est celui qui ouvre la porte aux cadres en tant que ressort utilisant le concept d’injection de dépendance de manière plus avancée. Dans ces cadres, les aspects ajoutés à nos classes sont une complexité multiple et élevée.
L’importance du modèle d’injection de dépendance est aujourd’hui dans la plupart des cadres.
Autres articles connexes
- Spring @qualifier à l’aide de @Autowired
- printemps @IMPORT, organisant le framework de printemps
- Java 8 modèle d’usine et sa mise en œuvre
articles externes
- Injection de dépendance