> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Service providers

> Uitleg over hoe je met service providers de services van je Laravel-applicatie registreert en opstart.

## Wat zijn service providers

Service providers vormen het hart van het bootstrappen van je hele Laravel-applicatie. Zowel je eigen applicatie als alle core services van Laravel worden via service providers gebootstrapt.

Met "bootstrappen" bedoelen we het **registreren** van allerlei zaken: bindings in de service container, event listeners, middleware, routes enzovoort. Service providers zijn de centrale plek waar je je applicatie configureert.

```mermaid theme={null}
flowchart TD
    A["Applicatie start"] --> B["bootstrap/providers.php laden"]
    B --> C["Alle providers instantiëren"]
    C --> D["register() van alle providers uitvoeren<br>alleen bindings registreren in de service container"]
    D --> E["boot() van alle providers uitvoeren<br>view composers, event listeners enz."]
    E --> F["Applicatie gereed<br>requestverwerking start"]
```

Laravel gebruikt intern veel service providers om core services zoals de mailer, queues en cache te bootstrappen. Veel van deze providers zijn "deferred" providers: ze worden niet bij elk request geladen, maar alleen wanneer de services die ze leveren daadwerkelijk nodig zijn.

Alle door de gebruiker gedefinieerde service providers registreer je in het bestand `bootstrap/providers.php`.

