b'\n_START_ARTICLE_\nInyecci\xc3\xb3n de dependencias\n_START_PARAGRAPH_\nEn inform\xc3\xa1tica, inyecci\xc3\xb3n de dependencias (en ingl\xc3\xa9s Dependency Injection, DI) es un patr\xc3\xb3n de dise\xc3\xb1o orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase la que cree dichos objetos. Esos objetos cumplen contratos que necesitan nuestras clases para poder funcionar (de ah\xc3\xad el concepto de dependencia). Nuestras clases no crean los objetos que necesitan, sino que se los suministra otra clase \'contenedora\' que inyectar\xc3\xa1 la implementaci\xc3\xb3n deseada a nuestro contrato.\xe2\x80\x8b_NEWLINE_El t\xc3\xa9rmino fue acu\xc3\xb1ado por primera vez por Martin Fowler.\n_START_SECTION_\nMotivaci\xc3\xb3n\n_START_PARAGRAPH_\nEn los comienzos de la programaci\xc3\xb3n, los programas eran lineales y monol\xc3\xadticos. El flujo de ejecuci\xc3\xb3n era simple y predecible, ejecut\xc3\xa1ndose l\xc3\xadnea tras l\xc3\xadnea._NEWLINE_Aparecieron dos conceptos para estructurar el c\xc3\xb3digo: la modularidad y la reutilizaci\xc3\xb3n 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._NEWLINE_El problema se empieza a considerar lo suficientemente importante como para definir nuevos conceptos en el dise\xc3\xb1o como la Inversi\xc3\xb3n de Control (IoC) implementada a trav\xc3\xa9s de Inyecci\xc3\xb3n de Dependencias o de eventos.\n_START_SECTION_\nEl contenedor\n_START_PARAGRAPH_\nLa forma habitual de implementar este patr\xc3\xb3n es mediante un "Contenedor DI", tambi\xc3\xa9n llamado "Contenedor IoC" y objetos planos o simples por ejemplo los llamados POJO en Java. El contenedor inyecta a cada objeto los objetos necesarios seg\xc3\xban las relaciones de dependencia registradas en la configuraci\xc3\xb3n previa._NEWLINE_T\xc3\xadpicamente este contenedor es implementado por un framework externo a la aplicaci\xc3\xb3n (como Spring entre otros), por lo cual en la aplicaci\xc3\xb3n tambi\xc3\xa9n se utilizar\xc3\xa1 inversi\xc3\xb3n de control al ser el contenedor (almacenado en una biblioteca) quien invoque el c\xc3\xb3digo de la aplicaci\xc3\xb3n.\n_START_SECTION_\nDeclaraci\xc3\xb3n de la inyecci\xc3\xb3n\n_START_PARAGRAPH_\nLa inyecci\xc3\xb3n de dependencias puede realizarse referenciando a las clases de dichas dependencias. Sin embargo, esa no es una buena pr\xc3\xa1ctica dado que sus componentes tienen una fuerte relaci\xc3\xb3n entre s\xc3\xad, que al final nos supondr\xc3\xa1 un inconveniente para el mantenimiento del software. Por eso, en la inyecci\xc3\xb3n de independencias, normalmente, se usan interfaces. De esta forma conseguimos abstraer la relaci\xc3\xb3n entre una clase A que depende de una clase B sin importar la implementaci\xc3\xb3n de cada uno de los dos. De esta forma, conseguimos desacoplamiento.\xe2\x80\x8b\n_START_SECTION_\nFormas de inyectar las dependencias\n_START_PARAGRAPH_\nEn java, y en general en los distintos lenguajes hay distintas formas de inyectar dependencias.\xe2\x80\x8bEsto se puede lograr de forma manual o mediante frameworks como Spring, para lograr esta versatilidad, la inyecci\xc3\xb3n de dependencias se apoya en la programaci\xc3\xb3n orientada a interfaces.\xe2\x80\x8b\n_START_SECTION_\nEn el constructor\n_START_PARAGRAPH_\nUsando el constructor del objeto. Por ejemplo si una clase A tiene la dependencia de un objeto con el interfaz B_NEWLINE_public class A {_NEWLINE_ private B dependency;_NEWLINE_ public A(B instancedepency)_NEWLINE_ {_NEWLINE_  this.dependency=instancedepency;_NEWLINE_ }_NEWLINE_ //... En su implementaci\xc3\xb3n A usa el objeto dependency}\n_START_SECTION_\nEn un m\xc3\xa9todo\n_START_PARAGRAPH_\nUsando un m\xc3\xa9todo, t\xc3\xadpicamente el m\xc3\xa9todo suelen ser un setter._NEWLINE_public class A {_NEWLINE_ private B dependency;_NEWLINE_ public setDependecy(B instancedepency)_NEWLINE_ {_NEWLINE_  this.dependency=instancedepency;_NEWLINE_ }_NEWLINE_ //... En su implementaci\xc3\xb3n A usa el objeto dependency}\n_START_SECTION_\nEn una variable de instancia\n_START_PARAGRAPH_\nUsando una variable de instancia o propiedad._NEWLINE_public class A {_NEWLINE_ public B dependency;_NEWLINE_ //... En su implementaci\xc3\xb3n A usa el objeto dependency}\n_START_SECTION_\nEjemplo\n_START_PARAGRAPH_\nEl siguiente ejemplo muestra una implementaci\xc3\xb3n sin inyecci\xc3\xb3n de dependencias._NEWLINE_public class Vehiculo {_NEWLINE__NEWLINE_    private Motor motor = new Motor();_NEWLINE_    _NEWLINE_    /** @return retorna la velocidad del veh\xc3\xadculo*/_NEWLINE_    public Double enAceleracionDePedal(int presionDePedal) {_NEWLINE_        motor.setPresionDePedal(presionDePedal);_NEWLINE_        int torque = motor.getTorque();_NEWLINE_        Double velocidad = ... //realiza el c\xc3\xa1lculo_NEWLINE_        return velocidad;_NEWLINE_    }}//se omite la clase Motor ya que no es relevante para este ejemplo_NEWLINE_La implementaci\xc3\xb3n de arriba necesita crear una instancia de Motor para calcular su velocidad. El siguiente ejemplo sencillo muestra una implementaci\xc3\xb3n realizando inyecci\xc3\xb3n de dependencias usando un m\xc3\xa9todo setter._NEWLINE_public class Vehiculo {_NEWLINE__NEWLINE_    private Motor motor = null;_NEWLINE_    _NEWLINE_    public void setMotor(Motor motor){_NEWLINE_    this.motor = motor;_NEWLINE_    }_NEWLINE__NEWLINE_    /** @retorna la velocidad del veh\xc3\xadculo*/_NEWLINE_    public Double enAceleracionDePedal(int presionDePedal) {_NEWLINE_        Double velocidad = null;_NEWLINE_        if (null != motor){_NEWLINE_            motor.setPresionDePedal(presionDePedal);_NEWLINE_            int torque = motor.getTorque();_NEWLINE_            velocidad = ... //realiza el c\xc3\xa1lculo_NEWLINE_        }   _NEWLINE_        return velocidad; _NEWLINE_    }}//se omite la clase Motor ya que no es relevante para este ejemplopublic class VehiculoFactory {_NEWLINE__NEWLINE_    public Vehiculo construyeVehiculo() {_NEWLINE_        Vehiculo vehiculo = new Vehiculo();_NEWLINE_        Motor motor = new Motor();_NEWLINE_        vehiculo.setMotor(motor);_NEWLINE_        return vehiculo;_NEWLINE_    }}_NEWLINE_En este ejemplo VehiculoFactory representa al proveedor. Es una aplicaci\xc3\xb3n sencilla del patr\xc3\xb3n de dise\xc3\xb1o factory que hace posible que la clase Veh\xc3\xadculo no requiera saber c\xc3\xb3mo obtener un motor por s\xc3\xad misma, sino que es la responsabilidad de VehiculoFactory.'