¿Cómo funciona la inyección de dependencias en PHP moderno?

Question

Accepted Answer

**Dependency Injection (DI)** es un patrón de diseño en el que una clase recibe sus dependencias desde el exterior (típicamente a través del constructor) en lugar de crearlas ella misma. Los frameworks modernos de PHP utilizan DI ampliamente, a menudo con un **container** que resuelve e inyecta automáticamente las dependencias — lo que lleva a código débilmente acoplado y comprobable.

## El problema que DI resuelve

```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
}
```

Inyectar dependencias (contra una **interface**) desacopla la clase de implementaciones concretas — puedes intercambiar implementaciones e inyectar mocks en las pruebas.

## Inyección por constructor (la forma estándar)

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

La inyección por constructor hace las dependencias explícitas y asegura que el objeto está completamente formado cuando se crea.

## Contenedores DI — resolución 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
```

Un **contenedor DI** (en Laravel, Symfony, o uno independiente como PHP-DI) construye automáticamente objetos resolviendo sus dependencias de constructor de forma recursiva — configuras enlaces de interface a implementación, y el contenedor conecta todo.

## Los beneficios

```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 qué es importante

La inyección de dependencias es un patrón fundamental en PHP moderno, central para cómo se estructuran las aplicaciones y frameworks profesionales (Laravel, Symfony), por lo que comprenderlo es conocimiento importante de nivel senior.

El valor principal es **desacoplamiento y comprobabilidad**: al tener clases que reciben sus dependencias (declaradas contra interfaces) en lugar de crearlas, el código se vuelve débilmente acoplado (dependiendo de abstracciones, no de implementaciones concretas), fácilmente **comprobable** (inyectas mocks en lugar de bases de datos/servicios reales — haciendo las pruebas unitarias exhaustivas prácticas), y flexible (intercambiar implementaciones a través de configuración).

Los frameworks modernos de PHP proporcionan **contenedores DI** que automatizan esto — resolviendo e inyectando todo el gráfico de dependencias automáticamente basado en enlaces de interface a implementación, así que no construyes objetos manualmente.

Comprender la inyección por constructor (la forma estándar), programar contra interfaces, y cómo funcionan los contenedores DI (resolución automática) es esencial para trabajar efectivamente con frameworks de PHP (que están construidos alrededor de DI) y para escribir código bien arquitecturado, mantenible y comprobable.

Ya que DI sustenta la estructura de todos los frameworks principales de PHP moderno y es un distintivo del diseño de aplicaciones profesionales, dominarlo — el patrón, sus beneficios, y la resolución basada en contenedor — es conocimiento importante que distingue a desarrolladores que pueden construir PHP limpio, comprobable e idiomático de framework de aquellos escribiendo código fuertemente acoplado y difícil de probar.