We've used autowiring SINCE chapter 8 (LoggerInterface, repositories, EntityManagerInterface), without naming the principle behind it explicitly. Time to fill in the foundation ALL of Symfony builds on.

The problem dependency injection solves

Imagine a class that creates its dependencies ITSELF:

class NotificationService
{
    public function sendNotification(string $message): void
    {
        $logger = new \Monolog\Logger('app'); // hardwired!
        $logger->info($message);
    }
}

Three concrete problems: the class is FIXED to ONE specific logger implementation (hard to swap out). It's HARD to test in isolation (chapter 42 needs a swappable fake logger for that). And if HOW the logger gets configured changes, EVERY spot that creates one itself must be updated.

The solution: passing dependencies in from outside

use Psr\Log\LoggerInterface;

class NotificationService
{
    public function __construct(
        private readonly LoggerInterface $logger,
    ) {
    }

    public function sendNotification(string $message): void
    {
        $this->logger->info($message);
    }
}

EXACTLY this pattern is already familiar from EVERY controller in this course – the class only requests an interface (LoggerInterface, not the concrete Logger class), WITHOUT knowing WHERE the actual implementation comes from. Providing that implementation is Symfony's service container's job.

The service container: Symfony's central factory

The container is a BIG directory: "if LoggerInterface is requested, provide THIS concrete instance." For EVERY use statement of a constructor parameter, Symfony automatically checks whether a matching service definition exists – EXACTLY this is autowiring.

php bin/console debug:container

Lists ALL registered services – a good first stop when debugging "autowiring doesn't work" (usually: the sought-after service simply doesn't exist under the expected name).

php bin/console debug:autowiring Logger

Specifically shows WHICH interfaces/classes with "Logger" in their name are available via autowiring – useful for finding the EXACT type for a constructor parameter.

Services are singletons by default

PER request, EVERY service gets instantiated ONLY ONCE – if ten different classes request LoggerInterface, ALL TEN get the same instance. This saves memory AND guarantees consistent state (e.g. a database connection opened once gets reused, instead of being rebuilt ten times).

Dependency injection vs. the service locator anti-pattern

Why this principle is so central to Symfony