Inyección de dependencias

Parte de la sección Programación Orientada a Objetos del Journey de PHP de Coddy. Lección 57 de 91.

En la lección anterior, viste cómo la composición permite que un Car contenga un objeto Engine. Pero hay un problema con crear dependencias dentro de la clase: hace que el código sea rígido y difícil de probar. La inyección de dependencias resuelve esto pasando las dependencias desde fuera en lugar de crearlas internamente.

Compara estos dos enfoques:

<?php
// Sin DI - dependencia creada dentro
class Car {
    private Engine $engine;
    
    public function __construct() {
        $this->engine = new Engine(); // Estrechamente acoplado
    }
}

// Con DI - dependencia pasada
class Car {
    public function __construct(private Engine $engine) {}
}

$engine = new Engine();
$car = new Car($engine); // Inyectado desde fuera

El segundo enfoque es la inyección de dependencias. El Car no crea su propio motor: recibe uno. Este sencillo cambio ofrece grandes beneficios: puedes pasar distintos tipos de motor, intercambiar implementaciones para realizar pruebas y la clase se vuelve más flexible.

Para una flexibilidad aún mayor, inyecta interfaces en lugar de clases concretas:

<?php
interface EngineInterface {
    public function start(): string;
}

class Car {
    public function __construct(private EngineInterface $engine) {}
    
    public function start(): string {
        return $this->engine->start();
    }
}

Ahora Car funciona con cualquier class que implemente EngineInterface: un motor de gasolina, un motor eléctrico o un mock para las pruebas. Este desacoplamiento es la razón por la que la inyección de dependencias es fundamental para escribir aplicaciones PHP mantenibles y comprobables.

Desafío

Fácil

Construyamos un sistema de notificaciones que demuestre el poder de la inyección de dependencias. En lugar de codificar de forma rígida cómo se envían los mensajes, crearás un sistema flexible en el que el método de entrega se pueda cambiar fácilmente.

Organizarás tu código en cuatro archivos:

MessageSenderInterface.php: Define una interfaz llamada MessageSenderInterface con un único método send(string $recipient, string $message): string. Esta interfaz establece el contrato que debe seguir cualquier remitente de mensajes.
EmailSender.php: Crea una clase EmailSender que implemente MessageSenderInterface. Incluye el archivo de la interfaz. El método send() debe devolver "Email to [recipient]: [message]".
NotificationService.php: Crea una clase NotificationService que reciba su dependencia mediante el constructor. Incluye el archivo de la interfaz. La clase debe:
- Aceptar un MessageSenderInterface en su constructor mediante la promoción del constructor
- Tener un método notify(string $recipient, string $message) que delegue en el remitente inyectado y devuelva su resultado
Observa cómo NotificationService depende de la interfaz, no de una clase concreta. Esto significa que podrías inyectar cualquier remitente que implemente la interfaz sin cambiar el servicio.
main.php: Incluye los archivos de EmailSender y NotificationService. Recibirás dos entradas: un destinatario y un mensaje. Crea un EmailSender, inyéctalo en un NotificationService, después llama a notify() e imprime el resultado.

Este patrón mantiene flexible tu NotificationService. Funciona con cualquier remitente que inyectes, ya sea correo electrónico, SMS o algo que todavía no hayas creado. El servicio no crea sus propias dependencias; las recibe desde el exterior.

Pruébalo tú mismo

<?php
require_once 'EmailSender.php';
require_once 'NotificationService.php';

// Leer entrada
$recipient = trim(fgets(STDIN));
$message = trim(fgets(STDIN));

// TODO: Crea una instancia de EmailSender
// TODO: Inyéctala en un NotificationService
// TODO: Llama a notify() e imprime el resultado

?>