Zum Hauptinhalt springen

​
Was sind Service-Provider

Service-Provider sind der zentrale Ort, an dem eine gesamte Laravel-Anwendung gebootstrapt wird. Sowohl Ihre eigene Anwendung als auch alle Kernservices von Laravel werden über Service-Provider gebootstrapt. Unter „Bootstrapping” versteht man das Registrieren unterschiedlichster Dinge, etwa Bindings im Service-Container, Event-Listener, Middleware und Routen. Service-Provider sind also die zentrale Stelle, an der Sie Ihre Anwendung konfigurieren. Intern verwendet Laravel zahlreiche Service-Provider, um Kerndienste wie Mailer, Queue und Cache zu bootstrappen. Viele davon sind „deferred provider” (verzögerte Provider): Sie werden nicht bei jedem Request geladen, sondern erst dann, wenn der von ihnen bereitgestellte Dienst tatsächlich benötigt wird. Alle benutzerdefinierten Service-Provider werden in der Datei bootstrap/providers.php registriert.
Wenn Sie genauer verstehen möchten, wie Laravel Anfragen verarbeitet, sehen Sie sich die Dokumentation zum Request-Lebenszyklus an.

​
Einen Service-Provider schreiben

Jeder Service-Provider erweitert die Klasse Illuminate\Support\ServiceProvider. Die meisten Service-Provider besitzen eine register- und eine boot-Methode. Um einen neuen Provider zu erzeugen, verwenden Sie den Artisan-Befehl make:provider. Laravel registriert den neuen Provider automatisch in bootstrap/providers.php. 
php artisan make:provider RiakServiceProvider

​
Die register-Methode

Innerhalb der register-Methode sollten Sie ausschließlich Bindings im Service-Container registrieren. Registrieren Sie in register keine Event-Listener, Routen oder andere Funktionen. Andernfalls könnten Sie versehentlich einen Service verwenden, der von einem noch nicht geladenen Service-Provider bereitgestellt wird. 
<?php

namespace App\Providers;

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

class RiakServiceProvider extends ServiceProvider
{
    /**
     * Anwendungsdienste registrieren
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
            return new Connection(config('riak'));
        });
    }
}
Innerhalb der Methoden eines Service-Providers können Sie über die Eigenschaft $this->app jederzeit auf den Service-Container zugreifen.

​
Die Eigenschaften bindings und singletons

Wenn Sie viele einfache Bindings registrieren, können Sie statt jedes Binding einzeln zu registrieren die Eigenschaften bindings und singletons nutzen. Beim Laden des Service-Providers prüft das Framework diese Eigenschaften automatisch und registriert die Bindings. 
<?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 zu registrierenden Container-Bindings
     *
     * @var array
     */
    public $bindings = [
        ServerProvider::class => DigitalOceanServerProvider::class,
    ];

    /**
     * Alle zu registrierenden Container-Singletons
     *
     * @var array
     */
    public $singletons = [
        DowntimeNotifier::class => PingdomDowntimeNotifier::class,
        ServerProvider::class => ServerToolsProvider::class,
    ];
}

​
Die boot-Methode

Wenn Sie innerhalb eines Service-Providers einen View-Composer registrieren möchten, tun Sie dies in der boot-Methode. Diese Methode wird erst aufgerufen, nachdem alle anderen Service-Provider registriert wurden. Sie haben daher Zugriff auf alle vom Framework registrierten Dienste. 
<?php

namespace App\Providers;

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

class ComposerServiceProvider extends ServiceProvider
{
    /**
     * Anwendungsdienste starten
     */
    public function boot(): void
    {
        View::composer('view', function () {
            // ...
        });
    }
}
Verwechseln Sie die Aufgaben der Methoden register und boot nicht: register dient ausschließlich zum Registrieren von Bindings, boot zur Initialisierung von Services und weiterem Setup.

​
Dependency Injection in boot

Auch in der boot-Methode können Sie Abhängigkeiten per Type-Hint entgegennehmen. Der Service-Container injiziert die benötigten Abhängigkeiten automatisch. 
use Illuminate\Contracts\Routing\ResponseFactory;

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

​
Service-Provider registrieren

Alle Service-Provider werden in der Datei bootstrap/providers.php registriert. Diese Datei gibt ein Array mit den Klassennamen der Service-Provider Ihrer Anwendung zurück. 
<?php

return [
    App\Providers\AppServiceProvider::class,
];
In Laravel 13 registrieren Sie Service-Provider nicht mehr im providers-Array von config/app.php, sondern in bootstrap/providers.php. Beim Verwenden des Befehls make:provider erfolgt der Eintrag automatisch.
Wenn Sie den Artisan-Befehl make:provider verwenden, trägt Laravel den Provider automatisch in die Datei ein. Erstellen Sie die Provider-Klasse manuell, müssen Sie den Klassennamen selbst in das Array eintragen. 
<?php

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

​
Einen eigenen Service-Provider erstellen

Erstellen wir nun praktisch einen eigenen Service-Provider.
1

Provider erzeugen

Legen Sie den Service-Provider mit dem Artisan-Befehl an.
php artisan make:provider PaymentServiceProvider
2

In der register-Methode binden

Tragen Sie die Bindings in die register-Methode des erzeugten Providers ein.
<?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
{
    /**
     * Anwendungsdienste registrieren
     */
    public function register(): void
    {
        $this->app->singleton(PaymentGateway::class, function (Application $app) {
            return new StripePaymentGateway(
                config('services.stripe.secret')
            );
        });
    }

    /**
     * Anwendungsdienste starten
     */
    public function boot(): void
    {
        // Falls beim Starten etwas zu tun ist, hier einfügen
    }
}
3

In bootstrap/providers.php registrieren

Bei Verwendung von make:provider erfolgt der Eintrag automatisch. Andernfalls fügen Sie ihn manuell hinzu.
<?php

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

​
Deferred Providers (verzögerte Provider)

Wenn ein Provider ausschließlich Bindings im Service-Container registriert, kann die Registrierung so lange verzögert werden, bis eines dieser Bindings tatsächlich benötigt wird. Da solche Provider nicht bei jedem Request vom Dateisystem geladen werden müssen, verbessert sich die Performance Ihrer Anwendung. Um einen deferred Provider anzulegen, implementieren Sie das Interface \Illuminate\Contracts\Support\DeferrableProvider und definieren die Methode provides. Die Methode provides gibt die vom Provider registrierten Container-Bindings zurück. 
<?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
{
    /**
     * Anwendungsdienste registrieren
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
                return new Connection(config('riak'));
            });
    }

    /**
     * Vom Provider bereitgestellte Dienste ermitteln
     *
     * @return array<int, string>
     */
    public function provides(): array
    {
        return [Connection::class];
    }
}
Deferred Provider eignen sich besonders für Dienste, die nicht in der gesamten Anwendung, sondern nur in bestimmten Funktionen benötigt werden. So vermeiden Sie das Laden nicht benötigter Dienste und optimieren die Performance.

​
Nächste Schritte

Service-Container

Sehen Sie sich die Funktionsweise des Service-Containers und die Details der Bindings an.
Zuletzt geändert am 13. Juli 2026

Verwandte Themen

Deferred Service ProviderService-ContainerFAQ zur neuen App-Struktur ab Laravel 11Request-LebenszyklusEinen eigenen Provider für das AI SDK erstellen