PHP - Dependency Injection and Service Containers in PHP

Modern PHP applications often contain many classes that work together to perform different tasks. As applications grow larger, managing these class relationships becomes increasingly complex. Dependency Injection (DI) is a design pattern that helps developers create flexible, maintainable, and testable code by providing required dependencies to a class rather than allowing the class to create those dependencies itself. Service Containers are tools that automate and simplify the process of managing dependencies in an application.

Understanding Dependencies

A dependency is an object that another object requires to function properly. Consider a simple example where a UserController needs a UserRepository to retrieve user information from a database.

Without Dependency Injection:

class UserController
{
    private $userRepository;

    public function __construct()
    {
        $this->userRepository = new UserRepository();
    }

    public function getUser()
    {
        return $this->userRepository->findAll();
    }
}

In this example, UserController creates its own UserRepository object. This creates tight coupling because the controller directly depends on a specific implementation.

With Dependency Injection:

class UserController
{
    private $userRepository;

    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function getUser()
    {
        return $this->userRepository->findAll();
    }
}

Now, the UserRepository object is provided from outside the class. This approach makes the controller more flexible and easier to test.

Types of Dependency Injection

Constructor Injection

Constructor Injection is the most common and recommended method. Dependencies are passed through the class constructor.

class ProductService
{
    private $repository;

    public function __construct(ProductRepository $repository)
    {
        $this->repository = $repository;
    }
}

Advantages include:

  • Dependencies are clearly visible.

  • Objects are fully initialized when created.

  • Promotes immutability.

  • Easier unit testing.

Setter Injection

Dependencies are provided through setter methods after object creation.

class ProductService
{
    private $repository;

    public function setRepository(ProductRepository $repository)
    {
        $this->repository = $repository;
    }
}

This method is useful when dependencies are optional.

Method Injection

Dependencies are passed directly to a method when needed.

class ProductService
{
    public function save(ProductRepository $repository)
    {
        $repository->store();
    }
}

This approach is suitable when a dependency is required only for a specific operation.

Problems Solved by Dependency Injection

Reduced Coupling

Classes become independent of concrete implementations.

interface LoggerInterface
{
    public function log($message);
}

class FileLogger implements LoggerInterface
{
    public function log($message)
    {
        echo "Logging to file: " . $message;
    }
}

class UserService
{
    private $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }
}

The UserService depends on an interface rather than a specific logger implementation.

Improved Testability

Mock objects can easily replace real dependencies during testing.

$mockLogger = $this->createMock(LoggerInterface::class);

$userService = new UserService($mockLogger);

This allows testing business logic without interacting with actual files, databases, or external services.

Better Code Maintenance

Changing an implementation does not require modifying dependent classes.

For example, switching from FileLogger to DatabaseLogger only requires changing the injected dependency.

What Is a Service Container?

A Service Container, also known as an Inversion of Control (IoC) Container, is a tool responsible for creating and managing object dependencies automatically.

Instead of manually creating every dependency, the container resolves and injects them as needed.

Without a Service Container:

$logger = new FileLogger();
$userRepository = new UserRepository();
$userService = new UserService($logger, $userRepository);

As the number of dependencies increases, manual creation becomes difficult to manage.

With a Service Container:

$userService = $container->get(UserService::class);

The container automatically creates all required dependencies.

How a Service Container Works

A service container stores definitions describing how objects should be created.

Example:

$container->set(LoggerInterface::class, function () {
    return new FileLogger();
});

When a class requests LoggerInterface, the container provides a FileLogger instance.

$container->set(UserService::class, function ($container) {
    return new UserService(
        $container->get(LoggerInterface::class)
    );
});

The container resolves nested dependencies automatically.

Service Containers in Popular PHP Frameworks

Laravel Service Container

Laravel provides one of the most powerful service containers in PHP.

Binding a service:

$this->app->bind(
    LoggerInterface::class,
    FileLogger::class
);

Resolving a service:

$logger = app(LoggerInterface::class);

Automatic dependency resolution:

class UserController
{
    public function __construct(UserService $service)
    {
        $this->service = $service;
    }
}

Laravel automatically injects UserService without manual configuration.

Symfony Dependency Injection Component

Symfony uses service definitions configured through YAML, XML, or PHP files.

Example YAML configuration:

services:
    App\Service\UserService:
        arguments:
            - '@App\Repository\UserRepository'

Symfony's container manages object creation and dependency resolution behind the scenes.

Singleton Services

Some services should only have one instance throughout the application.

Example:

$container->singleton(
    DatabaseConnection::class,
    function () {
        return new DatabaseConnection();
    }
);

Every request for DatabaseConnection returns the same instance.

Common singleton services include:

  • Database connections

  • Cache managers

  • Configuration managers

  • Logging services

Service Providers

Service Providers organize service registration in large applications.

Example in Laravel:

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind(
            LoggerInterface::class,
            FileLogger::class
        );
    }
}

Service providers centralize dependency configuration and improve project organization.

Best Practices for Dependency Injection

Depend on Interfaces

Use interfaces instead of concrete classes whenever possible.

public function __construct(PaymentGatewayInterface $gateway)
{
    $this->gateway = $gateway;
}

Prefer Constructor Injection

Constructor Injection makes dependencies explicit and ensures objects are always properly initialized.

Avoid Service Locator Pattern

This pattern hides dependencies inside methods.

Bad example:

public function process()
{
    $logger = app(LoggerInterface::class);
}

Better example:

public function __construct(LoggerInterface $logger)
{
    $this->logger = $logger;
}

Keep Services Focused

Each service should handle a single responsibility to maintain clean architecture.

Real-World Example

Consider an e-commerce application:

  • ProductService manages products.

  • OrderService handles orders.

  • PaymentService processes payments.

  • EmailService sends notifications.

  • LoggerService records system activities.

Using Dependency Injection:

class OrderService
{
    private $paymentService;
    private $emailService;

    public function __construct(
        PaymentService $paymentService,
        EmailService $emailService
    ) {
        $this->paymentService = $paymentService;
        $this->emailService = $emailService;
    }
}

The service container automatically resolves all dependencies, making the application easier to maintain, test, and scale.

Conclusion

Dependency Injection is a fundamental design pattern in modern PHP development that promotes loose coupling, better maintainability, and improved testability. By separating object creation from object usage, developers can build flexible systems that are easier to modify and extend. Service Containers enhance this pattern by automatically managing and resolving dependencies, reducing boilerplate code and simplifying application architecture. Frameworks such as Laravel and Symfony rely heavily on dependency injection containers because they provide a structured and efficient way to manage complex applications as they grow in size and functionality.