<Info>
  Wil je meer weten over hoe Laravel requests verwerkt, raadpleeg dan de documentatie over de [request-levenscyclus](https://laravel.com/docs/lifecycle).
</Info>

## Een service provider schrijven

Alle service providers erven van de klasse `Illuminate\Support\ServiceProvider`. De meeste service providers bevatten een `register`- en een `boot`-methode.

Om een nieuwe provider te genereren gebruik je het Artisan-commando `make:provider`. Laravel registreert de nieuwe provider automatisch in `bootstrap/providers.php`.

```shell theme={null}
php artisan make:provider RiakServiceProvider
```

### De register-methode

Voer binnen de `register`-methode uitsluitend bindings in de [service container](/nl/service-container) uit. Probeer geen event listeners, routes of andere functionaliteit te registreren in de `register`-methode. Je zou anders per ongeluk een service kunnen gebruiken van een service provider die nog niet geladen is.

```php theme={null}
<?php

namespace App\Providers;

use App\Services\Riak\Connection;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Support\ServiceProvider;

class RiakServiceProvider extends ServiceProvider
{
    /**
     * Registreer applicatieservices
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
            return new Connection(config('riak'));
        });
    }
}
```

Binnen de methoden van een service provider heb je altijd via de property `$this->app` toegang tot de service container.

#### De bindings- en singletons-property's

Registreer je veel eenvoudige bindings, dan kun je in plaats van elke binding handmatig te registreren de property's `bindings` en `singletons` gebruiken. Wanneer het framework de service provider laadt, controleert het deze property's automatisch en registreert de bindings.

```php theme={null}
<?php

namespace App\Providers;

use App\Contracts\DowntimeNotifier;
use App\Contracts\ServerProvider;
use App\Services\DigitalOceanServerProvider;
use App\Services\PingdomDowntimeNotifier;
use App\Services\ServerToolsProvider;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Alle te registreren containerbindings
     *
     * @var array
     */
    public $bindings = [
        ServerProvider::class => DigitalOceanServerProvider::class,
    ];

    /**
     * Alle te registreren containersingletons
     *
     * @var array
     */
    public $singletons = [
        DowntimeNotifier::class => PingdomDowntimeNotifier::class,
        ServerProvider::class => ServerToolsProvider::class,
    ];
}
```

### De boot-methode

Wil je in een service provider [view composers](https://laravel.com/docs/views#view-composers) registreren, doe dat dan in de `boot`-methode. **Deze methode wordt aangeroepen nadat alle andere service providers zijn geregistreerd.** Je hebt dus toegang tot alle andere services die het framework heeft geregistreerd.

```php theme={null}
<?php

namespace App\Providers;

use Illuminate\Support\Facades\View;
use Illuminate\Support\ServiceProvider;

class ComposerServiceProvider extends ServiceProvider
{
    /**
     * Start applicatieservices op
     */
    public function boot(): void
    {
        View::composer('view', function () {
            // ...
        });
    }
}
```

<Warning>
  Haal de rollen van de `register`- en `boot`-methode niet door elkaar. `register` is alleen voor het registreren van bindings, `boot` gebruik je voor het initialiseren van services en andere setup.
</Warning>

#### Dependency injection in de boot-methode

Ook in de `boot`-methode kun je afhankelijkheden injecteren via typehints. De [service container](/nl/service-container) injecteert de benodigde afhankelijkheden automatisch.

```php theme={null}
use Illuminate\Contracts\Routing\ResponseFactory;

/**
 * Start applicatieservices op
 */
public function boot(ResponseFactory $response): void
{
    $response->macro('serialized', function (mixed $value) {
        // ...
    });
}
```

## Service providers registreren

Alle service providers registreer je in het bestand `bootstrap/providers.php`. Dit bestand geeft een array terug met de klassenamen van de service providers van je applicatie.

```php theme={null}
<?php

return [
    App\Providers\AppServiceProvider::class,
];
```

<Info>
  In Laravel 13 registreer je service providers in `bootstrap/providers.php`, niet in de `providers`-array van `config/app.php`. Gebruik je het commando `make:provider`, dan wordt de provider automatisch toegevoegd.
</Info>

Voer je het Artisan-commando `make:provider` uit, dan voegt Laravel de provider automatisch aan het bestand toe. Heb je de providerklasse handmatig aangemaakt, voeg de klasse dan zelf toe aan de array.

```php theme={null}
<?php

return [
    App\Providers\AppServiceProvider::class,
    App\Providers\ComposerServiceProvider::class,
];
```

## Een eigen service provider maken

Laten we daadwerkelijk een eigen service provider maken.

<Steps>
  <Step title="De provider genereren">
    Genereer de service provider met een Artisan-commando.

    ```shell theme={null}
    php artisan make:provider PaymentServiceProvider
    ```
  </Step>

  <Step title="Binden in de register-methode">
    Schrijf de binding in de `register`-methode van de gegenereerde provider.

    ```php theme={null}
    <?php

    namespace App\Providers;

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

    class PaymentServiceProvider extends ServiceProvider
    {
        /**
         * Registreer applicatieservices
         */
        public function register(): void
        {
            $this->app->singleton(PaymentGateway::class, function (Application $app) {
                return new StripePaymentGateway(
                    config('services.stripe.secret')
                );
            });
        }

        /**
         * Start applicatieservices op
         */
        public function boot(): void
        {
            // Schrijf hier eventuele opstartlogica
        }
    }
    ```
  </Step>

  <Step title="Registreren in bootstrap/providers.php">
    Bij gebruik van `make:provider` gebeurt de registratie automatisch. Handmatig? Voeg de provider dan zelf toe.

    ```php theme={null}
    <?php

    return [
        App\Providers\AppServiceProvider::class,
        App\Providers\PaymentServiceProvider::class,
    ];
    ```
  </Step>
</Steps>

## Deferred providers

Registreert een provider uitsluitend bindings in de service container, dan kun je die registratie uitstellen totdat een geregistreerde binding daadwerkelijk nodig is. Door het laden van zulke deferred providers uit te stellen, worden ze niet bij elk request van het bestandssysteem geladen, wat de performance van je applicatie verbetert.

```mermaid theme={null}
flowchart TD
    A["Applicatie start"] --> B["Gewone providers laden en initialiseren"]
    B --> C["Van deferred providers wordt alleen<br>de lijst met geleverde services vastgelegd"]
    C --> D["Requestverwerking"]
    D --> E{{"Wordt een service van een<br>deferred provider gevraagd?"}}
    E -->|"No"| F["Provider wordt niet geladen<br>bespaart geheugen en verwerking"]
    E -->|"Yes"| G["Provider ter plekke laden"]
    G --> H["register() uitvoeren"]
    H --> I["Service leveren vanuit de container"]
```

Om een deferred provider te maken implementeer je de interface `\Illuminate\Contracts\Support\DeferrableProvider` en definieer je de methode `provides`. De methode `provides` geeft de service container-bindings terug die de provider registreert.

```php theme={null}
<?php

namespace App\Providers;

use App\Services\Riak\Connection;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\Support\DeferrableProvider;
use Illuminate\Support\ServiceProvider;

class RiakServiceProvider extends ServiceProvider implements DeferrableProvider
{
    /**
     * Registreer applicatieservices
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
                return new Connection(config('riak'));
            });
    }

    /**
     * Haal de services op die deze provider levert
     *
     * @return array<int, string>
     */
    public function provides(): array
    {
        return [Connection::class];
    }
}
```

<Tip>
  Deferred providers zijn geschikt voor services die je alleen voor specifieke functionaliteit gebruikt, niet in de hele applicatie. Door het onnodig laden van services te vermijden, optimaliseer je de performance.
</Tip>

## Volgende stap

<Card title="Service container" icon="box" href="/nl/service-container">
  Bekijk hoe de service container werkt en de details van bindings.
</Card>


## Related topics

- [Request lifecycle](/nl/lifecycle.md)
- [Uitgestelde service providers](/nl/advanced/deferred-provider.md)
- [Service container](/nl/service-container.md)
- [FAQ over de nieuwe appstructuur van Laravel 11+](/nl/advanced/app-structure-faq.md)
- [Een custom provider voor de AI SDK maken](/nl/advanced/ai-sdk-custom-provider.md)