Service Container

Dependency container and Dependency Injection in Laravel

graph TD A[Service Container] --> B[Binding] A --> C[Resolution] A --> D[Singleton] A --> E[Contextual Binding] B --> F[Interface to Class] B --> G[String to Class] C --> H[Automatic Resolution] C --> I[Manual Resolution] D --> J[Single Instance] E --> K[Context-Specific] L[Client Code] -->|Type Hints| A A -->|Injects| L

Service Container or IoC Container is the heart of Laravel that manages dependencies and Dependency Injection. This container is an implementation of Inversion of Control (IoC) pattern that allows you to manage dependencies and create loose coupling.

Main Features:

Automatic Resolution: Laravel automatically resolves dependencies using reflection. If you have type-hints, Laravel tries to resolve them from container.

Binding: You can bind interfaces to specific implementations. This allows you to create abstraction layer.

Singleton: You can create singleton instances that always return the same instance.

Contextual Binding: Specific bindings for different contexts. You can bind an interface to different implementations in different contexts.

Tagged Services: You can tag services and resolve them as a group.

Service Resolution: You can resolve services manually or automatically.

Benefits:

Reduced coupling between classes and increased cohesion
Increased testability with easy mocking capability
Better dependency management
More flexibility in design
Implementation of SOLID principles
Improved maintainability and scalability

Examples

Simple Binding

app()->bind('PaymentGateway', function ($app) {
    return new StripePaymentGateway();
});

$gateway = app('PaymentGateway');

We bind an interface or string to a specific implementation.

Singleton Binding

app()->singleton('DatabaseConnection', function ($app) {
    return new DatabaseConnection();
});

$db1 = app('DatabaseConnection');
$db2 = app('DatabaseConnection');
// $db1 and $db2 are the same instance

With singleton, the same instance is always returned.

Automatic Resolution

<?php

class UserService
{
    public function __construct(
        private UserRepository $repository,
        private CacheInterface $cache
    ) {}
}

// Laravel automatically resolves dependencies
$service = app(UserService::class);

// Or with type-hint in route
Route::get('/users', function (UserService $service) {
    return $service->getAllUsers();
});

Laravel automatically resolves dependencies using reflection.

Interface Binding

<?php

// Bind interface to implementation
app()->bind(
    App\Contracts\PaymentGateway::class,
    App\Services\StripePaymentGateway::class
);

// Now you can type-hint interface
class OrderController
{
    public function __construct(
        private App\Contracts\PaymentGateway $gateway
    ) {}
    
    // Laravel automatically resolves StripePaymentGateway
}

You can bind interface to implementation and Laravel automatically resolves it.

Tagged Services

<?php

// Tag multiple services
app()->bind('report.sales', SalesReport::class);
app()->bind('report.inventory', InventoryReport::class);
app()->tag(['report.sales', 'report.inventory'], 'reports');

// Resolve all tagged services
$reports = app()->tagged('reports');

// Use in service
class ReportAggregator
{
    public function __construct(
        private $reports
    ) {
        $this->reports = app()->tagged('reports');
    }
}

You can tag services and resolve them as a group.

Manual Resolution

<?php

// Manual resolution
$service = app()->make('ServiceName');
$service = app('ServiceName');
$service = resolve('ServiceName');

// With parameters
$service = app()->makeWith('ServiceName', ['param' => 'value']);

// Check if bound
if (app()->bound('ServiceName')) {
    $service = app('ServiceName');
}

// Get all bindings
$bindings = app()->getBindings();

You can manually resolve services.

Container Instance Access

<?php

// Get container instance
$container = app();
$container = app()->getContainer();

// Check if service is resolved
if (app()->resolved('ServiceName')) {
    // Service has been resolved
}

// Forget resolved instance
app()->forgetInstance('ServiceName');

// Flush all instances
app()->flush();

You can access container instance and manage it.

Container in Testing

<?php

namespace Tests;

use Tests\TestCase;

class ContainerTest extends TestCase
{
    public function test_container_binding()
    {
        // Bind mock in test
        $this->app->bind('Service', function () {
            return new MockService();
        });
        
        $service = $this->app->make('Service');
        $this->assertInstanceOf(MockService::class, $service);
    }
    
    public function test_container_singleton()
    {
        $this->app->singleton('Service', Service::class);
        
        $service1 = $this->app->make('Service');
        $service2 = $this->app->make('Service');
        
        $this->assertSame($service1, $service2);
    }
}

In tests you can manipulate container and bind mock objects.

Use Cases

Managing dependencies in application
Creating abstraction layer with interface binding
Optimizing performance with singleton pattern
Creating testable code with ability to mock
Managing service lifecycle
Creating plugin architecture with tagged services
Context-aware dependency resolution

Common Mistakes

Using Service Locator pattern instead of Dependency Injection
Binding at runtime instead of Service Provider
Using singleton for stateful services
Not binding interfaces causing tight coupling
Circular dependency causing infinite loop
Forgetting to bind causing errors

Best Practices

Always perform bindings in Service Provider
Use interface binding, not concrete classes
Use singleton for stateless and expensive services
Use type-hinting for automatic resolution
Use contextual binding for context-aware dependencies
Use tagged services for group resolution
Use deferred providers for rarely used services

Edge Cases

Circular dependencies requiring lazy loading
Primitive values requiring contextual binding
Optional dependencies that must be nullable type-hinted
Container in queue jobs which have different instance
Container in console commands
Container in event listeners

Performance Notes

Container resolution with type-hinting is faster than string-based
Singleton pattern can reduce memory usage
Container caching in production improves performance
Deferred providers can reduce bootstrap time
Laravel 11.x has performance improvements in container resolution

Security Notes

Ensure sensitive bindings are properly done
Use container for separation of concerns in security layers
Ensure services come from trusted sources

Interview Points

What is Service Container and how does it work?
What is the difference between bind() and singleton()?
How does Laravel perform automatic resolution?
What is contextual binding and when is it used?
How can you solve circular dependency?
What is the difference between Service Container and Service Locator?

Version Notes

Laravel 11.x: Improved performance in container resolution
Laravel 11.x: Better support for PHP 8.2+ attributes
Laravel 10.x: Improved container caching
Laravel 9.x: Improved reflection caching