Learn all about Laravel's dependency injection container

Laravel's dependency injection (DI) container is a powerful tool that helps manage class dependencies and performing dependency injection. The container allows you to bind interfaces to concrete classes, resolve dependencies automatically, and manage class instances with ease. Here's a comprehensive guide to understanding and using Laravel's dependency injection container:

Key Concepts

1. Service Container: Laravel’s service container is a powerful tool for managing class dependencies and performing dependency injection. It acts as a registry for all the classes and interfaces and their dependencies.

2. Binding: Binding is the process of associating a key (typically an interface or class name) with a concrete class or a closure that resolves the dependency.

3. Resolving: Resolving is the process of retrieving an instance of a class or interface from the container, with all its dependencies injected.

Using the Service Container

1. Basic Binding and Resolving

You can bind a concrete class to an interface or an abstract class and resolve it later.

use Illuminate\Support\Facades\App;

// Binding an interface to a concrete class
App::bind('App\Contracts\PaymentGateway', 'App\Services\StripePaymentGateway');

// Resolving the binding
$paymentGateway = App::make('App\Contracts\PaymentGateway');

2. Singleton Binding

Sometimes you might want to bind a class or interface as a singleton, meaning only one instance of the class will be created and shared.

App::singleton('App\Contracts\PaymentGateway', 'App\Services\StripePaymentGateway');

3. Binding a Closure

You can bind a closure to the container, which will be resolved when needed.

App::bind('App\Contracts\PaymentGateway', function ($app) {
    return new \App\Services\StripePaymentGateway(config('services.stripe.key'));
});

4. Automatic Injection

Laravel can automatically inject dependencies into your classes via constructors or method parameters.

namespace App\Http\Controllers;

use App\Contracts\PaymentGateway;

class PaymentController extends Controller
{
    protected $paymentGateway;

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

    public function charge()
    {
        // Use $this->paymentGateway to process payment
    }
}

Advanced Usage

1. Contextual Binding

Contextual binding allows you to specify which implementation of an interface should be used in a specific context.

use App\Contracts\PaymentGateway;
use App\Services\StripePaymentGateway;
use App\Services\PaypalPaymentGateway;

$this->app->when('App\Http\Controllers\StripePaymentController')
    ->needs(PaymentGateway::class)
    ->give(StripePaymentGateway::class);

$this->app->when('App\Http\Controllers\PaypalPaymentController')
    ->needs(PaymentGateway::class)
    ->give(PaypalPaymentGateway::class);

2. Tagging

Tagging allows you to group several bindings under a single tag, which can be resolved together.

App::bind('App\Contracts\PaymentGateway', 'App\Services\StripePaymentGateway');
App::bind('App\Contracts\PaymentGateway', 'App\Services\PaypalPaymentGateway');

App::tag(['App\Services\StripePaymentGateway', 'App\Services\PaypalPaymentGateway'], 'paymentGateways');

$paymentGateways = App::tagged('paymentGateways');

3. Service Providers

Service providers are the central place to configure your application and bind classes or interfaces to the container.

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Contracts\PaymentGateway;
use App\Services\StripePaymentGateway;

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

    public function boot()
    {
        //
    }
}

Register the service provider in config/app.php:

'providers' => [
    // Other Service Providers
    App\Providers\AppServiceProvider::class,
],

Practical Example

Step-by-Step

1. Create an Interface and a Concrete Class

// app/Contracts/PaymentGateway.php

namespace App\Contracts;

interface PaymentGateway
{
    public function charge($amount);
}

// app/Services/StripePaymentGateway.php

namespace App\Services;

use App\Contracts\PaymentGateway;

class StripePaymentGateway implements PaymentGateway
{
    public function charge($amount)
    {
        // Implement Stripe charging logic
        return "Charged {$amount} with Stripe";
    }
}

2. Bind the Interface to the Concrete Class in a Service Provider

// app/Providers/AppServiceProvider.php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Contracts\PaymentGateway;
use App\Services\StripePaymentGateway;

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

    public function boot()
    {
        //
    }
}

3. Inject the Dependency into a Controller

// app/Http/Controllers/PaymentController.php

namespace App\Http\Controllers;

use App\Contracts\PaymentGateway;

class PaymentController extends Controller
{
    protected $paymentGateway;

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

    public function charge($amount)
    {
        return $this->paymentGateway->charge($amount);
    }
}

4. Define a Route

// routes/web.php

use App\Http\Controllers\PaymentController;

Route::get('/charge/{amount}', [PaymentController::class, 'charge']);

5. Test the Implementation

Visit http://your-app.test/charge/100 to see the Stripe charging logic in action.

Conclusion

Laravel’s dependency injection container is a powerful and flexible tool for managing class dependencies and performing dependency injection. By using the container, you can easily bind interfaces to implementations, inject dependencies automatically, and manage class instances effectively. This leads to cleaner, more maintainable, and testable code.