Master Advanced Dependency Injection Techniques in Modern PHP

Dependency Injection (DI) is an essential design pattern in modern PHP development, forming the core of frameworks like Laravel and Symfony and enabling testable, maintainable code.

Essence and Advantages of Dependency Injection

The core idea of DI is the concrete implementation of the Inversion of Control (IoC) principle. Traditional code creates or looks up dependencies internally, while DI delegates that responsibility to an external container.

Key Advantages

Decouples components: classes no longer instantiate their dependencies directly, reducing coupling.

Improves testability: dependencies can be replaced with mock implementations for unit testing.

Enhances maintainability: dependency relationships are explicit, making changes easier.

Facilitates reuse: loosely coupled components can be reused in different contexts.

Three Forms of Dependency Injection

1. Constructor Injection

The recommended approach, declaring all dependencies explicitly via the constructor:

<code>class OrderService
{
    private $paymentGateway;

    public function __construct(PaymentGateway $paymentGateway)
    {
        $this->paymentGateway = $paymentGateway;
    }

    public function process(Order $order)
    {
        $this->paymentGateway->charge($order->total);
    }
}
</code>

2. Setter Injection

Suitable for optional dependencies or when the dependency needs to be changed:

<code>class OrderService
{
    private $logger;

    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }
}
</code>

3. Interface Injection

Less common, injecting dependencies through an interface method:

<code>interface LoggerAware
{
    public function setLogger(LoggerInterface $logger);
}

class OrderService implements LoggerAware
{
    // implement interface method
}
</code>

Advanced Dependency Injection Patterns

1. Autowiring

Modern DI containers such as PHP‑DI and Symfony can automatically resolve dependencies:

<code>// PHP‑DI example
$container = new Container();
$orderService = $container->get(OrderService::class);
</code>

The container automatically resolves OrderService and all its dependencies.

2. Contextual Dependency Injection

Sometimes dependencies need to vary based on context:

<code>class OrderProcessor
{
    public function __construct(
        private PaymentProvider $paymentProvider,
        #[CurrentUser] private User $user
    ) {}
}
</code>

Attributes or parameter markers provide context‑aware dependencies.

3. Lazy Injection

For resource‑intensive dependencies, a proxy can defer loading until needed:

<code>class OrderService
{
    public function __construct(
        private LazyLoadingInterface $heavyDependency
    ) {}

    public function doWork()
    {
        $dependency = $this->heavyDependency->getInstance(); // actual loading occurs here
    }
}
</code>

Advanced Uses of a Dependency Injection Container (DIC)

1. Factory Integration

<code>$container->factory(function (ContainerInterface $c) {
    return new HeavyService($c->get('config'));
});
</code>

2. Decorator Pattern

<code>$container->extend(LoggerInterface::class, function ($logger, $c) {
    return new DecoratingLogger($logger);
});
</code>

3. Conditional Registration

<code>$container->set(
    CacheInterface::class,
    $container->factory(function ($c) {
        return $c->get('config')['env'] === 'prod'
            ? new RedisCache()
            : new ArrayCache();
    })
);
</code>

Dependency Injection and Other Design Patterns

Combining DI with other patterns yields powerful results:

Strategy pattern: inject different strategy implementations.

Observer pattern: inject observers as dependencies.

Decorator pattern: stack decorators via the DI container.

Adapter pattern: inject various adapter implementations.

Performance Considerations and Best Practices

Avoid the Service Locator anti‑pattern.

Use singletons judiciously for stateless services.

Compile containers (e.g., Symfony) to improve performance.

Prevent circular dependencies; resolve them with setter injection if necessary.

Dependency Injection in Testing

DI greatly simplifies unit testing:

<code>public function testOrderProcessing()
{
    $mockGateway = $this->createMock(PaymentGateway::class);
    $mockGateway->expects($this->once())
                ->method('charge');

    $service = new OrderService($mockGateway);
    $service->process(new Order(/*...*/));
}
</code>

Conclusion

Understanding advanced DI concepts enables PHP developers to build more flexible and maintainable applications. From simple constructor injection to sophisticated context‑aware resolution, DI provides a powerful toolkit for modern PHP development, elevating code quality to a new level.