no es ésta inyección |
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.
0 comentarios:
Publicar un comentario