Published on May 12, 2026 by Admin User | Category: Laravel

Laravel Service Container vs Service Provider

Laravel Service Container vs Service Provider Explained with Real Example

If you are learning Laravel deeply, then understanding the difference between Service Container and Service Provider is extremely important. Most developers get confused between dependency injection, bindings, bootstrapping, register methods, and service resolution.

In this complete guide, we will understand everything step-by-step using a real Payment Gateway example so that you can clearly understand how Laravel internally works.

What is Laravel Service Container?

Laravel Service Container is Laravel’s Dependency Injection Engine. It is responsible for creating objects, resolving dependencies, injecting required classes automatically, and managing singleton instances.

In simple words:

Service Container automatically creates and provides required class objects.

Whenever you type-hint a class or interface inside a controller, middleware, service, or command, Laravel automatically resolves and injects that dependency using the Service Container.

For example:

class PaymentController extends Controller { public function pay(PaymentService $payment) { return $payment->pay(); } }

Here Laravel automatically creates the PaymentService object and injects it into the controller method. This complete process is handled by the Laravel Service Container.

What is Laravel Service Provider?

Service Provider is the central place where all application services and bindings are registered.

Laravel loads all providers during application startup.

Service Providers are mainly used for:

In simple words:

Service Provider tells Laravel what services should be loaded and how dependencies should be resolved.

Real World Example — Payment Gateway System

Now let’s understand everything using a practical Payment Gateway example.

Suppose we want to integrate Razorpay inside our Laravel application using proper architecture.

Step 1 — Create Interface

First we create an interface.

File:

app/Contracts/PaymentInterface.php

Code:

namespace App\Contracts; interface PaymentInterface { public function pay($amount); }

This interface defines a contract that every payment service must follow.

Step 2 — Create Payment Service

Now we create the actual service class.

File:

app/Services/RazorpayService.php

Code:

namespace App\Services; use App\Contracts\PaymentInterface; class RazorpayService implements PaymentInterface { public function pay($amount) { return "Paid ₹{$amount} using Razorpay"; } }

This class implements the interface and contains actual payment logic.

Step 3 — Create Service Provider

Now we create a Service Provider.

Command:

php artisan make:provider PaymentServiceProvider

Laravel automatically creates:

app/Providers/PaymentServiceProvider.php

Step 4 — Register Binding

Now we bind the interface with the actual service class.

namespace App\Providers; use Illuminate\Support\ServiceProvider; use App\Contracts\PaymentInterface; use App\Services\RazorpayService; class PaymentServiceProvider extends ServiceProvider { public function register() { $this->app->bind( PaymentInterface::class, RazorpayService::class ); } public function boot() { // } }

What Does bind() Mean?

$this->app->bind( PaymentInterface::class, RazorpayService::class );

This means:

Whenever someone requests PaymentInterface, Laravel should provide RazorpayService.

This binding is stored inside the Laravel Service Container.

Step 5 — Register Provider in Laravel

Now we must register the provider inside Laravel.

Open:

config/app.php

Add provider inside providers array:

'providers' => [ App\Providers\PaymentServiceProvider::class, ],

What Happens Internally?

When Laravel starts, it loads all providers from config/app.php.

Then Laravel executes the register() method of every provider.

During this process:

This complete startup process is called:

What is Bootstrapping in Laravel?

Bootstrapping means preparing the application before handling incoming user requests.

Laravel bootstrapping includes:

In simple words:

Bootstrapping means initializing the Laravel application completely before serving requests.

Step 6 — Create Controller

Now we create controller.

namespace App\Http\Controllers; use App\Contracts\PaymentInterface; class PaymentController extends Controller { public function pay(PaymentInterface $payment) { return $payment->pay(500); } }

Notice carefully:

PaymentInterface $payment

We are injecting the interface, not the actual class.

Laravel automatically resolves the correct class using Service Container bindings.

Step 7 — Add Route

use App\Http\Controllers\PaymentController; Route::get('/pay', [PaymentController::class, 'pay']);

Complete Internal Laravel Flow

When user visits:

/pay

Laravel internally performs this process:

Request ↓ Route ↓ Controller ↓ Needs PaymentInterface ↓ Service Container checks bindings ↓ PaymentServiceProvider mapping found ↓ Creates RazorpayService object ↓ Injects dependency ↓ Returns response

Difference Between Service Container and Service Provider

Feature Service Container Service Provider Purpose Resolve dependencies Register services Main Work Object creation Application bootstrapping Usage app(), resolve(), DI register(), boot() Handles Dependency Injection Service Registration Runtime Yes Startup Time

register() vs boot() in Laravel

register()

The register() method is used for:

Example:

public function register() { $this->app->bind(...); }

boot()

The boot() method runs after the application is fully loaded.

It is used for:

Example:

public function boot() { View::share('appName', 'BharatTodayTech'); }

bind() vs singleton()

bind()

Creates a new object every time.

$this->app->bind(...)

singleton()

Reuses the same object throughout the application lifecycle.

$this->app->singleton(...)

Singleton is useful for:

Real Project Usage

Laravel Service Container and Service Providers are heavily used in modern Laravel applications including:

Why Laravel Service Container is Powerful?

Benefits of Service Container:

Related Laravel & Development Guides

You may also like these helpful development tutorials:

Laravel Interview Questions

What is Service Container in Laravel?

Laravel Service Container is a powerful dependency injection container used to manage class dependencies and automatically resolve required objects.

What is Service Provider in Laravel?

Service Providers are the central place where all Laravel application services are registered and bootstrapped.

What is Dependency Injection in Laravel?

Dependency Injection means automatically providing required class dependencies into another class using Laravel Service Container.

What is Bootstrapping in Laravel?

Bootstrapping means initializing and preparing the Laravel application before handling incoming requests.

Final Conclusion

Service Provider and Service Container work together inside Laravel.

The easiest line to remember is:

Service Provider defines bindings, and Service Container resolves them at runtime.

Understanding these concepts properly helps you write scalable, maintainable, and professional Laravel applications.

Read More News