Laravel Dependency Injection Explained

Laravel’s service container handles class dependencies through dependency injection. In the example you provided, Laravel automatically injects the AppleMusic service into the PodcastController by using constructor injection. Let me explain how this works and what you would need to do manually if Laravel didn’t handle this for you.

Let’s start with Laravel Doc example

namespace App\Http\Controllers;
 
use App\Services\AppleMusic;
use Illuminate\View\View;
 
class PodcastController extends Controller
{
    /**
     * Create a new controller instance.
     */
    public function __construct(
        protected AppleMusic $apple,
    ) {}
 
    /**
     * Show information about the given podcast.
     */
    public function show(string $id): View
    {
        return view('podcasts.show', [
            'podcast' => $this->apple->findPodcast($id)
        ]);
    }
}

How Laravel’s Service Container Works:

1. Automatic Dependency Resolution:

• When the PodcastController is instantiated, Laravel's service container detects that the AppleMusic class is a required dependency for the controller.
• It looks into its container (a registry where it stores bindings between interfaces and their concrete implementations) to resolve the AppleMusic instance.
• If the AppleMusic class or its dependencies are not manually registered, Laravel uses auto-wiring to create an instance of AppleMusic and inject it.

1. Constructor Injection:

• By declaring the AppleMusic $apple in the controller's constructor, Laravel knows to resolve the dependency and pass an instance of AppleMusic when creating the PodcastController.

What You Would Need to Do Manually Without Laravel’s Service Container:

If Laravel’s service container didn’t handle this for you, here’s what you’d need to manage:

Manually Instantiate Dependencies:

• You would need to manually create instances of the AppleMusic service in the controller. For instance:

class PodcastController extends Controller
{
    protected AppleMusic $apple;

    public function __construct()
    {
        $this->apple = new AppleMusic();
    }

    public function show(string $id): View
    {
        return view('podcasts.show', [
            'podcast' => $this->apple->findPodcast($id)
        ]);
    }
}

In this case, you lose the flexibility of dependency injection because now you are hardcoding the dependency.

Resolve Dependencies Manually:

• If the AppleMusic class had its own dependencies, you would have to manually resolve them as well. For example, if AppleMusic requires an HttpClient, you would have to manually instantiate and pass it:

class PodcastController extends Controller
{
    protected AppleMusic $apple;

    public function __construct()
    {
        $httpClient = new HttpClient(); // manual dependency resolution
        $this->apple = new AppleMusic($httpClient);
    }

    public function show(string $id): View
    {
        return view('podcasts.show', [
            'podcast' => $this->apple->findPodcast($id)
        ]);
    }
}

No Interface Binding or Abstractions:

• Without Laravel’s service container, you’d need to manually bind interfaces to concrete classes. If AppleMusic was an implementation of an MusicServiceInterface, you would have to manually instantiate the appropriate class. Laravel allows you to easily bind interfaces to implementations in a central place using the container.

$this->app->bind(MusicServiceInterface::class, AppleMusic::class);

Tight Coupling and Testing Challenges:

• Without dependency injection, testing becomes more challenging because your controller is tightly coupled to the AppleMusic class. You’d have to manually mock or replace the dependency in tests. Laravel allows for better decoupling, making it easy to swap the real service with a mock during testing.

Laravel’s Benefits:

• Automatic Dependency Resolution: The service container resolves class dependencies for you, avoiding manual instantiation.
• Loose Coupling: With dependency injection, your classes are not tightly coupled, making the code more flexible and easier to test.
• Interface Binding: You can bind interfaces to implementations, enabling polymorphism and flexibility.
• Automatic Injection: Laravel injects dependencies automatically based on the type-hinted classes in the constructor or method.

In short, if Laravel didn’t handle this for you, you would be responsible for manually instantiating and managing dependencies, which would increase code complexity and reduce flexibility. Laravel’s service container makes this seamless and efficient.

how laravel managing class dependencies and performing dependency injection under the hood

Laravel manages class dependencies and performs dependency injection through its service container, also known as the IoC (Inversion of Control) container. This container is a powerful tool that automatically resolves and injects dependencies into classes.

Here’s an explanation of how Laravel handles this under the hood:

1. The Service Container (IoC Container):

• Laravel’s service container is a central place to resolve dependencies.
• It binds classes, interfaces, and closures, and when a class needs a dependency, the container knows how to instantiate it and inject it.

2. Automatic Dependency Resolution:

Laravel uses reflection to inspect a class’s constructor and see what dependencies are required. If the class has dependencies in its constructor, Laravel automatically resolves and injects them. This is called constructor injection.

