Como funciona injeção de dependência no PHP moderno?

Question

Accepted Answer

**Injeção de Dependência (DI)** é um padrão de design onde uma classe recebe suas dependências de fora (tipicamente via construtor) em vez de criá-las ela mesma. Frameworks PHP modernos usam DI pesadamente, frequentemente com um **container** que automaticamente resolve e injeta dependências — levando a código desacoplado e testável.

## O problema que DI resolve

```php
// ❌ tight coupling — the class CREATES its own dependencies (hard to test/swap)
class UserService {
    private $mailer;
    public function __construct() {
        $this->mailer = new SmtpMailer();   // hardcoded → can't mock, can't swap
    }
}

// ✅ dependency injection — dependencies are PASSED IN
class UserService {
    public function __construct(private MailerInterface $mailer) {}
    // depends on an INTERFACE, receives the concrete impl from outside
}
```

Injetar dependências (contra uma **interface**) desacopla a classe de implementações concretas — você pode trocar implementações e injetar mocks em testes.

## Injeção via construtor (a forma padrão)

```php
class OrderService {
    public function __construct(
        private OrderRepository $repo,        // dependencies declared in the constructor
        private MailerInterface $mailer,
        private LoggerInterface $logger,
    ) {}
}
```

Injeção via construtor torna as dependências explícitas e garante que o objeto esteja totalmente formado quando criado.

## Containers DI — resolução automática

```php
// a DI CONTAINER builds objects, resolving the whole dependency graph automatically
$container->bind(MailerInterface::class, SmtpMailer::class);   // map interface → impl

$service = $container->get(OrderService::class);
// the container sees OrderService needs OrderRepository, MailerInterface, LoggerInterface,
// constructs each (recursively), and injects them — you don't `new` anything manually
```

Um **container DI** (em Laravel, Symfony, ou standalone como PHP-DI) automaticamente constrói objetos resolvendo suas dependências de construtor recursivamente — você configura bindings interface-para-implementação, e o container conecta tudo.

## Os benefícios

```text
✓ Loose coupling — depend on interfaces/abstractions, not concrete classes
✓ Testability — inject mocks/fakes in tests (no real DB/mailer needed)
✓ Flexibility — swap implementations via container config (e.g. fake mailer in dev)
✓ Single responsibility — classes focus on logic, not constructing dependencies
```

## Por que isso importa

Injeção de dependência é um padrão fundamental no PHP moderno, central para como aplicações profissionais e frameworks (Laravel, Symfony) são estruturados, então entender isso é conhecimento importante de nível sênior.

O valor central é **desacoplamento e testabilidade**: ao ter classes recebendo suas dependências (declaradas contra interfaces) em vez de criá-las, o código fica desacoplado (dependendo de abstrações, não implementações concretas), facilmente **testável** (você injeta mocks em vez de bancos de dados/serviços reais — tornando testes unitários minuciosos práticos), e flexível (trocando implementações via configuração).

Frameworks PHP modernos fornecem **containers DI** que automatizam isso — resolvendo e injetando todo o grafo de dependências automaticamente baseado em bindings interface-para-implementação, então você não constrói objetos manualmente.

Entender injeção via construtor (a forma padrão), programar contra interfaces, e como containers DI funcionam (resolução automática) é essencial para trabalhar efetivamente com frameworks PHP (que são construídos em torno de DI) e para escrever código bem-arquitetado, mantível e testável.

Com DI sustentando a estrutura de todos os principais frameworks PHP modernos e sendo marca registrada de design profissional de aplicações, dominá-lo — o padrão, seus benefícios, e resolução baseada em container — é conhecimento importante que distingue desenvolvedores que podem construir PHP limpo, testável e idiomático de framework daqueles escrevendo código acoplado e difícil de testar.