Dependency Injection Container for PHP: A Complete Guide to Dependency Injection

Dependency Injection Container for PHP: A Complete Guide

Dependency Injection (DI) is one of the key design patterns in object-oriented programming that allows you to create loosely coupled, testable, and easily maintainable applications. In PHP, this approach is implemented using special tools — Dependency Injection containers (also known as dependency injection containers). In this article, we will take a detailed look at what a DI container is, how it works, and review the best libraries for PHP.

What is Dependency Injection?

Dependency Injection is a technique where an object receives its dependencies from the outside, rather than creating them itself. Instead of writing new Database() inside a class, you pass a ready-made object through the constructor, setter, or interface. This makes the code more flexible and simplifies testing.

Example without DI:

class UserService {    private $db;

    public function __construct() {        $this->db = new Database(); // tight coupling    }}

Example with DI via constructor:

class UserService {    private $db;

    public function __construct(Database $db) {        $this->db = $db; // dependency is passed from outside    }}

Why do you need a DI container?

When a project has many classes and dependencies, manually creating objects and passing dependencies becomes a headache. A DI container automates this process. It acts as a central registry that knows how to create objects and resolve their dependencies.

Main features of a DI container:

• Automatic dependency resolution — the container finds and injects the required objects itself.
• Object lifecycle management — you can configure whether to create a new instance each time or use a single one (singleton).
• Configuration via code or files — dependencies can be described in PHP, YAML, XML, or annotations.
• Support for interfaces and abstractions — the container can bind an interface to a specific implementation.

Popular DI containers for PHP

In the PHP ecosystem, there are several mature solutions. Let's look at the most popular ones:

1. PHP-DI (PHP Dependency Injection)

One of the most powerful and convenient containers. Supports autowiring, annotations, configuration via PHP arrays and YAML. Great for modern applications.

Example of using PHP-DI:

use DI\\ContainerBuilder;

$builder = new ContainerBuilder();$builder->addDefinitions([    'db.host' => 'localhost',    Database::class => DI\\create()        ->constructor(DI\\get('db.host')),]);

$container = $builder->build();$db = $container->get(Database::class);

2. Symfony DependencyInjection

A component from the Symfony framework that can be used separately. Offers flexible configuration via YAML, XML, or PHP. Ideal for large enterprise projects.

Example configuration in YAML:

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

3. Laravel Service Container

The built-in container of the Laravel framework. Supports autowiring, binding interfaces to implementations, contextual binding, and many other features. Used by default in Laravel.

Example of binding an interface:

use App\\Contracts\\PaymentGateway;use App\\Services\\StripePayment;

$this->app->bind(PaymentGateway::class, StripePayment::class);

4. Pimple

A lightweight DI container created by the creator of Symfony. Suitable for small