¿Te gustaría tomar un taller de API REST con Spring Boot y JPA?
Tenemos los diplomados que necesitas.¡Haz clic aquí!

 

El patrón de inyección de dependencia siempre ha sido uno de los conceptos que cuesta entender en el mundo del desarrollo de software sobre todo a la gente que esta empezando. ¿Para qué sirve este patrón de diseño y cual es su utilizad? Normalmente cuando nosotros programamos en el día a día con la programación orientada a objeto nos encontramos construyendo objetos y relacionando objetos utilizando dependencias.

Por ejemplo podemos tener un programa principal que use un sencillo servicio de impresión para imprimir un documento.

  1. package com.arquitecturajava;
  2. public class ServicioImpresion {
  3. public void imprimir() {
  4. System.out.println(“enviando el documento a imprimir”);
  5. System.out.println(“imprimiendo el documento en formato pdf”);
  6. }
  7. }

Utilizamos un programa main e imprimimos:

  1. package com.arquitecturajava;
  2. public class Principal {
  3. public static void main(String[] args) {
  4. ServicioImpresion miServicio= new ServicioImpresion();
  5. miServicio.imprimir();
  6. }
  7. }

Hasta ahí no tiene nada de especial y veremos impreso el resultado en la consola:

sin inyección de dependencia

Inyeccion de Dependencia

Sin embargo lo lógico es que este programa divida un poco más sus responsabilidades y este compuesto de varios servicios algo como lo siguiente:

Hasta aquí todo es bastante razonable y lo que conseguimos es que nuestro servicio de impresión dependa de otros servicios y las responsabilidades queden mas claras. Acabamos de generar dependencias al Servicio de impresión . El código sería algo como lo siguiente.

  1. public class ServicioImpresion {
  2. ServicioEnvio servicioA;
  3. ServicioPDF servicioB;
  4. public ServicioImpresion() {
  5. this.servicioA= new ServicioEnvio();
  6. this.servicioB= new ServicioPDF();
  7. }
  8. public void imprimir() {
  9. servicioA.enviar();
  10. servicioB.pdf();
  11. }
  12. }
  1. public class ServicioEnvio {
  2. public void enviar() {
  3. System.out.println(“enviando el documento a imprimir”);
  4. }
  5. }
  1. public class ServicioPDF {
  2. public void pdf() {
  3. System.out.println(“imprimiendo el documento en formato pdf”);
  4. }
  5. }

El resultado en la consola será el mismo solo que hemos dividido mejor.

inyección dependencia resultado

Se puede realizar la misma operación inyectando las dependencias al ServicioImpresión y que no sea él el que tenga que definirlas en el constructor.

Este parece en principio un cambio sin importancia, el código quedaría:

  1. package com.arquitecturajava.parte3;
  2. public class ServicioImpresion {
  3. ServicioEnvio servicioA;
  4. ServicioPDF servicioB;
  5. public ServicioImpresion(ServicioEnvio servicioA,ServicioPDF servicioB) {
  6. this.servicioA= servicioA;
  7. this.servicioB= servicioB;
  8. }
  9. public void imprimir() {
  10. servicioA.enviar();
  11. servicioB.pdf();
  12. }
  13. }
  1. public class Principal {
  2. public static void main(String[] args) {
  3. ServicioImpresion miServicio=
  4. new ServicioImpresion(new ServicioEnvio(),new ServicioPDF());
  5. miServicio.imprimir();
  6. }
  7. }

El resultado sigue siendo el mismo. Acabamos de inyectar las dependencias en el servicio desde nuestro programa main . ¿Qué ventajas aporta esto? . La realidad es que en principio parece que ninguna . Pero hay algo que ha cambiado ya no es el propio servicio el responsable de definir sus dependencias sino que lo es el programa principal.  Esto abre las puertas a la extensibilidad. Es decir ¿tenemos nosotros siempre que inyectar las mismas dependencias al servicio?. La respuesta parece obvia… claro que sí están ya definidas. Sin embargo la respuesta es NO , nosotros podemos cambiar el tipo de dependencia que inyectamos , simplemente extendiendo una de nuestras clases y cambiando el comportamiento, vamos a verlo.

  1. public class ServicioEnvioAspecto extends ServicioEnvio {
  2. @Override
  3. public void enviar() {
  4. System.out.println(“haciendo log del correo que vamos a enviar”);
  5. super.enviar();
  6. }
  7. }

Acabamos de crear una clase que extiende ServicioEnvio y añade una funcionalidad adicional de log que hace un “log” del correo que enviamos . Ahora es tan sencillo como decirle al programa principal que cuando inyecte la dependencia no inyecte el ServicioEnvio sino el ServicioEnvioAspecto de esta forma habremos cambiado el comportamiento de forma considerable.

  1. public class Principal {
  2. public static void main(String[] args) {
  3. ServicioImpresion miServicio=
  4. new ServicioImpresion(new ServicioEnvioAspecto(),new ServicioPDF());
  5. miServicio.imprimir();
  6. }
  7. }

El resultado en la consola será:

inyección dependencia

Acabamos de modificar el comportamiento de nuestro programa de forma significativa gracias al uso del concepto de inyección de dependencia.

La inyección de dependencia nos permite inyectar otras clases y añadir funcionalidad transversal a medida. Este patrón de diseño es el que abre la puerta a frameworks como Spring utilizando el concepto de inyección de dependencia de una forma más avanzada. En estos framework los aspectos que se añaden a nuestras clases son múltiples y la complejidad alta.

La importancia del patrón de inyección de dependencia es hoy clave en la mayoría de los frameworks.

Te esperamos en los siguientes artículos en donde hablaremos mas acerca de estos temas, los cuales hoy en día son de vital importancia en el mundo de la tecnología.

¿Te gustaría tomar un taller de API REST con Spring Boot y JPA?
Tenemos los diplomados que necesitas.¡Haz clic aquí!
About Author

NGuerrero

0 0 votos
Article Rating
Suscribir
Notificar de
guest
0 Comments
Comentarios.
Ver todos los comentarios
0
¿Te gusta este articulo? por favor comentax
()
x
Abrir chat
¿Quieres aprender a programar?
Hola 👋,
¿Te interesa información de nuestros cursos?