O patrón de inxección de dependencia ea súa utilidade

O patrón de inxección de dependencia sempre foi un dos conceptos que custa comprender no mundo do desenvolvemento de software, especialmente para as persoas que están empezando. Cal é este patrón de deseño para que é o seu uso? Normalmente, cando programamos día a día con programación orientada a obxectos, atopámosvos obxectos de construción e relacionación de obxectos mediante dependencias.

Por exemplo, podemos ter un programa primario que usa un servizo de impresión sinxelo para imprimir un documento.

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");}}

Utilizamos un programa principal e programa:

package com.arquitecturajava;public class Principal {public static void main(String args) {ServicioImpresion miServicio= new ServicioImpresion();miServicio.imprimir();}}

Up Non ten nada especial e veremos O resultado impreso na consola:

inxección de dependencia

Con todo, o lóxico é que este programa divide as súas responsabilidades un pouco máis e este composto de varios servizos algo así como o seguinte:

Ata agora todo é bastante razoable e o que obtemos é que o noso servizo de impresión é Depende doutros servizos e responsabilidades que sexan máis claras. Acabamos de xerar dependencias ao servizo de impresión. O código sería algo así como o seguinte.

public class ServicioEnvio {public void enviar() {System.out.println("enviando el documento a imprimir");}}

public class ServicioPDF {public void pdf() {System.out.println("imprimiendo el documento en formato pdf");}}

O resultado da consola será o mesmo que dividimos mellor.

Resultence de dependencia de inxección

A mesma operación pódese realizar inxectando as dependencias ao servizo e que non é o que ten que definilo no constructor.

isto parece en Principio Un cambio sen importancia, o código sería:

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();}}

public class Principal {public static void main(String args) { ServicioImpresion miServicio= new ServicioImpresion(new ServicioEnvio(),new ServicioPDF());miServicio.imprimir();}}

O resultado é aínda o mesmo. Acabamos de inxectar as dependencias do servizo do noso programa principal. Que vantaxes contribúe isto? .. A realidade é que, en principio, parece que ningunha. Pero hai algo que cambiou xa non é o servizo responsable de definir as súas dependencias, pero é o programa principal. Isto abre as portas á extensibilidade. É dicir, sempre temos que inxectar as mesmas dependencias en servizo?. A resposta parece obvia … por suposto que xa están definidos. Non obstante, a resposta non é, podemos cambiar o tipo de dependencia que inxectamos, simplemente estendendo unha das nosas clases e cambiando o comportamento, vémano.

public class ServicioEnvioAspecto extends ServicioEnvio {@Overridepublic void enviar() {System.out.println("haciendo log del correo que vamos a enviar");super.enviar();}}

Acabamos de crear unha clase que se estende a ServiceEnvius e engade unha funcionalidade de rexistro adicional que fai que un “rexistro” do correo electrónico que enviamos. Agora é tan sinxelo como dicir que o programa principal que ao inxectar a dependencia non inxecta a forma de servizo cambiará considerablemente o comportamento.

public class Principal {public static void main(String args) {ServicioImpresion miServicio= new ServicioImpresion(new ServicioEnvioAspecto(),new ServicioPDF());miServicio.imprimir();}}

O resultado da consola será:

Acabamos de modificar o comportamento do noso programa significativamente grazas ao uso do concepto inxección de dependencia.

A inxección de dependencia permítenos inxectar outras clases e engadir unha funcionalidade transversal personalizada. Este patrón de deseño é o que abre a porta a frameworks como a primavera usando o concepto de inxección de dependencia de forma máis avanzada. Neste marco, os aspectos que se engaden ás nosas clases son de múltiple e alta complexidade.