How does dependency injection work in modern PHP?

Question

Accepted Answer

**Dependency Injection (DI)** is a design pattern where a class receives its dependencies from outside (typically via the constructor) rather than creating them itself. Modern PHP frameworks use DI heavily, often with a **container** that automatically resolves and injects dependencies — leading to loosely-coupled, testable code.

## The problem DI solves

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

Injecting dependencies (against an **interface**) decouples the class from concrete implementations — you can swap implementations and inject mocks in tests.

## Constructor injection (the standard form)

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

Constructor injection makes dependencies explicit and ensures the object is fully formed when created.

## DI containers — automatic resolution

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

A **DI container** (in Laravel, Symfony, or a standalone like PHP-DI) automatically constructs objects by resolving their constructor dependencies recursively — you configure interface-to-implementation bindings, and the container wires everything together.

## The benefits

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

## Why it matters

Dependency injection is a fundamental pattern in modern PHP, central to how professional applications and frameworks (Laravel, Symfony) are structured, so understanding it is important senior-level knowledge.

The core value is **decoupling and testability**: by having classes receive their dependencies (declared against interfaces) rather than creating them, code becomes loosely coupled (depending on abstractions, not concrete implementations), easily **testable** (you inject mocks instead of real databases/services — making thorough unit testing practical), and flexible (swapping implementations via configuration).

Modern PHP frameworks provide **DI containers** that automate this — resolving and injecting the entire dependency graph automatically based on interface-to-implementation bindings, so you don't manually construct objects.

Understanding constructor injection (the standard form), programming against interfaces, and how DI containers work (automatic resolution) is essential for working effectively with PHP frameworks (which are built around DI) and for writing well-architected, maintainable, testable code.

Since DI underpins the structure of all major modern PHP frameworks and is a hallmark of professional application design, mastering it — the pattern, its benefits, and container-based resolution — is important knowledge that distinguishes developers who can build clean, testable, framework-idiomatic PHP from those writing tightly-coupled, hard-to-test code.