Inyección de dependencias

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

En Informática, Inyección de Dependencias (en inglés Dependency Injection, DI) es un patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase quien cree el objeto. El término fue acuñado por primera vez por Martin Fowler.

Historia[editar]

En los comienzos de la programación, los programas eran lineales y monolíticos. El flujo de ejecución era simple y predecible, ejecutándose línea tras línea.

Aparecieron dos conceptos para estructurar el código: la modularidad y la reutilización de los componentes: se crean bibliotecas de componentes reutilizables. El flujo se complica, saltando de componente a componente, y aparece un nuevo problema: la dependencia (acoplamiento) entre los componentes.

El problema de la dependencia se empieza a considerar lo suficientemente importante como para definir nuevos conceptos en el diseño :

  • Inversión de control (IoC, por sus siglas en inglés)
  • Inyección de Dependencias (Dependency Injection, DI) que es una forma de inversión de control.

Implementación del patrón en Java[editar]

La forma habitual de implementar este patrón es mediante un "Contenedor DI" y objetos planos o simples por ejemplo los llamados POJO en java. El contenedor inyecta a cada objeto los objetos necesarios según las relaciones plasmadas en un fichero de configuración.

Típicamente este contenedor es implementado por un framework externo a la aplicación (como Spring o uno propietario), por lo cual en la aplicación también se utilizará inversión de control al ser el contenedor (almacenado en una biblioteca) quien invoque el código de la aplicación. Ésta es la razón por la que los términos de inversión de control e inyección de dependencias se confunden habitualmente entre sí.

Ilustración de código usando Java[editar]

El siguiente ejemplo muestra una implementación sin inyección de dependencias.

public class Vehiculo {
 
    private Motor motor = new Motor();
 
    /** @retorna la velocidad del vehículo*/
    public Double enAceleracionDePedal(int presionDePedal) {
        motor.setPresionDePedal(presionDePedal);
        int torque = motor.getTorque();
        Double velocidad = ... //realiza el cálculo
        return velocidad;
    }
 
}
 
//se omite la clase Motor ya que no es relevante para este ejemplo

La implementación de arriba necesita crear una instancia de Motor para calcular su velocidad. El siguiente ejemplo sencillo muestra una implementación usando inyección de dependencias.

public class Vehiculo {
 
    private Motor motor = null;
 
    public setMotor(Motor motor){
    	this.motor = motor;
    }
 
    /** @retorna la velocidad del vehículo*/
    public Double enAceleracionDePedal(int presionDePedal) {
        Double velocidad = null;
        if (null != motor){
	 motor.setPresionDePedal(presionDePedal);
	 int torque = motor.getTorque();
	 velocidad = ... //realiza el cálculo
        }   
        return velocidad; 
    }
}
 
//se omite la clase Motor ya que no es relevante para este ejemplo
 
public class VehiculoFactory {
 
    public Vehiculo construyeVehiculo() {
        Vehiculo vehiculo = new Vehiculo();
        Motor motor = new Motor();
        vehiculo.setMotor(motor);
        return vehiculo;
    }
 
}

En este ejemplo VehiculoFactory representa al proveedor. Es una aplicación sencilla del patrón de diseño fábrica que hace posible que la clase Vehículo no requiera saber cómo obtener un motor por sí misma, sino que es la responsabilidad de VehiculoFactory.

Véase también[editar]

Enlaces externos[editar]