What is dependency injection? A practical guide with PHP examples

<?php
final class InvoiceMailer
{
    public function send(int $invoiceId): void
    {
        $db = new PDO('mysql:host=127.0.0.1;dbname=shop', 'shop', 'secret'); // hidden dependency
        $smtp = new SmtpClient('smtp.example.com', 587);                        // another one
        // ... load the invoice, build the message, send it
    }
}

<?php
declare(strict_types=1);

interface InvoiceRepository
{
    public function find(int $id): ?Invoice;
}

interface Mailer
{
    public function send(string $to, string $subject, string $body): void;
}

final readonly class Invoice
{
    public function __construct(public int $id, public string $email, public int $totalCents) {}
}

final class InvoiceMailer
{
    // Constructor injection: the class says what it needs and never builds it itself.
    public function __construct(
        private readonly InvoiceRepository $invoices,
        private readonly Mailer $mailer,
    ) {}

    public function send(int $invoiceId): void
    {
        $invoice = $this->invoices->find($invoiceId)
            ?? throw new DomainException("Invoice {$invoiceId} not found");
        $total = number_format($invoice->totalCents / 100, 2);
        $this->mailer->send($invoice->email, "Invoice #{$invoice->id}", "Amount due: {$total}");
    }
}

$mailer = new InvoiceMailer(
    new PdoInvoiceRepository($pdo),
    new SmtpMailer($smtpConfig),
);

<?php
declare(strict_types=1);
require __DIR__ . '/di-after.php';

// In a test, hand the class simple fakes: no database, no SMTP server.
final class InMemoryInvoices implements InvoiceRepository
{
    public function __construct(private array $rows) {}
    public function find(int $id): ?Invoice { return $this->rows[$id] ?? null; }
}

final class RecordingMailer implements Mailer
{
    public array $sent = [];
    public function send(string $to, string $subject, string $body): void { $this->sent[] = [$to, $subject, $body]; }
}

$mailer = new RecordingMailer();
$service = new InvoiceMailer(new InMemoryInvoices([7 => new Invoice(7, 'ana@example.com', 129900)]), $mailer);
$service->send(7);
var_dump($mailer->sent === [['ana@example.com', 'Invoice #7', 'Amount due: 1,299.00']]); // bool(true)

<?php
declare(strict_types=1);

interface Logger { public function info(string $message): void; }
final class NullLogger implements Logger { public function info(string $message): void {} }

final class ReportExporter
{
    private Logger $logger;

    public function __construct() { $this->logger = new NullLogger(); } // a safe default

    // Setter injection: for optional collaborators the class works without.
    public function setLogger(Logger $logger): void { $this->logger = $logger; }

    // Method injection: the dependency is needed for this one call only.
    public function export(array $rows, Closure $write): int
    {
        foreach ($rows as $row) $write(implode(',', $row) . "\n");
        $this->logger->info(count($rows) . ' rows exported');
        return count($rows);
    }
}
$e = new ReportExporter();
echo $e->export([[1, 'a'], [2, 'b']], fn (string $line) => print $line), "\n";

<?php
declare(strict_types=1);

// A minimal autowiring container: enough to see what Laravel's and Symfony's containers do for you.
final class Container
{
    private array $bindings = [];
    private array $instances = [];

    public function bind(string $abstract, Closure|string $concrete): void
    {
        $this->bindings[$abstract] = $concrete;
    }

    public function get(string $id): object
    {
        if (isset($this->instances[$id])) return $this->instances[$id];
        $concrete = $this->bindings[$id] ?? $id;
        $object = $concrete instanceof Closure ? $concrete($this) : $this->build($concrete);
        return $this->instances[$id] = $object; // one shared instance per id
    }

    private function build(string $class): object
    {
        $reflection = new ReflectionClass($class);
        if (!$reflection->isInstantiable()) throw new LogicException("No binding for {$class}");
        $arguments = [];
        foreach ($reflection->getConstructor()?->getParameters() ?? [] as $parameter) {
            $type = $parameter->getType();
            if (!$type instanceof ReflectionNamedType || $type->isBuiltin()) {
                throw new LogicException("Cannot resolve \${$parameter->getName()} of {$class}");
            }
            $arguments[] = $this->get($type->getName());
        }
        return $reflection->newInstanceArgs($arguments);
    }
}

$container = new Container();
$container->bind(InvoiceRepository::class, InMemoryInvoices::class);
$container->bind(Mailer::class, fn () => new EchoMailer());

$container->get(InvoiceMailer::class)->send(42);
// ana@example.com | Invoice #42 | Amount due: 50.00

(new Container())->get(InvoiceMailer::class);
// LogicException: No binding for InvoiceRepository