How Laravel Resolves Dependencies:

When Laravel needs to create an instance of a class (e.g., when a controller is invoked), it follows these steps:

a. Resolve from the Container:

• Laravel first checks its container to see if the requested class or interface is already registered (bound).
• If it’s found, it will return the bound object or closure.

$this->app->bind(MusicServiceInterface::class, AppleMusic::class);

Here, when Laravel sees a dependency on MusicServiceInterface, it resolves it by returning an instance of AppleMusic.

b. Reflection to Identify Dependencies:

If the class is not explicitly bound, Laravel uses PHP’s ReflectionClass to analyze the constructor and determine what dependencies the class requires.

$reflector = new ReflectionClass(AppleMusic::class);
$constructor = $reflector->getConstructor();
$parameters = $constructor->getParameters();

Laravel inspects the parameters and checks their types. If the constructor requires a dependency, Laravel recursively resolves those dependencies as well.

c. Recursive Resolution of Dependencies:

If a class has dependencies, Laravel resolves them by checking the container or using reflection. If those dependencies themselves have further dependencies, Laravel continues to resolve recursively.

public function __construct(HttpClient $client)
{
    $this->client = $client;
}

Laravel resolves the HttpClient instance first and passes it to the constructor of AppleMusic.

d. Instantiate the Class:

Once all dependencies are resolved, Laravel instantiates the class using the resolved dependencies.

3. Binding Classes and Interfaces:

Laravel allows you to explicitly bind classes or interfaces to concrete implementations in the service container. This is done in the AppServiceProvider or any custom service provider.

Example of manual binding:

$this->app->bind(MusicServiceInterface::class, AppleMusic::class);

• When MusicServiceInterface is required, Laravel knows to inject an instance of AppleMusic.
• This binding can also handle singleton patterns:

$this->app->singleton(AppleMusic::class, function ($app) {
    return new AppleMusic($app->make(HttpClient::class));
});

4. Type Hinting in Constructors:

When you type-hint a class or interface in the constructor, Laravel will automatically attempt to resolve that class or interface through the service container. This is the foundation of constructor injection.

class PodcastController
{
    public function __construct(AppleMusic $apple)
    {
        $this->apple = $apple;
    }
}

• Here, Laravel will automatically resolve the AppleMusic dependency.

5. Service Providers:

• Service providers are where most of your container bindings take place. They are classes that register services (like binding interfaces to implementations) and perform other bootstrapping tasks.

Example:

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind(AppleMusic::class, function ($app) {
            return new AppleMusic($app->make(HttpClient::class));
        });
    }
}

• The register method binds the AppleMusic class to the container, so Laravel knows how to resolve it when needed.

6. Method Injection:

Apart from constructor injection, Laravel also supports method injection. When a method is type-hinted with a class dependency, Laravel will automatically resolve and inject that dependency.

Example:

public function store(Request $request, AppleMusic $appleMusic)
{
    $podcast = $appleMusic->findPodcast($request->id);
}

• Here, Request and AppleMusic are automatically injected by Laravel.

7. Resolving Dependencies with the make Method:

Laravel’s container can resolve any class manually using the make method.

Example:

$appleMusic = app()->make(AppleMusic::class);

• This method directly tells Laravel to resolve and create an instance of the AppleMusic class.

8. Automatic Controller Resolution:

When you define a route in Laravel, such as:

Route::get('podcasts/{id}', [PodcastController::class, 'show']);

Laravel uses the service container to automatically resolve the PodcastController and its dependencies (such as AppleMusic) before calling the show method.

Summary of What Laravel Does:

1. Inspects Class Constructors using reflection to identify dependencies.
2. Resolves Dependencies using the IoC container, by checking if the dependencies are registered (bound) in the container or auto-wiring them.
3. Instantiates Classes with the necessary dependencies injected automatically.
4. Supports Method Injection to resolve dependencies in methods.
5. Binds Interfaces to Implementations to allow polymorphic behavior in resolving dependencies.
6. Manages Singleton and Scoped Instances to optimize performance and prevent multiple instantiations when not necessary.

Without Laravel:

You would have to manually instantiate and inject each dependency, keep track of the lifecycles of objects, and manage interfaces and implementations manually, which would increase the complexity of your application. Laravel’s service container abstracts all this, allowing for cleaner and more maintainable code.

💡 Let’s connect and stay in touch!

🌐 Portfolio: mohasin.dev
💼 LinkedIn: linkedin.com/in/mohasin-dev
👨‍💻 GitHub: github.com/mohasin-dev
🤝 ADPList: adplist.org/mentors/mohasin-hossain