Inyección de dependencias en PHP

Inyección de dependencias (en inglés Dependency Injection, DI) es un patrón de diseño orientado a objetos y ha sido un tema frecuente de discusión entre muchos desarrolladores corporativos en los últimos años. Uno de los temores para utilizarlo es el riesgo de sacrificar demasiado tiempo la construcción de la arquitectura de la aplicación sin hacer ningún trabajo real, como suele ser lo habitual.  Como característica se puede decir que el termino se le atribuye a Martin Fowler y que se le pasa objetos a una clase, en lugar de ser la clase en si la que vaya a crear el objeto

no es ésta inyección

Imaginemos que trabajamos haciendo un sitio web de preguntas y respuestas, estilo Stack Overflow. Seguramente crearíamos una clase llamada Pregunta, que contendría un miembro de tipo Autor. Un objeto Autor directamente en el constructor:

 class autor {
    private $nombre;
    private $apellido;
    public function __construct($nombre, $apellido) {
        $this->nombre = $nombre;
        $this->apellido = $apellido;
    }
    public function getnombre() {
        return $this->nombre;
    }
    public function getapellido() {
        return $this->apellido;
    }
}
class pregunta {
    private $autor;
    private $pregunta;
    public function __construct($pregunta, $autornombre, $autorapellido) {
        $this->autor = new autor($autornombre, $autorapellido);
        $this->pregunta = $pregunta;
    }
    public function getautor() {
        return $this->autor;
    }
    public function getpregunta() {
        return $this->pregunta;
    }
}

Podemos considerar que es un buen código, pero hay ciertos problemas:

•      La información de Autor que pasa al constructor pregunta no tiene nada que hacer dentro de alcance de pregunta. El nombre del autor debe estar dentro de la clase Autor porque no tiene nada que ver con pregunta.

•      La clase de Autor está estrechamente unida con la clase pregunta. Si añadimos un nuevo parámetro al constructor del autor, entonces tenemos que modificar todas las clases donde creamos un objeto Autor - un proceso tedioso y largo, especialmente en aplicaciones de gran tamaño. 

Una solución a estos problemas la da la inyección de dependencia, mediante la inserción de las dependencias a través de constructor de la clase dependiente ("inyección del constructor"). Obtenemos como resultado un código altamente mantenible, que se vería así.


class Author {
    private $firstName;
    private $lastName;
    public function __construct($firstName, $lastName) {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
    }
    public function getFirstName() {
        return $this->firstName;
    }
    public function getLastName() {
        return $this->lastName;
    }
}
class Question {
    private $author;
    private $question;
    public function __construct($question, Author $author) {
        $this->author = $author;
        $this->question = $question;
    }
    public function getAuthor() {
        return $this->author;
    }
    public function getQuestion() {
        return $this->question;
    }
}

Ventajas
    
Las ventajas saltan a la vista, siempre teniendo en cuenta que su uso es para proyectos a largo plazo, estos se vuelven mas fáciles de mantener, si bien puede ser mas lento al comienzo, al realizar cambios cuando la aplicación ya este en producción no sufrimos la típica cascada de cambios en las clases.esos i está bien hecho.

Dependencias de inyección en open source.

Las empresas pequeñas no tienen mucho presupuesto para crear herramientas, tales como un marco de inyección de dependencias. Sin embargo se encuentran muchas soluciones open source en la web. Symfony2 utiliza un componente DI muy sólido que se basa en Java Spring. 

 Cuándo utilizar la inyección de dependencias

La inyección de dependencia es más útil, cuando se trabaja en proyectos a largo plazo, proyectos que son desarrollados y mantenidos activamente durante un largo período de tiempo. Esto reduce enormemente los costes y atrae a los mejores desarrolladores. Pero puede resultar contraproducente cuando queremos sacar unas pantallas rapidas para impresionar a un cliente mostrandole como queda todo, ya que los tiempos de desarrollo se hacen mayores.