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. 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 para dentro
class Car {
    public function __construct(private Engine $engine) {}
}

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

A segunda abordagem é a injeção de dependência. O Car não cria seu próprio motor - ele recebe um. Essa mudança simples 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 uma flexibilidade ainda maior, 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 o Car funciona com qualquer classe que implemente a EngineInterface - um motor a gasolina, motor elétrico ou um mock para testes. Este desacoplamento é o motivo pelo qual a injeção de dependência é fundamental para escrever aplicações PHP sustentáveis e testáveis.

Desafio

Fácil

Vamos construir um sistema de notificação que demonstra o poder da injeção de dependência. Em vez de codificar rigidamente como as mensagens são enviadas, você criará um sistema flexível onde o método de entrega pode ser trocado facilmente.

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. Esta interface estabelece o contrato que qualquer remetente de mensagem deve seguir.
EmailSender.php — Crie uma classe EmailSender que implementa MessageSenderInterface. Inclua o arquivo da interface. O método send() deve retornar "Email to $recipient: $message".
NotificationService.php — Crie uma classe NotificationService que recebe sua dependência através do construtor. Inclua o arquivo da interface. A classe deve:
- Aceitar um MessageSenderInterface em seu construtor usando a promoção de construtor (constructor promotion)
- Ter um método notify(string $recipient, string $message) que delega para o remetente injetado e retorna seu resultado
Observe como o 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, então chame notify() e imprima o resultado.

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

Folha de consulta

Injeção de Dependência (DI) é uma técnica onde as dependências são passadas para uma classe a partir do exterior, em vez de serem criadas internamente.

Sem DI (fortemente acoplado):

<?php
class Car {
    private Engine $engine;
    
    public function __construct() {
        $this->engine = new Engine(); // Criado internamente
    }
}

Com DI (fracamente acoplado):

<?php
class Car {
    public function __construct(private Engine $engine) {}
}

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

Para máxima 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();
    }
}

Isso permite que Car funcione com qualquer classe que implemente EngineInterface, tornando o código mais fácil de manter e testar.

Experimente você mesmo

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

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

// TODO: Criar uma instância de EmailSender
// TODO: Injetá-la em um NotificationService
// TODO: Chamar notify() e imprimir o resultado

?>