Injeção de Dependência

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy. Lição 57 de 91.

Na lição anterior, você viu como a composição permite que um Car contenha um objeto Engine. Mas há um problema em criar dependências dentro da classe: isso torna o código rígido e difícil de testar. A Injeção de Dependência resolve isso passando as dependências de fora, em vez de criá-las internamente.

Compare estas duas abordagens:

<?php
// Sem DI - dependência criada internamente
class Car {
    private Engine $engine;
    
    public function __construct() {
        $this->engine = new Engine(); // Fortemente acoplado
    }
}

// Com DI - dependência passada
class Car {
    public function __construct(private Engine $engine) {}
}

$engine = new Engine();
$car = new Car($engine); // Injetado de fora

A segunda abordagem é a injeção de dependência. O Car não cria seu próprio motor — ele recebe um. Essa simples mudança traz benefícios poderosos: você pode passar diferentes tipos de motor, trocar implementações para testes, e a classe se torna mais flexível.

Para ter ainda mais flexibilidade, injete interfaces em vez de classes concretas:

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

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

Agora Car funciona com qualquer classe que implemente EngineInterface — um motor a combustão, um motor elétrico ou um mock para testes. Esse desacoplamento é o motivo pelo qual a injeção de dependências é fundamental para escrever aplicações PHP fáceis de manter e testar.

Desafio

Fácil

Vamos criar um sistema de notificações que demonstra o poder da injeção de dependências. Em vez de definir diretamente como as mensagens são enviadas, você criará um sistema flexível no qual o método de entrega pode ser facilmente substituído.

Você organizará seu código em quatro arquivos:

MessageSenderInterface.php: Defina uma interface chamada MessageSenderInterface com um único método send(string $recipient, string $message): string. Essa interface estabelece o contrato que qualquer remetente de mensagens deve seguir.
EmailSender.php: Crie uma classe EmailSender que implemente MessageSenderInterface. Inclua o arquivo da interface. O método send() deve retornar "Email to [recipient]: [message]".
NotificationService.php: Crie uma classe NotificationService que receba sua dependência por meio do construtor. Inclua o arquivo da interface. A classe deve:
- Aceitar um MessageSenderInterface em seu construtor usando a promoção de construtor
- Ter um método notify(string $recipient, string $message) que delegue ao remetente injetado e retorne o resultado
Observe como NotificationService depende da interface, não de uma classe concreta. Isso significa que você poderia injetar qualquer remetente que implemente a interface sem alterar o serviço.
main.php: Inclua os arquivos EmailSender e NotificationService. Você receberá duas entradas: um destinatário e uma mensagem. Crie um EmailSender, injete-o em um NotificationService, depois chame notify() e imprima o resultado.

Esse padrão mantém seu NotificationService flexível. Ele funciona com qualquer remetente que você injete, seja e-mail, SMS ou algo que você ainda não tenha criado. O serviço não cria suas próprias dependências; ele as recebe de fora.

Experimente você mesmo

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

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

// TODO: Crie uma instância de EmailSender
// TODO: Injete-a em um NotificationService
// TODO: Chame notify() e imprima o resultado

?>