What are service providers?

Question

Accepted Answer

**Service providers** are the central place to **bootstrap and configure** your Laravel application — registering services in the container, binding interfaces to implementations, and setting up packages. They're how Laravel (and packages) wire up their functionality at startup.

## The structure: register and boot

```php
<?php
class AppServiceProvider extends ServiceProvider {
    public function register(): void {
        // BIND things into the container — runs FIRST, for all providers
        $this->app->bind(PaymentGateway::class, StripeGateway::class);
        $this->app->singleton(Reporter::class, fn() => new Reporter(config('reporting')));
    }

public function boot(): void {
        // BOOTSTRAP — runs AFTER all providers are registered
        // (everything is available; use for view composers, observers, macros, etc.)
        View::composer('dashboard', DashboardComposer::class);
        Model::preventLazyLoading();
    }
}
```

Each provider has two methods: **`register()`** (bind services into the container — runs first, so don't use other services here) and **`boot()`** (runs after all providers are registered, so everything is available — for setup that depends on other services).

## What providers are used for

```text
✓ Binding interfaces to implementations in the container
✓ Registering singletons and configuring services
✓ Bootstrapping packages (their service providers register their features)
✓ Registering event listeners, observers, view composers, route/macro setup
✓ Loading config, routes, migrations, or views (especially for packages)
```

## Registering providers

```php
// providers are listed in config/app.php (or bootstrap/providers.php in newer Laravel)
// generate one: php artisan make:provider PaymentServiceProvider
```

## How packages use them

```text
A Laravel package ships a service provider that registers ITS services, routes,
config, and views into your app when installed — this is how packages "plug in".
```

## Why it matters

Service providers are an important Laravel concept — they're the central mechanism for **bootstrapping and configuring** an application and its packages, so understanding them is valuable for organizing application setup and for comprehending how Laravel and its ecosystem work.

Providers are where you register services into the container (binding interfaces to implementations, configuring singletons), set up application-wide behavior (event listeners, observers, view composers), and where the framework itself and every package wire up their functionality at startup.

Understanding the **`register()` vs `boot()` distinction** (register for binding services — runs first; boot for setup that depends on other services — runs after everything is registered) is key to using providers correctly and avoiding ordering bugs.

Crucially, service providers are how **packages integrate** with your application — a package ships a provider that registers its services, routes, config, and views, which is the foundation of Laravel's extensibility.

Knowing what providers are for, the register/boot lifecycle, and how they bootstrap both your code and packages is important knowledge for structuring application configuration properly, integrating and building packages, and understanding how Laravel assembles itself at startup — making it a meaningful topic for intermediate-to-advanced Laravel development and for working with the framework's package ecosystem.