This post is also available in:
English
En la programación orientada a objetos (OOP) se puede pensar en objetos o clases como componentes o módulos que trabajan juntos para proporcionar la funcionalidad del programa. En un programa bien estructurado, puede querer reemplazar el Módulo A por el Módulo B e incluso añadir nuevos componentes al Módulo B, puede querer añadir pruebas unitarias o refactorización del código heredado. Para lograr esto fácilmente, usted quiere desarrollar componentes que estén vagamente desacoplados unos de otros, vagamente desacoplados significa independientes unos de otros.
La inyección de dependencia es una técnica para desarrollar componentes de software que se acoplen libremente a sus dependencias.
Para entender mejor el concepto de DI, no usaré contenedores de inyección de dependencia como: Spring, Google Guice, Dagger para Android, Ninject para .NET, etc., pero estos marcos son extremadamente útiles si se trabaja en grandes proyectos.
DI es un tipo de Inversión de Control (IoC) y un patrón usado en casi todos los lenguajes de programación
Hay tres formas más comunes de inyección de dependencia
- Inyección de Constructor
- Inyección de Setter
- Inyección de interfaz
Inyección de Constructor
La dependencia se pasa como argumento al constructor
Inyección Setter
La dependencia se pasa como argumento a un método, esto también se llama inyección de propiedad o inyección de campo
Inyección de interfaz
Las clases dependientes implementan una interfaz
Echemos un vistazo al siguiente programa en Java:
Ferrari.java
|
1 2 3 4 5 6 7 |
public class Ferrari { public String drive() { return "I drive a Ferrari"; } } |
Driver.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public class Driver { private Ferrari ferrari; Driver() { this.ferrari = new Ferrari(); } public void drive() { System.out.println(ferrari.drive()); } public static void main(String... args) { Driver driver = new Driver(); driver.drive(); } } |
Genera: Conduzco un Ferrari
En este ejemplo, la clase de Conductor está estrechamente ligada a su dependencia (Ferrari), si el conductor tuviera que conducir un Porsche, tendríamos que refactorizar la clase de Conductor.
Desvinculemos al piloto de la clase Ferrari de tal manera que el piloto de la clase pueda conducir el coche que quiera.
Inyección de Constructor
En un primer paso, definimos una interfaz Car
Car.java
|
1 2 3 |
public interface Car { public String drive(); } |
Ahora la clase Ferrari implementa la interfaz Car
Ferrari.java
|
1 2 3 4 5 6 7 |
public class Ferrari implements Car { public String drive() { return "I drive a Ferrari"; } } |
Vamos a crear otra clase de tipo Car
Porsche.java
|
1 2 3 4 5 6 7 |
public class Porsche implements Car { public String drive() { return "I drive a Porsche"; } } |
Ahora refactorizamos la clase de Driver para que una instancia de Car se pase como argumento al constructor, luego fijamos la dependencia a un campo privado local y lo usamos en todas partes dentro de la clase.
Driver.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public class Driver { private Car car; Driver(Car car) { this.car = car; } public void drive() { System.out.println(car.drive()); } public static void main(String... args) { Driver ferrari = new Driver(new Ferrari()); ferrari.drive(); Driver porsche = new Driver(new Porsche()); porsche.drive(); } } |
Genera:
Conduzco un Ferrari
Conduzco un Porsche
Inyección de Setter
En este enfoque proporcionamos un método de fijación (setCar) que inyecta la dependencia. Básicamente es lo mismo que antes, pero utilizando un método de fijación en lugar del constructor.
Driver.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public class Driver { private Car car; public void setCar(Car car) { this.car = car; } public void drive() { System.out.println(car.drive()); } public static void main(String... args) { Driver driver = new Driver(); driver.setCar(new Ferrari()); driver.drive(); driver.setCar(new Porsche()); driver.drive(); } } |
Genera:
Conduzco un Ferrari
Conduzco un Porsche
Inyección de interfaz
Cada clase que utiliza la dependencia debe implementar una interfaz, en este caso el CarSetter, que proporciona un método para inyectar la dependencia de la que depende.
Driver.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public class Driver implements CarSetter{ private Car car; public void setCar(Car car) { this.car = car; } public void drive() { System.out.println(car.drive()); } public static void main(String... args) { Driver driver = new Driver(); driver.setCar(new Ferrari()); driver.drive(); driver.setCar(new Porsche()); driver.drive(); } } |
